test_periodic_dev.c

Go to the documentation of this file.

/**
 * @file test_periodic_dev.c
 * @brief Focused geometric-periodic boundary tests.
 */
 
#include "test_support.h"
#include "Metric.h"
 
#include "Boundaries.h"
#include "walkingsearch.h"
#include "setup.h"
 
/**
 * @brief Destroys one boundary-condition handler allocated by a periodic test.
 */
static PetscErrorCode DestroyBoundaryHandler(BoundaryCondition **bc_ptr)
{
    BoundaryCondition *bc = NULL;
 
    PetscFunctionBeginUser;
    if (!bc_ptr || !*bc_ptr) PetscFunctionReturn(0);
 
    bc = *bc_ptr;
    if (bc->Destroy) {
        PetscCall(bc->Destroy(bc));
    }
    PetscCall(PetscFree(bc));
    *bc_ptr = NULL;
    PetscFunctionReturn(0);
}
/**
 * @brief Marks the x faces as periodic for periodic-transfer harnesses.
 */
static void MarkXPeriodic(UserCtx *user)
{
    user->boundary_faces[BC_FACE_NEG_X].face_id = BC_FACE_NEG_X;
    user->boundary_faces[BC_FACE_NEG_X].mathematical_type = PERIODIC;
    user->boundary_faces[BC_FACE_NEG_X].handler_type = BC_HANDLER_PERIODIC_GEOMETRIC;
    user->boundary_faces[BC_FACE_POS_X].face_id = BC_FACE_POS_X;
    user->boundary_faces[BC_FACE_POS_X].mathematical_type = PERIODIC;
    user->boundary_faces[BC_FACE_POS_X].handler_type = BC_HANDLER_PERIODIC_GEOMETRIC;
}
/**
 * @brief Marks the y faces as periodic for periodic-transfer harnesses.
 */
static void MarkYPeriodic(UserCtx *user)
{
    user->boundary_faces[BC_FACE_NEG_Y].face_id = BC_FACE_NEG_Y;
    user->boundary_faces[BC_FACE_NEG_Y].mathematical_type = PERIODIC;
    user->boundary_faces[BC_FACE_NEG_Y].handler_type = BC_HANDLER_PERIODIC_GEOMETRIC;
    user->boundary_faces[BC_FACE_POS_Y].face_id = BC_FACE_POS_Y;
    user->boundary_faces[BC_FACE_POS_Y].mathematical_type = PERIODIC;
    user->boundary_faces[BC_FACE_POS_Y].handler_type = BC_HANDLER_PERIODIC_GEOMETRIC;
}
/**
 * @brief Tests periodic configuration rejects an unpaired geometric periodic face.
 */
static PetscErrorCode TestPeriodicConfigurationRequiresPairedFaces(void)
{
    SimCtx *simCtx = NULL;
    UserCtx *user = NULL;
    PetscErrorCode ierr_validate = 0;
 
    PetscFunctionBeginUser;
    PetscCall(PicurvCreateMinimalContextsWithPeriodicity(&simCtx, &user, 4, 4, 4, PETSC_TRUE, PETSC_FALSE, PETSC_FALSE));
    user->boundary_faces[BC_FACE_NEG_X].mathematical_type = PERIODIC;
    user->boundary_faces[BC_FACE_NEG_X].handler_type = BC_HANDLER_PERIODIC_GEOMETRIC;
 
    PetscCall(PetscPushErrorHandler(PetscIgnoreErrorHandler, NULL));
    ierr_validate = BoundarySystem_Validate(user);
    PetscCall(PetscPopErrorHandler());
 
    PetscCall(PicurvAssertBool((PetscBool)(ierr_validate != 0), "unpaired periodic faces should be rejected"));
    PetscCall(PicurvDestroyMinimalContexts(&simCtx, &user));
    PetscFunctionReturn(0);
}
/**
 * @brief Tests constant translational periodic geometry is accepted and stored.
 */
static PetscErrorCode TestPeriodicGeometryStoresTranslation(void)
{
    SimCtx *simCtx = NULL;
    UserCtx *user = NULL;
    Vec gcoor = NULL;
    const Cmpnts ***coor = NULL;
    PetscReal expected_x = 0.0;
 
    PetscFunctionBeginUser;
    PetscCall(PicurvCreateMinimalContextsWithPeriodicity(&simCtx, &user, 4, 4, 4, PETSC_TRUE, PETSC_FALSE, PETSC_FALSE));
    MarkXPeriodic(user);
 
    PetscCall(DMGetCoordinates(user->da, &gcoor));
    PetscCall(DMDAVecGetArrayRead(user->fda, gcoor, &coor));
    expected_x = coor[0][0][user->info.mx - 2].x - coor[0][0][0].x;
    PetscCall(DMDAVecRestoreArrayRead(user->fda, gcoor, &coor));
 
    PetscCall(ValidatePeriodicGeometry(user));
    PetscCall(PicurvAssertBool(user->periodic_translation_valid[0], "X-periodic translation should be marked valid"));
    PetscCall(PicurvAssertBool((PetscBool)!user->periodic_translation_valid[1], "Y translation should remain invalid"));
    PetscCall(PicurvAssertBool((PetscBool)!user->periodic_translation_valid[2], "Z translation should remain invalid"));
    PetscCall(PicurvAssertRealNear(expected_x, user->periodic_translation[0].x, 1.0e-12, "stored X translation"));
    PetscCall(PicurvAssertRealNear(0.0, user->periodic_translation[0].y, 1.0e-12, "stored X translation y component"));
    PetscCall(PicurvAssertRealNear(0.0, user->periodic_translation[0].z, 1.0e-12, "stored X translation z component"));
 
    PetscCall(PicurvDestroyMinimalContexts(&simCtx, &user));
    PetscFunctionReturn(0);
}
/**
 * @brief Tests that a particle beyond either x-periodic face re-enters through the paired face, shifted by the seam translation.
 */
static PetscErrorCode TestLocateParticleWrapsThroughPeriodicFace(void)
{
    SimCtx *simCtx = NULL;
    UserCtx *user = NULL;
    Particle particle;
    ParticleLocationStatus status = NEEDS_LOCATION;
    Vec gcoor = NULL;
    const Cmpnts ***coor = NULL;
    PetscReal x0, y0, T, Ty, yc, zc;
 
    PetscFunctionBeginUser;
    PetscCall(PicurvCreateMinimalContextsWithPeriodicity(&simCtx, &user, 4, 4, 4, PETSC_TRUE, PETSC_TRUE, PETSC_FALSE));
    MarkXPeriodic(user);
    MarkYPeriodic(user);
    PetscCall(ValidatePeriodicGeometry(user));
    user->boundary_faces[BC_FACE_NEG_X].particle_policy = PARTICLE_BOUNDARY_WRAP;
    user->boundary_faces[BC_FACE_POS_X].particle_policy = PARTICLE_BOUNDARY_WRAP;
    user->boundary_faces[BC_FACE_NEG_Y].particle_policy = PARTICLE_BOUNDARY_WRAP;
    user->boundary_faces[BC_FACE_POS_Y].particle_policy = PARTICLE_BOUNDARY_WRAP;
    PetscCall(SetupDomainCellDecompositionMap(user));
    simCtx->searchMetrics.currentSettlementPass = 1;
 
    /* Seam origin, translation, and the centre of the (., 1, 1) cell row in y and z. */
    PetscCall(DMGetCoordinates(user->da, &gcoor));
    PetscCall(DMDAVecGetArrayRead(user->fda, gcoor, &coor));
    x0 = coor[0][0][0].x;
    y0 = coor[0][0][0].y;
    yc = 0.5 * (coor[1][1][0].y + coor[1][2][0].y);
    zc = 0.5 * (coor[1][1][0].z + coor[2][1][0].z);
    PetscCall(DMDAVecRestoreArrayRead(user->fda, gcoor, &coor));
    T = user->periodic_translation[0].x;
    Ty = user->periodic_translation[1].y;
 
    /* Beyond -Xi out of cell 0: re-enters at the +Xi end. */
    PetscCall(PetscMemzero(&particle, sizeof(particle)));
    particle.PID = 51;
    particle.cell[0] = 0; particle.cell[1] = 1; particle.cell[2] = 1;
    particle.loc.x = x0 - 0.01 * T; particle.loc.y = yc; particle.loc.z = zc;
    PetscCall(LocateParticleOrFindMigrationTarget(user, &particle, &status));
    PetscCall(PicurvAssertIntEqual(ACTIVE_AND_LOCATED, status, "a wrapped particle should be located"));
    PetscCall(PicurvAssertRealNear(x0 + 0.99 * T, particle.loc.x, 1.0e-12, "x shifts forward by the seam translation"));
    PetscCall(PicurvAssertIntEqual(user->IM - 2, particle.cell[0], "the particle lands in the last cell"));
 
    /* Beyond +Xi out of the last cell: re-enters at the -Xi end. */
    PetscCall(PetscMemzero(&particle, sizeof(particle)));
    particle.PID = 52;
    particle.cell[0] = user->IM - 2; particle.cell[1] = 1; particle.cell[2] = 1;
    particle.loc.x = x0 + 1.01 * T; particle.loc.y = yc; particle.loc.z = zc;
    PetscCall(LocateParticleOrFindMigrationTarget(user, &particle, &status));
    PetscCall(PicurvAssertIntEqual(ACTIVE_AND_LOCATED, status, "a wrapped particle should be located"));
    PetscCall(PicurvAssertRealNear(x0 + 0.01 * T, particle.loc.x, 1.0e-12, "x shifts back by the seam translation"));
    PetscCall(PicurvAssertIntEqual(0, particle.cell[0], "the particle lands in the first cell"));
 
    /* Beyond -Xi and -Eta out of the corner cell: both seams are crossed in one wrap step. */
    PetscCall(PetscMemzero(&particle, sizeof(particle)));
    particle.PID = 53;
    particle.cell[0] = 0; particle.cell[1] = 0; particle.cell[2] = 1;
    particle.loc.x = x0 - 0.01 * T; particle.loc.y = y0 - 0.01 * Ty; particle.loc.z = zc;
    PetscCall(LocateParticleOrFindMigrationTarget(user, &particle, &status));
    PetscCall(PicurvAssertIntEqual(ACTIVE_AND_LOCATED, status, "a corner-wrapped particle should be located"));
    PetscCall(PicurvAssertRealNear(x0 + 0.99 * T, particle.loc.x, 1.0e-12, "x shifts forward at the corner"));
    PetscCall(PicurvAssertRealNear(y0 + 0.99 * Ty, particle.loc.y, 1.0e-12, "y shifts forward at the corner"));
    PetscCall(PicurvAssertIntEqual(user->IM - 2, particle.cell[0], "the corner particle lands in the last i cell"));
    PetscCall(PicurvAssertIntEqual(user->JM - 2, particle.cell[1], "the corner particle lands in the last j cell"));
    PetscCall(PicurvAssertIntEqual(4, (PetscInt)simCtx->searchMetrics.wrapCount, "one wrap per crossed periodic face"));
 
    PetscCall(PicurvDestroyMinimalContexts(&simCtx, &user));
    PetscFunctionReturn(0);
}
/**
 * @brief An off-axis seam: a rotated x-periodic grid validates the rotated translation and wraps by it.
 *
 * Rotates the grid 30 degrees about z, so the x seam translation gains a y component, then checks
 * that the validated translation is the rotated one and that a particle beyond -Xi re-enters at the
 * +Xi end shifted by it.
 */
static PetscErrorCode TestLocateParticleWrapsThroughOffAxisSeam(void)
{
    SimCtx *simCtx = NULL;
    UserCtx *user = NULL;
    Particle particle;
    ParticleLocationStatus status = NEEDS_LOCATION;
    Vec gcoor = NULL;
    Cmpnts ***coor = NULL;
    const Cmpnts ***lcoor = NULL;
    const PetscReal c = PetscCosReal(PETSC_PI / 6.0), s = PetscSinReal(PETSC_PI / 6.0);
    PetscReal T0, x0, yc, zc;
    Cmpnts p0;
 
    PetscFunctionBeginUser;
    PetscCall(PicurvCreateMinimalContextsWithPeriodicity(&simCtx, &user, 4, 4, 4, PETSC_TRUE, PETSC_FALSE, PETSC_FALSE));
    MarkXPeriodic(user);
    PetscCall(ValidatePeriodicGeometry(user));
    T0 = user->periodic_translation[0].x;
 
    /* Seam origin and the centre of the (., 1, 1) row, before rotation. */
    PetscCall(DMGetCoordinatesLocal(user->da, &gcoor));
    PetscCall(DMDAVecGetArrayRead(user->fda, gcoor, &lcoor));
    x0 = lcoor[0][0][0].x;
    yc = 0.5 * (lcoor[1][1][0].y + lcoor[1][2][0].y);
    zc = 0.5 * (lcoor[1][1][0].z + lcoor[2][1][0].z);
    PetscCall(DMDAVecRestoreArrayRead(user->fda, gcoor, &lcoor));
 
    /* Rotate every node about the z axis through the origin. */
    PetscCall(DMGetCoordinates(user->da, &gcoor));
    PetscCall(DMDAVecGetArray(user->fda, gcoor, &coor));
    for (PetscInt k = user->info.zs; k < user->info.zs + user->info.zm; k++)
        for (PetscInt j = user->info.ys; j < user->info.ys + user->info.ym; j++)
            for (PetscInt i = user->info.xs; i < user->info.xs + user->info.xm; i++) {
                const Cmpnts q = coor[k][j][i];
                coor[k][j][i].x = c * q.x - s * q.y;
                coor[k][j][i].y = s * q.x + c * q.y;
            }
    PetscCall(DMDAVecRestoreArray(user->fda, gcoor, &coor));
    PetscCall(UpdateLocalGhosts(user, FIELD_ID_COORDINATES)); /* As the grid builders refresh them */
    PetscCall(MetricDestroyFacePlanes(user)); /* The grid moved: its search planes are rebuilt */
    PetscCall(MetricComputeFacePlanes(user));
    PetscCall(ValidatePeriodicGeometry(user));
    PetscCall(PicurvAssertRealNear(c * T0, user->periodic_translation[0].x, 1.0e-12, "translation x is rotated"));
    PetscCall(PicurvAssertRealNear(s * T0, user->periodic_translation[0].y, 1.0e-12, "translation gains a y component"));
 
    user->boundary_faces[BC_FACE_NEG_X].particle_policy = PARTICLE_BOUNDARY_WRAP;
    user->boundary_faces[BC_FACE_POS_X].particle_policy = PARTICLE_BOUNDARY_WRAP;
    PetscCall(SetupDomainCellDecompositionMap(user));
    simCtx->searchMetrics.currentSettlementPass = 1;
 
    /* Beyond -Xi out of cell 0: re-enters at the +Xi end, shifted along the rotated translation. */
    PetscCall(PetscMemzero(&particle, sizeof(particle)));
    particle.PID = 54;
    particle.cell[0] = 0; particle.cell[1] = 1; particle.cell[2] = 1;
    p0.x = x0 - 0.01 * T0; p0.y = yc; p0.z = zc;
    particle.loc.x = c * p0.x - s * p0.y; particle.loc.y = s * p0.x + c * p0.y; particle.loc.z = p0.z;
    PetscCall(LocateParticleOrFindMigrationTarget(user, &particle, &status));
    PetscCall(PicurvAssertIntEqual(ACTIVE_AND_LOCATED, status, "a particle wrapped through an off-axis seam should be located"));
    PetscCall(PicurvAssertRealNear(c * (p0.x + T0) - s * p0.y, particle.loc.x, 1.0e-12, "x shifts along the rotated translation"));
    PetscCall(PicurvAssertRealNear(s * (p0.x + T0) + c * p0.y, particle.loc.y, 1.0e-12, "y shifts along the rotated translation"));
    PetscCall(PicurvAssertIntEqual(user->IM - 2, particle.cell[0], "the particle lands in the last cell"));
 
    PetscCall(PicurvDestroyMinimalContexts(&simCtx, &user));
    PetscFunctionReturn(0);
}
/**
 * @brief Tests mixed periodic directions are validated and stored independently.
 */
static PetscErrorCode TestPeriodicGeometryStoresMixedTranslations(void)
{
    SimCtx *simCtx = NULL;
    UserCtx *user = NULL;
 
    PetscFunctionBeginUser;
    PetscCall(PicurvCreateMinimalContextsWithPeriodicity(&simCtx, &user, 4, 6, 4, PETSC_TRUE, PETSC_TRUE, PETSC_FALSE));
    MarkXPeriodic(user);
    MarkYPeriodic(user);
 
    PetscCall(ValidatePeriodicGeometry(user));
    PetscCall(PicurvAssertBool(user->periodic_translation_valid[0], "mixed-periodic X translation should be valid"));
    PetscCall(PicurvAssertBool(user->periodic_translation_valid[1], "mixed-periodic Y translation should be valid"));
    PetscCall(PicurvAssertBool((PetscBool)!user->periodic_translation_valid[2], "mixed-periodic Z translation should remain invalid"));
    PetscCall(PicurvAssertBool((PetscBool)(PetscAbsReal(user->periodic_translation[0].x) > 0.0),
                               "mixed-periodic X translation should have nonzero x component"));
    PetscCall(PicurvAssertBool((PetscBool)(PetscAbsReal(user->periodic_translation[1].y) > 0.0),
                               "mixed-periodic Y translation should have nonzero y component"));
 
    PetscCall(PicurvDestroyMinimalContexts(&simCtx, &user));
    PetscFunctionReturn(0);
}
/**
 * @brief Tests non-translational seam geometry fails before metric construction.
 */
static PetscErrorCode TestPeriodicGeometryRejectsVaryingTranslation(void)
{
    SimCtx *simCtx = NULL;
    UserCtx *user = NULL;
    Vec gcoor = NULL;
    Cmpnts ***coor = NULL;
    PetscErrorCode ierr_validate = 0;
 
    PetscFunctionBeginUser;
    PetscCall(PicurvCreateMinimalContextsWithPeriodicity(&simCtx, &user, 4, 4, 4, PETSC_TRUE, PETSC_FALSE, PETSC_FALSE));
    MarkXPeriodic(user);
 
    PetscCall(DMGetCoordinates(user->da, &gcoor));
    PetscCall(DMDAVecGetArray(user->fda, gcoor, &coor));
    coor[1][1][user->info.mx - 2].y += 0.25;
    PetscCall(DMDAVecRestoreArray(user->fda, gcoor, &coor));
    PetscCall(UpdateLocalGhosts(user, FIELD_ID_COORDINATES));
 
    PetscCall(PetscPushErrorHandler(PetscIgnoreErrorHandler, NULL));
    ierr_validate = ValidatePeriodicGeometry(user);
    PetscCall(PetscPopErrorHandler());
 
    PetscCall(PicurvAssertBool((PetscBool)(ierr_validate != 0), "varying seam translation should be rejected"));
    PetscCall(PicurvDestroyMinimalContexts(&simCtx, &user));
    PetscFunctionReturn(0);
}
 
/**
 * @brief Tests face-center coordinates remain geometrically continuous across a periodic seam.
 */
static PetscErrorCode TestPeriodicFaceCenterCoordinateSynchronization(void)
{
    SimCtx *simCtx = NULL;
    UserCtx *user = NULL;
    Cmpnts ***centx = NULL;
    const Cmpnts ***lcentx = NULL;
    const FieldId fields[] = {FIELD_ID_CENTX};
    PetscReal translation, spacing;
 
    PetscFunctionBeginUser;
    PetscCall(PicurvCreateMinimalContextsWithPeriodicity(&simCtx, &user, 6, 4, 4, PETSC_TRUE, PETSC_FALSE, PETSC_FALSE));
    MarkXPeriodic(user);
    PetscCall(ValidatePeriodicGeometry(user));
    translation = user->periodic_translation[0].x;
    spacing = translation / (PetscReal)(user->info.mx - 2);
 
    PetscCall(DMDAVecGetArray(user->fda, user->Centx, &centx));
    for (PetscInt k = user->info.zs; k < user->info.zs + user->info.zm; k++) {
        for (PetscInt j = user->info.ys; j < user->info.ys + user->info.ym; j++) {
            for (PetscInt i = user->info.xs; i < user->info.xs + user->info.xm; i++) {
                centx[k][j][i] = (Cmpnts){spacing * i, 2.0 + j, 3.0 + k};
            }
        }
    }
    PetscCall(DMDAVecRestoreArray(user->fda, user->Centx, &centx));
 
    PetscCall(SynchronizePeriodicFaceFields(user, 'i', 1, fields));
    PetscCall(DMDAVecGetArrayRead(user->fda, user->lCentx, &lcentx));
    PetscCall(PicurvAssertRealNear(-spacing, lcentx[2][2][-1].x, 1.0e-12,
                                   "translated Centx negative adjacent ghost"));
    PetscCall(PicurvAssertRealNear(0.0, lcentx[2][2][0].x, 1.0e-12,
                                   "translated Centx negative endpoint"));
    PetscCall(PicurvAssertRealNear(translation + spacing, lcentx[2][2][user->info.mx - 1].x, 1.0e-12,
                                   "translated Centx positive endpoint"));
    PetscCall(PicurvAssertRealNear(translation + 2.0 * spacing, lcentx[2][2][user->info.mx].x, 1.0e-12,
                                   "translated Centx positive adjacent ghost"));
    PetscCall(DMDAVecRestoreArrayRead(user->fda, user->lCentx, &lcentx));
 
    PetscCall(PicurvDestroyMinimalContexts(&simCtx, &user));
    PetscFunctionReturn(0);
}
 
/**
 * @brief Tests the dedicated QUICK outer-ghost repair for cell-centered inputs.
 */
static PetscErrorCode TestPeriodicQuickStencilPreparation(void)
{
    SimCtx *simCtx = NULL;
    UserCtx *user = NULL;
    Cmpnts ***ucat = NULL;
    PetscReal ***nvert = NULL;
 
    PetscFunctionBeginUser;
    PetscCall(PicurvCreateMinimalContextsWithPeriodicity(&simCtx, &user, 6, 4, 4, PETSC_TRUE, PETSC_FALSE, PETSC_FALSE));
    MarkXPeriodic(user);
 
    PetscCall(DMDAVecGetArray(user->fda, user->Ucat, &ucat));
    PetscCall(DMDAVecGetArray(user->da, user->Nvert, &nvert));
    for (PetscInt k = user->info.zs; k < user->info.zs + user->info.zm; k++) {
        for (PetscInt j = user->info.ys; j < user->info.ys + user->info.ym; j++) {
            for (PetscInt i = user->info.xs; i < user->info.xs + user->info.xm; i++) {
                ucat[k][j][i] = (Cmpnts){100.0 + i, 200.0 + i, 300.0 + i};
                nvert[k][j][i] = 400.0 + i;
            }
        }
    }
    PetscCall(DMDAVecRestoreArray(user->da, user->Nvert, &nvert));
    PetscCall(DMDAVecRestoreArray(user->fda, user->Ucat, &ucat));
    PetscCall(UpdateLocalGhosts(user, FIELD_ID_UCAT));
    PetscCall(UpdateLocalGhosts(user, FIELD_ID_NVERT));
    PetscCall(PreparePeriodicQuickStencilFields(user, user->lUcat, user->lNvert));
 
    PetscCall(DMDAVecGetArrayRead(user->fda, user->lUcat, &ucat));
    PetscCall(DMDAVecGetArrayRead(user->da, user->lNvert, &nvert));
    PetscCall(PicurvAssertRealNear(100.0 + user->info.mx - 3, ucat[2][2][-1].x, 1.0e-12,
                                   "QUICK Ucat negative outer ghost"));
    PetscCall(PicurvAssertRealNear(102.0, ucat[2][2][user->info.mx].x, 1.0e-12,
                                   "QUICK Ucat positive outer ghost"));
    PetscCall(PicurvAssertRealNear(400.0 + user->info.mx - 3, nvert[2][2][-1], 1.0e-12,
                                   "QUICK Nvert negative outer ghost"));
    PetscCall(PicurvAssertRealNear(402.0, nvert[2][2][user->info.mx], 1.0e-12,
                                   "QUICK Nvert positive outer ghost"));
    PetscCall(DMDAVecRestoreArrayRead(user->da, user->lNvert, &nvert));
    PetscCall(DMDAVecRestoreArrayRead(user->fda, user->lUcat, &ucat));
 
    PetscCall(PicurvDestroyMinimalContexts(&simCtx, &user));
    PetscFunctionReturn(0);
}
/**
 * @brief Tests periodic geometric factory construction.
 */
static PetscErrorCode TestPeriodicGeometricFactoryAssignment(void)
{
    BoundaryCondition *bc = NULL;
 
    PetscFunctionBeginUser;
    PetscCall(BoundaryCondition_Create(BC_HANDLER_PERIODIC_GEOMETRIC, &bc));
    PetscCall(PicurvAssertBool((PetscBool)(bc != NULL), "periodic geometric factory should allocate a handler"));
    PetscCall(PicurvAssertIntEqual(BC_PRIORITY_WALL, bc->priority, "periodic geometric handler priority"));
    PetscCall(PicurvAssertBool((PetscBool)(bc->Apply == NULL), "periodic geometric handler should not expose Apply"));
    PetscCall(PicurvAssertBool((PetscBool)(bc->Initialize == NULL), "periodic geometric handler should not expose Initialize"));
    PetscCall(DestroyBoundaryHandler(&bc));
    PetscFunctionReturn(0);
}
/**
 * @brief Tests periodic metric transfer through the aggregate periodic-metrics helper.
 */
static PetscErrorCode TestApplyMetricsPeriodicBCsSynchronizesAj(void)
{
    SimCtx *simCtx = NULL;
    UserCtx *user = NULL;
    PetscReal ***aj = NULL;
    PetscReal expected_neg_face = 0.0;
    PetscReal expected_pos_face = 0.0;
    PetscReal expected_neg_ghost = 0.0;
    PetscReal expected_pos_ghost = 0.0;
 
    PetscFunctionBeginUser;
    PetscCall(PicurvCreateMinimalContextsWithPeriodicity(&simCtx, &user, 4, 4, 4, PETSC_TRUE, PETSC_FALSE, PETSC_FALSE));
    MarkXPeriodic(user);
    PetscCall(ValidatePeriodicGeometry(user));
 
    PetscCall(DMDAVecGetArray(user->da, user->Aj, &aj));
    for (PetscInt k = user->info.zs; k < user->info.zs + user->info.zm; ++k) {
        for (PetscInt j = user->info.ys; j < user->info.ys + user->info.ym; ++j) {
            for (PetscInt i = user->info.xs; i < user->info.xs + user->info.xm; ++i) {
                aj[k][j][i] = 100.0 + (PetscReal)i;
            }
        }
    }
    PetscCall(DMDAVecRestoreArray(user->da, user->Aj, &aj));
    PetscCall(DMGlobalToLocalBegin(user->da, user->Aj, INSERT_VALUES, user->lAj));
    PetscCall(DMGlobalToLocalEnd(user->da, user->Aj, INSERT_VALUES, user->lAj));
    PetscCall(DMDAVecGetArrayRead(user->da, user->lAj, &aj));
    expected_neg_face = aj[2][2][user->info.mx - 2];
    expected_pos_face = aj[2][2][1];
    expected_neg_ghost = expected_pos_face;
    expected_pos_ghost = expected_neg_face;
    PetscCall(DMDAVecRestoreArrayRead(user->da, user->lAj, &aj));
 
    PetscCall(ApplyMetricsPeriodicBCs(user));
 
    PetscCall(DMDAVecGetArrayRead(user->da, user->lAj, &aj));
    PetscCall(PicurvAssertRealNear(expected_neg_face, aj[2][2][0], 1.0e-12, "NEG_X periodic metric face should copy from the opposite interior face"));
    PetscCall(PicurvAssertRealNear(expected_pos_face, aj[2][2][user->info.mx - 1], 1.0e-12, "POS_X periodic metric face should copy from the leading interior face"));
    PetscCall(PicurvAssertRealNear(expected_neg_ghost, aj[2][2][-1], 1.0e-12, "cell-centered Aj negative ghost should retain PETSc wraparound"));
    PetscCall(PicurvAssertRealNear(expected_pos_ghost, aj[2][2][user->info.mx], 1.0e-12, "cell-centered Aj positive ghost should retain PETSc wraparound"));
    PetscCall(DMDAVecRestoreArrayRead(user->da, user->lAj, &aj));
 
    PetscCall(PicurvDestroyMinimalContexts(&simCtx, &user));
    PetscFunctionReturn(0);
}
/**
 * @brief Tests ordered cell-field synchronization across two periodic directions.
 */
static PetscErrorCode TestSynchronizePeriodicCellFieldsCopiesMixedAxes(void)
{
    SimCtx *simCtx = NULL;
    UserCtx *user = NULL;
    PetscReal ***p = NULL;
    PetscReal ***cs = NULL;
    PetscReal ***diffusivity = NULL;
    Cmpnts ***ucat = NULL;
    PetscInt mx, my;
    const FieldId fields[] = {FIELD_ID_UCAT, FIELD_ID_P, FIELD_ID_PHI, FIELD_ID_NVERT, FIELD_ID_NU_T, FIELD_ID_CS, FIELD_ID_DIFFUSIVITY};
 
    PetscFunctionBeginUser;
    PetscCall(PicurvCreateMinimalContextsWithPeriodicity(&simCtx, &user, 4, 4, 4, PETSC_TRUE, PETSC_TRUE, PETSC_FALSE));
    MarkXPeriodic(user);
    MarkYPeriodic(user);
 
    PetscCall(DMCreateGlobalVector(user->da, &user->Nu_t));
    PetscCall(DMCreateLocalVector(user->da, &user->lNu_t));
    PetscCall(VecSet(user->Nu_t, 5.0));
    PetscCall(VecSet(user->lNu_t, 0.0));
    PetscCall(DMCreateGlobalVector(user->da, &user->CS));
    PetscCall(DMCreateLocalVector(user->da, &user->lCs));
    PetscCall(VecSet(user->Phi, 3.0));
    PetscCall(VecSet(user->Nvert, 4.0));
 
    PetscCall(DMDAVecGetArray(user->da, user->P, &p));
    PetscCall(DMDAVecGetArray(user->da, user->CS, &cs));
    PetscCall(DMDAVecGetArray(user->da, user->Diffusivity, &diffusivity));
    PetscCall(DMDAVecGetArray(user->fda, user->Ucat, &ucat));
    for (PetscInt k = user->info.zs; k < user->info.zs + user->info.zm; ++k) {
        for (PetscInt j = user->info.ys; j < user->info.ys + user->info.ym; ++j) {
            for (PetscInt i = user->info.xs; i < user->info.xs + user->info.xm; ++i) {
                PetscReal value = (PetscReal)(i + 10 * j + 100 * k);
                p[k][j][i] = value;
                cs[k][j][i] = value + 4000.0;
                diffusivity[k][j][i] = value + 5000.0;
                ucat[k][j][i].x = value + 1000.0;
                ucat[k][j][i].y = value + 2000.0;
                ucat[k][j][i].z = value + 3000.0;
            }
        }
    }
    PetscCall(DMDAVecRestoreArray(user->da, user->P, &p));
    PetscCall(DMDAVecRestoreArray(user->da, user->CS, &cs));
    PetscCall(DMDAVecRestoreArray(user->da, user->Diffusivity, &diffusivity));
    PetscCall(DMDAVecRestoreArray(user->fda, user->Ucat, &ucat));
 
    PetscCall(SynchronizePeriodicCellFields(user, 7, fields));
 
    mx = user->info.mx;
    my = user->info.my;
    PetscCall(DMDAVecGetArrayRead(user->da, user->P, &p));
    PetscCall(DMDAVecGetArrayRead(user->da, user->CS, &cs));
    PetscCall(DMDAVecGetArrayRead(user->da, user->Diffusivity, &diffusivity));
    PetscCall(DMDAVecGetArrayRead(user->fda, user->Ucat, &ucat));
    PetscCall(PicurvAssertRealNear((PetscReal)((mx - 2) + 20 + 200), p[2][2][0], 1.0e-12,
                                    "x-periodic negative endpoint should copy the opposite interior value"));
    PetscCall(PicurvAssertRealNear((PetscReal)(1 + 20 + 200), p[2][2][mx - 1], 1.0e-12,
                                    "x-periodic positive endpoint should copy the leading interior value"));
    PetscCall(PicurvAssertRealNear((PetscReal)(2 + 10 * (my - 2) + 200), p[2][0][2], 1.0e-12,
                                    "y-periodic negative endpoint should copy the opposite interior value"));
    PetscCall(PicurvAssertRealNear((PetscReal)((mx - 2) + 10 * (my - 2) + 200), p[2][0][0], 1.0e-12,
                                    "ordered synchronization should propagate the opposite periodic corner"));
    PetscCall(PicurvAssertRealNear((PetscReal)((mx - 2) + 10 * (my - 2) + 1200), ucat[2][0][0].x, 1.0e-12,
                                    "vector fields should use the same ordered periodic-corner protocol"));
    PetscCall(PicurvAssertRealNear((PetscReal)((mx - 2) + 10 * (my - 2) + 4200), cs[2][0][0], 1.0e-12,
                                    "CS should use the ordered periodic-corner protocol"));
    PetscCall(PicurvAssertRealNear((PetscReal)((mx - 2) + 10 * (my - 2) + 5200), diffusivity[2][0][0], 1.0e-12,
                                    "Diffusivity should use the ordered periodic-corner protocol"));
    PetscCall(DMDAVecRestoreArrayRead(user->da, user->P, &p));
    PetscCall(DMDAVecRestoreArrayRead(user->da, user->CS, &cs));
    PetscCall(DMDAVecRestoreArrayRead(user->da, user->Diffusivity, &diffusivity));
    PetscCall(DMDAVecRestoreArrayRead(user->fda, user->Ucat, &ucat));
    PetscCall(PicurvAssertVecConstant(user->Nu_t, 5.0, 1.0e-12, "Nu_t should be accepted by periodic cell synchronization"));
 
    PetscCall(PicurvDestroyMinimalContexts(&simCtx, &user));
    PetscFunctionReturn(0);
}
 
/**
 * @brief Tests ordered persistent synchronization for an I-face scalar metric.
 */
static PetscErrorCode TestSynchronizePeriodicFaceFieldsCopiesMixedAxes(void)
{
    SimCtx *simCtx = NULL;
    UserCtx *user = NULL;
    PetscReal ***iaj = NULL;
    Cmpnts ***csi = NULL;
    const FieldId fields[] = {FIELD_ID_CSI, FIELD_ID_IAJ};
    PetscInt mx, my;
 
    PetscFunctionBeginUser;
    PetscCall(PicurvCreateMinimalContextsWithPeriodicity(&simCtx, &user, 4, 4, 4, PETSC_TRUE, PETSC_TRUE, PETSC_FALSE));
    MarkXPeriodic(user);
    MarkYPeriodic(user);
    mx = user->info.mx;
    my = user->info.my;
 
    PetscCall(DMDAVecGetArray(user->da, user->IAj, &iaj));
    PetscCall(DMDAVecGetArray(user->fda, user->Csi, &csi));
    for (PetscInt k = user->info.zs; k < user->info.zs + user->info.zm; k++) {
        for (PetscInt j = user->info.ys; j < user->info.ys + user->info.ym; j++) {
            for (PetscInt i = user->info.xs; i < user->info.xs + user->info.xm; i++) {
                PetscReal value = (PetscReal)(i + 10 * j + 100 * k);
                iaj[k][j][i] = value;
                csi[k][j][i] = (Cmpnts){value + 1000.0, value + 2000.0, value + 3000.0};
            }
        }
    }
    PetscCall(DMDAVecRestoreArray(user->da, user->IAj, &iaj));
    PetscCall(DMDAVecRestoreArray(user->fda, user->Csi, &csi));
 
    PetscCall(SynchronizePeriodicFaceFields(user, 'i', 2, fields));
 
    PetscCall(DMDAVecGetArrayRead(user->da, user->IAj, &iaj));
    PetscCall(DMDAVecGetArrayRead(user->fda, user->Csi, &csi));
    PetscCall(PicurvAssertRealNear((PetscReal)(mx - 2 + 20 + 200), iaj[2][2][0], 1.0e-12,
                                   "I-face negative seam should copy the opposite physical seam face"));
    PetscCall(PicurvAssertRealNear((PetscReal)(1 + 20 + 200), iaj[2][2][mx - 1], 1.0e-12,
                                   "I-face positive dummy should copy the leading physical face"));
    PetscCall(PicurvAssertRealNear((PetscReal)(2 + 10 * (my - 2) + 200), iaj[2][0][2], 1.0e-12,
                                   "I-face field should use cell-style synchronization tangentially"));
    PetscCall(PicurvAssertRealNear((PetscReal)(mx - 2 + 10 * (my - 2) + 200), iaj[2][0][0], 1.0e-12,
                                   "ordered face synchronization should propagate mixed-axis corners"));
    PetscCall(PicurvAssertRealNear((PetscReal)(mx - 2 + 10 * (my - 2) + 1200), csi[2][0][0].x, 1.0e-12,
                                   "vector I-face fields should use the same ordered synchronization"));
    PetscCall(DMDAVecRestoreArrayRead(user->da, user->IAj, &iaj));
    PetscCall(DMDAVecRestoreArrayRead(user->fda, user->Csi, &csi));
 
    PetscCall(DMDAVecGetArrayRead(user->da, user->lIAj, &iaj));
    PetscCall(PicurvAssertRealNear((PetscReal)(mx - 3 + 20 + 200), iaj[2][2][-1], 1.0e-12,
                                   "I-face negative adjacent ghost should be shifted to the prior face"));
    PetscCall(PicurvAssertRealNear((PetscReal)(2 + 20 + 200), iaj[2][2][mx], 1.0e-12,
                                   "I-face positive adjacent ghost should be shifted to the next face"));
    PetscCall(PicurvAssertRealNear((PetscReal)(2 + 10 + 200), iaj[2][-1][2], 1.0e-12,
                                   "I-face tangential ghosts should retain cell-style wraparound"));
    PetscCall(DMDAVecRestoreArrayRead(user->da, user->lIAj, &iaj));
 
    PetscCall(PicurvDestroyMinimalContexts(&simCtx, &user));
    PetscFunctionReturn(0);
}
 
/**
 * @brief Tests ordered persistent synchronization for component-staggered Ucont.
 */
static PetscErrorCode TestSynchronizePeriodicStaggeredFieldsCopiesMixedAxes(void)
{
    SimCtx *simCtx = NULL;
    UserCtx *user = NULL;
    Cmpnts ***ucont = NULL;
    const FieldId fields[] = {FIELD_ID_UCONT};
    PetscInt mx, my;
 
    PetscFunctionBeginUser;
    PetscCall(PicurvCreateMinimalContextsWithPeriodicity(&simCtx, &user, 4, 4, 4, PETSC_TRUE, PETSC_TRUE, PETSC_FALSE));
    MarkXPeriodic(user);
    MarkYPeriodic(user);
    mx = user->info.mx;
    my = user->info.my;
 
    PetscCall(DMDAVecGetArray(user->fda, user->Ucont, &ucont));
    for (PetscInt k = user->info.zs; k < user->info.zs + user->info.zm; k++) {
        for (PetscInt j = user->info.ys; j < user->info.ys + user->info.ym; j++) {
            for (PetscInt i = user->info.xs; i < user->info.xs + user->info.xm; i++) {
                PetscReal value = (PetscReal)(i + 10 * j + 100 * k);
                ucont[k][j][i] = (Cmpnts){value + 1000.0, value + 2000.0, value + 3000.0};
            }
        }
    }
    PetscCall(DMDAVecRestoreArray(user->fda, user->Ucont, &ucont));
 
    PetscCall(SynchronizePeriodicStaggeredFields(user, 1, fields));
 
    PetscCall(DMDAVecGetArrayRead(user->fda, user->Ucont, &ucont));
    PetscCall(PicurvAssertRealNear((PetscReal)(mx - 2 + 20 + 1200), ucont[2][2][0].x, 1.0e-12,
                                   "Ucont.x negative X seam should copy the opposite physical seam"));
    PetscCall(PicurvAssertRealNear((PetscReal)(1 + 20 + 2200), ucont[2][2][mx - 1].y, 1.0e-12,
                                   "Ucont.y positive X dummy should copy the leading physical value"));
    PetscCall(PicurvAssertRealNear((PetscReal)(2 + 10 * (my - 2) + 3200), ucont[2][0][2].z, 1.0e-12,
                                   "Ucont.z should synchronize tangentially in Y"));
    PetscCall(PicurvAssertRealNear((PetscReal)(mx - 2 + 10 * (my - 2) + 2200), ucont[2][0][0].y, 1.0e-12,
                                   "ordered staggered synchronization should propagate mixed-axis corners"));
    PetscCall(DMDAVecRestoreArrayRead(user->fda, user->Ucont, &ucont));
 
    PetscCall(DMDAVecGetArrayRead(user->fda, user->lUcont, &ucont));
    PetscCall(PicurvAssertRealNear((PetscReal)(mx - 3 + 20 + 1200), ucont[2][2][-1].x, 1.0e-12,
                                   "Ucont.x should use face-normal X ghost repair"));
    PetscCall(PicurvAssertRealNear((PetscReal)(1 + 20 + 2200), ucont[2][2][-1].y, 1.0e-12,
                                   "Ucont.y should retain cell-style wraparound tangentially in X"));
    PetscCall(PicurvAssertRealNear((PetscReal)(2 + 20 + 1200), ucont[2][2][mx].x, 1.0e-12,
                                   "Ucont.x positive adjacent ghost should use the next face"));
    PetscCall(PicurvAssertRealNear((PetscReal)(mx - 2 + 20 + 2200), ucont[2][2][mx].y, 1.0e-12,
                                   "Ucont.y positive X ghost should retain cell-style wraparound"));
    PetscCall(DMDAVecRestoreArrayRead(user->fda, user->lUcont, &ucont));
 
    PetscCall(PicurvDestroyMinimalContexts(&simCtx, &user));
    PetscFunctionReturn(0);
}
 
/**
 * @brief Tests mixed-boundary post-projection cell finalization and Ucont preservation.
 */
static PetscErrorCode TestFinalizePostProjectionCellFieldsMixedBoundaries(void)
{
    SimCtx *simCtx = NULL;
    UserCtx *user = NULL;
    Vec ucont_before = NULL;
    Vec ucont_difference = NULL;
    Cmpnts ***ucat = NULL;
    Cmpnts ***ucont = NULL;
    PetscReal ***p = NULL;
    PetscReal difference_norm = 0.0;
    PetscInt mx;
 
    PetscFunctionBeginUser;
    PetscCall(PicurvCreateMinimalContextsWithPeriodicity(&simCtx, &user, 4, 4, 4, PETSC_TRUE, PETSC_FALSE, PETSC_FALSE));
    MarkXPeriodic(user);
    PetscCall(VecSet(user->Bcs.Ubcs, 0.0));
 
    PetscCall(DMDAVecGetArray(user->fda, user->Ucat, &ucat));
    PetscCall(DMDAVecGetArray(user->fda, user->Ucont, &ucont));
    PetscCall(DMDAVecGetArray(user->da, user->P, &p));
    for (PetscInt k = user->info.zs; k < user->info.zs + user->info.zm; ++k) {
        for (PetscInt j = user->info.ys; j < user->info.ys + user->info.ym; ++j) {
            for (PetscInt i = user->info.xs; i < user->info.xs + user->info.xm; ++i) {
                PetscReal value = (PetscReal)(i + 10 * j + 100 * k);
                ucat[k][j][i].x = value + 1000.0;
                ucat[k][j][i].y = value + 2000.0;
                ucat[k][j][i].z = value + 3000.0;
                ucont[k][j][i].x = value + 4000.0;
                ucont[k][j][i].y = value + 5000.0;
                ucont[k][j][i].z = value + 6000.0;
                p[k][j][i] = value;
            }
        }
    }
    PetscCall(DMDAVecRestoreArray(user->fda, user->Ucat, &ucat));
    PetscCall(DMDAVecRestoreArray(user->fda, user->Ucont, &ucont));
    PetscCall(DMDAVecRestoreArray(user->da, user->P, &p));
 
    PetscCall(VecDuplicate(user->Ucont, &ucont_before));
    PetscCall(VecDuplicate(user->Ucont, &ucont_difference));
    PetscCall(VecCopy(user->Ucont, ucont_before));
 
    PetscCall(FinalizePostProjectionCellFields(user));
 
    PetscCall(VecWAXPY(ucont_difference, -1.0, user->Ucont, ucont_before));
    PetscCall(VecNorm(ucont_difference, NORM_INFINITY, &difference_norm));
    PetscCall(PicurvAssertRealNear(0.0, difference_norm, 1.0e-12,
                                    "post-projection cell finalization must preserve mixed-boundary Ucont"));
 
    mx = user->info.mx;
    PetscCall(DMDAVecGetArrayRead(user->fda, user->Ucat, &ucat));
    PetscCall(DMDAVecGetArrayRead(user->da, user->P, &p));
    PetscCall(PicurvAssertRealNear((PetscReal)((mx - 2) + 20 + 200 + 1000), ucat[2][2][0].x, 1.0e-12,
                                    "mixed finalization should restore the negative x-periodic Ucat endpoint"));
    PetscCall(PicurvAssertRealNear((PetscReal)(-(2 + 10 + 200 + 1000)), ucat[2][0][2].x, 1.0e-12,
                                    "mixed finalization should extrapolate the non-periodic y dummy face"));
    PetscCall(PicurvAssertRealNear((PetscReal)(-((mx - 2) + 10 + 200 + 1000)), ucat[2][0][0].x, 1.0e-12,
                                    "periodic synchronization should win at a mixed x-periodic/y-physical edge"));
    PetscCall(PicurvAssertRealNear((PetscReal)((mx - 2) + 20 + 200), p[2][2][0], 1.0e-12,
                                    "mixed finalization should restore the negative x-periodic pressure endpoint"));
    PetscCall(DMDAVecRestoreArrayRead(user->fda, user->Ucat, &ucat));
    PetscCall(DMDAVecRestoreArrayRead(user->da, user->P, &p));
 
    PetscCall(VecDestroy(&ucont_difference));
    PetscCall(VecDestroy(&ucont_before));
    PetscCall(PicurvDestroyMinimalContexts(&simCtx, &user));
    PetscFunctionReturn(0);
}
 
/** @brief Verifies reconstructed Ucat periodic duplicates and local values are finalized. */
static PetscErrorCode TestContra2CartPeriodicUcatFinalization(void)
{
    SimCtx *simCtx=NULL; UserCtx *user=NULL; Cmpnts ***ucont=NULL,***ucat=NULL,***lucat=NULL;
    const FieldId staggered_fields[] = {FIELD_ID_UCONT}, cell_fields[] = {FIELD_ID_UCAT};
    PetscInt mx;
    PetscFunctionBeginUser;
    PetscCall(PicurvCreateMinimalContextsWithPeriodicity(&simCtx,&user,4,4,4,PETSC_TRUE,PETSC_FALSE,PETSC_FALSE));
    MarkXPeriodic(user); mx=user->info.mx;
    PetscCall(VecSet(user->Ucont,0.0));
    PetscCall(DMDAVecGetArray(user->fda,user->Ucont,&ucont));
    for(PetscInt k=1;k<user->info.mz-1;k++) for(PetscInt j=1;j<user->info.my-1;j++)
        for(PetscInt i=1;i<mx-1;i++) ucont[k][j][i].x=(PetscReal)i;
    PetscCall(DMDAVecRestoreArray(user->fda,user->Ucont,&ucont));
    PetscCall(SynchronizePeriodicStaggeredFields(user,1,staggered_fields));
    PetscCall(VecSet(user->Ucat,-99.0));
    PetscCall(Contra2Cart(user));
    PetscCall(SynchronizePeriodicCellFields(user,1,cell_fields));
    PetscCall(UpdateLocalGhosts(user, FIELD_ID_UCAT));
 
    PetscCall(DMDAVecGetArrayRead(user->fda,user->Ucat,&ucat));
    PetscCall(PicurvAssertRealNear(ucat[2][2][mx-2].x,ucat[2][2][0].x,1e-12,"negative Ucat duplicate follows opposite independent cell"));
    PetscCall(PicurvAssertRealNear(ucat[2][2][1].x,ucat[2][2][mx-1].x,1e-12,"positive Ucat duplicate follows leading independent cell"));
    PetscCall(DMDAVecGetArrayRead(user->fda,user->lUcat,&lucat));
    PetscCall(PicurvAssertRealNear(ucat[2][2][0].x,lucat[2][2][0].x,1e-12,"local negative Ucat endpoint matches corrected global"));
    PetscCall(PicurvAssertRealNear(ucat[2][2][mx-1].x,lucat[2][2][mx-1].x,1e-12,"local positive Ucat endpoint matches corrected global"));
    PetscCall(DMDAVecRestoreArrayRead(user->fda,user->lUcat,&lucat));
    PetscCall(DMDAVecRestoreArrayRead(user->fda,user->Ucat,&ucat));
    PetscCall(PicurvDestroyMinimalContexts(&simCtx,&user));
    PetscFunctionReturn(0);
}
/**
 * @brief Runs the focused geometric-periodic PETSc test binary.
 */
int main(int argc, char **argv)
{
    PetscErrorCode ierr;
    const PicurvTestCase cases[] = {
        {"periodic-geometric-factory-assignment", TestPeriodicGeometricFactoryAssignment},
        {"periodic-configuration-requires-paired-faces", TestPeriodicConfigurationRequiresPairedFaces},
        {"periodic-geometry-stores-translation", TestPeriodicGeometryStoresTranslation},
        {"periodic-geometry-stores-mixed-translations", TestPeriodicGeometryStoresMixedTranslations},
        {"locate-particle-wraps-through-periodic-face", TestLocateParticleWrapsThroughPeriodicFace},
        {"locate-particle-wraps-through-off-axis-seam", TestLocateParticleWrapsThroughOffAxisSeam},
        {"periodic-geometry-rejects-varying-translation", TestPeriodicGeometryRejectsVaryingTranslation},
        {"periodic-face-center-coordinate-synchronization", TestPeriodicFaceCenterCoordinateSynchronization},
        {"periodic-quick-stencil-preparation", TestPeriodicQuickStencilPreparation},
        {"apply-metrics-periodic-bcs-synchronizes-aj", TestApplyMetricsPeriodicBCsSynchronizesAj},
        {"synchronize-periodic-cell-fields-copies-mixed-axes", TestSynchronizePeriodicCellFieldsCopiesMixedAxes},
        {"synchronize-periodic-face-fields-copies-mixed-axes", TestSynchronizePeriodicFaceFieldsCopiesMixedAxes},
        {"synchronize-periodic-staggered-fields-copies-mixed-axes", TestSynchronizePeriodicStaggeredFieldsCopiesMixedAxes},
        {"finalize-post-projection-cell-fields-mixed-boundaries", TestFinalizePostProjectionCellFieldsMixedBoundaries},
        {"contra2cart-periodic-ucat-finalization", TestContra2CartPeriodicUcatFinalization},
    };
 
    ierr = PetscInitialize(&argc, &argv, NULL, "PICurv geometric-periodic tests");
    if (ierr) {
        return (int)ierr;
    }
 
    ierr = PicurvRunTests("unit-periodic", cases, sizeof(cases) / sizeof(cases[0]));
    if (ierr) {
        PetscFinalize();
        return (int)ierr;
    }
 
    ierr = PetscFinalize();
    return (int)ierr;
}