ParticleInitialConditions.h File Reference

Configured initial values of particle-carried fields, and the expression language that defines them. More...

#include "variables.h"
#include "particle_field_catalog.h"

Include dependency graph for ParticleInitialConditions.h:

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

Go to the source code of this file.

Data Structures
struct	PicurvExpressionDrawKey
	What a random draw is keyed on, besides the particle and its stream. More...
struct	ParticleFieldEvent
	When and why a plan is applied. More...

Typedefs
typedef struct PicurvExpression	PicurvExpression
	A compiled expression: postfix code for a small stack evaluator.
typedef struct ParticleFieldPlan	ParticleFieldPlan
	Compiled initial values for every configured particle field.

Functions
PetscErrorCode	PicurvExpressionCompile (const char *text, const char *const *names, PetscInt name_count, PetscBool allow_random, PicurvExpression **expression)
	Compile one expression against a list of variable names.
PetscErrorCode	PicurvExpressionEvaluate (const PicurvExpression *expression, const PetscReal *values, const PicurvExpressionDrawKey *key, PetscReal *result)
	Evaluate a compiled expression.
PetscErrorCode	PicurvExpressionDestroy (PicurvExpression **expression)
	Free a compiled expression.
PetscErrorCode	ParticleFieldPlanCreate (ParticleFieldPlan **plan)
	Read a plan from the options database.
PetscErrorCode	ParticleFieldPlanApply (UserCtx *user, const ParticleFieldPlan *plan, const ParticleFieldEvent *event, PetscInt first, PetscInt end)
	Write the plan's values into swarm entries [first, end) of this rank.
PetscErrorCode	ParticleFieldPlanSummarize (UserCtx *user, const ParticleFieldPlan *plan)
	Log and record the realized initial values of every planned field.
PetscErrorCode	ParticleFieldPlanDestroy (ParticleFieldPlan **plan)
	Free a plan and its compiled expressions.

Detailed Description

Configured initial values of particle-carried fields, and the expression language that defines them.

A plan binds each configured particle field to one compiled expression per component. Expressions are written in physical units: x, y, z are physical coordinates, t is physical time, and a value is divided by its field's catalog reference scale when written. The plan is applied to a contiguous local range of swarm entries, so the t=0 population and, later, particles injected at a boundary share one path.

The language is the one generators/ic.gen validates and evaluates for Eulerian expressions; tests/fixtures/expression_conformance.txt holds cases both implementations must agree on.

Definition in file ParticleInitialConditions.h.

---

Data Structure Documentation

PicurvExpressionDrawKey

struct PicurvExpressionDrawKey

What a random draw is keyed on, besides the particle and its stream.

Definition at line 31 of file ParticleInitialConditions.h.

Data Fields
PetscInt64	seed	Run seed (-particle_random_seed).
PetscInt64	pid	Particle identity; draws are pure functions of it.
PetscInt64	salt	Event that produced the particle: 0 for the t=0 population.
PetscInt64	field	Field whose expression draws, the default stream's namespace.

ParticleFieldEvent

struct ParticleFieldEvent

When and why a plan is applied.

Definition at line 79 of file ParticleInitialConditions.h.

Data Fields
PetscReal	physical_time	Time, in seconds, the evaluated particles appear at.
PetscInt64	salt	Event identity keying random draws: 0 for the t=0 population.

Typedef Documentation

PicurvExpression

typedef struct PicurvExpression PicurvExpression

A compiled expression: postfix code for a small stack evaluator.

Definition at line 28 of file ParticleInitialConditions.h.

ParticleFieldPlan

typedef struct ParticleFieldPlan ParticleFieldPlan

Compiled initial values for every configured particle field.

Definition at line 76 of file ParticleInitialConditions.h.

Function Documentation

PicurvExpressionCompile()

PetscErrorCode PicurvExpressionCompile	(	const char *	text,
		const char *const *	names,
		PetscInt	name_count,
		PetscBool	allow_random,
		PicurvExpression **	expression
	)

Compile one expression against a list of variable names.

The grammar is Python's expression syntax restricted to numbers, the given names, pi, arithmetic (+ - * / % **), comparisons (chained ones included), and/or/not, and the functions abs cos exp maximum minimum sin sqrt tan where, plus uniform and normal when allow_random is true. Comparisons and logical operators yield 1 or 0; % takes the sign of the divisor; ** binds tighter than a unary minus on its left and groups to the right.

Parameters

[in]	text	Expression text.
[in]	names	Variable names, in the order evaluation supplies their values.
[in]	name_count	Number of names.
[in]	allow_random	Whether uniform and normal may be called.
[out]	expression	Compiled expression, owned by the caller.

Returns

Zero on success; PETSC_ERR_ARG_WRONG for a syntax error or an unknown name or function, with the offending position in the message.

Compile one expression against a list of variable names.

See also

PicurvExpressionCompile()

Definition at line 385 of file ParticleInitialConditions.c.

{
    ExpressionParser parser;
    PetscInt         root, depth = 0;
 
    PetscFunctionBeginUser;
    PetscCheck(text && expression, PETSC_COMM_SELF, PETSC_ERR_ARG_NULL, "Expression text and output are required.");
    PetscCall(PetscMemzero(&parser, sizeof(parser)));
    parser.text = text;
    parser.names = names;
    parser.name_count = name_count;
    parser.allow_random = allow_random;
    parser.capacity = 4 * (PetscInt)strlen(text) + 8;
    PetscCall(PetscMalloc1(parser.capacity, &parser.nodes));
 
    root = ParseOr(&parser);
    SkipSpace(&parser);
    if (!parser.error[0] && parser.text[parser.pos]) ParserFail(&parser, "unexpected text");
    if (parser.error[0]) {
        PetscCall(PetscFree(parser.nodes));
        SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Invalid expression: %s.", parser.error);
    }
 
    PetscCall(PetscNew(expression));
    (*expression)->length = 0;
    PetscCall(PetscMalloc1(CountCode(&parser, root), &(*expression)->code));
    EmitNode(&parser, root, *expression, &depth);
    PetscCall(PetscFree(parser.nodes));
    PetscFunctionReturn(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PicurvExpressionEvaluate()

PetscErrorCode PicurvExpressionEvaluate	(	const PicurvExpression *	expression,
		const PetscReal *	values,
		const PicurvExpressionDrawKey *	key,
		PetscReal *	result
	)

Evaluate a compiled expression.

Parameters

[in]	expression	Compiled expression.
[in]	values	One value per compiled name, in compile order.
[in]	key	Draw key, required when the expression draws; may be NULL otherwise.
[out]	result	Value of the expression; may be non-finite, which the caller judges.

Returns

Zero on success.

Evaluate a compiled expression.

See also

PicurvExpressionEvaluate()

Definition at line 463 of file ParticleInitialConditions.c.

{
    PetscReal stack[expression->max_depth + 1];
    PetscInt  top = 0;
 
    PetscFunctionBeginUser;
    PetscCheck(!expression->draws || key, PETSC_COMM_SELF, PETSC_ERR_ARG_NULL,
               "An expression that draws random numbers needs a draw key.");
    for (PetscInt i = 0; i < expression->length; ++i) {
        const ExpressionInstruction *instruction = &expression->code[i];
        PetscReal a, b, c;
 
        switch (instruction->op) {
        case OP_CONST: stack[top++] = instruction->value; break;
        case OP_VAR: stack[top++] = values[instruction->arg]; break;
        case OP_UNIFORM:
        case OP_NORMAL: stack[top++] = Draw(key, instruction); break;
        case OP_NEG: stack[top - 1] = -stack[top - 1]; break;
        case OP_POS: break;
        case OP_NOT: stack[top - 1] = (stack[top - 1] == 0.0) ? 1.0 : 0.0; break;
        case OP_ABS: stack[top - 1] = PetscAbsReal(stack[top - 1]); break;
        case OP_COS: stack[top - 1] = PetscCosReal(stack[top - 1]); break;
        case OP_EXP: stack[top - 1] = PetscExpReal(stack[top - 1]); break;
        case OP_SIN: stack[top - 1] = PetscSinReal(stack[top - 1]); break;
        case OP_SQRT: stack[top - 1] = PetscSqrtReal(stack[top - 1]); break;
        case OP_TAN: stack[top - 1] = PetscTanReal(stack[top - 1]); break;
        case OP_WHERE:
            c = stack[--top]; b = stack[--top]; a = stack[top - 1];
            stack[top - 1] = (a != 0.0) ? b : c;
            break;
        default:
            b = stack[--top]; a = stack[top - 1];
            switch (instruction->op) {
            case OP_ADD: a = a + b; break;
            case OP_SUB: a = a - b; break;
            case OP_MUL: a = a * b; break;
            case OP_DIV: a = a / b; break;
            /* Python's modulus takes the sign of the divisor. */
            case OP_MOD: a = (b == 0.0) ? NAN : a - b * PetscFloorReal(a / b); break;
            case OP_POW: a = PetscPowReal(a, b); break;
            case OP_EQ: a = (a == b) ? 1.0 : 0.0; break;
            case OP_NE: a = (a != b) ? 1.0 : 0.0; break;
            case OP_LT: a = (a < b) ? 1.0 : 0.0; break;
            case OP_LE: a = (a <= b) ? 1.0 : 0.0; break;
            case OP_GT: a = (a > b) ? 1.0 : 0.0; break;
            case OP_GE: a = (a >= b) ? 1.0 : 0.0; break;
            case OP_AND: a = (a != 0.0 && b != 0.0) ? 1.0 : 0.0; break;
            case OP_OR: a = (a != 0.0 || b != 0.0) ? 1.0 : 0.0; break;
            case OP_MAXIMUM: a = Extreme(a, b, PETSC_TRUE); break;
            case OP_MINIMUM: a = Extreme(a, b, PETSC_FALSE); break;
            default: SETERRQ(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Unknown expression opcode %d.", (int)instruction->op);
            }
            stack[top - 1] = a;
        }
    }
    *result = stack[0];
    PetscFunctionReturn(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PicurvExpressionDestroy()

PetscErrorCode PicurvExpressionDestroy

(

PicurvExpression **

expression

)

Free a compiled expression.

Parameters

[in,out]

expression

Expression to free; set to NULL.

Returns

Zero on success.

Free a compiled expression.

See also

PicurvExpressionDestroy()

Definition at line 527 of file ParticleInitialConditions.c.

{
    PetscFunctionBeginUser;
    if (!expression || !*expression) PetscFunctionReturn(0);
    PetscCall(PetscFree((*expression)->code));
    PetscCall(PetscFree(*expression));
    PetscFunctionReturn(0);
}

Here is the caller graph for this function:

ParticleFieldPlanCreate()

PetscErrorCode ParticleFieldPlanCreate

(

ParticleFieldPlan **

plan

)

Read a plan from the options database.

Reads -particle_fields_count, and for each field i, -particle_fields_<i>_name and one expression per component, -particle_fields_<i>_expr_<c>. Every named field must be a particle-carried field of the catalog (capability USER_INITIALIZE).

Parameters

[out]

plan

Compiled plan, or NULL when no field is configured.

Returns

Zero on success; PETSC_ERR_ARG_WRONG for an unknown or non-settable field or a malformed expression.

Read a plan from the options database.

See also

ParticleFieldPlanCreate()

Definition at line 563 of file ParticleInitialConditions.c.

{
    PetscInt  count = 0;
    PetscBool found = PETSC_FALSE;
    char      option[256];
 
    PetscFunctionBeginUser;
    PetscCheck(plan, PETSC_COMM_SELF, PETSC_ERR_ARG_NULL, "Plan output is required.");
    *plan = NULL;
    PetscCall(PetscSNPrintf(option, sizeof(option), "-particle_fields_count"));
    PetscCall(PetscOptionsGetInt(NULL, NULL, option, &count, &found));
    if (!found || count == 0) PetscFunctionReturn(0);
    PetscCheck(count > 0 && count <= PARTICLE_FIELD_ID_COUNT, PETSC_COMM_WORLD, PETSC_ERR_ARG_OUTOFRANGE,
               "%s must be between 0 and %d (got %" PetscInt_FMT ").", option, (int)PARTICLE_FIELD_ID_COUNT, count);
 
    PetscCall(PetscNew(plan));
    PetscCall(PetscCalloc1(count, &(*plan)->bindings));
    (*plan)->count = count;
    for (PetscInt i = 0; i < count; ++i) {
        ParticleFieldBinding          *binding = &(*plan)->bindings[i];
        const ParticleFieldDescriptor *descriptor = NULL;
        char                           name[64];
 
        PetscCall(PetscSNPrintf(option, sizeof(option), "-particle_fields_%" PetscInt_FMT "_name", i));
        PetscCall(PetscOptionsGetString(NULL, NULL, option, name, sizeof(name), &found));
        PetscCheck(found, PETSC_COMM_WORLD, PETSC_ERR_ARG_WRONG, "%s is missing.", option);
        PetscCall(ParticleFieldIdFromName(name, &binding->field));
        PetscCall(ParticleFieldGetDescriptor(binding->field, &descriptor));
        PetscCheck(descriptor->capabilities & PARTICLE_FIELD_CAPABILITY_USER_INITIALIZE, PETSC_COMM_WORLD,
                   PETSC_ERR_ARG_WRONG,
                   "Particle field '%s' cannot be given an initial value: the runtime sets it from the "
                   "Eulerian fields or from particle location.", name);
        PetscCheck(descriptor->dimension.kind == FIELD_DIMENSION_FIXED && descriptor->data_type == PETSC_REAL,
                   PETSC_COMM_WORLD, PETSC_ERR_PLIB, "Settable particle field '%s' must be a real quantity.", name);
        for (PetscInt j = 0; j < i; ++j) {
            PetscCheck((*plan)->bindings[j].field != binding->field, PETSC_COMM_WORLD, PETSC_ERR_ARG_WRONG,
                       "Particle field '%s' is configured twice.", name);
        }
        binding->components = descriptor->components;
        PetscCheck(binding->components <= PARTICLE_FIELD_MAX_COMPONENTS, PETSC_COMM_WORLD, PETSC_ERR_PLIB,
                   "Particle field '%s' has more components than an initial value supports.", name);
        for (PetscInt c = 0; c < binding->components; ++c) {
            char text[PARTICLE_FIELD_EXPRESSION_LENGTH];
 
            PetscCall(PetscSNPrintf(option, sizeof(option), "-particle_fields_%" PetscInt_FMT "_expr_%" PetscInt_FMT, i, c));
            PetscCall(PetscOptionsGetString(NULL, NULL, option, text, sizeof(text), &found));
            PetscCheck(found, PETSC_COMM_WORLD, PETSC_ERR_ARG_WRONG, "%s is missing.", option);
            PetscCall(PicurvExpressionCompile(text, kParticleVariables, PARTICLE_VARIABLE_COUNT, PETSC_TRUE,
                                              &binding->component[c]));
        }
    }
    PetscFunctionReturn(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParticleFieldPlanApply()

PetscErrorCode ParticleFieldPlanApply	(	UserCtx *	user,
		const ParticleFieldPlan *	plan,
		const ParticleFieldEvent *	event,
		PetscInt	first,
		PetscInt	end
	)

Write the plan's values into swarm entries [first, end) of this rank.

Not collective: each rank evaluates its own entries, and the domain bounds for xn, yn, zn come from the replicated rank bounding boxes. A value that is not finite is an error naming the particle and its position.

Parameters

[in,out]	user	Block owning the swarm.
[in]	plan	Plan to apply; NULL does nothing.
[in]	event	Time and identity of the event producing these particles.
[in]	first	First local entry.
[in]	end	One past the last local entry.

Returns

Zero on success.

Write the plan's values into swarm entries [first, end) of this rank.

See also

ParticleFieldPlanApply()

Definition at line 649 of file ParticleInitialConditions.c.

{
    SimCtx           *simCtx = NULL;
    const PetscReal  *positions = NULL;
    const PetscInt64 *pids = NULL;
    Cmpnts            lower, upper;
 
    PetscFunctionBeginUser;
    if (!plan || end <= first) PetscFunctionReturn(0);
    PetscCheck(user && user->swarm && event, PETSC_COMM_SELF, PETSC_ERR_ARG_NULL, "Swarm and event are required.");
    simCtx = user->simCtx;
    PetscCall(DomainBounds(simCtx, &lower, &upper));
 
    PetscCall(DMSwarmGetField(user->swarm, ParticleFieldName(PARTICLE_FIELD_ID_POSITION), NULL, NULL, (void **)&positions));
    PetscCall(DMSwarmGetField(user->swarm, ParticleFieldName(PARTICLE_FIELD_ID_PID), NULL, NULL, (void **)&pids));
    for (PetscInt b = 0; b < plan->count; ++b) {
        const ParticleFieldBinding    *binding = &plan->bindings[b];
        const ParticleFieldDescriptor *descriptor = NULL;
        PetscReal                     *field = NULL, scale = 1.0;
 
        PetscCall(ParticleFieldGetDescriptor(binding->field, &descriptor));
        /* A value is physical; the swarm stores solver units. */
        PetscCall(FieldDimensionReferenceScale(&simCtx->scaling, descriptor->dimension, &scale));
        PetscCall(DMSwarmGetField(user->swarm, descriptor->canonical_name, NULL, NULL, (void **)&field));
        for (PetscInt p = first; p < end; ++p) {
            const PetscReal *position = &positions[3 * p];
            const PetscReal  values[] = {
                position[0] * simCtx->scaling.L_ref, position[1] * simCtx->scaling.L_ref,
                position[2] * simCtx->scaling.L_ref,
                Normalized(position[0], lower.x, upper.x), Normalized(position[1], lower.y, upper.y),
                Normalized(position[2], lower.z, upper.z),
                (PetscReal)pids[p], event->physical_time,
            };
            const PicurvExpressionDrawKey key = {
                (PetscInt64)simCtx->particleRandomSeed, pids[p], event->salt, (PetscInt64)binding->field,
            };
            for (PetscInt c = 0; c < binding->components; ++c) {
                PetscReal value = 0.0;
 
                PetscCall(PicurvExpressionEvaluate(binding->component[c], values, &key, &value));
                PetscCheck(!PetscIsInfOrNanReal(value), PETSC_COMM_SELF, PETSC_ERR_FP,
                           "The initial value of '%s' is not finite for particle %lld at (%g, %g, %g).",
                           descriptor->canonical_name, (long long)pids[p], (double)values[0],
                           (double)values[1], (double)values[2]);
                field[binding->components * p + c] = value / scale;
            }
        }
        PetscCall(DMSwarmRestoreField(user->swarm, descriptor->canonical_name, NULL, NULL, (void **)&field));
    }
    PetscCall(DMSwarmRestoreField(user->swarm, ParticleFieldName(PARTICLE_FIELD_ID_PID), NULL, NULL, (void **)&pids));
    PetscCall(DMSwarmRestoreField(user->swarm, ParticleFieldName(PARTICLE_FIELD_ID_POSITION), NULL, NULL, (void **)&positions));
    PetscFunctionReturn(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParticleFieldPlanSummarize()

PetscErrorCode ParticleFieldPlanSummarize	(	UserCtx *	user,
		const ParticleFieldPlan *	plan
	)

Log and record the realized initial values of every planned field.

Collective. Reports count, mean, variance, minimum, maximum, and a ten-bin histogram per field component, in physical units, to the log and to particle_initial_fields.csv in the run's metrics directory.

Parameters

[in]	user	Block owning the swarm.
[in]	plan	Plan whose fields are summarized; NULL does nothing.

Returns

Zero on success.

Log and record the realized initial values of every planned field.

See also

ParticleFieldPlanSummarize()

Definition at line 708 of file ParticleInitialConditions.c.

{
    SimCtx *simCtx = NULL;
    FILE   *csv = NULL;
    PetscInt nlocal = 0;
 
    PetscFunctionBeginUser;
    if (!plan) PetscFunctionReturn(0);
    simCtx = user->simCtx;
    PetscCall(DMSwarmGetLocalSize(user->swarm, &nlocal));
    if (simCtx->rank == 0) {
        char path[PETSC_MAX_PATH_LEN];
 
        PetscCall(PetscSNPrintf(path, sizeof(path), "%s/particle_initial_fields.csv", simCtx->analysis_dir));
        csv = fopen(path, "w");
        if (!csv) {
            LOG_ALLOW(GLOBAL, LOG_WARNING, "Could not write '%s'.\n", path);
        } else {
            fprintf(csv, "field,component,count,mean,variance,min,max");
            for (int bin = 0; bin < PARTICLE_FIELD_HISTOGRAM_BINS; ++bin) fprintf(csv, ",bin_%d", bin);
            fprintf(csv, "\n");
        }
    }
 
    for (PetscInt b = 0; b < plan->count; ++b) {
        const ParticleFieldBinding    *binding = &plan->bindings[b];
        const ParticleFieldDescriptor *descriptor = NULL;
        const PetscReal               *field = NULL;
        PetscReal                      scale = 1.0;
 
        PetscCall(ParticleFieldGetDescriptor(binding->field, &descriptor));
        PetscCall(FieldDimensionReferenceScale(&simCtx->scaling, descriptor->dimension, &scale));
        PetscCall(DMSwarmGetField(user->swarm, descriptor->canonical_name, NULL, NULL, (void **)&field));
        for (PetscInt c = 0; c < binding->components; ++c) {
            /* Sums and extremes in one reduction, then a histogram over the global range. */
            PetscReal sums[3] = {0.0, 0.0, 0.0}, extremes[2] = {PETSC_MAX_REAL, PETSC_MAX_REAL};
            PetscReal bins_local[PARTICLE_FIELD_HISTOGRAM_BINS] = {0.0}, bins[PARTICLE_FIELD_HISTOGRAM_BINS];
 
            for (PetscInt p = 0; p < nlocal; ++p) {
                const PetscReal value = field[binding->components * p + c] * scale;
                sums[0] += 1.0;
                sums[1] += value;
                sums[2] += value * value;
                extremes[0] = PetscMin(extremes[0], value);
                extremes[1] = PetscMin(extremes[1], -value);
            }
            PetscCallMPI(MPI_Allreduce(MPI_IN_PLACE, sums, 3, MPIU_REAL, MPI_SUM, PETSC_COMM_WORLD));
            PetscCallMPI(MPI_Allreduce(MPI_IN_PLACE, extremes, 2, MPIU_REAL, MPI_MIN, PETSC_COMM_WORLD));
            const PetscReal count = sums[0], lowest = extremes[0], highest = -extremes[1];
            const PetscReal mean = (count > 0.0) ? sums[1] / count : 0.0;
            const PetscReal variance = (count > 0.0) ? PetscMax(sums[2] / count - mean * mean, 0.0) : 0.0;
            const PetscReal width = (highest > lowest) ? (highest - lowest) / PARTICLE_FIELD_HISTOGRAM_BINS : 1.0;
 
            for (PetscInt p = 0; p < nlocal; ++p) {
                const PetscReal value = field[binding->components * p + c] * scale;
                PetscInt bin = (PetscInt)((value - lowest) / width);
                bins_local[PetscMax(0, PetscMin(bin, PARTICLE_FIELD_HISTOGRAM_BINS - 1))] += 1.0;
            }
            PetscCallMPI(MPI_Allreduce(bins_local, bins, PARTICLE_FIELD_HISTOGRAM_BINS, MPIU_REAL, MPI_SUM,
                                       PETSC_COMM_WORLD));
            LOG_ALLOW(GLOBAL, LOG_INFO,
                      "[Particle IC] %s[%" PetscInt_FMT "]: n=%.0f mean=%.6g var=%.6g min=%.6g max=%.6g\n",
                      descriptor->canonical_name, c, (double)count, (double)mean, (double)variance,
                      (double)(count > 0.0 ? lowest : 0.0), (double)(count > 0.0 ? highest : 0.0));
            if (csv) {
                fprintf(csv, "%s,%d,%.0f,%.10e,%.10e,%.10e,%.10e", descriptor->canonical_name, (int)c,
                        (double)count, (double)mean, (double)variance,
                        (double)(count > 0.0 ? lowest : 0.0), (double)(count > 0.0 ? highest : 0.0));
                for (int bin = 0; bin < PARTICLE_FIELD_HISTOGRAM_BINS; ++bin) fprintf(csv, ",%.0f", (double)bins[bin]);
                fprintf(csv, "\n");
            }
        }
        PetscCall(DMSwarmRestoreField(user->swarm, descriptor->canonical_name, NULL, NULL, (void **)&field));
    }
    if (csv) fclose(csv);
    PetscFunctionReturn(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ParticleFieldPlanDestroy()

PetscErrorCode ParticleFieldPlanDestroy

(

ParticleFieldPlan **

plan

)

Free a plan and its compiled expressions.

Parameters

[in,out]

plan

Plan to free; set to NULL.

Returns

Zero on success.

Free a plan and its compiled expressions.

See also

ParticleFieldPlanDestroy()

Definition at line 790 of file ParticleInitialConditions.c.

{
    PetscFunctionBeginUser;
    if (!plan || !*plan) PetscFunctionReturn(0);
    for (PetscInt b = 0; b < (*plan)->count; ++b) {
        for (PetscInt c = 0; c < PARTICLE_FIELD_MAX_COMPONENTS; ++c) {
            PetscCall(PicurvExpressionDestroy(&(*plan)->bindings[b].component[c]));
        }
    }
    PetscCall(PetscFree((*plan)->bindings));
    PetscCall(PetscFree(*plan));
    PetscFunctionReturn(0);
}

Here is the call graph for this function:

Here is the caller graph for this function: