Logging utilities and macros for PETSc-based applications. More...

#include <petsc.h>
#include <stdlib.h>
#include <string.h>
#include <petscsys.h>
#include <ctype.h>
#include "variables.h"
#include "AnalyticalSolution.h"
#include "Boundaries.h"

Include dependency graph for logging.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	DualMonitorCtx
	Context for a dual-purpose KSP monitor. More...

Macros
#define	LOCAL 0
	Logging scope definitions for controlling message output.

#define	GLOBAL 1
	Scope for global logging across all processes.

#define	LOG(scope, level, fmt, ...)
	Logging macro for PETSc-based applications with scope control.

#define	LOG_DEFAULT(level, fmt, ...)
	Default logging macro for PETSc-based applications.

#define	LOG_SYNC(scope, level, fmt, ...)
	Logging macro for PETSc-based applications with scope control, using synchronized output across processes.

#define	LOG_SYNC_DEFAULT(level, fmt, ...)
	Default synchronized logging macro for PETSc-based applications.

#define	LOG_ALLOW(scope, level, fmt, ...)
	Logging macro that checks both the log level and whether the calling function is in the allowed-function list before printing.

#define	LOG_ALLOW_SYNC(scope, level, fmt, ...)
	----— DEBUG ---------------------------------------— #define LOG_ALLOW(scope, level, fmt, ...) \ do { \ MPI_Comm comm = (scope == LOCAL) ? MPI_COMM_SELF : MPI_COMM_WORLD; \ PetscInt current_level_val = get_log_level(); \ PetscBool __allowed_func_val = is_function_allowed(__func); \ Print BEFORE the check \ if (strcmp(func, "LocateAllParticlesInGrid") == 0) { \ printf("[DEBUG LOG_ALLOW in %s] Checking: level=%d, get_log_level() returned %d, func_allowed=%d\n", \ func, (int)level, (int)__current_level_val, (int)__allowed_func_val); \ } \ if ((int)(level) <= (int)__current_level_val && allowed_func_val) { \ Print AFTER passing the check // \ if (strcmp(__func, "LocateAllParticlesInGrid") == 0) { \ printf("[DEBUG LOG_ALLOW in %s] Check PASSED. Printing log.\n", func); \ } \ PetscPrintf(comm, "[%s] " fmt, func, ##__VA_ARGS__); \ } \

#define	LOG_LOOP_ALLOW(scope, level, iterVar, interval, fmt, ...)
	Logs a message inside a loop, but only every `interval` iterations.

#define	LOG_LOOP_ALLOW_EXACT(scope, level, var, val, fmt, ...)
	Logs a custom message if a variable equals a specific value.

#define	LOG_ARRAY_ELEMENT_ALLOW(scope, level, arr, length, idx, fmt)
	Logs a single element of an array, given an index.

#define	LOG_ARRAY_SUBRANGE_ALLOW(scope, level, arr, length, start, end, fmt)
	Logs a consecutive subrange of an array.

#define	LOG_FUNC_TIMER_BEGIN_EVENT(eventID, scope)
	Begins timing a function by:

#define	LOG_FUNC_TIMER_END_EVENT(eventID, scope)
	Ends timing a function by:

#define	LOG_PROFILE_MSG(scope, fmt, ...)

#define	PROFILE_FUNCTION_BEGIN _ProfilingStart(__FUNCT__)
	Marks the beginning of a profiled code block (typically a function).

#define	PROFILE_FUNCTION_END _ProfilingEnd(__FUNCT__)
	Marks the end of a profiled code block.

Enumerations
enum	LogLevel { LOG_ERROR = 0 , LOG_WARNING , LOG_PROFILE , LOG_INFO , LOG_DEBUG }
	Enumeration of logging levels. More...

Functions
LogLevel	get_log_level ()
	Retrieves the current logging level from the environment variable `LOG_LEVEL`.

PetscErrorCode	print_log_level (void)
	Prints the current logging level to the console.

void	set_allowed_functions (const char **functionList, int count)
	Sets the global list of function names that are allowed to log.

PetscBool	is_function_allowed (const char *functionName)
	Checks if a given function is in the allow-list.

PetscErrorCode	LOG_CELL_VERTICES (const Cell *cell, PetscMPIInt rank)
	Prints the coordinates of a cell's vertices.

PetscErrorCode	LOG_FACE_DISTANCES (PetscReal *d)
	Prints the signed distances to each face of the cell.

PetscErrorCode	LOG_PARTICLE_FIELDS (UserCtx *user, PetscInt printInterval)
	Prints particle fields in a table that automatically adjusts its column widths.

PetscErrorCode	FreeAllowedFunctions (char **funcs, PetscInt n)
	Free an array previously returned by LoadAllowedFunctionsFromFile().

PetscErrorCode	LoadAllowedFunctionsFromFile (const char filename[], char **funcsOut, PetscInt nOut)
	Load function names from a text file.

const char *	BCFaceToString (BCFace face)
	Helper function to convert BCFace enum to a string representation.

const char *	BCTypeToString (BCType type)
	Helper function to convert BCType enum to a string representation.

const char *	BCHandlerTypeToString (BCHandlerType handler_type)
	Converts a BCHandlerType enum to its string representation.

PetscErrorCode	DualKSPMonitor (KSP ksp, PetscInt it, PetscReal rnorm, void *ctx)
	A custom KSP monitor that logs to a file and optionally to the console.

PetscErrorCode	DualMonitorDestroy (void **ctx)
	Destroys the DualMonitorCtx.

PetscErrorCode	LOG_CONTINUITY_METRICS (UserCtx *user)
	Logs continuity metrics for a single block to a file.

const char *	ParticleLocationStatusToString (ParticleLocationStatus level)
	A function that outputs the name of the current level in the ParticleLocation enum.

PetscErrorCode	ProfilingInitialize (SimCtx *simCtx)
	Initializes the custom profiling system using configuration from SimCtx.

PetscErrorCode	ProfilingLogTimestepSummary (PetscInt step)
	Logs the performance summary for the current timestep and resets timers.

PetscErrorCode	ProfilingFinalize (void)
	Prints the final, cumulative performance summary and cleans up resources.

void	_ProfilingStart (const char *func_name)

void	_ProfilingEnd (const char *func_name)

Variables
PetscLogEvent	EVENT_Individualwalkingsearch

PetscLogEvent	EVENT_walkingsearch

PetscLogEvent	EVENT_GlobalParticleLocation

PetscLogEvent	EVENT_IndividualLocation

Detailed Description

Logging utilities and macros for PETSc-based applications.

This header defines logging levels, scopes, and macros for consistent logging throughout the application. It provides functions to retrieve the current logging level and macros to simplify logging with scope control.

Definition in file logging.h.

Data Structure Documentation

◆ DualMonitorCtx

struct DualMonitorCtx

Context for a dual-purpose KSP monitor.

This struct holds a file viewer for unconditional logging and a boolean flag to enable/disable optional logging to the console.

Definition at line 63 of file logging.h.

Data Fields
FILE *	file_handle
PetscBool	log_to_console
PetscReal	bnorm
PetscInt	step
PetscInt	block_id

Macro Definition Documentation

◆ LOCAL

#define LOCAL 0

Logging scope definitions for controlling message output.

LOCAL: Logs on the current process using MPI_COMM_SELF.
GLOBAL: Logs across all processes using MPI_COMM_WORLD. Scope for local logging on the current process.

Definition at line 44 of file logging.h.

◆ GLOBAL

#define GLOBAL 1

Scope for global logging across all processes.

Definition at line 45 of file logging.h.

◆ LOG

#define LOG	(	scope,
		level,
		fmt,
		...
	)

Value:

    do { \
        /* Determine the MPI communicator based on the scope */ \
        MPI_Comm comm = (scope == LOCAL) ? MPI_COMM_SELF : MPI_COMM_WORLD; \
        /* Check if the log level is within the allowed range */ \
        if ((int)(level) <= (int)get_log_level()) { \
            /* Print the message to the specified communicator */ \
            PetscPrintf(comm, fmt, ##__VA_ARGS__); \
        } \
    } while (0)

Logging macro for PETSc-based applications with scope control.

This macro provides a convenient way to log messages with different scopes (LOCAL or GLOBAL) and severity levels. It utilizes PETSc's PetscPrintf function for message output.

Parameters

scope	Specifies the logging scope: LOCAL: Logs on the current process using MPI_COMM_SELF. GLOBAL: Logs on all processes using MPI_COMM_WORLD.
level	The severity level of the message (e.g., LOG_INFO, LOG_ERROR).
fmt	The format string for the message (similar to printf).
...	Additional arguments for the format string (optional).

Example usage: LOG(LOCAL, LOG_ERROR, "An error occurred at index %ld.\n", idx); LOG(GLOBAL, LOG_INFO, "Grid size: %ld x %ld x %ld.\n", nx, ny, nz);

Definition at line 91 of file logging.h.

       { \
        /* Determine the MPI communicator based on the scope */ \
        MPI_Comm comm = (scope == LOCAL) ? MPI_COMM_SELF : MPI_COMM_WORLD; \
        /* Check if the log level is within the allowed range */ \
        if ((int)(level) <= (int)get_log_level()) { \
            /* Print the message to the specified communicator */ \
            PetscPrintf(comm, fmt, ##__VA_ARGS__); \
        } \
    } while (0)

◆ LOG_DEFAULT

#define LOG_DEFAULT	(	level,
		fmt,
		...
	)

Value:

    do { \
        /* Set the communicator to global (MPI_COMM_WORLD) by default */ \
        MPI_Comm comm = MPI_COMM_WORLD; \
        /* Check if the log level is within the allowed range */ \
        if ((int)(level) <= (int)get_log_level()) { \
            /* Print the message using PetscPrintf with the global communicator */ \
            PetscPrintf(comm, fmt, ##__VA_ARGS__); \
        } \
    } while (0)

Default logging macro for PETSc-based applications.

This macro simplifies logging by defaulting the scope to GLOBAL (i.e., MPI_COMM_WORLD) and providing a convenient interface for common logging needs.

Parameters

level	The severity level of the message (e.g., LOG_ERROR, LOG_INFO).
fmt	The format string for the log message (similar to printf).
...	Additional arguments for the format string (optional).

Example usage: LOG_DEFAULT(LOG_ERROR, "Error occurred at index %ld.\n", idx); LOG_DEFAULT(LOG_INFO, "Grid size: %ld x %ld x %ld.\n", nx, ny, nz);

Note

By default, this macro logs across all MPI processes using MPI_COMM_WORLD.
If finer control (e.g., local logging) is required, use the more general LOG macro.
The log level is filtered based on the value returned by get_log_level().

Definition at line 122 of file logging.h.

       { \
        /* Set the communicator to global (MPI_COMM_WORLD) by default */ \
        MPI_Comm comm = MPI_COMM_WORLD; \
        /* Check if the log level is within the allowed range */ \
        if ((int)(level) <= (int)get_log_level()) { \
            /* Print the message using PetscPrintf with the global communicator */ \
            PetscPrintf(comm, fmt, ##__VA_ARGS__); \
        } \
    } while (0)

◆ LOG_SYNC

#define LOG_SYNC	(	scope,
		level,
		fmt,
		...
	)

Value:

    do { \
        /* Determine the MPI communicator based on the scope */ \
        MPI_Comm comm = (scope == LOCAL) ? MPI_COMM_SELF : MPI_COMM_WORLD; \
        /* Check if the log level is within the allowed range */ \
        if ((int)(level) <= (int)get_log_level()) { \
            /* Synchronized print (collective) on the specified communicator */ \
            PetscSynchronizedPrintf(comm, fmt, ##__VA_ARGS__); \
            /* Ensure all ranks have finished printing before continuing */ \
            PetscSynchronizedFlush(comm, PETSC_STDOUT); \
        } \
    } while (0)

Logging macro for PETSc-based applications with scope control, using synchronized output across processes.

This macro uses PetscSynchronizedPrintf and PetscSynchronizedFlush to ensure messages from different ranks are printed in a synchronized (rank-by-rank) manner, preventing interleaved outputs.

Parameters

scope	Specifies the logging scope: LOCAL: Logs on the current process using MPI_COMM_SELF. GLOBAL: Logs on all processes using MPI_COMM_WORLD.
level	The severity level of the message (e.g., LOG_INFO, LOG_ERROR).
fmt	The format string for the message (similar to printf).
...	Additional arguments for the format string (optional).

Example usage: LOG_SYNC(LOCAL, LOG_ERROR, "An error occurred at index %ld.\n", idx); LOG_SYNC(GLOBAL, LOG_INFO, "Synchronized info: rank = %ld.\n", rank);

Definition at line 152 of file logging.h.

       { \
        /* Determine the MPI communicator based on the scope */ \
        MPI_Comm comm = (scope == LOCAL) ? MPI_COMM_SELF : MPI_COMM_WORLD; \
        /* Check if the log level is within the allowed range */ \
        if ((int)(level) <= (int)get_log_level()) { \
            /* Synchronized print (collective) on the specified communicator */ \
            PetscSynchronizedPrintf(comm, fmt, ##__VA_ARGS__); \
            /* Ensure all ranks have finished printing before continuing */ \
            PetscSynchronizedFlush(comm, PETSC_STDOUT); \
        } \
    } while (0)

◆ LOG_SYNC_DEFAULT

#define LOG_SYNC_DEFAULT	(	level,
		fmt,
		...
	)

Value:

    do { \
        if ((int)(level) <= (int)get_log_level()) { \
            PetscSynchronizedPrintf(MPI_COMM_WORLD, fmt, ##__VA_ARGS__); \
            PetscSynchronizedFlush(MPI_COMM_WORLD, PETSC_STDOUT); \
        } \
    } while (0)

Default synchronized logging macro for PETSc-based applications.

This macro simplifies logging by defaulting the scope to GLOBAL (i.e., MPI_COMM_WORLD) and provides synchronized output across all processes.

Parameters

level	The severity level of the message (e.g., LOG_ERROR, LOG_INFO).
fmt	The format string for the log message (similar to printf).
...	Additional arguments for the format string (optional).

Example usage: LOG_SYNC_DEFAULT(LOG_ERROR, "Error at index %ld.\n", idx); LOG_SYNC_DEFAULT(LOG_INFO, "Process rank: %ld.\n", rank);

Note

By default, this macro logs across all MPI processes using MPI_COMM_WORLD.
If local (per-process) logging is required, use the more general LOG_SYNC macro.
The log level is filtered based on the value returned by get_log_level().

Definition at line 185 of file logging.h.

       { \
        if ((int)(level) <= (int)get_log_level()) { \
            PetscSynchronizedPrintf(MPI_COMM_WORLD, fmt, ##__VA_ARGS__); \
            PetscSynchronizedFlush(MPI_COMM_WORLD, PETSC_STDOUT); \
        } \
    } while (0)

◆ LOG_ALLOW

#define LOG_ALLOW	(	scope,
		level,
		fmt,
		...
	)

Value:

    do { \
        MPI_Comm comm = (scope == LOCAL) ? MPI_COMM_SELF : MPI_COMM_WORLD; \
        if ((int)(level) <= (int)get_log_level() && is_function_allowed(__func__)) { \
            PetscPrintf(comm, "[%s] " fmt, __func__, ##__VA_ARGS__); \
        } \
    } while (0)

Logging macro that checks both the log level and whether the calling function is in the allowed-function list before printing.

Useful for selective, per-function logging.

Parameters

scope	Specifies the logging scope (LOCAL or GLOBAL).
level	The severity level of the message (e.g., LOG_INFO, LOG_ERROR).
fmt	The format string for the message (similar to printf).
...	Additional arguments for the format string (optional).

Example usage: LOG_ALLOW(LOCAL, LOG_DEBUG, "Debugging info in function: %s\n", func);

Definition at line 207 of file logging.h.

       { \
        MPI_Comm comm = (scope == LOCAL) ? MPI_COMM_SELF : MPI_COMM_WORLD; \
        if ((int)(level) <= (int)get_log_level() && is_function_allowed(__func__)) { \
            PetscPrintf(comm, "[%s] " fmt, __func__, ##__VA_ARGS__); \
        } \
    } while (0)

◆ LOG_ALLOW_SYNC

#define LOG_ALLOW_SYNC	(	scope,
		level,
		fmt,
		...
	)

Value:

do {                                                                               \
    /* ------------------------------------------------------------------ */      \
    /* Validate scope and pick communicator *before* any early exits.     */      \
    /* ------------------------------------------------------------------ */      \
    MPI_Comm _comm;                                                                \
    if      ((scope) == LOCAL)  _comm = MPI_COMM_SELF;                             \
    else if ((scope) == GLOBAL) _comm = MPI_COMM_WORLD;                            \
    else {                                                                        \
        fprintf(stderr, "LOG_ALLOW_SYNC ERROR: invalid scope (%d) at %s:%d\n",     \
                (scope), __FILE__, __LINE__);                                      \
        MPI_Abort(MPI_COMM_WORLD, 1);                                              \
    }                                                                              \
                                                                                   \
    /* ------------------------------------------------------------------ */      \
    /* Decide whether *this* rank should actually print.                   */      \
    /* ------------------------------------------------------------------ */      \
    PetscBool _doPrint =                                                          \
        is_function_allowed(__func__) && ((int)(level) <= (int)get_log_level());   \
                                                                                   \
    if (_doPrint) {                                                                \
        PetscSynchronizedPrintf(_comm, "[%s] " fmt, __func__, ##__VA_ARGS__);      \
    }                                                                              \
                                                                                   \
    /* ------------------------------------------------------------------ */      \
    /* ALL ranks call the flush, even if they printed nothing.            */      \
    /* ------------------------------------------------------------------ */      \
    PetscSynchronizedFlush(_comm, PETSC_STDOUT);                                   \
} while (0)

----— DEBUG ---------------------------------------— #define LOG_ALLOW(scope, level, fmt, ...) \ do { \ MPI_Comm comm = (scope == LOCAL) ? MPI_COMM_SELF : MPI_COMM_WORLD; \ PetscInt current_level_val = get_log_level(); \ PetscBool __allowed_func_val = is_function_allowed(__func); \ Print BEFORE the check \ if (strcmp(func, "LocateAllParticlesInGrid") == 0) { \ printf("[DEBUG LOG_ALLOW in %s] Checking: level=%d, get_log_level() returned %d, func_allowed=%d\n", \ func, (int)level, (int)__current_level_val, (int)__allowed_func_val); \ } \ if ((int)(level) <= (int)__current_level_val && allowed_func_val) { \ Print AFTER passing the check // \ if (strcmp(__func, "LocateAllParticlesInGrid") == 0) { \ printf("[DEBUG LOG_ALLOW in %s] Check PASSED. Printing log.\n", func); \ } \ PetscPrintf(comm, "[%s] " fmt, func, ##__VA_ARGS__); \ } \

} while (0)

Synchronized logging macro that checks both the log level and whether the calling function is in the allow-list.

This macro uses PetscSynchronizedPrintf and PetscSynchronizedFlush to ensure messages from different ranks are printed in a rank-ordered fashion (i.e., to avoid interleaving). It also filters out messages if the current function is not in the allow-list (is_function_allowed(__func__)) or the requested log level is higher than get_log_level().

Parameters

scope	Either LOCAL (MPI_COMM_SELF) or GLOBAL (MPI_COMM_WORLD).
level	One of LOG_ERROR, LOG_WARNING, LOG_INFO, LOG_DEBUG.
fmt	A `printf`-style format string (e.g., "Message: %ld\n").
...	Variadic arguments to fill in `fmt`.

Example usage:

LOG_ALLOW_SYNC(LOCAL, LOG_DEBUG, "Debug info: rank = %ld\n", rank);

LOG_ALLOW_SYNC(GLOBAL, LOG_INFO, "Synchronized info in %s\n", __func__);

LOG_ALLOW_SYNC

#define LOG_ALLOW_SYNC(scope, level, fmt,...)

----— DEBUG ---------------------------------------— #define LOG_ALLOW(scope, level,...

Definition logging.h:274

LOG_INFO

@ LOG_INFO

Informational messages about program execution.

Definition logging.h:32

LOG_DEBUG

@ LOG_DEBUG

Detailed debugging information.

Definition logging.h:33

Definition at line 274 of file logging.h.

   {                                                                               \
    /* ------------------------------------------------------------------ */      \
    /* Validate scope and pick communicator *before* any early exits.     */      \
    /* ------------------------------------------------------------------ */      \
    MPI_Comm _comm;                                                                \
    if      ((scope) == LOCAL)  _comm = MPI_COMM_SELF;                             \
    else if ((scope) == GLOBAL) _comm = MPI_COMM_WORLD;                            \
    else {                                                                        \
        fprintf(stderr, "LOG_ALLOW_SYNC ERROR: invalid scope (%d) at %s:%d\n",     \
                (scope), __FILE__, __LINE__);                                      \
        MPI_Abort(MPI_COMM_WORLD, 1);                                              \
    }                                                                              \
                                                                                   \
    /* ------------------------------------------------------------------ */      \
    /* Decide whether *this* rank should actually print.                   */      \
    /* ------------------------------------------------------------------ */      \
    PetscBool _doPrint =                                                          \
        is_function_allowed(__func__) && ((int)(level) <= (int)get_log_level());   \
                                                                                   \
    if (_doPrint) {                                                                \
        PetscSynchronizedPrintf(_comm, "[%s] " fmt, __func__, ##__VA_ARGS__);      \
    }                                                                              \
                                                                                   \
    /* ------------------------------------------------------------------ */      \
    /* ALL ranks call the flush, even if they printed nothing.            */      \
    /* ------------------------------------------------------------------ */      \
    PetscSynchronizedFlush(_comm, PETSC_STDOUT);                                   \
} while (0)

◆ LOG_LOOP_ALLOW

#define LOG_LOOP_ALLOW	(	scope,
		level,
		iterVar,
		interval,
		fmt,
		...
	)

Value:

    do {                                                                       \
        if (is_function_allowed(__func__) && (int)(level) <= (int)get_log_level()) { \
            if ((iterVar) % (interval) == 0) {                                 \
                MPI_Comm comm = (scope == LOCAL) ? MPI_COMM_SELF : MPI_COMM_WORLD; \
                PetscPrintf(comm, "[%s] [%s=%d] " fmt,                       \
                            __func__, #iterVar, (iterVar), ##__VA_ARGS__);               \
            }                                                                  \
        }                                                                      \
    } while (0)

Logs a message inside a loop, but only every interval iterations.

Parameters

scope	LOCAL or GLOBAL.
level	LOG_* level.
iterVar	The loop variable (e.g., i).
interval	Only log when (iterVar % interval == 0).
fmt	printf-style format string.
...	Variadic arguments to include in the formatted message.

Example: for (int i = 0; i < 100; i++) { LOG_LOOP_ALLOW(LOCAL, LOG_DEBUG, i, 10, "Value of i=%d\n", i); }

Definition at line 319 of file logging.h.

       {                                                                       \
        if (is_function_allowed(__func__) && (int)(level) <= (int)get_log_level()) { \
            if ((iterVar) % (interval) == 0) {                                 \
                MPI_Comm comm = (scope == LOCAL) ? MPI_COMM_SELF : MPI_COMM_WORLD; \
                PetscPrintf(comm, "[%s] [%s=%d] " fmt,                       \
                            __func__, #iterVar, (iterVar), ##__VA_ARGS__);               \
            }                                                                  \
        }                                                                      \
    } while (0)

◆ LOG_LOOP_ALLOW_EXACT

#define LOG_LOOP_ALLOW_EXACT	(	scope,
		level,
		var,
		val,
		fmt,
		...
	)

Value:

    do {                                                                       \
        /* First, perform the cheap, standard gatekeeper checks. */            \
        if (is_function_allowed(__func__) && (int)(level) <= (int)get_log_level()) { \
            /* Only if those pass, check the user's specific condition. */      \
            if ((var) == (val)) {                                              \
                MPI_Comm comm = ((scope) == LOCAL) ? MPI_COMM_SELF : MPI_COMM_WORLD; \
                /* Print the standard prefix, then the user's custom message. */ \
                PetscPrintf(comm, "[%s] [%s=%d] " fmt,                          \
                    __func__, #var, (var), ##__VA_ARGS__);                      \
            }                                                                  \
        }                                                                      \
    } while (0)

Logs a custom message if a variable equals a specific value.

This is a variadic macro for logging a single event when a condition is met. It is extremely useful for printing debug information at a specific iteration of a loop or when a state variable reaches a certain value.

Parameters

scope	Either LOCAL or GLOBAL.
level	The logging level.
var	The variable to check (e.g., a loop counter 'k').
val	The value that triggers the log (e.g., 6). The log prints if var == val.
...	A printf-style format string and its corresponding arguments.

Definition at line 355 of file logging.h.

       {                                                                       \
        /* First, perform the cheap, standard gatekeeper checks. */            \
        if (is_function_allowed(__func__) && (int)(level) <= (int)get_log_level()) { \
            /* Only if those pass, check the user's specific condition. */      \
            if ((var) == (val)) {                                              \
                MPI_Comm comm = ((scope) == LOCAL) ? MPI_COMM_SELF : MPI_COMM_WORLD; \
                /* Print the standard prefix, then the user's custom message. */ \
                PetscPrintf(comm, "[%s] [%s=%d] " fmt,                          \
                    __func__, #var, (var), ##__VA_ARGS__);                      \
            }                                                                  \
        }                                                                      \
    } while (0)

◆ LOG_ARRAY_ELEMENT_ALLOW

#define LOG_ARRAY_ELEMENT_ALLOW	(	scope,
		level,
		arr,
		length,
		idx,
		fmt
	)

Value:

    do {                                                                      \
        if (is_function_allowed(__func__) && (int)(level) <= (int)get_log_level()) { \
            if ((idx) >= 0 && (idx) < (length)) {                             \
                MPI_Comm comm = (scope == LOCAL) ? MPI_COMM_SELF : MPI_COMM_WORLD; \
                PetscPrintf(comm, "[%s] arr[%d] = " fmt "\n",                 \
                            __func__, (idx), (arr)[idx]);                     \
            }                                                                 \
        }                                                                     \
    } while (0)

Logs a single element of an array, given an index.

Parameters

scope	Either LOCAL or GLOBAL.
level	LOG_ERROR, LOG_WARNING, LOG_INFO, or LOG_DEBUG.
arr	Pointer to the array to log from.
length	The length of the array (to prevent out-of-bounds).
idx	The index of the element to print.
fmt	The printf-style format specifier (e.g. "%g", "%f", etc.).

This macro only logs if: 1) The current function is in the allow-list (is_function_allowed(__func__)). 2) The requested logging level <= the current global get_log_level(). 3) The index idx is valid (0 <= idx < length).

Definition at line 384 of file logging.h.

       {                                                                      \
        if (is_function_allowed(__func__) && (int)(level) <= (int)get_log_level()) { \
            if ((idx) >= 0 && (idx) < (length)) {                             \
                MPI_Comm comm = (scope == LOCAL) ? MPI_COMM_SELF : MPI_COMM_WORLD; \
                PetscPrintf(comm, "[%s] arr[%d] = " fmt "\n",                 \
                            __func__, (idx), (arr)[idx]);                     \
            }                                                                 \
        }                                                                     \
    } while (0)

◆ LOG_ARRAY_SUBRANGE_ALLOW

#define LOG_ARRAY_SUBRANGE_ALLOW	(	scope,
		level,
		arr,
		length,
		start,
		end,
		fmt
	)

Value:

    do {                                                                      \
        if (is_function_allowed(__func__) && (int)(level) <= (int)get_log_level()) { \
            MPI_Comm comm = (scope == LOCAL) ? MPI_COMM_SELF : MPI_COMM_WORLD; \
            PetscInt _start = (start) < 0 ? 0 : (start);                      \
            PetscInt _end   = (end) >= (length) ? (length) - 1 : (end);       \
            for (PetscInt i = _start; i <= _end; i++) {                       \
                PetscPrintf(comm, "[%s] arr[%d] = " fmt "\n", __func__, i, (arr)[i]); \
            }                                                                 \
        }                                                                     \
    } while (0)

Logs a consecutive subrange of an array.

Parameters

scope	Either LOCAL or GLOBAL.
level	LOG_ERROR, LOG_WARNING, LOG_INFO, or LOG_DEBUG.
arr	Pointer to the array to log from.
length	Total length of the array.
start	Starting index of the subrange.
end	Ending index of the subrange (inclusive).
fmt	The printf-style format specifier (e.g., "%g", "%f").

This macro prints each element arr[i] for i in [start, end], bounded by [0, length-1].

Definition at line 408 of file logging.h.

       {                                                                      \
        if (is_function_allowed(__func__) && (int)(level) <= (int)get_log_level()) { \
            MPI_Comm comm = (scope == LOCAL) ? MPI_COMM_SELF : MPI_COMM_WORLD; \
            PetscInt _start = (start) < 0 ? 0 : (start);                      \
            PetscInt _end   = (end) >= (length) ? (length) - 1 : (end);       \
            for (PetscInt i = _start; i <= _end; i++) {                       \
                PetscPrintf(comm, "[%s] arr[%d] = " fmt "\n", __func__, i, (arr)[i]); \
            }                                                                 \
        }                                                                     \
    } while (0)

◆ LOG_FUNC_TIMER_BEGIN_EVENT

#define LOG_FUNC_TIMER_BEGIN_EVENT	(	eventID,
		scope
	)

Value:

    double __funcTimerStart = 0.0;                                              \
    PetscBool __funcTimerActive = PETSC_FALSE;                                  \
    do {                                                                        \
        if (is_function_allowed(__func__) && (int)(LOG_PROFILE) == (int)get_log_level()) { \
            PetscLogDouble _timeStamp = 0.0;                                    \
            PetscTime(&_timeStamp);                                             \
            __funcTimerStart = (double)_timeStamp;                              \
            __funcTimerActive = PETSC_TRUE;                                     \
            /* Start the PETSc log event (rank-wide). */                        \
            (void)PetscLogEventBegin(eventID, 0, 0, 0, 0);                            \
        }                                                                       \
    } while (0)

Begins timing a function by:

Starting a wall-clock timer (PetscTime).
Beginning a PETSc log event.

Parameters

eventID	A previously registered PetscLogEvent (e.g., EVENT_EvalPosition).
scope	LOCAL or GLOBAL (for potential later usage in logging).
level	LOG_ERROR, LOG_WARNING, LOG_INFO, LOG_DEBUG.

Example usage:

LOG_FUNC_TIMER_BEGIN_EVENT(EVENT_EvalPosition, LOCAL, LOG_DEBUG);
// ... function body ...
LOG_FUNC_TIMER_END_EVENT(EVENT_EvalPosition, LOCAL, LOG_DEBUG);

Definition at line 436 of file logging.h.

       {                                                                        \
        if (is_function_allowed(__func__) && (int)(LOG_PROFILE) == (int)get_log_level()) { \
            PetscLogDouble _timeStamp = 0.0;                                    \
            PetscTime(&_timeStamp);                                             \
            __funcTimerStart = (double)_timeStamp;                              \
            __funcTimerActive = PETSC_TRUE;                                     \
            /* Start the PETSc log event (rank-wide). */                        \
            (void)PetscLogEventBegin(eventID, 0, 0, 0, 0);                            \
        }                                                                       \
    } while (0)

◆ LOG_FUNC_TIMER_END_EVENT

#define LOG_FUNC_TIMER_END_EVENT	(	eventID,
		scope
	)

Value:

    do {                                                                        \
        if (__funcTimerActive == PETSC_TRUE) {                                  \
            /* End the PETSc log event */                                       \
            (void)PetscLogEventEnd(eventID, 0, 0, 0, 0);                              \
            /* Log the wall-clock elapsed time */                               \
            if (is_function_allowed(__func__) && (int)(LOG_PROFILE) == (int)get_log_level()) { \
                PetscLogDouble _timeEnd = 0.0;                                  \
                PetscTime(&_timeEnd);                                           \
                double elapsed = (double)_timeEnd - __funcTimerStart;           \
                MPI_Comm comm = (scope == LOCAL) ? MPI_COMM_SELF : MPI_COMM_WORLD; \
                PetscPrintf(comm, "[%s] Elapsed Time: %f seconds\n", __func__, elapsed); \
            }                                                                   \
        }                                                                       \
    } while (0)

Ends timing a function by:

Ending a PETSc log event.
Logging the wall-clock elapsed time, if active.

Parameters

eventID	The same PetscLogEvent handle passed to LOG_FUNC_TIMER_BEGIN_EVENT.
scope	LOCAL or GLOBAL for possible MPI_Comm usage.
level	The log level at which to print the timing message.

The log message is only printed if the function is in the allow-list and the current log level is >= the requested level.

Definition at line 462 of file logging.h.

       {                                                                        \
        if (__funcTimerActive == PETSC_TRUE) {                                  \
            /* End the PETSc log event */                                       \
            (void)PetscLogEventEnd(eventID, 0, 0, 0, 0);                              \
            /* Log the wall-clock elapsed time */                               \
            if (is_function_allowed(__func__) && (int)(LOG_PROFILE) == (int)get_log_level()) { \
                PetscLogDouble _timeEnd = 0.0;                                  \
                PetscTime(&_timeEnd);                                           \
                double elapsed = (double)_timeEnd - __funcTimerStart;           \
                MPI_Comm comm = (scope == LOCAL) ? MPI_COMM_SELF : MPI_COMM_WORLD; \
                PetscPrintf(comm, "[%s] Elapsed Time: %f seconds\n", __func__, elapsed); \
            }                                                                   \
        }                                                                       \
    } while (0)

◆ LOG_PROFILE_MSG

#define LOG_PROFILE_MSG	(	scope,
		fmt,
		...
	)

Value:

    do {                                                                     \
        if ((int)(LOG_PROFILE) <= (int)get_log_level()) {                    \
            MPI_Comm comm = (scope == LOCAL) ? MPI_COMM_SELF : MPI_COMM_WORLD; \
            PetscPrintf(comm, "[PROFILE] " fmt, ##__VA_ARGS__);              \
        }                                                                    \
    } while (0)

Definition at line 479 of file logging.h.

       {                                                                     \
        if ((int)(LOG_PROFILE) <= (int)get_log_level()) {                    \
            MPI_Comm comm = (scope == LOCAL) ? MPI_COMM_SELF : MPI_COMM_WORLD; \
            PetscPrintf(comm, "[PROFILE] " fmt, ##__VA_ARGS__);              \
        }                                                                    \
    } while (0)

◆ PROFILE_FUNCTION_BEGIN

#define PROFILE_FUNCTION_BEGIN _ProfilingStart(__FUNCT__)

Marks the beginning of a profiled code block (typically a function).

Place this macro at the very beginning of a function you wish to profile. It automatically captures the function's name and starts a wall-clock timer.

Definition at line 758 of file logging.h.

◆ PROFILE_FUNCTION_END

#define PROFILE_FUNCTION_END _ProfilingEnd(__FUNCT__)

Marks the end of a profiled code block.

Place this macro just before every return point in a function that starts with PROFILE_FUNCTION_BEGIN. It stops the timer and accumulates the results.

Definition at line 767 of file logging.h.

Enumeration Type Documentation

◆ LogLevel

enum LogLevel

Enumeration of logging levels.

Defines various severity levels for logging messages.

Enumerator
LOG_ERROR	Critical errors that may halt the program.
LOG_WARNING	Non-critical issues that warrant attention.
LOG_PROFILE	Exclusive log level for performance timing and profiling.
LOG_INFO	Informational messages about program execution.
LOG_DEBUG	Detailed debugging information.

Definition at line 28 of file logging.h.

             {
    LOG_ERROR = 0,   /**< Critical errors that may halt the program */
    LOG_WARNING,     /**< Non-critical issues that warrant attention */
    LOG_PROFILE,      /**< Exclusive log level for performance timing and profiling */
    LOG_INFO,        /**< Informational messages about program execution */
    LOG_DEBUG,       /**< Detailed debugging information */
} LogLevel;

Function Documentation

◆ get_log_level()

LogLevel get_log_level ( )

Retrieves the current logging level from the environment variable LOG_LEVEL.

The function checks the LOG_LEVEL environment variable and sets the logging level accordingly. Supported levels are "DEBUG", "INFO", "WARNING", and defaults to "ERROR" if not set or unrecognized.

Returns: LogLevel The current logging level.

The function checks the LOG_LEVEL environment variable and sets the logging level accordingly. Supported levels are "DEBUG", "INFO", "WARNING", and defaults to "ERROR" if not set or unrecognized. The log level is cached after the first call to avoid repeated environment variable checks.

Returns: LogLevel The current logging level.

Definition at line 49 of file logging.c.

                         {
    if (current_log_level == -1) { // Log level not set yet
        const char *env = getenv("LOG_LEVEL");
        if (!env) {
            current_log_level = LOG_ERROR; // Default level
        }
        else if (strcmp(env, "DEBUG") == 0) {
            current_log_level = LOG_DEBUG;
        }
        else if (strcmp(env, "INFO") == 0) {
            current_log_level = LOG_INFO;
        }
        else if (strcmp(env, "WARNING") == 0) {
            current_log_level = LOG_WARNING;
        }
        else if (strcmp(env, "PROFILE") == 0) {  // <-- New profile level
            current_log_level = LOG_PROFILE;
        }
        else {
            current_log_level = LOG_ERROR; // Default if unrecognized
        }
    }
    return current_log_level;
}

Here is the caller graph for this function:

◆ print_log_level()

PetscErrorCode print_log_level ( void )

Prints the current logging level to the console.

This function retrieves the log level using get_log_level() and prints the corresponding log level name. It helps verify the logging configuration at runtime.

The log levels supported are:

LOG_PROFILE (0) : Logs performance profiling details.
LOG_ERROR (1) : Logs only critical errors.
LOG_WARNING (2) : Logs warnings and errors.
LOG_INFO (3) : Logs general information, warnings, and errors.
LOG_DEBUG (4) : Logs debugging information, info, warnings, and errors.

Note: The log level is determined from the LOG_LEVEL environment variable. If LOG_LEVEL is not set, it defaults to LOG_INFO.

See also: get_log_level()

This function retrieves the log level using get_log_level() and prints the corresponding log level name. It helps verify the logging configuration at runtime.

Note: The log level is determined from the LOG_LEVEL environment variable. If LOG_LEVEL is not set, it defaults to LOG_INFO.

See also: get_log_level()

Definition at line 86 of file logging.c.

{
  PetscMPIInt     rank;
  PetscErrorCode  ierr;
  int             level;
  const char     *level_name;
 
  PetscFunctionBeginUser;
  /* get MPI rank */
  ierr = MPI_Comm_rank(PETSC_COMM_WORLD, &rank); CHKERRMPI(ierr);
 
  /* decide level name */
  level       = get_log_level();
  level_name = (level == LOG_ERROR)   ? "ERROR"   :
               (level == LOG_WARNING) ? "WARNING" :
               (level == LOG_INFO)    ? "INFO"    :
               (level == LOG_DEBUG)   ? "DEBUG"   :
               (level == LOG_PROFILE) ? "PROFILE" : "UNKNOWN";
 
  /* print it out */
  ierr = PetscPrintf(PETSC_COMM_SELF,
                     "Current log level: %s (%d) | rank: %d\n",
                     level_name, level, (int)rank);
  CHKERRMPI(ierr);
 
  PetscFunctionReturn(PETSC_SUCCESS);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_allowed_functions()

void set_allowed_functions	(	const char **	functionList,
		int	count
	)

Sets the global list of function names that are allowed to log.

You can replace the entire list of allowed function names at runtime.

Parameters

functionList	An array of function name strings (e.g., {"foo", "bar"}).
count	The number of entries in the array.

The existing allow-list is cleared and replaced by the new one. If you pass an empty list (count = 0), then no function will be allowed unless you change it later.

Definition at line 124 of file logging.c.

{
    // 1. Free any existing entries
    if (gAllowedFunctions) {
        for (int i = 0; i < gNumAllowed; ++i) {
            free(gAllowedFunctions[i]); // each was strdup'ed
        }
        free(gAllowedFunctions);
        gAllowedFunctions = NULL;
        gNumAllowed = 0;
    }
 
    // 2. Allocate new array
    if (count > 0) {
        gAllowedFunctions = (char**)malloc(sizeof(char*) * count);
    }
 
    // 3. Copy the new entries
    for (int i = 0; i < count; ++i) {
        // strdup is a POSIX function. If not available, implement your own string copy.
        gAllowedFunctions[i] = strdup(functionList[i]);
    }
    gNumAllowed = count;
}

Here is the caller graph for this function:

◆ is_function_allowed()

PetscBool is_function_allowed ( const char * functionName )

Checks if a given function is in the allow-list.

This helper is used internally by the LOG_ALLOW macro.

Checks if a given function is in the allow-list.

Parameters

functionName The name of the function to check.

Returns: PETSC_TRUE if functionName is allowed, otherwise PETSC_FALSE.

If no functions are in the list, nothing is allowed by default. You can reverse this logic if you prefer to allow everything unless specified otherwise.

Definition at line 159 of file logging.c.

{
    /* no list ⇒ allow all */
    if (gNumAllowed == 0) {
        return PETSC_TRUE;
    }
 
    /* otherwise only the listed functions are allowed */
    for (int i = 0; i < gNumAllowed; ++i) {
        if (strcmp(gAllowedFunctions[i], functionName) == 0) {
            return PETSC_TRUE;
        }
    }
    return PETSC_FALSE;
}

Here is the caller graph for this function:

◆ LOG_CELL_VERTICES()

PetscErrorCode LOG_CELL_VERTICES	(	const Cell *	cell,
		PetscMPIInt	rank
	)

Prints the coordinates of a cell's vertices.

This function iterates through the eight vertices of a given cell and prints their coordinates. It is primarily used for debugging purposes to verify the correctness of cell vertex assignments.

Parameters

[in]	cell	Pointer to a `Cell` structure representing the cell, containing its vertices.
[in]	rank	MPI rank for identification (useful in parallel environments).

Returns: PetscErrorCode Returns 0 to indicate successful execution. Non-zero on failure.

Note

Ensure that the cell pointer is not NULL before calling this function..

Definition at line 189 of file logging.c.

{
 
    // Validate input pointers
    if (cell == NULL) {
      LOG_ALLOW(LOCAL,LOG_ERROR, "LOG_CELL_VERTICES - 'cell' is NULL.\n");
        SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_NULL, "LOG_CELL_VERTICES - Input parameter 'cell' is NULL.");
    }
 
      LOG_ALLOW(LOCAL,LOG_DEBUG, "LOG_CELL_VERTICES - Rank %d, Cell Vertices:\n", rank);
        for(int i = 0; i < 8; i++){ 
      LOG_ALLOW(LOCAL,LOG_DEBUG, "  Vertex[%d]: (%.2f, %.2f, %.2f)\n", 
                       i, cell->vertices[i].x, cell->vertices[i].y, cell->vertices[i].z);
        }
 
    return 0; // Indicate successful execution
}

Here is the caller graph for this function:

◆ LOG_FACE_DISTANCES()

PetscErrorCode LOG_FACE_DISTANCES ( PetscReal * d )

Prints the signed distances to each face of the cell.

This function iterates through the six signed distances from a point to each face of a given cell and prints their values. It is primarily used for debugging purposes to verify the correctness of distance calculations.

Parameters

[in]

d

An array of six PetscReal values representing the signed distances. The indices correspond to:

d[LEFT]: Left Face
d[RIGHT]: Right Face
d[BOTTOM]: Bottom Face
d[TOP]: Top Face
d[FRONT]: Front Face
d[BACK]: Back Face

Returns: PetscErrorCode Returns 0 to indicate successful execution. Non-zero on failure.

Note

Ensure that the d array is correctly populated with signed distances before calling this function.

Definition at line 229 of file logging.c.

{
 
    // Validate input array
    if (d == NULL) {
      LOG_ALLOW(LOCAL,LOG_ERROR, " LOG_FACE_DISTANCES - 'd' is NULL.\n");
        SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_NULL, " LOG_FACE_DISTANCES - Input array 'd' is NULL.");
    }
 
    PetscPrintf(PETSC_COMM_SELF, " LOG_FACE_DISTANCES - Face Distances:\n");
    PetscPrintf(PETSC_COMM_SELF, "  LEFT(%d):   %.15f\n", LEFT, d[LEFT]);
    PetscPrintf(PETSC_COMM_SELF, "  RIGHT(%d):  %.15f\n", RIGHT, d[RIGHT]);
    PetscPrintf(PETSC_COMM_SELF, "  BOTTOM(%d): %.15f\n", BOTTOM, d[BOTTOM]);
    PetscPrintf(PETSC_COMM_SELF, "  TOP(%d):    %.15f\n", TOP, d[TOP]);
    PetscPrintf(PETSC_COMM_SELF, "  FRONT(%d):  %.15f\n", FRONT, d[FRONT]);
    PetscPrintf(PETSC_COMM_SELF, "  BACK(%d):   %.15f\n", BACK, d[BACK]);
 
    return 0; // Indicate successful execution
}

Here is the caller graph for this function:

◆ LOG_PARTICLE_FIELDS()

PetscErrorCode LOG_PARTICLE_FIELDS	(	UserCtx *	user,
		PetscInt	printInterval
	)

Prints particle fields in a table that automatically adjusts its column widths.

This function retrieves data from the particle swarm and prints a table where the width of each column is determined by the maximum width needed to display the data. Only every 'printInterval'-th particle is printed.

Parameters

[in]	user	Pointer to the UserCtx structure.
[in]	printInterval	Only every printInterval‑th particle is printed.

Returns: PetscErrorCode Returns 0 on success.

Definition at line 402 of file logging.c.

{
    DM swarm = user->swarm;
    PetscErrorCode ierr;
    PetscInt localNumParticles;
    PetscReal *positions = NULL;
    PetscInt64 *particleIDs = NULL;
    PetscMPIInt *particleRanks = NULL;
    PetscInt *cellIDs = NULL;
    PetscReal *weights = NULL;
    PetscReal *velocities = NULL;
    PetscMPIInt rank;
    
    ierr = MPI_Comm_rank(PETSC_COMM_WORLD, &rank); CHKERRQ(ierr);
    LOG_ALLOW(LOCAL,LOG_INFO, "PrintParticleFields - Rank %d is retrieving particle data.\n", rank);
 
    ierr = DMSwarmGetLocalSize(swarm, &localNumParticles); CHKERRQ(ierr);
    LOG_ALLOW(LOCAL,LOG_DEBUG,"PrintParticleFields - Rank %d has %d particles.\n", rank, localNumParticles);
 
    ierr = DMSwarmGetField(swarm, "position", NULL, NULL, (void**)&positions); CHKERRQ(ierr);
    ierr = DMSwarmGetField(swarm, "DMSwarm_pid", NULL, NULL, (void**)&particleIDs); CHKERRQ(ierr);
    ierr = DMSwarmGetField(swarm, "DMSwarm_rank", NULL, NULL, (void**)&particleRanks); CHKERRQ(ierr);
    ierr = DMSwarmGetField(swarm, "DMSwarm_CellID", NULL, NULL, (void**)&cellIDs); CHKERRQ(ierr);
    ierr = DMSwarmGetField(swarm, "weight", NULL, NULL, (void**)&weights); CHKERRQ(ierr);
    ierr = DMSwarmGetField(swarm, "velocity", NULL, NULL, (void**)&velocities); CHKERRQ(ierr);
    
    /* Compute maximum column widths. */
    int wRank, wPID, wCell, wPos, wVel, wWt;
    wRank = wPID = wCell = wPos = wVel = wWt = 0;
    ierr = ComputeMaxColumnWidths(localNumParticles, particleRanks, particleIDs, cellIDs,
                                  positions, velocities, weights,
                                  &wRank, &wPID, &wCell, &wPos, &wVel, &wWt); CHKERRQ(ierr);
 
    /* Build a header string and a row format string. */
    char headerFmt[256];
    char rowFmt[256];
    BuildHeaderString(headerFmt, sizeof(headerFmt), wRank, wPID, wCell, wPos, wVel, wWt);
    BuildRowFormatString(wRank, wPID, wCell, wPos, wVel, wWt, rowFmt, sizeof(rowFmt));
    
    /* Print header (using synchronized printing for parallel output). */
    ierr = PetscSynchronizedPrintf(PETSC_COMM_WORLD, "--------------------------------------------------------------------------------------------------------------\n"); CHKERRQ(ierr);
    ierr = PetscSynchronizedPrintf(PETSC_COMM_WORLD, "%s", headerFmt); CHKERRQ(ierr);
    ierr = PetscSynchronizedPrintf(PETSC_COMM_WORLD, "--------------------------------------------------------------------------------------------------------------\n"); CHKERRQ(ierr);
    
    /* Loop over particles and print every printInterval-th row. */
    char rowStr[256];
    for (PetscInt i = 0; i < localNumParticles; i++) {
        if (i % printInterval == 0) {
      // ------- DEBUG 
      //char cellStr[TMP_BUF_SIZE], posStr[TMP_BUF_SIZE], velStr[TMP_BUF_SIZE], wtStr[TMP_BUF_SIZE];
      //CellToStr(&cellIDs[3*i], cellStr, TMP_BUF_SIZE);
      //TripleRealToStr(&positions[3*i], posStr, TMP_BUF_SIZE);
      //TripleRealToStr(&velocities[3*i], velStr, TMP_BUF_SIZE);
      // TripleRealToStr(&weights[3*i], wtStr, TMP_BUF_SIZE);
            
      // if (rank == 0) { // Or whatever rank is Rank 0
        //PetscPrintf(PETSC_COMM_SELF, "[Rank 0 DEBUG LPF] Particle %lld: PID=%lld, Rank=%d\n", (long long)i, (long long)particleIDs[i], particleRanks[i]);
        //PetscPrintf(PETSC_COMM_SELF, "[Rank 0 DEBUG LPF] Raw Pos: (%.10e, %.10e, %.10e)\n", positions[3*i+0], positions[3*i+1], positions[3*i+2]);
        //PetscPrintf(PETSC_COMM_SELF, "[Rank 0 DEBUG LPF] Str Pos: %s\n", posStr);
        //PetscPrintf(PETSC_COMM_SELF, "[Rank 0 DEBUG LPF] Raw Vel: (%.10e, %.10e, %.10e)\n", velocities[3*i+0], velocities[3*i+1], velocities[3*i+2]);
        // PetscPrintf(PETSC_COMM_SELF, "[Rank 0 DEBUG LPF] Str Vel: %s\n", velStr);
        // Add similar for cell, weights
        // PetscPrintf(PETSC_COMM_SELF, "[Rank 0 DEBUG LPF] About to build rowStr for particle %lld\n", (long long)i);
        //  fflush(stdout);
        // }
 
      //  snprintf(rowStr, sizeof(rowStr), rowFmt,
          //           particleRanks[i],
          //           particleIDs[i],
          //           cellStr,
          //           posStr,
          //           velStr,
      //         wtStr);
 
         
         //    ierr = PetscSynchronizedPrintf(PETSC_COMM_WORLD, "%s", rowStr); CHKERRQ(ierr);
      
         // ierr = PetscSynchronizedPrintf(PETSC_COMM_WORLD, "%s", rowStr); CHKERRQ(ierr); 
      
      // -------- DEBUG
            /* Format the row by converting each field to a string first.
             * We use temporary buffers and then build the row string.
             */
      
       char cellStr[TMP_BUF_SIZE], posStr[TMP_BUF_SIZE], velStr[TMP_BUF_SIZE], wtStr[TMP_BUF_SIZE];
            CellToStr(&cellIDs[3*i], cellStr, TMP_BUF_SIZE);
            TripleRealToStr(&positions[3*i], posStr, TMP_BUF_SIZE);
            TripleRealToStr(&velocities[3*i], velStr, TMP_BUF_SIZE);
            TripleRealToStr(&weights[3*i], wtStr, TMP_BUF_SIZE);
            
            /* Build the row string. Note that for the integer fields we can use the row format string. */
            snprintf(rowStr, sizeof(rowStr), rowFmt,
                     particleRanks[i],
                     particleIDs[i],
                     cellStr,
                     posStr,
                     velStr,
                     wtStr);
     ierr = PetscSynchronizedPrintf(PETSC_COMM_WORLD, "%s", rowStr); CHKERRQ(ierr);
        }
    }
 
 
    ierr = PetscSynchronizedPrintf(PETSC_COMM_WORLD, "--------------------------------------------------------------------------------------------------------------\n"); CHKERRQ(ierr);
    ierr = PetscSynchronizedPrintf(PETSC_COMM_WORLD, "\n"); CHKERRQ(ierr);
    ierr = PetscSynchronizedFlush(PETSC_COMM_WORLD, PETSC_STDOUT); CHKERRQ(ierr);
 
    LOG_ALLOW_SYNC(GLOBAL,LOG_DEBUG,"PrintParticleFields - Completed printing on Rank %d.\n", rank);
 
    /* Restore fields */
    ierr = DMSwarmRestoreField(swarm, "position", NULL, NULL, (void**)&positions); CHKERRQ(ierr);
    ierr = DMSwarmRestoreField(swarm, "DMSwarm_pid", NULL, NULL, (void**)&particleIDs); CHKERRQ(ierr);
    ierr = DMSwarmRestoreField(swarm, "DMSwarm_rank", NULL, NULL, (void**)&particleRanks); CHKERRQ(ierr);
    ierr = DMSwarmRestoreField(swarm, "DMSwarm_CellID", NULL, NULL, (void**)&cellIDs); CHKERRQ(ierr);
    ierr = DMSwarmRestoreField(swarm, "weight", NULL, NULL, (void**)&weights); CHKERRQ(ierr);
    ierr = DMSwarmRestoreField(swarm, "velocity", NULL, NULL, (void**)&velocities); CHKERRQ(ierr);
 
    LOG_ALLOW(LOCAL,LOG_DEBUG, "PrintParticleFields - Restored all particle fields.\n");
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FreeAllowedFunctions()

PetscErrorCode FreeAllowedFunctions	(	char **	funcs,
		PetscInt	n
	)

Free an array previously returned by LoadAllowedFunctionsFromFile().

Parameters

[in,out]	funcs	Array of strings to release (may be `NULL`).
[in]	n	Number of entries in `funcs`. Ignored if `funcs` is `NULL`.

Returns: 0 on success or a PETSc error code.

Definition at line 627 of file logging.c.

{
  PetscErrorCode ierr;
  PetscFunctionBegin;
  if (funcs) {
    for (PetscInt i = 0; i < n; ++i) {
      ierr = PetscFree(funcs[i]); CHKERRQ(ierr);
    }
    ierr = PetscFree(funcs); CHKERRQ(ierr);
  }
  PetscFunctionReturn(0);
}

◆ LoadAllowedFunctionsFromFile()

PetscErrorCode LoadAllowedFunctionsFromFile	(	const char	filename[],
		char ***	funcsOut,
		PetscInt *	nOut
	)

Load function names from a text file.

The file is expected to contain one identifier per line. Blank lines and lines whose first non‑blank character is a # are silently skipped so the file can include comments. Example:

# Allowed function list
main
InitializeSimulation
InterpolateAllFieldsToSwarm  # inline comments are OK, too

The routine allocates memory as needed (growing an internal buffer with PetscRealloc()) and returns the resulting array and its length to the caller. Use FreeAllowedFunctions() to clean up when done.

Parameters

[in]	filename	Path of the configuration file to read.
[out]	funcsOut	On success, points to a freshly‑allocated array of `char*` (size `nOut`).
[out]	nOut	Number of valid entries in `funcsOut`.

Returns: 0 on success, or a PETSc error code on failure (e.g. I/O error, OOM).

Definition at line 568 of file logging.c.

{
  FILE          *fp    = NULL;
  char         **funcs = NULL;
  size_t         cap   = 16;   /* initial capacity */
  size_t         n     = 0;    /* number of names  */
  char           line[PETSC_MAX_PATH_LEN];
  PetscErrorCode ierr;
 
  PetscFunctionBegin;
 
  /* ---------------------------------------------------------------------- */
  /* 1. Open file                                                           */
  fp = fopen(filename, "r");
  if (!fp) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_FILE_OPEN,
                    "Cannot open %s", filename);
 
  /* 2. Allocate initial pointer array                                      */
  ierr = PetscMalloc1(cap, &funcs); CHKERRQ(ierr);
 
  /* 3. Read file line by line                                              */
  while (fgets(line, sizeof line, fp)) {
    /* Strip everything after a comment character '#'. */
    char *hash = strchr(line, '#');
    if (hash) *hash = '\0';
 
    trim(line);                 /* remove leading/trailing blanks */
    if (!*line) continue;       /* skip if empty                  */
 
    /* Grow the array if necessary */
    if (n == cap) {
      cap *= 2;
      ierr = PetscRealloc(cap * sizeof(*funcs), (void **)&funcs); CHKERRQ(ierr);
    }
 
    /* Deep‑copy the cleaned identifier */
    ierr = PetscStrallocpy(line, &funcs[n++]); CHKERRQ(ierr);
  }
  fclose(fp);
 
  /* 4. Return results to caller                                           */
  *funcsOut = funcs;
  *nOut     = (PetscInt)n;
 
  PetscFunctionReturn(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BCFaceToString()

const char * BCFaceToString ( BCFace face )

Helper function to convert BCFace enum to a string representation.

Parameters

[in] face The BCFace enum value.

Returns: Pointer to a constant string representing the face.

Definition at line 645 of file logging.c.

                                        {
    switch (face) {
        case BC_FACE_NEG_X: return "-Xi (I-Min)";
        case BC_FACE_POS_X: return "+Xi (I-Max)";
        case BC_FACE_NEG_Y: return "-Eta (J-Min)";
        case BC_FACE_POS_Y: return "+Eta (J-Max)";
        case BC_FACE_NEG_Z: return "-Zeta (K-Min)";
        case BC_FACE_POS_Z: return "+Zeta (K-Max)";
        default:            return "Unknown Face";
    }
}

Here is the caller graph for this function:

◆ BCTypeToString()

const char * BCTypeToString ( BCType type )

Helper function to convert BCType enum to a string representation.

Parameters

[in] type The BCType enum value.

Returns: Pointer to a constant string representing the BC type.

Definition at line 662 of file logging.c.

                                        {
    switch (type) {
      //  case DIRICHLET: return "DIRICHLET";
      //  case NEUMANN:   return "NEUMANN";
        case WALL:      return "WALL";
        case INLET:     return "INLET";
        case OUTLET:    return "OUTLET";
        case FARFIELD:  return "FARFIELD";
        case PERIODIC:  return "PERIODIC";
        case INTERFACE: return "INTERFACE";
        case NOGRAD:    return "NOGRAD";
 
    // case CUSTOM:    return "CUSTOM";
        default:        return "Unknown BC Type";
    }
}

Here is the caller graph for this function:

◆ BCHandlerTypeToString()

const char * BCHandlerTypeToString ( BCHandlerType handler_type )

Converts a BCHandlerType enum to its string representation.

Provides a descriptive string for a specific boundary condition implementation strategy. This is crucial for logging the exact behavior configured for a face.

Parameters

handler_type The BCHandlerType enum value (e.g., BC_HANDLER_WALL_NOSLIP).

Returns: A constant character string corresponding to the enum. Returns "UNKNOWN_HANDLER" if the enum value is not recognized.

Definition at line 689 of file logging.c.

                                                              {
    switch (handler_type) {
        // Wall & Symmetry Handlers
        case BC_HANDLER_WALL_NOSLIP:             return "noslip";
        case BC_HANDLER_WALL_MOVING:             return "moving";
        case BC_HANDLER_SYMMETRY_PLANE:          return "symmetry_plane";
 
        // Inlet Handlers
        case BC_HANDLER_INLET_CONSTANT_VELOCITY: return "constant_velocity";
        case BC_HANDLER_INLET_PULSANTILE_FLUX:   return "pulsatile_flux";
        case BC_HANDLER_INLET_PARABOLIC: return "parabolic";
 
        // Outlet Handlers
        case BC_HANDLER_OUTLET_CONSERVATION:     return "conservation";
        case BC_HANDLER_OUTLET_PRESSURE:         return "pressure";
 
        // Other Physical Handlers
        case BC_HANDLER_FARFIELD_NONREFLECTING:  return "nonreflecting";
        case BC_HANDLER_NOGRAD_COPY_GHOST: return "no_gradient";
 
        // Multi-Block / Interface Handlers
        case BC_HANDLER_PERIODIC:                return "periodic";
        case BC_HANDLER_INTERFACE_OVERSET:       return "overset";
 
        // Default case
        case BC_HANDLER_UNDEFINED:
        default:                                 return "UNKNOWN_HANDLER";
    }
}

Here is the caller graph for this function:

◆ DualKSPMonitor()

PetscErrorCode DualKSPMonitor	(	KSP	ksp,
		PetscInt	it,
		PetscReal	rnorm,
		void *	ctx
	)

A custom KSP monitor that logs to a file and optionally to the console.

This function unconditionally calls the standard true residual monitor to log to a file viewer provided in the context. It also checks a flag in the context and, if true, calls the monitor again to log to standard output.

Parameters

ksp	The Krylov subspace context.
it	The current iteration number.
rnorm	The preconditioned residual norm.
ctx	A pointer to the DualMonitorCtx structure.

Returns: PetscErrorCode 0 on success.

Definition at line 759 of file logging.c.

{
    DualMonitorCtx *monctx = (DualMonitorCtx*)ctx;
    PetscErrorCode ierr;
    PetscReal      trnorm, relnorm;
    Vec            r;
    char           norm_buf[256];
    PetscMPIInt    rank;
 
    PetscFunctionBeginUser;
    ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&rank); CHKERRQ(ierr);
 
    // 1. Calculate the true residual norm.
    ierr = KSPBuildResidual(ksp, NULL, NULL, &r); CHKERRQ(ierr);
    ierr = VecNorm(r, NORM_2, &trnorm); CHKERRQ(ierr);
 
    // 2. On the first iteration, compute and store the norm of the RHS vector `b`.
    if (it == 0) {
        Vec b;
        ierr = KSPGetRhs(ksp, &b); CHKERRQ(ierr);
        ierr = VecNorm(b, NORM_2, &monctx->bnorm); CHKERRQ(ierr);
    }
 
    if(!rank){
    // 3. Compute the relative norm and format the output string.
    if (monctx->bnorm > 1.e-15) {
      relnorm = trnorm / monctx->bnorm;
      sprintf(norm_buf, "ts: %-5d | block: %-2d | iter: %-3d | Unprecond Norm: %12.5e | True Norm: %12.5e | Rel Norm: %12.5e",(int)monctx->step, (int)monctx->block_id, (int)it, (double)rnorm, (double)trnorm, (double)relnorm);
    } else {
      sprintf(norm_buf,"ts: %-5d | block: %-2d | iter: %-3d | Unprecond Norm: %12.5e | True Norm: %12.5e",(int)monctx->step, (int)monctx->block_id, (int)it, (double)rnorm, (double)trnorm);
    }
 
    // 4. Log to the file viewer (unconditionally).
    if(monctx->file_handle){
      ierr = PetscFPrintf(PETSC_COMM_SELF,monctx->file_handle,"%s\n", norm_buf); CHKERRQ(ierr);
    }
    // 5. Log to the console (conditionally).
    if (monctx->log_to_console) {
      PetscFPrintf(PETSC_COMM_SELF,stdout, "%s\n", norm_buf); CHKERRQ(ierr);
    }
 
    } //rank
 
    PetscFunctionReturn(0);
}

Here is the caller graph for this function:

◆ DualMonitorDestroy()

PetscErrorCode DualMonitorDestroy ( void ** ctx )

Destroys the DualMonitorCtx.

This function is passed to KSPMonitorSet to ensure the viewer is properly destroyed and the context memory is freed when the KSP is destroyed.

Parameters

Ctx	a pointer to the context pointer to be destroyed

Returns: PetscErrorCode

Definition at line 727 of file logging.c.

{
    DualMonitorCtx *monctx = (DualMonitorCtx*)*ctx;
    PetscErrorCode ierr;
    PetscMPIInt    rank;
    
    PetscFunctionBeginUser;
    ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&rank); CHKERRQ(ierr);
    if(!rank && monctx->file_handle){
      fclose(monctx->file_handle);
    }
    
    ierr = PetscFree(monctx); CHKERRQ(ierr);
    *ctx = NULL;
    PetscFunctionReturn(0);
}

Here is the caller graph for this function:

◆ LOG_CONTINUITY_METRICS()

PetscErrorCode LOG_CONTINUITY_METRICS ( UserCtx * user )

Logs continuity metrics for a single block to a file.

This function should be called for each block, once per timestep. It opens a central log file in append mode. To ensure the header is written only once, it checks if it is processing block 0 on the simulation's start step.

Parameters

user	A pointer to the UserCtx for the specific block whose metrics are to be logged. The function accesses both global (SimCtx) and local (user->...) data.

Returns: PetscErrorCode 0 on success.

Definition at line 819 of file logging.c.

{
    PetscErrorCode ierr;
    PetscMPIInt    rank;
    SimCtx         *simCtx = user->simCtx;      // Get the shared SimCtx
    const PetscInt bi = user->_this;          // Get this block's specific ID
    const PetscInt ti = simCtx->step;         // Get the current timestep
 
    PetscFunctionBeginUser;
    ierr = MPI_Comm_rank(PETSC_COMM_WORLD, &rank); CHKERRQ(ierr);
 
    // Only rank 0 performs file I/O.
    if (!rank) {
        FILE *f;
        char filen[128];
        sprintf(filen, "logs/Continuity_Metrics.log");
 
        // Open the log file in append mode.
        f = fopen(filen, "a");
        if (!f) {
            SETERRQ(PETSC_COMM_SELF, PETSC_ERR_FILE_OPEN, "Cannot open log file: %s", filen);
        }
 
        // Write a header only for the very first block (bi=0) on the very
        // first timestep (ti=StartStep). This ensures it's written only once.
        if (ti == simCtx->StartStep && bi == 0) {
            PetscFPrintf(PETSC_COMM_SELF, f, "%-10s | %-6s | %-18s | %-30s | %-18s | %-18s | %-18s | %-18s\n",
                         "Timestep", "Block", "Max Divergence", "Max Divergence Location ([k][j][i]=idx)", "Sum(RHS)","Total Flux In", "Total Flux Out", "Net Flux");
            PetscFPrintf(PETSC_COMM_SELF, f, "------------------------------------------------------------------------------------------------------------------------------------------\n");
        }
 
        // Prepare the data strings and values for the current block.
        PetscReal net_flux = simCtx->FluxInSum - simCtx->FluxOutSum;
        char location_str[64];
        sprintf(location_str, "([%d][%d][%d] = %d)", (int)simCtx->MaxDivz, (int)simCtx->MaxDivy, (int)simCtx->MaxDivx, (int)simCtx->MaxDivFlatArg);
 
        // Write the formatted line for the current block.
        PetscFPrintf(PETSC_COMM_SELF, f, "%-10d | %-6d | %-18.10e | %-39s | %-18.10e | %-18.10e | %-18.10e | %-18.10e\n",
                     (int)ti,
                     (int)bi,
                     (double)simCtx->MaxDiv,
                     location_str,
                     (double)simCtx->summationRHS,
             (double)simCtx->FluxInSum,
                     (double)simCtx->FluxOutSum,
                     (double)net_flux);
 
        fclose(f);
    }
 
    PetscFunctionReturn(0);
}

Here is the caller graph for this function:

◆ ParticleLocationStatusToString()

const char * ParticleLocationStatusToString ( ParticleLocationStatus level )

A function that outputs the name of the current level in the ParticleLocation enum.

Parameters

level The ParticleLocation enum value.

Returns: A constant character string corresponding to the enum. Returns "UNKNOWN_LEVEL" if the enum value is not recognized.

Definition at line 878 of file logging.c.

{
    switch (level) {
        case NEEDS_LOCATION:        return "NEEDS_LOCATION";
        case ACTIVE_AND_LOCATED: return "ACTIVE_AND_LOCATED";
        case MIGRATING_OUT:     return "MIGRATING_OUT";
        case LOST:               return "LOST";
        case UNINITIALIZED:      return "UNINITIALIZED";
        default:            return "UNKNOWN_LEVEL";
    }
}

◆ ProfilingInitialize()

PetscErrorCode ProfilingInitialize ( SimCtx * simCtx )

Initializes the custom profiling system using configuration from SimCtx.

This function sets up the internal data structures for tracking function performance. It reads the list of "critical functions" from the provided SimCtx and marks them for per-step logging at LOG_INFO level.

It should be called once at the beginning of the application, after CreateSimulationContext() but before the main time loop.

Parameters

simCtx The master simulation context, which contains the list of critical function names to always log.

Returns: PetscErrorCode

Definition at line 955 of file logging.c.

{
    PetscFunctionBeginUser;
    if (!simCtx) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_NULL, "SimCtx cannot be null for ProfilingInitialize");
 
    // Iterate through the list of critical functions provided in SimCtx
    for (PetscInt i = 0; i < simCtx->nCriticalFuncs; ++i) {
        PetscInt idx;
        const char *func_name = simCtx->criticalFuncs[i];
        PetscErrorCode ierr = _FindOrCreateEntry(func_name, &idx); CHKERRQ(ierr);
        g_profiler_registry[idx].always_log = PETSC_TRUE;
 
        LOG_ALLOW(GLOBAL, LOG_DEBUG, "Marked '%s' as a critical function for profiling.\n", func_name);
    }
    PetscFunctionReturn(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ProfilingLogTimestepSummary()

PetscErrorCode ProfilingLogTimestepSummary ( PetscInt step )

Logs the performance summary for the current timestep and resets timers.

Depending on the current log level, this function will print:

LOG_PROFILE: Timings for ALL functions called during the step.
LOG_INFO/LOG_DEBUG: Timings for only the "always log" functions.

It must be called once per timestep, typically at the end of the main loop. After logging, it resets the per-step counters and timers.

Parameters

step	The current simulation step number, for logging context.

Returns: PetscErrorCode

Definition at line 994 of file logging.c.

{
    LogLevel log_level = get_log_level();
    PetscBool should_print = PETSC_FALSE;
 
    PetscFunctionBeginUser;
 
    // Decide if we should print anything at all
    if (log_level >= LOG_INFO) {
        for (PetscInt i = 0; i < g_profiler_count; ++i) {
            if (g_profiler_registry[i].current_step_call_count > 0) {
                 if (log_level == LOG_PROFILE || g_profiler_registry[i].always_log) {
                    should_print = PETSC_TRUE;
                    break;
                 }
            }
        }
    }
    
    if (should_print) {
        PetscPrintf(MPI_COMM_WORLD, "[PROFILE] ----- Timestep %d Summary -----\n", step);
        for (PetscInt i = 0; i < g_profiler_count; ++i) {
            if (g_profiler_registry[i].current_step_call_count > 0) {
                if (log_level == LOG_PROFILE || g_profiler_registry[i].always_log) {
                    PetscPrintf(MPI_COMM_WORLD, "[PROFILE]   %-25s: %.6f s (%lld calls)\n",
                                g_profiler_registry[i].name,
                                g_profiler_registry[i].current_step_time,
                                g_profiler_registry[i].current_step_call_count);
                }
            }
        }
    }
 
    // Reset per-step counters for the next iteration
    for (PetscInt i = 0; i < g_profiler_count; ++i) {
        g_profiler_registry[i].current_step_time = 0.0;
        g_profiler_registry[i].current_step_call_count = 0;
    }
    PetscFunctionReturn(0);
}

Here is the call graph for this function:

◆ ProfilingFinalize()

PetscErrorCode ProfilingFinalize ( void )

Prints the final, cumulative performance summary and cleans up resources.

This should be called once at the end of the simulation, before PetscFinalize(). It prints a table with total time, call count, and average time per call for every function that was profiled. This summary is only printed if the log level is LOG_PROFILE.

Returns: PetscErrorCode

Definition at line 1046 of file logging.c.

{
    PetscFunctionBeginUser;
    if (get_log_level() >= LOG_PROFILE) {
        
        // --- Step 1: Sort the data for readability ---
        qsort(g_profiler_registry, g_profiler_count, sizeof(ProfiledFunction), _CompareProfiledFunctions);
 
        // --- Step 2: Dynamically determine the width for the function name column ---
        PetscInt max_name_len = strlen("Function"); // Start with the header's length
        for (PetscInt i = 0; i < g_profiler_count; ++i) {
            if (g_profiler_registry[i].total_call_count > 0) {
                PetscInt len = strlen(g_profiler_registry[i].name);
                if (len > max_name_len) {
                    max_name_len = len;
                }
            }
        }
        // Add a little padding
        max_name_len += 2; 
 
        // --- Step 3: Define fixed widths for numeric columns for consistent alignment ---
        const int time_width = 18;
        const int count_width = 15;
        const int avg_width = 22;
 
        // --- Step 4: Print the formatted table ---
        PetscPrintf(MPI_COMM_WORLD, "\n=======================================================================================\n");
        PetscPrintf(MPI_COMM_WORLD, "                         FINAL PROFILING SUMMARY (Sorted by Total Time)\n");
        PetscPrintf(MPI_COMM_WORLD, "=======================================================================================\n");
        
        // Header Row
        PetscPrintf(MPI_COMM_WORLD, "%-*s | %-*s | %-*s | %-*s\n",
                    max_name_len, "Function",
                    time_width, "Total Time (s)",
                    count_width, "Call Count",
                    avg_width, "Avg. Time/Call (ms)");
        
        // Separator Line (dynamically sized)
        for (int i = 0; i < max_name_len; i++) PetscPrintf(MPI_COMM_WORLD, "-");
        PetscPrintf(MPI_COMM_WORLD, "-|-");
        for (int i = 0; i < time_width; i++) PetscPrintf(MPI_COMM_WORLD, "-");
        PetscPrintf(MPI_COMM_WORLD, "-|-");
        for (int i = 0; i < count_width; i++) PetscPrintf(MPI_COMM_WORLD, "-");
        PetscPrintf(MPI_COMM_WORLD, "-|-");
        for (int i = 0; i < avg_width; i++) PetscPrintf(MPI_COMM_WORLD, "-");
        PetscPrintf(MPI_COMM_WORLD, "\n");
 
        // Data Rows
        for (PetscInt i = 0; i < g_profiler_count; ++i) {
            if (g_profiler_registry[i].total_call_count > 0) {
                double avg_time_ms = (g_profiler_registry[i].total_time / g_profiler_registry[i].total_call_count) * 1000.0;
                PetscPrintf(MPI_COMM_WORLD, "%-*s | %*.*f | %*lld | %*.*f\n",
                            max_name_len, g_profiler_registry[i].name,
                            time_width, 6, g_profiler_registry[i].total_time,
                            count_width, g_profiler_registry[i].total_call_count,
                            avg_width, 6, avg_time_ms);
            }
        }
        PetscPrintf(MPI_COMM_WORLD, "=======================================================================================\n");
    }
 
    // --- Final Cleanup ---
    PetscFree(g_profiler_registry);
    g_profiler_registry = NULL;
    g_profiler_count = 0;
    g_profiler_capacity = 0;
    PetscFunctionReturn(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _ProfilingStart()

void _ProfilingStart ( const char * func_name )

Definition at line 972 of file logging.c.

{
    PetscInt idx;
    if (_FindOrCreateEntry(func_name, &idx) != 0) return; // Fail silently
    PetscTime(&g_profiler_registry[idx].start_time);
}

Here is the call graph for this function:

◆ _ProfilingEnd()

void _ProfilingEnd ( const char * func_name )

Definition at line 979 of file logging.c.

{
    double end_time;
    PetscTime(&end_time);
 
    PetscInt idx;
    if (_FindOrCreateEntry(func_name, &idx) != 0) return; // Fail silently
 
    double elapsed = end_time - g_profiler_registry[idx].start_time;
    g_profiler_registry[idx].total_time += elapsed;
    g_profiler_registry[idx].current_step_time += elapsed;
    g_profiler_registry[idx].total_call_count++;
    g_profiler_registry[idx].current_step_call_count++;
}

Here is the call graph for this function:

Variable Documentation

◆ EVENT_Individualwalkingsearch

PetscLogEvent EVENT_Individualwalkingsearch

extern

Definition at line 33 of file logging.c.

◆ EVENT_walkingsearch

PetscLogEvent EVENT_walkingsearch

extern

Definition at line 34 of file logging.c.

◆ EVENT_GlobalParticleLocation

PetscLogEvent EVENT_GlobalParticleLocation

extern

Definition at line 35 of file logging.c.

◆ EVENT_IndividualLocation

PetscLogEvent EVENT_IndividualLocation

extern

Definition at line 36 of file logging.c.

Data Structures

Macros

Enumerations

Functions

Variables

Detailed Description

Data Structure Documentation

◆ DualMonitorCtx

Macro Definition Documentation

◆ LOCAL

◆ GLOBAL

◆ LOG

◆ LOG_DEFAULT

◆ LOG_SYNC

◆ LOG_SYNC_DEFAULT

◆ LOG_ALLOW

◆ LOG_ALLOW_SYNC

} while (0)

◆ LOG_LOOP_ALLOW

◆ LOG_LOOP_ALLOW_EXACT

◆ LOG_ARRAY_ELEMENT_ALLOW

◆ LOG_ARRAY_SUBRANGE_ALLOW

◆ LOG_FUNC_TIMER_BEGIN_EVENT

◆ LOG_FUNC_TIMER_END_EVENT

◆ LOG_PROFILE_MSG

◆ PROFILE_FUNCTION_BEGIN

◆ PROFILE_FUNCTION_END

Enumeration Type Documentation

◆ LogLevel

Function Documentation

◆ get_log_level()

◆ print_log_level()

◆ set_allowed_functions()

◆ is_function_allowed()

◆ LOG_CELL_VERTICES()

◆ LOG_FACE_DISTANCES()

◆ LOG_PARTICLE_FIELDS()

◆ FreeAllowedFunctions()

◆ LoadAllowedFunctionsFromFile()

◆ BCFaceToString()

◆ BCTypeToString()

◆ BCHandlerTypeToString()

◆ DualKSPMonitor()

◆ DualMonitorDestroy()

◆ LOG_CONTINUITY_METRICS()

◆ ParticleLocationStatusToString()

◆ ProfilingInitialize()

◆ ProfilingLogTimestepSummary()

◆ ProfilingFinalize()

◆ _ProfilingStart()

◆ _ProfilingEnd()

Variable Documentation

◆ EVENT_Individualwalkingsearch

◆ EVENT_walkingsearch

◆ EVENT_GlobalParticleLocation

◆ EVENT_IndividualLocation