AMRFoam class is a standalone adaptive mesh refinement application that uses polyMesh as its base and provides useful interface for use of different solvers and mesh formats. More...

Detailed Description

Initially the supported refinement criterias would be size field defined over mesh as well as a gradient field of any simulation quantity.

Any object/pointer created for this class in C++ runtime will act as finiteVolume mesh of OpenFOAM.

Definition at line 52 of file AMRFoam.H.

Public Member Functions
	AMRFoam (const Foam::IOobject &iomesh)
	Standard constructor. More...

	~AMRFoam ()
	Class destructor. More...

bool	updateAMR (const int &refineInterval, const int &maxRefinement, volScalarField &vFld, const double &lowerRefineLevel, const double &upperRefineLevel, const double &unrefineAbove, const double &unrefineBelow, const int &nBufferLayers, const int &maxCells)
	updateAMR is a master method for this process. More...

bool	updateAMRML (const int &refineInterval, const int &maxRefinement, const int &nBufferLayers, const int &maxCells, volScalarField &vFld)
	New method for machine learning ML. More...

void	solveMotion ()
	A mesh motion solver. More...

Foam::scalarField	cell2Pt (const scalarField &vFld)
	Converts volume field to point field. More...

void	writeHistory ()
	Writes refinement history in current time directory. More...

const polyMesh &	getMesh ()
	Access to current mesh at every time step. More...

void	writeMesh ()
	Ability to write current mesh into current time directory. More...

void	disableMotion ()
	Ability to explicitely disable motion. More...

pointScalarField	readIncomingPtField (const std::string &inName, const std::string &outName)
	Converts incoming size-field/solution-field into pointScalarField defined over all points of mesh. More...

volScalarField	pF2vF (const pointScalarField &pntF, const std::string &outName)
	Converts pointScalarField to volScalarField. More...

volScalarField	readInitialField (const std::string &fldName)
	Reads the refinement field and registers it. More...

pointScalarField	initPntSField (const std::string &fldName)
	Creates an empty pointScalarField based on current mesh. More...

volScalarField	initScalarField (const std::string &fldName)
	Creates an empty volScalarField based on current mesh. More...

volScalarField	initGradientField (const std::string &fldName)
	Creates an empty volScalarField for gradient magnitude. More...

volScalarField	assignToVolScalarField (const std::vector< int > &vec)
	Converts vector to volScalarField for refinement/unrefinement. More...

void	enableUpdatedField ()
	Access to updated field at every time step. More...

void	enableRefHistoryData ()
	Access to refinement history data. More...

void	enableMeshWriting ()
	Access to mesh data. More...

volScalarField	readIncomingCellField (const std::string &inName, const std::string &outName)
	reads incoming field and converts to volScalarField More...

void	transformField (volScalarField &inField)
	Transforms incoming scalar field into refinement levels understood by OpenFOAM environement. More...

volScalarField	getGradient (const volScalarField &fldGrd)
	Returns a gradient of scalar field over mesh param fldGrd Scalar Field for Gradient Calculation. More...

virtual bool	update ()

const hexRef8 &	meshCutter () const

const bitSet &	protectedCell () const

bitSet &	protectedCell ()

bool	writeObjectAMR (const bool valid) const

virtual void	mapFields (const mapPolyMesh &mpm)

Public Attributes
std::vector< double >	lowerRefLvl
	Vector to store lower refinement levels. More...

std::vector< double >	upperRefLvl
	Vector to store upper refinement levels. More...

std::vector< double >	unrefAboveLvl
	Vector to store unrefine levels. More...

std::vector< double >	unrefBelowLvl
	Vector to store unrefine levels. More...

int	stepSz = 1
	Step size for one time refinement. More...

bool	enableMotion {false}
	Boolean to check if mesh motion is needed. More...

autoPtr< motionSolver >	motionPtr_

Protected Member Functions
void	checkForMotion ()
	Checks for availability of mesh motion keywords in dictionary. More...

void	calcProtectedCells ()
	Calculates and stores non-hex cells in protected cells catagory to avoid their refinement. More...

virtual Foam::autoPtr< Foam::mapPolyMesh >	refine (const labelList &)
	Unrefines selected cells in a mesh. More...

virtual Foam::autoPtr< Foam::mapPolyMesh >	unrefine (const labelList &)
	Refines selected cells in a mesh. More...

void	calculateProtectedCells (bitSet &unrefineableCell) const

void	readDict ()

scalar	getRefineLevel (const label maxCells, const label maxRefinement, const scalar refineLevel, const scalarField &) const

scalarField	maxPointField (const scalarField &) const

scalarField	maxCellField (const volScalarField &) const

scalarField	cellToPoint (const scalarField &vFld) const

scalarField	error (const scalarField &fld, const scalar minLevel, const scalar maxLevel) const

virtual void	selectRefineCandidates (const scalar lowerRefineLevel, const scalar upperRefineLevel, const scalarField &vFld, bitSet &candidateCell) const

virtual labelList	selectRefineCells (const label maxCells, const label maxRefinement, const bitSet &candidateCell) const

virtual labelList	selectUnrefinePoints (const scalar unrefineAbove, const scalar unrefineBelow, const bitSet &markedCell, const scalarField &pFld) const
	Marked the cells to unrefine based on user defined levels. More...

void	extendMarkedCells (bitSet &markedCell) const

void	checkEightAnchorPoints (bitSet &protectedCell) const

template<class T >
void	mapNewInternalFaces (const labelList &faceMap, GeometricField< T, fvsPatchField, surfaceMesh > &)

template<class T >
void	mapNewInternalFaces (const labelList &faceMap)

template<class T >
void	mapNewInternalFaces (const surfaceVectorField &Sf, const surfaceScalarField &magSf, const labelList &faceMap)

Protected Attributes
hexRef8	meshCutter_

bool	dumpLevel_

HashTable< word >	correctFluxes_

label	nRefinementIterations_

bitSet	protectedCell_

Private Attributes
bool	writeField {false}
	Boolean to enable writing of updated solution field every timestep. More...

bool	writeRefHistory {false}
	Boolean to enable writing of refinement history. More...

bool	writeMeshData {false}
	Boolean to enable writing of mesh. More...

std::vector< double >	incomingField
	Vector to store user defined vector. More...

Inherits dynamicFvMesh.

Constructor & Destructor Documentation

◆ AMRFoam()

Foam::AMRFoam::AMRFoam ( const Foam::IOobject & iomesh )

Accepts polyMesh object for initialization. It needs dynamicMeshDict present in constant folder. Method for same is available in MeshManipulationFoam class as "createDynamicMeshDict"

Parameters

iomesh A polyMesh input object

Definition at line 62 of file AMRFoam.C.

References calcProtectedCells(), and checkForMotion().

     : dynamicFvMesh(iomesh),
       meshCutter_(*this),
       dumpLevel_(true),
       nRefinementIterations_(0),
       protectedCell_(nCells()) {
   checkForMotion();
   calcProtectedCells();
 }

◆ ~AMRFoam()

Foam::AMRFoam::~AMRFoam ( )

inline

Definition at line 65 of file AMRFoam.H.

References assignToVolScalarField(), cell2Pt(), disableMotion(), enableMeshWriting(), enableRefHistoryData(), enableUpdatedField(), getGradient(), getMesh(), initGradientField(), initPntSField(), initScalarField(), pF2vF(), readIncomingCellField(), readIncomingPtField(), readInitialField(), solveMotion(), transformField(), updateAMR(), updateAMRML(), writeHistory(), and writeMesh().

              {
     // Nothing
   }

Member Function Documentation

◆ assignToVolScalarField()

volScalarField Foam::AMRFoam::assignToVolScalarField ( const std::vector< int > & vec )

Parameters

vec	Incoming vector

Returns: volScalarField

Definition at line 750 of file AMRFoam.C.

References initScalarField().

Referenced by NEM::DRV::FoamRefineDriver::execute(), and ~AMRFoam().

                                                                         {
   volScalarField vFld = initScalarField("vFld");
   for (int i = 0; i < (int)vec.size(); i++) vFld[i] = vec[i];
   return vFld;
 }

◆ calcProtectedCells()

void Foam::AMRFoam::calcProtectedCells ( )

protected

Definition at line 86 of file AMRFoam.C.

References checkEightAnchorPoints(), enableMotion, meshCutter_, and protectedCell_.

Referenced by AMRFoam().

                                  {
   const labelList &cellLevel = meshCutter_.cellLevel();
   const labelList &pointLevel = meshCutter_.pointLevel();
 
   // Set cells that should not be refined.
   // This is currently any cell which does not have 8 anchor points or
   // uses any face which does not have 4 anchor points.
   // Note: do not use cellPoint addressing
 
   // Count number of points <= cellLevel
   // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
   labelList nAnchors(nCells(), Zero);
 
   label nProtected = 0;
 
   forAll (pointCells(), pointi) {
     const labelList &pCells = pointCells()[pointi];
 
     for (const label celli : pCells) {
       if (!protectedCell_.test(celli)) {
         if (pointLevel[pointi] <= cellLevel[celli]) {
           ++nAnchors[celli];
 
           if (nAnchors[celli] > 8) {
             protectedCell_.set(celli);
             nProtected++;
           }
         }
       }
     }
   }
 
   // Count number of points <= faceLevel
   // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   // Bit tricky since proc face might be one more refined than the owner since
   // the coupled one is refined.
 
   {
     labelList neiLevel(nFaces());
 
     for (label facei = 0; facei < nInternalFaces(); ++facei) {
       neiLevel[facei] = cellLevel[faceNeighbour()[facei]];
     }
     for (label facei = nInternalFaces(); facei < nFaces(); ++facei) {
       neiLevel[facei] = cellLevel[faceOwner()[facei]];
     }
     syncTools::swapFaceList(*this, neiLevel);
 
     bitSet protectedFace(nFaces());
 
     forAll (faceOwner(), facei) {
       const label faceLevel =
           max(cellLevel[faceOwner()[facei]], neiLevel[facei]);
 
       const face &f = faces()[facei];
 
       label nnAnchors = 0;
 
       for (const label pointi : f) {
         if (pointLevel[pointi] <= faceLevel) {
           ++nnAnchors;
 
           if (nnAnchors > 4) {
             protectedFace.set(facei);
             break;
           }
         }
       }
     }
 
     syncTools::syncFaceList(*this, protectedFace, orEqOp<unsigned int>());
 
     for (label facei = 0; facei < nInternalFaces(); ++facei) {
       if (protectedFace.test(facei)) {
         protectedCell_.set(faceOwner()[facei]);
         nProtected++;
         protectedCell_.set(faceNeighbour()[facei]);
         nProtected++;
       }
     }
     for (label facei = nInternalFaces(); facei < nFaces(); ++facei) {
       if (protectedFace.test(facei)) {
         protectedCell_.set(faceOwner()[facei]);
         nProtected++;
       }
     }
 
     // Also protect any cells that are less than hex
     forAll (cells(), celli) {
       const cell &cFaces = cells()[celli];
 
       if (cFaces.size() < 6) {
         if (protectedCell_.set(celli)) { nProtected++; }
 
       } else {
         for (const label cfacei : cFaces) {
           if (faces()[cfacei].size() < 4) {
             if (protectedCell_.set(celli)) { nProtected++; }
             break;
           }
         }
       }
     }
 
     // Check cells for 8 corner points
     checkEightAnchorPoints(protectedCell_);
 
     if (enableMotion) {
       // Block boundary cells from refinement
       const polyBoundaryMesh &patches = boundaryMesh();
       wordList ptchTypes = patches.types();
 
       labelList assignedScore(nCells(), 0);
 
       forAll (patches, patchI) {
         if (ptchTypes[patchI] != "empty") {
           auto allCells = patches[patchI].faceCells();
           forAll (allCells, cellI) {
             assignedScore[allCells[cellI]] += 1;
             // Find all neighbours and assign the score of one
             auto neiCells = cellCells()[allCells[cellI]];
             forAll (neiCells, nCellI) { assignedScore[neiCells[nCellI]] += 1; }
           }
         }
       }
 
       forAll (assignedScore, scoreI) {
         if (assignedScore[scoreI] >= 2) { protectedCell_.set(scoreI); }
       }
     }
   }
 
   if (!returnReduce(protectedCell_.any(), orOp<bool>())) {
     protectedCell_.clear();
   } else {
     cellSet protectedCells(*this, "protectedCells",
                            HashSetOps::used(protectedCell_));
     Info << "Detected " << returnReduce(protectedCells.size(), sumOp<label>())
          << " cells that are protected from refinement."
          << " Writing these to cellSet " << protectedCells.name() << "."
          << endl;
 
     protectedCells.write();
   }
 }

◆ calculateProtectedCells()

void Foam::AMRFoam::calculateProtectedCells ( bitSet & unrefineableCell ) const

protected

Definition at line 847 of file AMRFoam.C.

References meshCutter_, and protectedCell_.

Referenced by selectRefineCells().

                                                                     {
   if (protectedCell_.empty()) {
     unrefineableCell.clear();
     return;
   }
 
   const labelList &cellLevel = meshCutter_.cellLevel();
 
   unrefineableCell = protectedCell_;
 
   // Get neighbouring cell level
   labelList neiLevel(nFaces() - nInternalFaces());
 
   for (label facei = nInternalFaces(); facei < nFaces(); ++facei) {
     neiLevel[facei - nInternalFaces()] = cellLevel[faceOwner()[facei]];
   }
   syncTools::swapBoundaryFaceList(*this, neiLevel);
 
   bitSet seedFace;
 
   while (true) {
     // Pick up faces on border of protected cells
     seedFace.reset();
     seedFace.resize(nFaces());
 
     for (label facei = 0; facei < nInternalFaces(); ++facei) {
       const label own = faceOwner()[facei];
       const label nei = faceNeighbour()[facei];
 
       if (
           // Protected owner
           (unrefineableCell.test(own) && (cellLevel[nei] > cellLevel[own])) ||
           // Protected neighbour
           (unrefineableCell.test(nei) && (cellLevel[own] > cellLevel[nei]))) {
         seedFace.set(facei);
       }
     }
     for (label facei = nInternalFaces(); facei < nFaces(); facei++) {
       const label own = faceOwner()[facei];
 
       if (
           // Protected owner
           (unrefineableCell.test(own) &&
            (neiLevel[facei - nInternalFaces()] > cellLevel[own]))) {
         seedFace.set(facei);
       }
     }
 
     syncTools::syncFaceList(*this, seedFace, orEqOp<unsigned int>());
 
     // Extend unrefineableCell
     bool hasExtended = false;
 
     for (label facei = 0; facei < nInternalFaces(); ++facei) {
       if (seedFace.test(facei)) {
         if (unrefineableCell.set(faceOwner()[facei])) { hasExtended = true; }
         if (unrefineableCell.set(faceNeighbour()[facei])) {
           hasExtended = true;
         }
       }
     }
     for (label facei = nInternalFaces(); facei < nFaces(); ++facei) {
       if (seedFace.test(facei)) {
         const label own = faceOwner()[facei];
 
         if (unrefineableCell.set(own)) { hasExtended = true; }
       }
     }
 
     if (!returnReduce(hasExtended, orOp<bool>())) { break; }
   }
 }

◆ cell2Pt()

scalarField Foam::AMRFoam::cell2Pt ( const scalarField & vFld )

Parameters

vFld	Volume Field.

Returns: Point Field.

Definition at line 680 of file AMRFoam.C.

Referenced by ~AMRFoam().

                                                     {
   scalarField pFld(nPoints());
 
   forAll (pointCells(), pointi) {
     const labelList &pCells = pointCells()[pointi];
 
     scalar sum = 0.0;
     forAll (pCells, i)
       sum += vFld[pCells[i]];
 
     pFld[pointi] = sum / pCells.size();
   }
 
   return pFld;
 }

◆ cellToPoint()

scalarField Foam::AMRFoam::cellToPoint ( const scalarField & vFld ) const

protected

Definition at line 1286 of file AMRFoam.C.

Referenced by selectRefineCandidates().

                                                               {
   scalarField pFld(nPoints());
 
   forAll (pointCells(), pointi) {
     const labelList &pCells = pointCells()[pointi];
 
     scalar sum = 0.0;
     for (const label celli : pCells) { sum += vFld[celli]; }
     pFld[pointi] = sum / pCells.size();
   }
   return pFld;
 }

◆ checkEightAnchorPoints()

void Foam::AMRFoam::checkEightAnchorPoints ( bitSet & protectedCell ) const

protected

Definition at line 1401 of file AMRFoam.C.

References meshCutter_.

Referenced by calcProtectedCells().

                                                                 {
   const labelList &cellLevel = meshCutter_.cellLevel();
   const labelList &pointLevel = meshCutter_.pointLevel();
 
   labelList nAnchorPoints(nCells(), Zero);
 
   forAll (pointLevel, pointi) {
     const labelList &pCells = pointCells(pointi);
 
     for (const label celli : pCells) {
       if (pointLevel[pointi] <= cellLevel[celli]) {
         // Check if cell has already 8 anchor points -> protect cell
         if (nAnchorPoints[celli] == 8) { protectedCell.set(celli); }
 
         if (!protectedCell.test(celli)) { ++nAnchorPoints[celli]; }
       }
     }
   }
 
   forAll (protectedCell, celli) {
     if (nAnchorPoints[celli] != 8) { protectedCell.set(celli); }
   }
 }

◆ checkForMotion()

void Foam::AMRFoam::checkForMotion ( )

protected

Definition at line 72 of file AMRFoam.C.

References enableMotion, motionPtr_, and NEM::MSH::New().

Referenced by AMRFoam().

                              {
   // Check if motion needs to be enabled
   dictionary refineDict(IOdictionary(
       IOobject("dynamicMeshDict", time().constant(), *this,
                IOobject::MUST_READ_IF_MODIFIED, IOobject::NO_WRITE, false)));
 
   word subType = word(refineDict.lookup("dynamicFvMesh"));
   if (subType == "dynamicMotionSolverFvMesh") { enableMotion = true; }
 
   if (enableMotion) { motionPtr_ = motionSolver::New(*this); }
 }

◆ disableMotion()

void Foam::AMRFoam::disableMotion ( )

Definition at line 84 of file AMRFoam.C.

References enableMotion.

Referenced by ~AMRFoam().

84 { enableMotion = false; }

Foam::AMRFoam::enableMotion

bool enableMotion

Boolean to check if mesh motion is needed.

Definition: AMRFoam.H:231

◆ enableMeshWriting()

void Foam::AMRFoam::enableMeshWriting ( )

Definition at line 832 of file AMRFoam.C.

References writeMeshData.

Referenced by ~AMRFoam().

832 { writeMeshData = true; }

Foam::AMRFoam::writeMeshData

bool writeMeshData

Boolean to enable writing of mesh.

Definition: AMRFoam.H:245

◆ enableRefHistoryData()

void Foam::AMRFoam::enableRefHistoryData ( )

Definition at line 828 of file AMRFoam.C.

References writeRefHistory.

Referenced by ~AMRFoam().

828 { writeRefHistory = true; }

Foam::AMRFoam::writeRefHistory

bool writeRefHistory

Boolean to enable writing of refinement history.

Definition: AMRFoam.H:241

◆ enableUpdatedField()

void Foam::AMRFoam::enableUpdatedField ( )

Definition at line 830 of file AMRFoam.C.

References writeField.

Referenced by ~AMRFoam().

830 { writeField = true; }

Foam::AMRFoam::writeField

bool writeField

Boolean to enable writing of updated solution field every timestep.

Definition: AMRFoam.H:237

◆ error()

scalarField Foam::AMRFoam::error	(	const scalarField &	fld,
		const scalar	minLevel,
		const scalar	maxLevel
	)		const

protected

Definition at line 1299 of file AMRFoam.C.

Referenced by selectRefineCandidates().

                                                         {
   scalarField c(fld.size(), scalar(-1));
   forAll (fld, i) {
     scalar err = min(fld[i] - minLevel, maxLevel - fld[i]);
 
     if (err >= 0) { c[i] = err; }
   }
   return c;
 }

◆ extendMarkedCells()

void Foam::AMRFoam::extendMarkedCells ( bitSet & markedCell ) const

protected

Definition at line 1379 of file AMRFoam.C.

Referenced by update(), updateAMR(), and updateAMRML().

                                                         {
   // Mark faces using any marked cell
   bitSet markedFace(nFaces());
 
   for (const label celli : markedCell) {
     markedFace.set(cells()[celli]);  // set multiple faces
   }
 
   syncTools::syncFaceList(*this, markedFace, orEqOp<unsigned int>());
 
   // Update cells using any markedFace
   for (label facei = 0; facei < nInternalFaces(); ++facei) {
     if (markedFace.test(facei)) {
       markedCell.set(faceOwner()[facei]);
       markedCell.set(faceNeighbour()[facei]);
     }
   }
   for (label facei = nInternalFaces(); facei < nFaces(); ++facei) {
     if (markedFace.test(facei)) { markedCell.set(faceOwner()[facei]); }
   }
 }

◆ getGradient()

volScalarField Foam::AMRFoam::getGradient ( const volScalarField & fldGrd )

Returns: scalar field of gradient over mesh

Definition at line 834 of file AMRFoam.C.

References initGradientField().

Referenced by ~AMRFoam().

                                                                 {
   volVectorField returnGrad(IOobject("fldName", time().timeName(), *this,
                                      IOobject::NO_READ, IOobject::NO_WRITE),
                             *this, dimensionedVector("vector", dimless, Zero));
 
   returnGrad = Foam::fvc::grad(fldGrd);
   returnGrad.write();
   volScalarField returnScalar = initGradientField("gradient");
   returnScalar = mag(returnGrad);
 
   return returnScalar;
 }

◆ getMesh()

const polyMesh & Foam::AMRFoam::getMesh ( )

Returns: A polyMesh object

Definition at line 702 of file AMRFoam.C.

References meshCutter_.

Referenced by ~AMRFoam().

702 { return meshCutter_.mesh(); }

Foam::AMRFoam::meshCutter_

hexRef8 meshCutter_

Definition: AMRFoam.H:253

◆ getRefineLevel()

scalar Foam::AMRFoam::getRefineLevel	(	const label	maxCells,
		const label	maxRefinement,
		const scalar	refineLevel,
		const scalarField &
	)		const

protected

◆ initGradientField()

volScalarField Foam::AMRFoam::initGradientField ( const std::string & fldName )

Parameters

fldName Name of field to create in current runTime directory

Definition at line 806 of file AMRFoam.C.

Referenced by getGradient(), and ~AMRFoam().

                                                                   {
   volScalarField emptyScalar(IOobject(fldName, time().timeName(), *this,
                                       IOobject::NO_READ, IOobject::AUTO_WRITE),
                              *this, dimensionedScalar("scalar", dimless, 0));
 
   return emptyScalar;
 }

◆ initPntSField()

pointScalarField Foam::AMRFoam::initPntSField ( const std::string & fldName )

Parameters

fldName Name of field to create in current runTime directory

Definition at line 814 of file AMRFoam.C.

Referenced by readIncomingPtField(), and ~AMRFoam().

                                                                 {
   // Initialize a pointMesh object
   pointMesh pMesh(*this);
 
   // Zero pointScalarField declaration. InternalField contains all mesh
   // points. Can be overwritten with incoming stream.
   pointScalarField initFieldZero(
       IOobject(fldName, time().timeName(), *this, IOobject::NO_READ,
                IOobject::AUTO_WRITE),
       pMesh, dimensionedScalar("scalar", dimLength, 0));
 
   return initFieldZero;
 }

◆ initScalarField()

volScalarField Foam::AMRFoam::initScalarField ( const std::string & fldName )

Parameters

fldName Name of field to create in current runTime directory

Definition at line 798 of file AMRFoam.C.

Referenced by assignToVolScalarField(), pF2vF(), readIncomingCellField(), and ~AMRFoam().

                                                                 {
   volScalarField emptyScalar(IOobject(fldName, time().timeName(), *this,
                                       IOobject::NO_READ, IOobject::AUTO_WRITE),
                              *this, dimensionedScalar("scalar", dimLength, 0));
 
   return emptyScalar;
 }

◆ mapFields()

void Foam::AMRFoam::mapFields ( const mapPolyMesh & mpm )

virtual

Definition at line 937 of file AMRFoam.C.

References correctFluxes_.

Referenced by protectedCell().

                                               {
   dynamicFvMesh::mapFields(mpm);
 
   // Correct the flux for modified/added faces. All the faces which only
   // have been renumbered will already have been handled by the mapping.
   {
     const labelList &faceMap = mpm.faceMap();
     const labelList &reverseFaceMap = mpm.reverseFaceMap();
 
     // Storage for any master faces. These will be the original faces
     // on the coarse cell that get split into four (or rather the
     // master face gets modified and three faces get added from the master)
     // Estimate number of faces created
 
     bitSet masterFaces(nFaces());
 
     forAll (faceMap, facei) {
       const label oldFacei = faceMap[facei];
 
       if (oldFacei >= 0) {
         const label masterFacei = reverseFaceMap[oldFacei];
 
         if (masterFacei < 0) {
           FatalErrorInFunction << "Problem: should not have removed faces"
                                << " when refining." << nl << "face:" << facei
                                << endl
                                << abort(FatalError);
         } else if (masterFacei != facei) {
           masterFaces.set(masterFacei);
         }
       }
     }
 
     if (debug) {
       Pout << "Found " << masterFaces.count() << " split faces " << endl;
     }
 
     HashTable<surfaceScalarField *> fluxes(lookupClass<surfaceScalarField>());
     forAllIters(fluxes, iter) {
       if (!correctFluxes_.found(iter.key())) {
         WarningInFunction
             << "Cannot find surfaceScalarField " << iter.key()
             << " in user-provided flux mapping table " << correctFluxes_ << endl
             << "    The flux mapping table is used to recreate the"
             << " flux on newly created faces." << endl
             << "    Either add the entry if it is a flux or use (" << iter.key()
             << " none) to suppress this warning." << endl;
         continue;
       }
 
       const word &UName = correctFluxes_[iter.key()];
 
       if (UName == "none") { continue; }
 
       surfaceScalarField &phi = *iter();
 
       if (UName == "NaN") {
         Pout << "Setting surfaceScalarField " << iter.key() << " to NaN"
              << endl;
 
         sigFpe::fillNan(phi.primitiveFieldRef());
 
         continue;
       }
 
       if (debug) {
         Pout << "Mapping flux " << iter.key() << " using interpolated flux "
              << UName << endl;
       }
 
       const surfaceScalarField phiU(
           fvc::interpolate(lookupObject<volVectorField>(UName)) & Sf());
 
       // Recalculate new internal faces.
       for (label facei = 0; facei < nInternalFaces(); ++facei) {
         const label oldFacei = faceMap[facei];
 
         if (oldFacei == -1) {
           // Inflated/appended
           phi[facei] = phiU[facei];
         } else if (reverseFaceMap[oldFacei] != facei) {
           // face-from-masterface
           phi[facei] = phiU[facei];
         }
       }
 
       // Recalculate new boundary faces.
       surfaceScalarField::Boundary &phiBf = phi.boundaryFieldRef();
 
       forAll (phiBf, patchi) {
         fvsPatchScalarField &patchPhi = phiBf[patchi];
         const fvsPatchScalarField &patchPhiU = phiU.boundaryField()[patchi];
 
         label facei = patchPhi.patch().start();
 
         forAll (patchPhi, i) {
           const label oldFacei = faceMap[facei];
 
           if (oldFacei == -1) {
             // Inflated/appended
             patchPhi[i] = patchPhiU[i];
           } else if (reverseFaceMap[oldFacei] != facei) {
             // face-from-masterface
             patchPhi[i] = patchPhiU[i];
           }
 
           ++facei;
         }
       }
 
       // Update master faces
       for (const label facei : masterFaces) {
         if (isInternalFace(facei)) {
           phi[facei] = phiU[facei];
         } else {
           const label patchi = boundaryMesh().whichPatch(facei);
           const label i = facei - boundaryMesh()[patchi].start();
 
           const fvsPatchScalarField &patchPhiU = phiU.boundaryField()[patchi];
 
           fvsPatchScalarField &patchPhi = phiBf[patchi];
 
           patchPhi[i] = patchPhiU[i];
         }
       }
     }
   }
 
   // Correct the flux for injected faces - these are the faces which have
   // no correspondence to the old mesh (i.e. added without a masterFace, edge
   // or point). An example is the internal faces from hexRef8.
   {
     const labelList &faceMap = mpm.faceMap();
 
     mapNewInternalFaces<scalar>(this->Sf(), this->magSf(), faceMap);
     mapNewInternalFaces<vector>(this->Sf(), this->magSf(), faceMap);
 
     // No oriented fields of more complex type
     mapNewInternalFaces<sphericalTensor>(faceMap);
     mapNewInternalFaces<symmTensor>(faceMap);
     mapNewInternalFaces<tensor>(faceMap);
   }
 }

◆ mapNewInternalFaces() [1/3]

template<class T >

void Foam::AMRFoam::mapNewInternalFaces	(	const labelList &	faceMap,
		GeometricField< T, fvsPatchField, surfaceMesh > &	sFld
	)

protected

Definition at line 1458 of file AMRFoam.C.

Referenced by mapNewInternalFaces().

                                                          {
   using GeoField = GeometricField<T, fvsPatchField, surfaceMesh>;
 
   //- Make flat field for ease of looping
   Field<T> tsFld(this->nFaces(), Zero);
   SubField<T>(tsFld, this->nInternalFaces()) = sFld.internalField();
 
   const typename GeoField::Boundary &bFld = sFld.boundaryField();
   forAll (bFld, patchi) {
     label facei = this->boundaryMesh()[patchi].start();
     for (const T &val : bFld[patchi]) { tsFld[facei++] = val; }
   }
 
   const labelUList &owner = this->faceOwner();
   const labelUList &neighbour = this->faceNeighbour();
   const cellList &cells = this->cells();
 
   for (label facei = 0; facei < nInternalFaces(); facei++) {
     label oldFacei = faceMap[facei];
 
     // Map surface field on newly generated faces by obtaining the
     // hull of the outside faces
     if (oldFacei == -1) {
       // Loop over all owner/neighbour cell faces
       // and find already mapped ones (master-faces):
       T tmpValue(pTraits<T>::zero);
       label counter = 0;
 
       const cell &ownFaces = cells[owner[facei]];
       for (auto ownFacei : ownFaces) {
         if (faceMap[ownFacei] != -1) {
           tmpValue += tsFld[ownFacei];
           counter++;
         }
       }
 
       const cell &neiFaces = cells[neighbour[facei]];
       for (auto neiFacei : neiFaces) {
         if (faceMap[neiFacei] != -1) {
           tmpValue += tsFld[neiFacei];
           counter++;
         }
       }
 
       if (counter > 0) { sFld[facei] = tmpValue / counter; }
     }
   }
 }

◆ mapNewInternalFaces() [2/3]

template<class T >

void Foam::AMRFoam::mapNewInternalFaces ( const labelList & faceMap )

protected

Definition at line 1510 of file AMRFoam.C.

References mapNewInternalFaces().

                                                           {
   using GeoField = GeometricField<T, fvsPatchField, surfaceMesh>;
   HashTable<GeoField *> sFlds(this->objectRegistry::lookupClass<GeoField>());
 
   forAllIters(sFlds, iter) {
     // if (mapSurfaceFields_.found(iter.key()))
     {
       DebugInfo << "dynamicRefineMotionFvMesh::mapNewInternalFaces():"
                 << " Mapping new internal faces by interpolation on "
                 << iter.key() << endl;
 
       GeoField &sFld = *iter();
 
       if (sFld.oriented()()) {
         WarningInFunction << "Ignoring mapping oriented field " << sFld.name()
                           << " since of type " << sFld.type() << endl;
       } else {
         mapNewInternalFaces(faceMap, sFld);
       }
     }
   }
 }

◆ mapNewInternalFaces() [3/3]

template<class T >

void Foam::AMRFoam::mapNewInternalFaces	(	const surfaceVectorField &	Sf,
		const surfaceScalarField &	magSf,
		const labelList &	faceMap
	)

protected

Definition at line 1534 of file AMRFoam.C.

References mapNewInternalFaces().

                                                             {
   using GeoField = GeometricField<T, fvsPatchField, surfaceMesh>;
   HashTable<GeoField *> sFlds(this->objectRegistry::lookupClass<GeoField>());
 
   forAllIters(sFlds, iter) {
     // if (mapSurfaceFields_.found(iter.key()))
     {
       DebugInfo << "dynamicRefineMotionFvMesh::mapNewInternalFaces():"
                 << " Mapping new internal faces by interpolation on "
                 << iter.key() << endl;
 
       GeoField &sFld = *iter();
 
       if (sFld.oriented()()) {
         DebugInfo << "dynamicRefineMotionFvMesh::mapNewInternalFaces(): "
                   << "Converting oriented field " << iter.key()
                   << " to intensive field and mapping" << endl;
 
         // Assume any oriented field is face area weighted (i.e. a flux)
         // Convert to intensive (& oriented) before mapping. Untested.
 
         using NormalGeoField =
             GeometricField<typename outerProduct<vector, T>::type,
                            fvsPatchField, surfaceMesh>;
 
         // Convert to intensive and non oriented
         NormalGeoField fFld(sFld * Sf / Foam::sqr(magSf));
 
         // Interpolate
         mapNewInternalFaces(faceMap, fFld);
 
         // Convert back to extensive and oriented
         sFld = (fFld & Sf);
       } else {
         mapNewInternalFaces(faceMap, sFld);
       }
     }
   }
 }

◆ maxCellField()

scalarField Foam::AMRFoam::maxCellField ( const volScalarField & vFld ) const

protected

Definition at line 1273 of file AMRFoam.C.

Referenced by update(), updateAMR(), and updateAMRML().

                                                                   {
   scalarField pFld(nPoints(), -GREAT);
 
   forAll (pointCells(), pointi) {
     const labelList &pCells = pointCells()[pointi];
 
     for (const label celli : pCells) {
       pFld[pointi] = max(pFld[pointi], vFld[celli]);
     }
   }
   return pFld;
 }

◆ maxPointField()

scalarField Foam::AMRFoam::maxPointField ( const scalarField & pFld ) const

protected

Definition at line 1260 of file AMRFoam.C.

Referenced by selectRefineCandidates().

                                                                 {
   scalarField vFld(nCells(), -GREAT);
 
   forAll (pointCells(), pointi) {
     const labelList &pCells = pointCells()[pointi];
 
     for (const label celli : pCells) {
       vFld[celli] = max(vFld[celli], pFld[pointi]);
     }
   }
   return vFld;
 }

◆ meshCutter()

const hexRef8& Foam::AMRFoam::meshCutter ( ) const

inline

Definition at line 370 of file AMRFoam.H.

References meshCutter_.

Referenced by update(), updateAMR(), and updateAMRML().

370 { return meshCutter_; }

Foam::AMRFoam::meshCutter_

hexRef8 meshCutter_

Definition: AMRFoam.H:253

◆ pF2vF()

volScalarField Foam::AMRFoam::pF2vF	(	const pointScalarField &	pntF,
		const std::string &	outName
	)

Parameters

pntF	A point field defined on mesh points
outName	Object name for output scalar

Returns: A Scalar Field defined on cells

Definition at line 792 of file AMRFoam.C.

References initScalarField().

Referenced by ~AMRFoam().

                                                         {
   volScalarField returnFld = initScalarField(outName);
   return returnFld;
 }

◆ protectedCell() [1/2]

const bitSet& Foam::AMRFoam::protectedCell ( ) const

inline

Definition at line 373 of file AMRFoam.H.

References protectedCell_.

373 { return protectedCell_; }

Foam::AMRFoam::protectedCell_

bitSet protectedCell_

Definition: AMRFoam.H:265

◆ protectedCell() [2/2]

bitSet& Foam::AMRFoam::protectedCell ( )

inline

Definition at line 376 of file AMRFoam.H.

References mapFields(), protectedCell_, and writeObjectAMR().

376 { return protectedCell_; }

Foam::AMRFoam::protectedCell_

bitSet protectedCell_

Definition: AMRFoam.H:265

◆ readDict()

void Foam::AMRFoam::readDict ( )

protected

Definition at line 920 of file AMRFoam.C.

References correctFluxes_, and dumpLevel_.

                        {
   dictionary refineDict(
       IOdictionary(IOobject("dynamicMeshDict", time().constant(), *this,
                             IOobject::MUST_READ_IF_MODIFIED, IOobject::NO_WRITE,
                             false))
           .optionalSubDict("dynamicRefineMotionFvMeshCoeffs"));
 
   List<Pair<word>> fluxVelocities =
       List<Pair<word>>(refineDict.lookup("correctFluxes"));
   // Rework into hashtable.
   correctFluxes_.resize(fluxVelocities.size());
   forAll (fluxVelocities, i)
     correctFluxes_.insert(fluxVelocities[i][0], fluxVelocities[i][1]);
 
   dumpLevel_ = Switch(refineDict.lookup("dumpLevel"));
 }

◆ readIncomingCellField()

volScalarField Foam::AMRFoam::readIncomingCellField	(	const std::string &	inName,
		const std::string &	outName
	)

Parameters

inName	Input file name
outName	Object name for volScalarField

Returns: Scalar Field

Definition at line 723 of file AMRFoam.C.

References incomingField, initScalarField(), and nemAux::strToChar().

Referenced by ~AMRFoam().

                                                                         {
   std::cout << " - Parsing Input file ... " << std::endl;
   std::ifstream inFld(inName);
   if (inFld.is_open()) {
     std::string linesOut;              // Temporary string for multiple uses
     std::vector<std::string> myLines;  // Stores whole file line by line
     while (std::getline(inFld, linesOut)) myLines.push_back(linesOut);
 
     incomingField.clear();
     incomingField.resize(myLines.size());
 
     for (int i = 0; i < (int)myLines.size(); i++)
       incomingField[i] =
           std::strtod(nemAux::strToChar(myLines[i]).get(), nullptr);
 
     volScalarField returnFld = initScalarField(outName);
 
     for (int i = 0; i < returnFld.size(); i++) returnFld[i] = incomingField[i];
 
     return returnFld;
   } else {
     std::cerr << "Cannot open/find " << inName << " file!" << std::endl;
     throw;
   }
 }

◆ readIncomingPtField()

pointScalarField Foam::AMRFoam::readIncomingPtField	(	const std::string &	inName,
		const std::string &	outName
	)

Parameters

inName

Returns: A pointScalarField with appended incoming values

Definition at line 756 of file AMRFoam.C.

References incomingField, initPntSField(), and nemAux::strToChar().

Referenced by ~AMRFoam().

                                                                         {
   std::cout << " - Parsing Input file ... " << std::endl;
   std::ifstream inFld(inName);
   if (inFld.is_open()) {
     std::string linesOut;              // Temporary string for multiple uses
     std::vector<std::string> myLines;  // Stores whole file line by line
     while (std::getline(inFld, linesOut)) myLines.push_back(linesOut);
 
     incomingField.clear();
     incomingField.resize(myLines.size());
 
     for (int i = 0; i < (int)myLines.size(); i++) {
       incomingField[i] =
           std::strtod(nemAux::strToChar(myLines[i]).get(), nullptr);
     }
 
     pointScalarField returnFld = initPntSField(outName);
 
     for (int i = 0; i < returnFld.size(); i++) returnFld[i] = incomingField[i];
 
     return returnFld;
   } else {
     std::cerr << "Cannot open/find " << inName << " file!" << std::endl;
     throw;
   }
 }

◆ readInitialField()

volScalarField Foam::AMRFoam::readInitialField ( const std::string & fldName )

Parameters

fldName Name of field present in current runTime directory

Definition at line 784 of file AMRFoam.C.

Referenced by ~AMRFoam().

                                                                  {
   volScalarField meshFieldXY(IOobject(fldName, time().timeName(), *this,
                                       IOobject::NO_READ, IOobject::AUTO_WRITE),
                              *this);
 
   return meshFieldXY;
 }

◆ refine()

autoPtr< mapPolyMesh > Foam::AMRFoam::refine ( const labelList & cellsToRefine )

protectedvirtual

Parameters

splitPoints Selected hanging nodes that can be erased to unrefine previously refined cells. Selection is performed using criteria and protected cells are excluded.

Returns: Mapped Polymesh.

Definition at line 1082 of file AMRFoam.C.

References enableMotion, meshCutter_, motionPtr_, and protectedCell_.

Referenced by update(), updateAMR(), and updateAMRML().

                                                                        {
   // Mesh changing engine.
   polyTopoChange meshMod(*this);
 
   // Play refinement commands into mesh changer.
   meshCutter_.setRefinement(cellsToRefine, meshMod);
 
   // Create mesh (with inflation), return map from old to new mesh.
   // autoPtr<mapPolyMesh> map = meshMod.changeMesh(*this, true);
   autoPtr<mapPolyMesh> map = meshMod.changeMesh(*this, false);
 
   Info << "Refined from " << returnReduce(map().nOldCells(), sumOp<label>())
        << " to " << globalData().nTotalCells() << " cells." << endl;
 
   if (debug) {
     // Check map.
     for (label facei = 0; facei < nInternalFaces(); ++facei) {
       const label oldFacei = map().faceMap()[facei];
 
       if (oldFacei >= nInternalFaces()) {
         FatalErrorInFunction << "New internal face:" << facei
                              << " fc:" << faceCentres()[facei]
                              << " originates from boundary oldFace:" << oldFacei
                              << abort(FatalError);
       }
     }
   }
 
   // Update fields
   updateMesh(*map);
 
   if (enableMotion) {
     // Solve for mesh motion and move points
     motionPtr_->updateMesh(*map);
     movePoints(motionPtr_->newPoints());
   }
 
   // Update numbering of cells/vertices.
   meshCutter_.updateMesh(*map);
 
   // Update numbering of protectedCell_
   if (!protectedCell_.empty()) {
     bitSet newProtectedCell(nCells());
     forAll (newProtectedCell, celli) {
       const label oldCelli = map().cellMap()[celli];
       if (protectedCell_.test(oldCelli)) { newProtectedCell.set(celli); }
     }
     protectedCell_.transfer(newProtectedCell);
   }
 
   // Debug: Check refinement levels (across faces only)
   meshCutter_.checkRefinementLevels(-1, labelList());
 
   return map;
 }

◆ selectRefineCandidates()

void Foam::AMRFoam::selectRefineCandidates	(	const scalar	lowerRefineLevel,
		const scalar	upperRefineLevel,
		const scalarField &	vFld,
		bitSet &	candidateCell
	)		const

protectedvirtual

Definition at line 1310 of file AMRFoam.C.

References cellToPoint(), error(), and maxPointField().

Referenced by update(), updateAMR(), and updateAMRML().

                                                                   {
   // Get error per cell. Is -1 (not to be refined) to >0 (to be refined,
   // higher more desirable to be refined).
   scalarField cellError(maxPointField(
       error(cellToPoint(vFld), lowerRefineLevel, upperRefineLevel)));
 
   // Mark cells that are candidates for refinement.
   forAll (cellError, celli) {
     if (cellError[celli] > 0) { candidateCell.set(celli); }
   }
 }

◆ selectRefineCells()

labelList Foam::AMRFoam::selectRefineCells	(	const label	maxCells,
		const label	maxRefinement,
		const bitSet &	candidateCell
	)		const

protectedvirtual

Definition at line 1325 of file AMRFoam.C.

References calculateProtectedCells(), and meshCutter_.

Referenced by update(), updateAMR(), and updateAMRML().

                                                                         {
   // Every refined cell causes 7 extra cells
   label nTotToRefine = (maxCells - globalData().nTotalCells()) / 7;
 
   const labelList &cellLevel = meshCutter_.cellLevel();
 
   // Mark cells that cannot be refined since they would trigger refinement
   // of protected cells (since 2:1 cascade)
   bitSet unrefineableCell;
   calculateProtectedCells(unrefineableCell);
 
   // Count current selection
   label nLocalCandidates = candidateCell.count();
   label nCandidates = returnReduce(nLocalCandidates, sumOp<label>());
 
   // Collect all cells
   DynamicList<label> candidates(nLocalCandidates);
 
   if (nCandidates < nTotToRefine) {
     for (const label celli : candidateCell) {
       if ((!unrefineableCell.test(celli)) && cellLevel[celli] < maxRefinement) {
         candidates.append(celli);
       }
     }
   } else {
     // Sort by error? For now just truncate.
     for (label level = 0; level < maxRefinement; ++level) {
       for (const label celli : candidateCell) {
         if ((!unrefineableCell.test(celli)) && cellLevel[celli] == level) {
           candidates.append(celli);
         }
       }
 
       if (returnReduce(candidates.size(), sumOp<label>()) > nTotToRefine) {
         break;
       }
     }
   }
 
   // Guarantee 2:1 refinement after refinement
   labelList consistentSet(meshCutter_.consistentRefinement(
       candidates.shrink(),
       true  // Add to set to guarantee 2:1
       ));
 
   Info << "Selected " << returnReduce(consistentSet.size(), sumOp<label>())
        << " cells for refinement out of " << globalData().nTotalCells() << "."
        << endl;
 
   return consistentSet;
 }

◆ selectUnrefinePoints()

labelList Foam::AMRFoam::selectUnrefinePoints	(	const scalar	unrefineAbove,
		const scalar	unrefineBelow,
		const bitSet &	markedCell,
		const scalarField &	pFld
	)		const

protectedvirtual

Parameters

unrefineAbove	Unrefine cells above this thresold.
unrefineBelow	Unrefine cells below this thresold.
markedCell	Unrefinable cells list
pFld	PointField at current runTime

Returns: List of cells/points to unrefine.

Definition at line 616 of file AMRFoam.C.

References meshCutter_, and protectedCell_.

Referenced by update(), updateAMR(), and updateAMRML().

                                                                        {
   // All points that can be unrefined
   const labelList splitPoints(meshCutter_.getSplitPoints());
 
   const labelListList &pointCells = this->pointCells();
 
   // If we have any protected cells make sure they also are not being
   // unrefined
 
   bitSet protectedPoint(nPoints());
 
   if (!protectedCell_.empty()) {
     // Get all points on a protected cell
     forAll (pointCells, pointi) {
       for (const label celli : pointCells[pointi]) {
         if (protectedCell_.test(celli)) {
           protectedPoint.set(pointi);
           break;
         }
       }
     }
 
     syncTools::syncPointList(*this, protectedPoint, orEqOp<unsigned int>(), 0u);
 
     DebugInfo << "From " << returnReduce(protectedCell_.count(), sumOp<label>())
               << " protected cells found "
               << returnReduce(protectedPoint.count(), sumOp<label>())
               << " protected points." << endl;
   }
 
   DynamicList<label> newSplitPoints(splitPoints.size());
 
   for (const label pointi : splitPoints) {
     if ((!protectedPoint[pointi] && pFld[pointi] < unrefineBelow) ||
         (!protectedPoint[pointi] && pFld[pointi] > unrefineAbove)) {
       // Check that all cells are not marked
       bool hasMarked = false;
 
       for (const label celli : pointCells[pointi]) {
         if (markedCell.test(celli)) {
           hasMarked = true;
           break;
         }
       }
 
       if (!hasMarked) { newSplitPoints.append(pointi); }
     }
   }
 
   newSplitPoints.shrink();
 
   // Guarantee 2:1 refinement after unrefinement
   labelList consistentSet(
       meshCutter_.consistentUnrefinement(newSplitPoints, false));
   Info << "Selected " << returnReduce(consistentSet.size(), sumOp<label>())
        << " split points out of a possible "
        << returnReduce(splitPoints.size(), sumOp<label>()) << "." << endl;
 
   return consistentSet;
 }

◆ solveMotion()

void Foam::AMRFoam::solveMotion ( )

This method allows solving of mesh motion along with mesh refinment. Flux correction takes place after motion and refinement operations are performed. Experimental method.

Definition at line 1449 of file AMRFoam.C.

References motionPtr_.

Referenced by update(), updateAMR(), and ~AMRFoam().

                           {
   movePoints(motionPtr_->newPoints());
 
   if (foundObject<volVectorField>("U")) {
     lookupObjectRef<volVectorField>("U").correctBoundaryConditions();
   }
 }

◆ transformField()

void Foam::AMRFoam::transformField ( volScalarField & inField )

Appends this information to lower, upper and unrefine level vectors for AMR

Definition at line 708 of file AMRFoam.C.

Referenced by ~AMRFoam().

                                                     {
   double maxNum = 0;
   for (int i = 0; i < inField.size(); i++) {
     if (inField[i] < 0) {
       // Do Nothing
     } else if (inField[i] > maxNum) {
       maxNum = inField[i];
     } else {
       // Do Nothing
     }
   }
 
   for (int i = 0; i < inField.size(); i++) inField[i] = inField[i] / maxNum;
 }

◆ unrefine()

autoPtr< mapPolyMesh > Foam::AMRFoam::unrefine ( const labelList & splitPoints )

protectedvirtual

Parameters

cellsToRefine Cell list selected for refinement.

Returns: Mapped Polymesh.

Definition at line 1138 of file AMRFoam.C.

References correctFluxes_, enableMotion, meshCutter_, motionPtr_, and protectedCell_.

Referenced by update(), updateAMR(), and updateAMRML().

                                                                        {
   polyTopoChange meshMod(*this);
 
   // Play refinement commands into mesh changer.
   meshCutter_.setUnrefinement(splitPoints, meshMod);
 
   // Save information on faces that will be combined
   // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
   // Find the faceMidPoints on cells to be combined.
   // for each face resulting of split of face into four store the
   // midpoint
   Map<label> faceToSplitPoint(3 * splitPoints.size());
 
   {
     for (const label pointi : splitPoints) {
       const labelList &pEdges = pointEdges()[pointi];
 
       for (const label edgei : pEdges) {
         const label otherPointi = edges()[edgei].otherVertex(pointi);
 
         const labelList &pFaces = pointFaces()[otherPointi];
 
         for (const label facei : pFaces) {
           faceToSplitPoint.insert(facei, otherPointi);
         }
       }
     }
   }
 
   // Change mesh and generate map.
   // autoPtr<mapPolyMesh> map = meshMod.changeMesh(*this, true);
   autoPtr<mapPolyMesh> map = meshMod.changeMesh(*this, false);
 
   Info << "Unrefined from " << returnReduce(map().nOldCells(), sumOp<label>())
        << " to " << globalData().nTotalCells() << " cells." << endl;
 
   // Update fields
   updateMesh(*map);
 
   if (enableMotion) {
     // Solve for mesh motion and move points
     motionPtr_->updateMesh(*map);
     movePoints(motionPtr_->newPoints());
   }
 
   // Correct the flux for modified faces.
   {
     const labelList &reversePointMap = map().reversePointMap();
     const labelList &reverseFaceMap = map().reverseFaceMap();
 
     HashTable<surfaceScalarField *> fluxes(lookupClass<surfaceScalarField>());
     forAllIters(fluxes, iter) {
       if (!correctFluxes_.found(iter.key())) {
         WarningInFunction
             << "Cannot find surfaceScalarField " << iter.key()
             << " in user-provided flux mapping table " << correctFluxes_ << endl
             << "    The flux mapping table is used to recreate the"
             << " flux on newly created faces." << endl
             << "    Either add the entry if it is a flux or use (" << iter.key()
             << " none) to suppress this warning." << endl;
         continue;
       }
 
       const word &UName = correctFluxes_[iter.key()];
 
       if (UName == "none") { continue; }
 
       DebugInfo << "Mapping flux " << iter.key() << " using interpolated flux "
                 << UName << endl;
 
       surfaceScalarField &phi = *iter();
       surfaceScalarField::Boundary &phiBf = phi.boundaryFieldRef();
 
       const surfaceScalarField phiU(
           fvc::interpolate(lookupObject<volVectorField>(UName)) & Sf());
 
       forAllConstIters(faceToSplitPoint, iter2) {
         const label oldFacei = iter2.key();
         const label oldPointi = iter2.val();
         if (reversePointMap[oldPointi] < 0) {
           // midpoint was removed. See if face still exists.
           const label facei = reverseFaceMap[oldFacei];
 
           if (facei >= 0) {
             if (isInternalFace(facei)) {
               phi[facei] = phiU[facei];
             } else {
               label patchi = boundaryMesh().whichPatch(facei);
               label i = facei - boundaryMesh()[patchi].start();
 
               const fvsPatchScalarField &patchPhiU =
                   phiU.boundaryField()[patchi];
               fvsPatchScalarField &patchPhi = phiBf[patchi];
               patchPhi[i] = patchPhiU[i];
             }
           }
         }
       }
     }
   }
 
   // Update numbering of cells/vertices.
   meshCutter_.updateMesh(*map);
 
   // Update numbering of protectedCell_
   if (!protectedCell_.empty()) {
     bitSet newProtectedCell(nCells());
 
     forAll (newProtectedCell, celli) {
       const label oldCelli = map().cellMap()[celli];
       if (protectedCell_.test(oldCelli)) { newProtectedCell.set(celli); }
     }
     protectedCell_.transfer(newProtectedCell);
   }
 
   // Debug: Check refinement levels (across faces only)
   meshCutter_.checkRefinementLevels(-1, labelList());
 
   return map;
 }

◆ update()

bool Foam::AMRFoam::update ( )

virtual

Definition at line 233 of file AMRFoam.C.

References nemAux::cellsToRefine(), correctFluxes_, dumpLevel_, enableMotion, extendMarkedCells(), maxCellField(), meshCutter(), nRefinementIterations_, refine(), selectRefineCandidates(), selectRefineCells(), selectUnrefinePoints(), solveMotion(), unrefine(), writeHistory(), and writeMesh().

                      {
   // Re-read dictionary. Chosen since usually -small so trivial amount
   // of time compared to actual refinement. Also very useful to be able
   // to modify on-the-fly.
   dictionary refineDict(
       IOdictionary(IOobject("dynamicMeshDict", time().constant(), *this,
                             IOobject::MUST_READ_IF_MODIFIED, IOobject::NO_WRITE,
                             false))
           .optionalSubDict("dynamicRefineMotionFvMeshCoeffs"));
 
   auto fluxVelocities = refineDict.get<List<Pair<word>>>("correctFluxes");
 
   // Rework into hashtable.
   correctFluxes_.resize(fluxVelocities.size());
   for (const auto &pr : fluxVelocities) {
     correctFluxes_.insert(pr.first(), pr.second());
   }
 
   refineDict.readEntry("dumpLevel", dumpLevel_);
   const label refineInterval = refineDict.get<label>("refineInterval");
 
   bool hasChanged = false;
 
   if (refineInterval == 0) {
     polyMesh::topoChanging(hasChanged);
     return hasChanged;
   } else if (refineInterval < 0) {
     FatalErrorInFunction << "Illegal refineInterval " << refineInterval << nl
                          << "The refineInterval value should"
                          << " be >= 1." << nl << exit(FatalError);
   }
 
   if (time().timeIndex() > 0 && time().timeIndex() % refineInterval == 0) {
     label maxCells = refineDict.get<label>("maxCells");
 
     if (maxCells < 0) maxCells = 500000;
 
     if (maxCells <= 0) {
       FatalErrorInFunction
           << "Illegal maximum number of cells " << maxCells << nl
           << "The maxCells setting in the dynamicMeshDict should"
           << " be > 0." << nl << exit(FatalError);
     }
 
     const label maxRefinement = refineDict.get<label>("maxRefinement");
 
     if (maxRefinement <= 0) {
       FatalErrorInFunction
           << "Illegal maximum refinement level " << maxRefinement << nl
           << "The maxCells setting in the dynamicMeshDict should"
           << " be > 0." << nl << exit(FatalError);
     }
 
     const word fieldName(refineDict.get<word>("field"));
 
     const volScalarField &vFld = lookupObject<volScalarField>(fieldName);
 
     const scalar lowerRefineLevel = refineDict.get<scalar>("lowerRefineLevel");
     const scalar upperRefineLevel = refineDict.get<scalar>("upperRefineLevel");
     const scalar unrefineBelow =
         refineDict.getOrDefault<scalar>("unrefineLevel", GREAT);
     const scalar unrefineAbove =
         refineDict.getOrDefault<scalar>("unrefineAbove", 50000);
     const label nBufferLayers = refineDict.get<label>("nBufferLayers");
 
     // Cells marked for refinement or otherwise protected from unrefinement.
     bitSet refineCell(nCells());
 
     // Determine candidates for refinement (looking at field only)
     selectRefineCandidates(lowerRefineLevel, upperRefineLevel, vFld,
                            refineCell);
 
     if (globalData().nTotalCells() < maxCells) {
       // Select subset of candidates. Take into account max allowable
       // cells, refinement level, protected cells.
       labelList cellsToRefine(
           selectRefineCells(maxCells, maxRefinement, refineCell));
 
       const label nCellsToRefine =
           returnReduce(cellsToRefine.size(), sumOp<label>());
 
       if (nCellsToRefine > 0) {
         // Refine/update mesh and map fields
         autoPtr<mapPolyMesh> map = refine(cellsToRefine);
 
         // Update refineCell. Note that some of the marked ones have
         // not been refined due to constraints.
         {
           const labelList &cellMap = map().cellMap();
           const labelList &reverseCellMap = map().reverseCellMap();
 
           bitSet newRefineCell(cellMap.size());
 
           forAll (cellMap, celli) {
             const label oldCelli = cellMap[celli];
             if ((oldCelli < 0) || (reverseCellMap[oldCelli] != celli) ||
                 (refineCell.test(oldCelli))) {
               newRefineCell.set(celli);
             }
           }
           refineCell.transfer(newRefineCell);
         }
 
         // Extend with a buffer layer to prevent neighbouring points
         // being unrefined.
         for (label i = 0; i < nBufferLayers; ++i) {
           extendMarkedCells(refineCell);
         }
 
         hasChanged = true;
       }
     }
 
     {
       // Select unrefineable points that are not marked in refineCell
       labelList pointsToUnrefine(selectUnrefinePoints(
           unrefineAbove, unrefineBelow, refineCell, maxCellField(vFld)));
 
       const label nSplitPoints =
           returnReduce(pointsToUnrefine.size(), sumOp<label>());
 
       if (nSplitPoints > 0) {
         // Refine/update mesh
         unrefine(pointsToUnrefine);
 
         hasChanged = true;
       }
     }
 
     if ((nRefinementIterations_ % 1) == 0) {
       // Compact refinement history occasionally (how often?).
       // Unrefinement causes holes in the refinementHistory.
       const_cast<refinementHistory &>(meshCutter().history()).compact();
     }
     nRefinementIterations_++;
   }
 
   writeHistory();
 
   writeMesh();
 
   topoChanging(hasChanged);
 
   if (hasChanged) {
     // Reset moving flag (if any). If not using inflation we'll not move,
     // if are using inflation any follow on movePoints will set it.
     moving(false);
   } else {
     if (enableMotion) solveMotion();
   }
   return hasChanged;
 }

◆ updateAMR()

bool Foam::AMRFoam::updateAMR	(	const int &	refineInterval,
		const int &	maxRefinement,
		volScalarField &	vFld,
		const double &	lowerRefineLevel,
		const double &	upperRefineLevel,
		const double &	unrefineAbove,
		const double &	unrefineBelow,
		const int &	nBufferLayers,
		const int &	maxCells
	)

It drives the refinement and unrefinement procedure between any two given timesteps.

Parameters

refineInterval	Refinement interval/frequency
maxRefinement	Maximum refinement allowed by user
vFld	A scalar field of refinement criteria quantity
lowerRefineLevel	Lower refinement level (Based on vFld)
upperRefineLevel	Upper refinement level (Based on vFld)
unrefineAbove	Criteria for unrefinement above this value
unrefineBelow	Criteria for unrefinement below this value
nBufferLayers	Buffer layers for slower than 2:1 refinement
maxCells	Maximum number of cells allowed in mesh. Once this level is reached, refinement will be stopped.

Returns: A boolean indicating mesh change

Definition at line 386 of file AMRFoam.C.

References nemAux::cellsToRefine(), enableMotion, extendMarkedCells(), maxCellField(), meshCutter(), nRefinementIterations_, refine(), selectRefineCandidates(), selectRefineCells(), selectUnrefinePoints(), solveMotion(), unrefine(), writeField, writeHistory(), writeMesh(), writeMeshData, and writeRefHistory.

Referenced by ~AMRFoam().

                                              {
   bool hasChanged = false;
 
   if (refineInterval == 0) {
     polyMesh::topoChanging(hasChanged);
     return hasChanged;
   } else if (refineInterval < 0) {
     FatalErrorInFunction << "Illegal refineInterval " << refineInterval << nl
                          << "The refineInterval value should"
                          << " be >= 1." << nl << exit(FatalError);
   }
 
   if (time().timeIndex() > 0 && time().timeIndex() % refineInterval == 0) {
     if (maxCells <= 0) {
       FatalErrorInFunction
           << "Illegal maximum number of cells " << maxCells << nl
           << "The maxCells setting in the dynamicMeshDict should"
           << " be > 0." << nl << exit(FatalError);
     }
 
     if (maxRefinement <= 0) {
       FatalErrorInFunction
           << "Illegal maximum refinement level " << maxRefinement << nl
           << "The maxCells setting in the dynamicMeshDict should"
           << " be > 0." << nl << exit(FatalError);
     }
 
     // Cells marked for refinement or otherwise protected from unrefinement.
     bitSet refineCell(nCells());
 
     // Determine candidates for refinement (looking at field only)
     selectRefineCandidates(lowerRefineLevel, upperRefineLevel, vFld,
                            refineCell);
 
     if (globalData().nTotalCells() < maxCells) {
       // Select subset of candidates. Take into account max allowable
       // cells, refinement level, protected cells.
       labelList cellsToRefine(
           selectRefineCells(maxCells, maxRefinement, refineCell));
 
       const label nCellsToRefine =
           returnReduce(cellsToRefine.size(), sumOp<label>());
 
       if (nCellsToRefine > 0) {
         // Refine/update mesh and map fields
         autoPtr<mapPolyMesh> map = refine(cellsToRefine);
 
         // Update refineCell. Note that some of the marked ones have
         // not been refined due to constraints.
         {
           const labelList &cellMap = map().cellMap();
           const labelList &reverseCellMap = map().reverseCellMap();
 
           bitSet newRefineCell(cellMap.size());
 
           forAll (cellMap, celli) {
             const label oldCelli = cellMap[celli];
             if ((oldCelli < 0) || (reverseCellMap[oldCelli] != celli) ||
                 (refineCell.test(oldCelli))) {
               newRefineCell.set(celli);
             }
           }
           refineCell.transfer(newRefineCell);
         }
 
         // Extend with a buffer layer to prevent neighbouring points
         // being unrefined.
         for (label i = 0; i < nBufferLayers; ++i) {
           extendMarkedCells(refineCell);
         }
 
         hasChanged = true;
       }
     }
 
     {
       // Select unrefineable points that are not marked in refineCell
       labelList pointsToUnrefine(selectUnrefinePoints(
           unrefineAbove, unrefineBelow, refineCell, maxCellField(vFld)));
 
       const label nSplitPoints =
           returnReduce(pointsToUnrefine.size(), sumOp<label>());
 
       if (nSplitPoints > 0) {
         // Refine/update mesh
         unrefine(pointsToUnrefine);
 
         hasChanged = true;
       }
     }
 
     if ((nRefinementIterations_ % 10) == 0) {
       // Compact refinement history occasionally (how often?).
       // Unrefinement causes holes in the refinementHistory.
       const_cast<refinementHistory &>(meshCutter().history()).compact();
     }
     nRefinementIterations_++;
   }
 
   topoChanging(hasChanged);
 
   if (hasChanged) {
     // Reset moving flag (if any). If not using inflation we'll not move,
     // if are using inflation any follow on movePoints will set it.
     moving(false);
   } else {
     if (enableMotion) solveMotion();
   }
 
   if (writeField) vFld.write();
 
   if (writeRefHistory) writeHistory();
 
   if (writeMeshData) writeMesh();
 
   return hasChanged;
 }

◆ updateAMRML()

bool Foam::AMRFoam::updateAMRML	(	const int &	refineInterval,
		const int &	maxRefinement,
		const int &	nBufferLayers,
		const int &	maxCells,
		volScalarField &	vFld
	)

Takes output from ML model and performs refinement/unrefinement.

Parameters

refineInterval	Refinement interval/frequency
maxRefinement	Maximum refinement allowed by user
nBufferLayers	Buffer layers for slower than 2:1 refinement
maxCells	Maximum number of cells allowed in mesh. Once this level is reached, refinement will be stopped.
vFld	Machine learning model output vector

Returns: A boolean indicating mesh change

Definition at line 510 of file AMRFoam.C.

References nemAux::cellsToRefine(), extendMarkedCells(), maxCellField(), meshCutter(), nRefinementIterations_, refine(), selectRefineCandidates(), selectRefineCells(), selectUnrefinePoints(), and unrefine().

Referenced by NEM::DRV::FoamRefineDriver::execute(), and ~AMRFoam().

                                                 {
   bool hasChanged = false;
   if (refineInterval == 0) {
     polyMesh::topoChanging(hasChanged);
     return hasChanged;
   } else if (refineInterval < 0) {
     FatalErrorInFunction << "Illegal refineInterval " << refineInterval << nl
                          << "The refineInterval value should"
                          << " be >= 1." << nl << exit(FatalError);
   }
 
   // if (maxCells < 0)
   //   maxCells = 500000;
 
   // Cannot refine at time = 0;
   if (fvMesh::time().timeIndex() > 0 &&
       fvMesh::time().timeIndex() % refineInterval == 0) {
     if (maxCells <= 0) {
       FatalErrorInFunction << "Illegal maximum number of cells " << maxCells
                            << nl << "The maxCells value should"
                            << " be > 0." << nl << exit(FatalError);
     }
 
     if (maxRefinement <= 0) {
       FatalErrorInFunction << "Illegal maximum refinement level "
                            << maxRefinement << nl << "The maxCells value should"
                            << " be > 0." << nl << exit(FatalError);
     }
 
     // Cells marked for refinement or otherwise protected from unrefinement.
     bitSet refineCell(primitiveMesh::nCells());
 
     // Selecting refinement candidates based on lower and upper refinement
     // levels in scalar field
     selectRefineCandidates(0.5, 1.5, vFld, refineCell);
 
     // Refinement Procedure Loop
     if (polyMesh::globalData().nTotalCells() < maxCells) {
       // Select subset of candidates. Take into account max allowable
       // cells, refinement level, protected cells.
       labelList cellsToRefine(
           selectRefineCells(maxCells, maxRefinement, refineCell));
 
       label nCellsToRefine = returnReduce(cellsToRefine.size(), sumOp<label>());
 
       if (nCellsToRefine > 0) {
         // Refine/update mesh and map fields
         autoPtr<mapPolyMesh> map = refine(cellsToRefine);
 
         // Update refineCell. Note that some of the marked ones have not been
         // refined due to constraints.
         const labelList &cellMap = map().cellMap();
         const labelList &reverseCellMap = map().reverseCellMap();
 
         bitSet newRefineCell(cellMap.size());
 
         forAll (cellMap, celli) {
           label oldCelli = cellMap[celli];
 
           if (oldCelli < 0)
             newRefineCell.set(celli, 1);
           else if (reverseCellMap[oldCelli] != celli)
             newRefineCell.set(celli, 1);
           else
             newRefineCell.set(celli, refineCell.get(oldCelli));
         }
         refineCell.transfer(newRefineCell);
 
         // Extended with a buffer layer to prevent neighbouring points
         // being unrefined
         for (label i = 0; i < nBufferLayers; i++) {
           extendMarkedCells(refineCell);
         }
 
         hasChanged = true;
       }
     }
 
     // Select unrefinable points that are not marked in refineCell
     labelList pointsToUnrefine(
         selectUnrefinePoints(-1, 0.5, refineCell, maxCellField(vFld)));
 
     label nSplitPoints = returnReduce(pointsToUnrefine.size(), sumOp<label>());
     autoPtr<mapPolyMesh> mapUnrefine;
 
     if (nSplitPoints > 0) {
       // Refine/update mesh
       unrefine(pointsToUnrefine);
       hasChanged = true;
     }
 
     if ((nRefinementIterations_ % 10) == 0) {
       // Unrefinement causes holes in the refinementHistory
       const_cast<refinementHistory &>(meshCutter().history()).compact();
     }
     nRefinementIterations_++;
   }
 
   polyMesh::topoChanging(hasChanged);
   if (hasChanged) { polyMesh::moving(false); }
 
   return hasChanged;
 }

◆ writeHistory()

void Foam::AMRFoam::writeHistory ( )

Definition at line 696 of file AMRFoam.C.

References meshCutter_.

Referenced by update(), updateAMR(), and ~AMRFoam().

                            {
   // Just write refiment history in current time
   const_cast<hexRef8 &>(meshCutter_).setInstance(time().timeName());
   meshCutter_.write(true);
 }

◆ writeMesh()

void Foam::AMRFoam::writeMesh ( )

Definition at line 704 of file AMRFoam.C.

References writeObjectAMR().

Referenced by update(), updateAMR(), and ~AMRFoam().

                         {
   writeObjectAMR(true);
 }

◆ writeObjectAMR()

bool Foam::AMRFoam::writeObjectAMR ( const bool valid ) const

Definition at line 1425 of file AMRFoam.C.

References dumpLevel_, and meshCutter_.

Referenced by protectedCell(), and writeMesh().

                                                    {
   // Force refinement data to go to the current time directory.
   const_cast<hexRef8 &>(meshCutter_).setInstance(time().timeName());
   auto strmOpt =
       IOstreamOption(time().writeFormat(), time().writeCompression());
   bool writeOk =
       (dynamicFvMesh::writeObject(strmOpt, true) && meshCutter_.write(valid));
 
   if (dumpLevel_) {
     volScalarField scalarCellLevel(
         IOobject("cellLevel", time().timeName(), *this, IOobject::NO_READ,
                  IOobject::AUTO_WRITE, false),
         *this, dimensionedScalar("level", dimless, 0));
 
     const labelList &cellLevel = meshCutter_.cellLevel();
 
     forAll (cellLevel, celli) { scalarCellLevel[celli] = cellLevel[celli]; }
 
     writeOk = writeOk && scalarCellLevel.write();
   }
 
   return writeOk;
 }

Member Data Documentation

◆ correctFluxes_

HashTable<word> Foam::AMRFoam::correctFluxes_

protected

Definition at line 259 of file AMRFoam.H.

Referenced by mapFields(), readDict(), unrefine(), and update().

◆ dumpLevel_

bool Foam::AMRFoam::dumpLevel_

protected

Definition at line 256 of file AMRFoam.H.

Referenced by readDict(), update(), and writeObjectAMR().

◆ enableMotion

bool Foam::AMRFoam::enableMotion {false}

Definition at line 231 of file AMRFoam.H.

Referenced by calcProtectedCells(), checkForMotion(), disableMotion(), refine(), unrefine(), update(), and updateAMR().

◆ incomingField

std::vector<double> Foam::AMRFoam::incomingField

private

Definition at line 249 of file AMRFoam.H.

Referenced by readIncomingCellField(), and readIncomingPtField().

◆ lowerRefLvl

std::vector<double> Foam::AMRFoam::lowerRefLvl

Definition at line 211 of file AMRFoam.H.

◆ meshCutter_

hexRef8 Foam::AMRFoam::meshCutter_

protected

Definition at line 253 of file AMRFoam.H.

Referenced by calcProtectedCells(), calculateProtectedCells(), checkEightAnchorPoints(), getMesh(), meshCutter(), refine(), selectRefineCells(), selectUnrefinePoints(), unrefine(), writeHistory(), and writeObjectAMR().

◆ motionPtr_

autoPtr<motionSolver> Foam::AMRFoam::motionPtr_

Definition at line 365 of file AMRFoam.H.

Referenced by checkForMotion(), refine(), solveMotion(), and unrefine().

◆ nRefinementIterations_

label Foam::AMRFoam::nRefinementIterations_

protected

Definition at line 262 of file AMRFoam.H.

Referenced by update(), updateAMR(), and updateAMRML().

◆ protectedCell_

bitSet Foam::AMRFoam::protectedCell_

protected

Definition at line 265 of file AMRFoam.H.

Referenced by calcProtectedCells(), calculateProtectedCells(), protectedCell(), refine(), selectUnrefinePoints(), and unrefine().

◆ stepSz

int Foam::AMRFoam::stepSz = 1

Definition at line 227 of file AMRFoam.H.

◆ unrefAboveLvl

std::vector<double> Foam::AMRFoam::unrefAboveLvl

Definition at line 219 of file AMRFoam.H.

◆ unrefBelowLvl

std::vector<double> Foam::AMRFoam::unrefBelowLvl

Definition at line 223 of file AMRFoam.H.

◆ upperRefLvl

std::vector<double> Foam::AMRFoam::upperRefLvl

Definition at line 215 of file AMRFoam.H.

◆ writeField

bool Foam::AMRFoam::writeField {false}

private

Definition at line 237 of file AMRFoam.H.

Referenced by enableUpdatedField(), and updateAMR().

◆ writeMeshData

bool Foam::AMRFoam::writeMeshData {false}

private

Definition at line 245 of file AMRFoam.H.

Referenced by enableMeshWriting(), and updateAMR().

◆ writeRefHistory

bool Foam::AMRFoam::writeRefHistory {false}

private

Definition at line 241 of file AMRFoam.H.

Referenced by enableRefHistoryData(), and updateAMR().

The documentation for this class was generated from the following files:

Detailed Description

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Attributes

Constructor & Destructor Documentation

◆ AMRFoam()

◆ ~AMRFoam()

Member Function Documentation

◆ assignToVolScalarField()

◆ calcProtectedCells()

◆ calculateProtectedCells()

◆ cell2Pt()

◆ cellToPoint()

◆ checkEightAnchorPoints()

◆ checkForMotion()

◆ disableMotion()

◆ enableMeshWriting()

◆ enableRefHistoryData()

◆ enableUpdatedField()

◆ error()

◆ extendMarkedCells()

◆ getGradient()

◆ getMesh()

◆ getRefineLevel()

◆ initGradientField()

◆ initPntSField()

◆ initScalarField()

◆ mapFields()

◆ mapNewInternalFaces() [1/3]

◆ mapNewInternalFaces() [2/3]

◆ mapNewInternalFaces() [3/3]

◆ maxCellField()

◆ maxPointField()

◆ meshCutter()

◆ pF2vF()

◆ protectedCell() [1/2]

◆ protectedCell() [2/2]

◆ readDict()

◆ readIncomingCellField()

◆ readIncomingPtField()

◆ readInitialField()

◆ refine()

◆ selectRefineCandidates()

◆ selectRefineCells()

◆ selectUnrefinePoints()

◆ solveMotion()

◆ transformField()

◆ unrefine()

◆ update()

◆ updateAMR()

◆ updateAMRML()

◆ writeHistory()

◆ writeMesh()

◆ writeObjectAMR()

Member Data Documentation

◆ correctFluxes_

◆ dumpLevel_

◆ enableMotion

◆ incomingField

◆ lowerRefLvl

◆ meshCutter_

◆ motionPtr_

◆ nRefinementIterations_

◆ protectedCell_

◆ stepSz

◆ unrefAboveLvl

◆ unrefBelowLvl

◆ upperRefLvl

◆ writeField

◆ writeMeshData

◆ writeRefHistory