statistics_window.h File Reference

Window lifecycle, scheduling, and weighting for the field-statistics pipeline. More...

#include <petscsys.h>

Include dependency graph for statistics_window.h:

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

Go to the source code of this file.

Data Structures
struct	PicurvWindowFieldRequest
	One field a window accumulates. More...
struct	PicurvWindowCovarianceRequest
	One cross-field covariance a window accumulates. More...
struct	PicurvWindowDefinition
	The scientifically immutable definition of one window. More...
struct	PicurvWindow
	Runtime state of one window. More...

Macros
#define	PICURV_WINDOW_NAME_LENGTH   64
	Maximum stored length of a window name, including the terminator.
#define	PICURV_WINDOW_MAX_REQUESTS   16
	Maximum fields or covariance pairs one window may request.
#define	PICURV_WINDOW_HASH_GROUP_COUNT   8
	Number of independently hashed property groups in a window definition.
#define	PICURV_WINDOW_HASH_GROUP_LENGTH   17
	Stored length of one truncated group digest, including the terminator.

Typedefs
typedef struct PicurvWindow	PicurvWindow
	Runtime state of one window.

Enumerations
enum	PicurvWindowState { PICURV_WINDOW_PENDING = 0 , PICURV_WINDOW_ACTIVE , PICURV_WINDOW_COMPLETE }
	Lifecycle state of one window. More...
enum	PicurvWeighting { PICURV_WEIGHTING_SAMPLE = 0 , PICURV_WEIGHTING_PHYSICAL_TIME }
	How an accepted state's weight is determined. More...
enum	PicurvCadenceKind { PICURV_CADENCE_STEP = 0 , PICURV_CADENCE_TIME }
	Which schedule selects due states. More...

Functions
PetscErrorCode	PicurvWindowInit (PicurvWindow *window, const PicurvWindowDefinition *definition)
	Validates a definition and initializes a window to the pending state.
PetscErrorCode	PicurvWindowOfferState (PicurvWindow *window, PetscInt step, PetscReal time, PetscBool *accepted, PetscReal *weight)
	Offers one completed state to a window and reports the decision.
PetscErrorCode	PicurvWindowComputeHash (const PicurvWindowDefinition *definition, char digest_hex[65], char group_digest_hex[][17])
	Computes the resolved identity hash of one window definition.
PetscErrorCode	PicurvWindowFirstHashDifference (const PicurvWindowDefinition *definition, const char *saved_group_digests, PetscInt *group)
	Reports which hashed property group first differs from saved group digests.
const char *	PicurvWindowHashGroupName (PetscInt group)
	Returns the stable name of one hashed property group.
PetscReal	PicurvWindowProgress (const PicurvWindow *window)
	Reports the fraction of a bounded window's span that has been represented.
const char *	PicurvWindowStateName (PicurvWindowState state)
	Returns a stable human-readable name for a window state.
PetscBool	FieldStatisticsIsActive (const struct SimCtx *simCtx)
	Reports whether this run has live field-statistics state.
PetscErrorCode	FieldStatisticsUpdateWindows (struct SimCtx *simCtx, PetscInt step, PetscReal time)
	Offers one completed state to every configured window.

Detailed Description

Window lifecycle, scheduling, and weighting for the field-statistics pipeline.

Implements the window semantics described in 2. Windows and 3. Weighting and Quadrature — right-rectangle weighting, final-interval clipping, and the rule that a state representing a zero-length interval is not a sample.

This module decides whether a completed state is accepted and what weight it carries. It holds no PETSc objects and performs no field accumulation; the caller applies the returned weight through the moment kernels.

Definition in file statistics_window.h.

---

Data Structure Documentation

PicurvWindowFieldRequest

struct PicurvWindowFieldRequest

One field a window accumulates.

The first moment is always kept.

Definition at line 47 of file statistics_window.h.

Data Fields
PetscInt	field_id	Catalogued Eulerian field identity.
PetscBool	want_second	Also keep the centered second moment.

PicurvWindowCovarianceRequest

struct PicurvWindowCovarianceRequest

One cross-field covariance a window accumulates.

Definition at line 53 of file statistics_window.h.

Data Fields
PetscInt	first	First member; must also appear in the field list.
PetscInt	second	Second member; must also appear in the field list.

PicurvWindowDefinition

struct PicurvWindowDefinition

The scientifically immutable definition of one window.

Definition at line 59 of file statistics_window.h.

Collaboration diagram for PicurvWindowDefinition:

Data Fields
char	name[64]
PetscReal	start_time	Requested start.
PetscReal	end_time	Requested end; ignored when bounded is false.
PetscBool	bounded	False for an open-ended window.
PicurvWeighting	weighting
PicurvCadenceKind	cadence_kind
PetscInt	step_cadence	Used when cadence_kind is step; must be positive.
PetscReal	time_cadence	Used when cadence_kind is time; must be positive.
PetscInt	field_count
PicurvWindowFieldRequest	fields[16]
PetscInt	covariance_count
PicurvWindowCovarianceRequest	covariances[16]

PicurvWindow

struct PicurvWindow

Runtime state of one window.

Definition at line 75 of file statistics_window.h.

Collaboration diagram for PicurvWindow:

Data Fields
PicurvWindowDefinition	definition
PicurvWindowState	state
PetscReal	effective_start	Origin of the first represented interval.
PetscReal	effective_end	End of the last represented interval.
PetscReal	last_accepted_time	Right edge of the last represented interval.
PetscInt	sample_count
PetscReal	total_weight
PetscReal	represented_time	Physical time the window covers.
PetscInt	activation_step	Step at which the window became active.
PetscInt	last_event_step	Guards against a step being offered twice.
PetscInt	next_time_target	k in effective_start + k*time_cadence.
PetscInt	restart_count	Restart segments this state descends from.

Macro Definition Documentation

PICURV_WINDOW_NAME_LENGTH

#define PICURV_WINDOW_NAME_LENGTH   64

Maximum stored length of a window name, including the terminator.

Definition at line 22 of file statistics_window.h.

PICURV_WINDOW_MAX_REQUESTS

#define PICURV_WINDOW_MAX_REQUESTS   16

Maximum fields or covariance pairs one window may request.

Definition at line 44 of file statistics_window.h.

PICURV_WINDOW_HASH_GROUP_COUNT

#define PICURV_WINDOW_HASH_GROUP_COUNT   8

Number of independently hashed property groups in a window definition.

Definition at line 125 of file statistics_window.h.

PICURV_WINDOW_HASH_GROUP_LENGTH

#define PICURV_WINDOW_HASH_GROUP_LENGTH   17

Stored length of one truncated group digest, including the terminator.

Definition at line 128 of file statistics_window.h.

Typedef Documentation

PicurvWindow

typedef struct PicurvWindow PicurvWindow

Runtime state of one window.

Enumeration Type Documentation

PicurvWindowState

enum PicurvWindowState

Lifecycle state of one window.

Enumerator
PICURV_WINDOW_PENDING	Requested start not yet reached.
PICURV_WINDOW_ACTIVE	Accepting due states.
PICURV_WINDOW_COMPLETE	Bounded end reached; accepts nothing further.

Definition at line 25 of file statistics_window.h.

             {
    PICURV_WINDOW_PENDING = 0,  /**< Requested start not yet reached. */
    PICURV_WINDOW_ACTIVE,       /**< Accepting due states. */
    PICURV_WINDOW_COMPLETE      /**< Bounded end reached; accepts nothing further. */
} PicurvWindowState;

PicurvWeighting

enum PicurvWeighting

How an accepted state's weight is determined.

Enumerator
PICURV_WEIGHTING_SAMPLE	Equal weight per accepted state.
PICURV_WEIGHTING_PHYSICAL_TIME	Weight is the represented interval.

Definition at line 32 of file statistics_window.h.

             {
    PICURV_WEIGHTING_SAMPLE = 0,    /**< Equal weight per accepted state. */
    PICURV_WEIGHTING_PHYSICAL_TIME  /**< Weight is the represented interval. */
} PicurvWeighting;

PicurvCadenceKind

enum PicurvCadenceKind

Which schedule selects due states.

Exactly one is used.

Enumerator
PICURV_CADENCE_STEP	Every n completed steps from activation.
PICURV_CADENCE_TIME	First state at or past each nominal time target.

Definition at line 38 of file statistics_window.h.

             {
    PICURV_CADENCE_STEP = 0,  /**< Every n completed steps from activation. */
    PICURV_CADENCE_TIME       /**< First state at or past each nominal time target. */
} PicurvCadenceKind;

Function Documentation

PicurvWindowInit()

PetscErrorCode PicurvWindowInit	(	PicurvWindow *	window,
		const PicurvWindowDefinition *	definition
	)

Validates a definition and initializes a window to the pending state.

Parameters

[out]	window	Window to initialize.
[in]	definition	Requested definition; copied into the window.

Returns

Zero on success, or PETSC_ERR_ARG_OUTOFRANGE for a non-positive cadence, an empty name, or a bounded window whose end does not exceed its start.

Validates a definition and initializes a window to the pending state.

See also

PicurvWindowInit()

Definition at line 39 of file statistics_window.c.

{
    PetscFunctionBeginUser;
    PROFILE_FUNCTION_BEGIN;
    PetscCheck(window != NULL && definition != NULL, PETSC_COMM_SELF, PETSC_ERR_ARG_NULL,
               "Window and definition are required.");
    PetscCheck(definition->name[0] != '\0', PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE,
               "Window name must not be empty.");
    if (definition->cadence_kind == PICURV_CADENCE_STEP) {
        PetscCheck(definition->step_cadence > 0, PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE,
                   "Window '%s' needs a positive step cadence, got %" PetscInt_FMT ".",
                   definition->name, definition->step_cadence);
    } else {
        PetscCheck(definition->time_cadence > 0.0, PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE,
                   "Window '%s' needs a positive time cadence, got %g.",
                   definition->name, (double)definition->time_cadence);
    }
    PetscCheck(!definition->bounded || definition->end_time > definition->start_time,
               PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE,
               "Window '%s' must end after it starts.", definition->name);
 
    PetscCall(PetscMemzero(window, sizeof(*window)));
    window->definition = *definition;
    window->state = PICURV_WINDOW_PENDING;
    /* Anchoring the interval origin at the requested start, rather than at the
     * first accepted state, is what lets the first sample represent the interval
     * back to the requested bound instead of silently dropping it. */
    window->effective_start = definition->start_time;
    window->effective_end = definition->start_time;
    window->last_accepted_time = definition->start_time;
    window->activation_step = -1;
    window->last_event_step = PETSC_MIN_INT;
    window->next_time_target = 0;
    PROFILE_FUNCTION_END;
    PetscFunctionReturn(0);
}

Here is the caller graph for this function:

PicurvWindowOfferState()

PetscErrorCode PicurvWindowOfferState	(	PicurvWindow *	window,
		PetscInt	step,
		PetscReal	time,
		PetscBool *	accepted,
		PetscReal *	weight
	)

Offers one completed state to a window and reports the decision.

Applies the interval convention in full: the state carries the interval ending at it, measured from the previous accepted state or from the effective start; a zero-length interval is not a sample; and a bounded window clips its final interval to the requested end and then completes.

When accepted is returned true the window's bookkeeping has already been advanced, and the caller applies weight through the moment kernels. When it is false the window is scientifically unchanged.

Offering the same step twice is rejected, so a completed state cannot be counted more than once.

Parameters

[in,out]	window	Window to offer the state to.
[in]	step	Completed step number.
[in]	time	Physical time of the completed state.
[out]	accepted	Whether the state became a sample.
[out]	weight	Weight to apply; zero when not accepted.

Returns

Zero on success, or a PETSc error for a null argument.

Offers one completed state to a window and reports the decision.

See also

PicurvWindowOfferState()

Definition at line 117 of file statistics_window.c.

{
    PetscReal interval = 0.0;
    PetscReal right_edge = 0.0;
    PetscBool closes = PETSC_FALSE;
 
    PetscFunctionBeginUser;
    PetscCheck(window != NULL && accepted != NULL && weight != NULL,
               PETSC_COMM_SELF, PETSC_ERR_ARG_NULL,
               "Window, acceptance flag, and weight output are required.");
    *accepted = PETSC_FALSE;
    *weight = 0.0;
 
    if (window->state == PICURV_WINDOW_COMPLETE) PetscFunctionReturn(0);
    /* A completed state is accepted at most once, so a step already seen is
     * rejected outright rather than double counted. */
    if (step == window->last_event_step) PetscFunctionReturn(0);
    if (time < window->definition.start_time - WINDOW_TIME_EPSILON) PetscFunctionReturn(0);
 
    /* First observation: a window resumed later than its requested start cannot
     * claim represented time it never saw, so the origin moves forward. */
    if (window->state == PICURV_WINDOW_PENDING) {
        if (time > window->definition.start_time + WINDOW_TIME_EPSILON) {
            window->effective_start = time;
            window->last_accepted_time = time;
        }
        window->state = PICURV_WINDOW_ACTIVE;
        window->activation_step = step;
        window->effective_end = window->effective_start;
        window->next_time_target = 0;
        WindowAdvanceTimeTarget(window, window->effective_start);
    }
 
    if (!WindowStateIsDue(window, step, time)) {
        /* An active off-schedule state changes no scientific state. */
        PetscFunctionReturn(0);
    }
    window->last_event_step = step;
 
    /* Clip the final represented interval to the requested bound. */
    right_edge = time;
    if (window->definition.bounded && time >= window->definition.end_time - WINDOW_TIME_EPSILON) {
        right_edge = window->definition.end_time;
        closes = PETSC_TRUE;
    }
 
    interval = right_edge - window->last_accepted_time;
    WindowAdvanceTimeTarget(window, time);
 
    if (interval <= WINDOW_TIME_EPSILON) {
        /* A zero-length interval is not a sample. It still anchors the origin, which
         * is what makes initial-state handling identical under both weightings. */
        window->last_accepted_time = right_edge;
        window->effective_end = right_edge;
        if (closes) window->state = PICURV_WINDOW_COMPLETE;
        PetscFunctionReturn(0);
    }
 
    *weight = (window->definition.weighting == PICURV_WEIGHTING_SAMPLE) ? 1.0 : interval;
    *accepted = PETSC_TRUE;
 
    window->last_accepted_time = right_edge;
    window->effective_end = right_edge;
    window->sample_count += 1;
    window->total_weight += *weight;
    window->represented_time += interval;
    if (closes) window->state = PICURV_WINDOW_COMPLETE;
    PetscFunctionReturn(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PicurvWindowComputeHash()

PetscErrorCode PicurvWindowComputeHash	(	const PicurvWindowDefinition *	definition,
		char	digest_hex[65],
		char	group_digest_hex[][17]
	)

Computes the resolved identity hash of one window definition.

Hashes the canonical serialization defined in 6. Window Identity and What May Change, in that fixed order, so a saved window can be matched against a resolved one without storing the definition itself.

end_time and the enabled flag are deliberately excluded, which is what lets a bounded window be extended forward and lets statistics be switched off and on without invalidating saved state.

Field and covariance entries are serialized in catalog order rather than the order the user listed them, so a reordered but otherwise identical configuration continues rather than being rejected.

Each property group is additionally hashed on its own. A restart that finds a mismatched full digest compares the group digests to name the first differing property, which a single digest could not do.

Parameters

[in]	definition	Window definition to hash.
[out]	digest_hex	Full 64-character digest plus terminator.
[out]	group_digest_hex	Optional per-group truncated digests; pass NULL to skip.

Returns

Zero on success, or a PETSc error for a null argument or unknown field.

Here is the caller graph for this function:

PicurvWindowFirstHashDifference()

PetscErrorCode PicurvWindowFirstHashDifference	(	const PicurvWindowDefinition *	definition,
		const char *	saved_group_digests,
		PetscInt *	group
	)

Reports which hashed property group first differs from saved group digests.

A checkpoint stores the group digests but never the definition itself, so this is what turns "two hashes differ" into a message naming the property that changed.

Parameters

[in]	definition	Resolved definition to compare against.
[in]	saved_group_digests	Comma-separated group digests from a checkpoint.
[out]	group	First differing group index, or -1 when the saved digests match or are too malformed to compare.

Returns

Zero on success, or a PETSc error for a null argument or unknown field.

Reports which hashed property group first differs from saved group digests.

See also

PicurvWindowFirstHashDifference()

Definition at line 374 of file statistics_window.c.

{
    char digest[65];
    char current[PICURV_WINDOW_HASH_GROUP_COUNT][PICURV_WINDOW_HASH_GROUP_LENGTH];
    const char *cursor = saved_group_digests;
 
    PetscFunctionBeginUser;
    PetscCheck(definition != NULL && group != NULL, PETSC_COMM_SELF, PETSC_ERR_ARG_NULL,
               "Definition and group output are required.");
    *group = -1;
    if (!saved_group_digests) PetscFunctionReturn(0);
    PetscCall(PicurvWindowComputeHash(definition, digest, current));
 
    for (PetscInt index = 0; index < PICURV_WINDOW_HASH_GROUP_COUNT; ++index) {
        const char *comma = strchr(cursor, ',');
        const size_t length = comma ? (size_t)(comma - cursor) : strlen(cursor);
        size_t expected = 0;
 
        PetscCall(PetscStrlen(current[index], &expected));
        /* Every well-formed digest is fixed width, so a short segment means the
         * saved list is malformed rather than that this property changed. A
         * malformed list localizes to nothing: reporting the wrong property would
         * be worse than reporting none. */
        if (length != expected) PetscFunctionReturn(0);
        if (strncmp(cursor, current[index], length)) {
            *group = index;
            PetscFunctionReturn(0);
        }
        if (!comma) PetscFunctionReturn(0);
        cursor = comma + 1;
    }
    PetscFunctionReturn(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PicurvWindowHashGroupName()

const char * PicurvWindowHashGroupName

(

PetscInt

group

)

Returns the stable name of one hashed property group.

Parameters

[in]

group

Group index in [0, PICURV_WINDOW_HASH_GROUP_COUNT).

Returns

Static string; "unknown" for an out-of-range index, never NULL.

Returns the stable name of one hashed property group.

See also

PicurvWindowHashGroupName()

Definition at line 197 of file statistics_window.c.

{
    if (group < 0 || group >= PICURV_WINDOW_HASH_GROUP_COUNT) return "unknown";
    return kHashGroupNames[group];
}

Here is the caller graph for this function:

PicurvWindowProgress()

PetscReal PicurvWindowProgress

(

const PicurvWindow *

window

)

Reports the fraction of a bounded window's span that has been represented.

Parameters

[in]

window

Window to query.

Returns

Value in [0,1] for a bounded window, or zero for an open one.

Reports the fraction of a bounded window's span that has been represented.

See also

PicurvWindowProgress()

Definition at line 414 of file statistics_window.c.

{
    PetscReal span = 0.0;
 
    if (window == NULL || !window->definition.bounded) return 0.0;
    span = window->definition.end_time - window->effective_start;
    if (span <= 0.0) return 0.0;
    return PetscMin(1.0, window->represented_time / span);
}

Here is the caller graph for this function:

PicurvWindowStateName()

const char * PicurvWindowStateName

(

PicurvWindowState

state

)

Returns a stable human-readable name for a window state.

Parameters

[in]

state

Window lifecycle state.

Returns

Static string; never NULL.

Returns a stable human-readable name for a window state.

See also

PicurvWindowStateName()

Definition at line 23 of file statistics_window.c.

{
    switch (state) {
    case PICURV_WINDOW_PENDING:  return "pending";
    case PICURV_WINDOW_ACTIVE:   return "active";
    case PICURV_WINDOW_COMPLETE: return "complete";
    default:                     return "unknown";
    }
}

Here is the caller graph for this function:

FieldStatisticsIsActive()

PetscBool FieldStatisticsIsActive

(

const struct SimCtx *

simCtx

)

Reports whether this run has live field-statistics state.

The subsystem is active only when it is enabled, at least one window is configured, and the window array exists. Every caller that touches window or accumulator state asks this rather than restating the condition, so the three parts cannot drift apart between the runloop, the checkpoint writer, and the console monitor.

Parameters

[in]

simCtx

Simulation context; may be NULL.

Returns

PETSC_TRUE when window state exists and may be touched.

Here is the caller graph for this function:

FieldStatisticsUpdateWindows()

PetscErrorCode FieldStatisticsUpdateWindows	(	SimCtx *	simCtx,
		PetscInt	step,
		PetscReal	time
	)

Offers one completed state to every configured window.

Called once per completed step from the runloop. Each due window advances its own bookkeeping independently; windows share the source state but never share accumulator state. Does nothing when field statistics are disabled or no window is configured, which is the case until configuration ingress exists.

Parameters

[in,out]	simCtx	Simulation context carrying the window array.
[in]	step	Completed step number.
[in]	time	Physical time of the completed state.

Returns

Zero on success, or a PETSc error propagated from a window update.

Offers one completed state to every configured window.

See also

FieldStatisticsUpdateWindows()

Definition at line 441 of file statistics_window.c.

{
    PetscFunctionBeginUser;
    PROFILE_FUNCTION_BEGIN;
    PetscCheck(simCtx != NULL, PETSC_COMM_SELF, PETSC_ERR_ARG_NULL, "SimCtx cannot be NULL.");
    if (!FieldStatisticsIsActive(simCtx)) { PROFILE_FUNCTION_END; PetscFunctionReturn(0); }
 
    for (PetscInt window_index = 0; window_index < simCtx->fieldStatisticsWindowCount; ++window_index) {
        PicurvWindow *window = &simCtx->fieldStatisticsWindows[window_index];
        const PicurvWindowState before = window->state;
        PetscBool accepted = PETSC_FALSE;
        PetscReal weight = 0.0;
 
        PetscCall(PicurvWindowOfferState(window, step, time, &accepted, &weight));
 
        if (before == PICURV_WINDOW_PENDING && window->state == PICURV_WINDOW_ACTIVE) {
            LOG_ALLOW(GLOBAL, LOG_INFO,
                      "Statistics window '%s' active from t=%.6g.\n",
                      window->definition.name, (double)window->effective_start);
        }
        if (accepted) {
            /* Apply the accepted weight to every block's accumulators. Windows share
             * the source state but own independent accumulator state. */
            for (PetscInt bi = 0; bi < simCtx->block_number; ++bi) {
                UserCtx *user = &simCtx->usermg.mgctx[simCtx->usermg.mglevels - 1].user[bi];
                if (!user->fieldStatisticsStorage) continue;
                PetscCall(PicurvWindowAccumulate(user, &window->definition,
                                                 &user->fieldStatisticsStorage[window_index], weight));
            }
            LOG_ALLOW(GLOBAL, LOG_DEBUG,
                      "Statistics window '%s' accepted step %d at t=%.6g with weight %.6g "
                      "(samples=%d, represented=%.6g).\n",
                      window->definition.name, step, (double)time, (double)weight,
                      window->sample_count, (double)window->represented_time);
        } else if (window->state == PICURV_WINDOW_ACTIVE) {
            /* An active window that took nothing was either off schedule or offered a
             * zero-length interval. Both are expected, so this is the level that
             * explains a sample count without implying anything is wrong. */
            LOG_ALLOW(GLOBAL, LOG_DEBUG,
                      "Statistics window '%s' did not sample step %d at t=%.6g "
                      "(last accepted t=%.6g, samples=%d).\n",
                      window->definition.name, step, (double)time,
                      (double)window->last_accepted_time, window->sample_count);
        }
        if (before != PICURV_WINDOW_COMPLETE && window->state == PICURV_WINDOW_COMPLETE) {
            LOG_ALLOW(GLOBAL, LOG_INFO,
                      "Statistics window '%s' complete: %d sample(s), total weight %.6g, "
                      "represented time %.6g.\n",
                      window->definition.name, window->sample_count,
                      (double)window->total_weight, (double)window->represented_time);
            if (window->sample_count == 0) {
                LOG_ALLOW(GLOBAL, LOG_WARNING,
                          "Statistics window '%s' completed without accepting any sample.\n",
                          window->definition.name);
            } else {
                UserCtx *user = simCtx->usermg.mgctx[simCtx->usermg.mglevels - 1].user;
 
                /* A point that was never valid carries no average at all, which a
                 * reader of the mean field cannot see. Report it once, at the only
                 * moment the final coverage is known. The reduction is collective and
                 * runs once per window, not per step. */
                if (user && user->fieldStatisticsStorage) {
                    PetscReal lowest = 1.0, highest = 0.0;
 
                    PetscCall(PicurvWindowValidFractionRange(user, &window->definition,
                                                             &user->fieldStatisticsStorage[window_index],
                                                             window->sample_count, &lowest, &highest));
                    if (lowest <= 0.0) {
                        LOG_ALLOW(GLOBAL, LOG_WARNING,
                                  "Statistics window '%s' completed with points that were never "
                                  "valid; their mean and moments are undefined.\n",
                                  window->definition.name);
                    } else {
                        LOG_ALLOW(GLOBAL, LOG_INFO,
                                  "Statistics window '%s' per-point valid fraction spans [%.3f, %.3f].\n",
                                  window->definition.name, (double)lowest, (double)highest);
                    }
                }
            }
        }
    }
    PROFILE_FUNCTION_END;
    PetscFunctionReturn(0);
}

Here is the call graph for this function:

Here is the caller graph for this function: