particle_field_catalog.c

Go to the documentation of this file.

/**
 * @file particle_field_catalog.c
 * @brief Persistent solver-particle-field catalog implementation.
 */
 
#include "particle_field_catalog.h"
#include "logging.h"
 
#define PARTICLE_FIELD_ENTRY(field_id_, name_, alias1_, alias2_, components_, type_, registration_, capabilities_, default_, scatter_target_, dimension_) \
    [field_id_] = {                                                                                                                                     \
        field_id_, name_, alias1_, alias2_, components_, type_, registration_, capabilities_, default_, scatter_target_, dimension_                     \
    }
 
static const ParticleFieldDescriptor gParticleFieldCatalog[PARTICLE_FIELD_ID_COUNT] = {
    PARTICLE_FIELD_ENTRY(PARTICLE_FIELD_ID_POSITION, "position", "ParticlePosition", NULL,
                         3, PETSC_REAL, PARTICLE_FIELD_REGISTRATION_PICURV,
                         PARTICLE_FIELD_CAPABILITY_CHECKPOINT, 0.0, FIELD_ID_INVALID,
                FIELD_DIM_LENGTH),
    PARTICLE_FIELD_ENTRY(PARTICLE_FIELD_ID_VELOCITY, "velocity", "ParticleVelocity", NULL,
                         3, PETSC_REAL, PARTICLE_FIELD_REGISTRATION_PICURV,
                         PARTICLE_FIELD_CAPABILITY_DEFAULT_INITIALIZE |
                         PARTICLE_FIELD_CAPABILITY_EULERIAN_SCATTER |
                         PARTICLE_FIELD_CAPABILITY_CHECKPOINT, 0.0, FIELD_ID_UCAT,
                FIELD_DIM_VELOCITY),
    PARTICLE_FIELD_ENTRY(PARTICLE_FIELD_ID_CELL_ID, "DMSwarm_CellID", "CellID", NULL,
                         3, PETSC_INT, PARTICLE_FIELD_REGISTRATION_PICURV,
                         PARTICLE_FIELD_CAPABILITY_CHECKPOINT, 0.0, FIELD_ID_INVALID,
                FIELD_DIM_NOT_A_QUANTITY),
    PARTICLE_FIELD_ENTRY(PARTICLE_FIELD_ID_WEIGHT, "weight", "ParticleWeight", NULL,
                         3, PETSC_REAL, PARTICLE_FIELD_REGISTRATION_PICURV,
                         PARTICLE_FIELD_CAPABILITY_DEFAULT_INITIALIZE |
                         PARTICLE_FIELD_CAPABILITY_CHECKPOINT, 0.0, FIELD_ID_INVALID,
                FIELD_DIM_DIMENSIONLESS),
    PARTICLE_FIELD_ENTRY(PARTICLE_FIELD_ID_DIFFUSIVITY, "Diffusivity", NULL, NULL,
                         1, PETSC_REAL, PARTICLE_FIELD_REGISTRATION_PICURV,
                         PARTICLE_FIELD_CAPABILITY_DEFAULT_INITIALIZE, 1.0, FIELD_ID_INVALID,
                FIELD_DIM_DIFFUSIVITY),
    PARTICLE_FIELD_ENTRY(PARTICLE_FIELD_ID_DIFFUSIVITY_GRADIENT, "DiffusivityGradient", NULL, NULL,
                         3, PETSC_REAL, PARTICLE_FIELD_REGISTRATION_PICURV,
                         PARTICLE_FIELD_CAPABILITY_DEFAULT_INITIALIZE, 1.0, FIELD_ID_INVALID,
                FIELD_DIM_VELOCITY),
    PARTICLE_FIELD_ENTRY(PARTICLE_FIELD_ID_PSI, "Psi", NULL, NULL,
                         1, PETSC_REAL, PARTICLE_FIELD_REGISTRATION_PICURV,
                         PARTICLE_FIELD_CAPABILITY_DEFAULT_INITIALIZE |
                         PARTICLE_FIELD_CAPABILITY_MODEL_UPDATE |
                         PARTICLE_FIELD_CAPABILITY_EULERIAN_SCATTER |
                         PARTICLE_FIELD_CAPABILITY_CHECKPOINT |
                         PARTICLE_FIELD_CAPABILITY_USER_INITIALIZE,
                         0.0, FIELD_ID_PSI,
                FIELD_DIM_DIMENSIONLESS),
    PARTICLE_FIELD_ENTRY(PARTICLE_FIELD_ID_LOCATION_STATUS, "DMSwarm_location_status", "Migration Status", NULL,
                         1, PETSC_INT, PARTICLE_FIELD_REGISTRATION_PICURV,
                         PARTICLE_FIELD_CAPABILITY_CHECKPOINT, 0.0, FIELD_ID_INVALID,
                FIELD_DIM_NOT_A_QUANTITY),
    PARTICLE_FIELD_ENTRY(PARTICLE_FIELD_ID_PID, "DMSwarm_pid", "pid", "Particle ID",
                         1, PETSC_INT64, PARTICLE_FIELD_REGISTRATION_PETSC,
                         PARTICLE_FIELD_CAPABILITY_CHECKPOINT, 0.0, FIELD_ID_INVALID,
                FIELD_DIM_NOT_A_QUANTITY),
    PARTICLE_FIELD_ENTRY(PARTICLE_FIELD_ID_RANK, "DMSwarm_rank", "rank", NULL,
                         1, PETSC_INT, PARTICLE_FIELD_REGISTRATION_PETSC,
                         PARTICLE_FIELD_CAPABILITY_NONE, 0.0, FIELD_ID_INVALID,
                FIELD_DIM_NOT_A_QUANTITY)
};
 
_Static_assert(sizeof(gParticleFieldCatalog) / sizeof(gParticleFieldCatalog[0]) == PARTICLE_FIELD_ID_COUNT,
               "Particle field catalog must contain one entry per ParticleFieldId.");
 
/**
 * @brief Validates and returns one immutable particle-field descriptor.
 * @see ParticleFieldGetDescriptor()
 */
PetscErrorCode ParticleFieldGetDescriptor(ParticleFieldId field_id,
                                          const ParticleFieldDescriptor **descriptor)
{
    PetscFunctionBeginUser;
    PROFILE_FUNCTION_BEGIN;
    PetscCheck(descriptor != NULL, PETSC_COMM_SELF, PETSC_ERR_ARG_NULL,
               "Particle field descriptor output cannot be NULL.");
    PetscCheck(field_id >= 0 && field_id < PARTICLE_FIELD_ID_COUNT,
               PETSC_COMM_SELF, PETSC_ERR_ARG_OUTOFRANGE,
               "Invalid ParticleFieldId value %d.", (int)field_id);
    PetscCheck(gParticleFieldCatalog[field_id].id == field_id,
               PETSC_COMM_SELF, PETSC_ERR_PLIB,
               "Particle field catalog entry %d is not initialized consistently.", (int)field_id);
 
    *descriptor = &gParticleFieldCatalog[field_id];
    PROFILE_FUNCTION_END;
    PetscFunctionReturn(0);
}
 
/**
 * @brief Returns the particle field scattering to one Eulerian field.
 * @see ParticleFieldIdFromScatterTarget()
 */
PetscErrorCode ParticleFieldIdFromScatterTarget(FieldId target, ParticleFieldId *field_id)
{
    PetscFunctionBeginUser;
    PROFILE_HELPER_BEGIN;
    PetscCheck(field_id != NULL, PETSC_COMM_SELF, PETSC_ERR_ARG_NULL,
               "ParticleFieldId output cannot be NULL.");
    for (PetscInt index = 0; index < PARTICLE_FIELD_ID_COUNT; ++index) {
        if ((gParticleFieldCatalog[index].capabilities & PARTICLE_FIELD_CAPABILITY_EULERIAN_SCATTER) &&
            gParticleFieldCatalog[index].eulerian_scatter_target == target) {
            *field_id = (ParticleFieldId)index;
            PROFILE_HELPER_END;
            PetscFunctionReturn(0);
        }
    }
    SETERRQ(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG,
            "No particle field scatters to Eulerian field '%s'.", FieldCanonicalName(target));
    PROFILE_HELPER_END;
}
 
/**
 * @brief Resolves particle field text once by searching canonical names and aliases.
 * @see ParticleFieldIdFromName()
 */
PetscErrorCode ParticleFieldIdFromName(const char *field_name, ParticleFieldId *field_id)
{
    PetscBool found = PETSC_FALSE;
 
    PetscFunctionBeginUser;
    PROFILE_FUNCTION_BEGIN;
    PetscCall(ParticleFieldTryIdFromName(field_name, field_id, &found));
    PetscCheck(found, PETSC_COMM_SELF, PETSC_ERR_ARG_UNKNOWN_TYPE,
               "Particle field name '%s' is not registered in the persistent particle field catalog.",
               field_name);
    PROFILE_FUNCTION_END;
    PetscFunctionReturn(0);
}
 
/**
 * @brief Searches canonical names and aliases, reporting a miss instead of failing.
 * @see ParticleFieldTryIdFromName()
 */
PetscErrorCode ParticleFieldTryIdFromName(const char *field_name, ParticleFieldId *field_id,
                                          PetscBool *found)
{
    PetscFunctionBeginUser;
    PROFILE_FUNCTION_BEGIN;
    PetscCheck(field_name != NULL, PETSC_COMM_SELF, PETSC_ERR_ARG_NULL,
               "Particle field name cannot be NULL.");
    PetscCheck(field_id != NULL && found != NULL, PETSC_COMM_SELF, PETSC_ERR_ARG_NULL,
               "ParticleFieldId and found outputs cannot be NULL.");
 
    *field_id = PARTICLE_FIELD_ID_INVALID;
    *found = PETSC_FALSE;
    for (PetscInt index = 0; index < PARTICLE_FIELD_ID_COUNT; ++index) {
        const ParticleFieldDescriptor *descriptor = &gParticleFieldCatalog[index];
        PetscBool match = PETSC_FALSE;
 
        PetscCall(PetscStrcasecmp(field_name, descriptor->canonical_name, &match));
        if (!match && descriptor->alias_1) PetscCall(PetscStrcasecmp(field_name, descriptor->alias_1, &match));
        if (!match && descriptor->alias_2) PetscCall(PetscStrcasecmp(field_name, descriptor->alias_2, &match));
        if (match) {
            *field_id = descriptor->id;
            *found = PETSC_TRUE;
            break;
        }
    }
    PROFILE_FUNCTION_END;
    PetscFunctionReturn(0);
}
 
/**
 * @brief Returns the canonical PETSc name without performing name lookup.
 * @see ParticleFieldName()
 */
const char *ParticleFieldName(ParticleFieldId field_id)
{
    PROFILE_HELPER_BEGIN;
    if (field_id < 0 || field_id >= PARTICLE_FIELD_ID_COUNT) { PROFILE_HELPER_END; return "InvalidParticleField"; }
    if (gParticleFieldCatalog[field_id].id != field_id) { PROFILE_HELPER_END; return "InvalidParticleField"; }
    PROFILE_HELPER_END;
    return gParticleFieldCatalog[field_id].canonical_name;
}
 
#undef PARTICLE_FIELD_ENTRY