test_periodic_dev.c File Reference

Focused geometric-periodic boundary tests. More...

#include "test_support.h"
#include "Metric.h"
#include "Boundaries.h"
#include "walkingsearch.h"
#include "setup.h"

Include dependency graph for test_periodic_dev.c:

Go to the source code of this file.

Functions
static PetscErrorCode	DestroyBoundaryHandler (BoundaryCondition **bc_ptr)
	Destroys one boundary-condition handler allocated by a periodic test.
static void	MarkXPeriodic (UserCtx *user)
	Marks the x faces as periodic for periodic-transfer harnesses.
static void	MarkYPeriodic (UserCtx *user)
	Marks the y faces as periodic for periodic-transfer harnesses.
static PetscErrorCode	TestPeriodicConfigurationRequiresPairedFaces (void)
	Tests periodic configuration rejects an unpaired geometric periodic face.
static PetscErrorCode	TestPeriodicGeometryStoresTranslation (void)
	Tests constant translational periodic geometry is accepted and stored.
static PetscErrorCode	TestLocateParticleWrapsThroughPeriodicFace (void)
	Tests that a particle beyond either x-periodic face re-enters through the paired face, shifted by the seam translation.
static PetscErrorCode	TestLocateParticleWrapsThroughOffAxisSeam (void)
	An off-axis seam: a rotated x-periodic grid validates the rotated translation and wraps by it.
static PetscErrorCode	TestPeriodicGeometryStoresMixedTranslations (void)
	Tests mixed periodic directions are validated and stored independently.
static PetscErrorCode	TestPeriodicGeometryRejectsVaryingTranslation (void)
	Tests non-translational seam geometry fails before metric construction.
static PetscErrorCode	TestPeriodicFaceCenterCoordinateSynchronization (void)
	Tests face-center coordinates remain geometrically continuous across a periodic seam.
static PetscErrorCode	TestPeriodicQuickStencilPreparation (void)
	Tests the dedicated QUICK outer-ghost repair for cell-centered inputs.
static PetscErrorCode	TestPeriodicGeometricFactoryAssignment (void)
	Tests periodic geometric factory construction.
static PetscErrorCode	TestApplyMetricsPeriodicBCsSynchronizesAj (void)
	Tests periodic metric transfer through the aggregate periodic-metrics helper.
static PetscErrorCode	TestSynchronizePeriodicCellFieldsCopiesMixedAxes (void)
	Tests ordered cell-field synchronization across two periodic directions.
static PetscErrorCode	TestSynchronizePeriodicFaceFieldsCopiesMixedAxes (void)
	Tests ordered persistent synchronization for an I-face scalar metric.
static PetscErrorCode	TestSynchronizePeriodicStaggeredFieldsCopiesMixedAxes (void)
	Tests ordered persistent synchronization for component-staggered Ucont.
static PetscErrorCode	TestFinalizePostProjectionCellFieldsMixedBoundaries (void)
	Tests mixed-boundary post-projection cell finalization and Ucont preservation.
static PetscErrorCode	TestContra2CartPeriodicUcatFinalization (void)
	Verifies reconstructed Ucat periodic duplicates and local values are finalized.
int	main (int argc, char **argv)
	Runs the focused geometric-periodic PETSc test binary.

Detailed Description

Focused geometric-periodic boundary tests.

Definition in file test_periodic_dev.c.

Function Documentation

DestroyBoundaryHandler()

static PetscErrorCode DestroyBoundaryHandler ( BoundaryCondition **  bc_ptr )

static

Destroys one boundary-condition handler allocated by a periodic test.

Definition at line 16 of file test_periodic_dev.c.

{
    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);
}

Here is the caller graph for this function:

MarkXPeriodic()

static void MarkXPeriodic ( UserCtx *  user )

static

Marks the x faces as periodic for periodic-transfer harnesses.

Definition at line 34 of file test_periodic_dev.c.

{
    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;
}

Here is the caller graph for this function:

MarkYPeriodic()

static void MarkYPeriodic ( UserCtx *  user )

static

Marks the y faces as periodic for periodic-transfer harnesses.

Definition at line 46 of file test_periodic_dev.c.

{
    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;
}

Here is the caller graph for this function:

TestPeriodicConfigurationRequiresPairedFaces()

static PetscErrorCode TestPeriodicConfigurationRequiresPairedFaces ( void  )

static

Tests periodic configuration rejects an unpaired geometric periodic face.

Definition at line 58 of file test_periodic_dev.c.

{
    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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

TestPeriodicGeometryStoresTranslation()

static PetscErrorCode TestPeriodicGeometryStoresTranslation ( void  )

static

Tests constant translational periodic geometry is accepted and stored.

Definition at line 80 of file test_periodic_dev.c.

{
    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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

TestLocateParticleWrapsThroughPeriodicFace()

static PetscErrorCode TestLocateParticleWrapsThroughPeriodicFace ( void  )

static

Tests that a particle beyond either x-periodic face re-enters through the paired face, shifted by the seam translation.

Definition at line 111 of file test_periodic_dev.c.

{
    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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

TestLocateParticleWrapsThroughOffAxisSeam()

static PetscErrorCode TestLocateParticleWrapsThroughOffAxisSeam ( void  )

static

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.

Definition at line 187 of file test_periodic_dev.c.

{
    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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

TestPeriodicGeometryStoresMixedTranslations()

static PetscErrorCode TestPeriodicGeometryStoresMixedTranslations ( void  )

static

Tests mixed periodic directions are validated and stored independently.

Definition at line 255 of file test_periodic_dev.c.

{
    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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

TestPeriodicGeometryRejectsVaryingTranslation()

static PetscErrorCode TestPeriodicGeometryRejectsVaryingTranslation ( void  )

static

Tests non-translational seam geometry fails before metric construction.

Definition at line 280 of file test_periodic_dev.c.

{
    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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

TestPeriodicFaceCenterCoordinateSynchronization()

static PetscErrorCode TestPeriodicFaceCenterCoordinateSynchronization ( void  )

static

Tests face-center coordinates remain geometrically continuous across a periodic seam.

Definition at line 310 of file test_periodic_dev.c.

{
    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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

TestPeriodicQuickStencilPreparation()

static PetscErrorCode TestPeriodicQuickStencilPreparation ( void  )

static

Tests the dedicated QUICK outer-ghost repair for cell-centered inputs.

Definition at line 355 of file test_periodic_dev.c.

{
    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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

TestPeriodicGeometricFactoryAssignment()

static PetscErrorCode TestPeriodicGeometricFactoryAssignment ( void  )

static

Tests periodic geometric factory construction.

Definition at line 401 of file test_periodic_dev.c.

{
    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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

TestApplyMetricsPeriodicBCsSynchronizesAj()

static PetscErrorCode TestApplyMetricsPeriodicBCsSynchronizesAj ( void  )

static

Tests periodic metric transfer through the aggregate periodic-metrics helper.

Definition at line 417 of file test_periodic_dev.c.

{
    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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

TestSynchronizePeriodicCellFieldsCopiesMixedAxes()

static PetscErrorCode TestSynchronizePeriodicCellFieldsCopiesMixedAxes ( void  )

static

Tests ordered cell-field synchronization across two periodic directions.

Definition at line 465 of file test_periodic_dev.c.

{
    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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

TestSynchronizePeriodicFaceFieldsCopiesMixedAxes()

static PetscErrorCode TestSynchronizePeriodicFaceFieldsCopiesMixedAxes ( void  )

static

Tests ordered persistent synchronization for an I-face scalar metric.

Definition at line 547 of file test_periodic_dev.c.

{
    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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

TestSynchronizePeriodicStaggeredFieldsCopiesMixedAxes()

static PetscErrorCode TestSynchronizePeriodicStaggeredFieldsCopiesMixedAxes ( void  )

static

Tests ordered persistent synchronization for component-staggered Ucont.

Definition at line 610 of file test_periodic_dev.c.

{
    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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

TestFinalizePostProjectionCellFieldsMixedBoundaries()

static PetscErrorCode TestFinalizePostProjectionCellFieldsMixedBoundaries ( void  )

static

Tests mixed-boundary post-projection cell finalization and Ucont preservation.

Definition at line 667 of file test_periodic_dev.c.

{
    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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

TestContra2CartPeriodicUcatFinalization()

static PetscErrorCode TestContra2CartPeriodicUcatFinalization ( void  )

static

Verifies reconstructed Ucat periodic duplicates and local values are finalized.

Definition at line 737 of file test_periodic_dev.c.

{
    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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char **	argv
	)

Runs the focused geometric-periodic PETSc test binary.

Definition at line 770 of file test_periodic_dev.c.

{
    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;
}

Here is the call graph for this function: