/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | www.openfoam.com
\\/ M anipulation |
-------------------------------------------------------------------------------
Copyright (C) 2011-2016 OpenFOAM Foundation
Copyright (C) 2018-2023 OpenCFD Ltd.
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see .
Class
Foam::cyclicAMIPolyPatch
Description
Cyclic patch for Arbitrary Mesh Interface (AMI)
Includes provision for updating the patch topology to enforce a 1-to-1
face match across the interface, based on the \c createAMIFaces flag.
The manipulations are based on the reference:
\verbatim
H.J. Aguerre, S. Márquez Damián, J.M. Gimenez, N.M.Nigro, Conservative
handling of arbitrary non-conformal interfaces using an efficient
supermesh, Journal of Computational Physics 335(15) 21-49. 2017.
https://doi.org/10.1016/j.jcp.2017.01.018.
\endverbatim
SourceFiles
cyclicAMIPolyPatch.C
\*---------------------------------------------------------------------------*/
#ifndef Foam_cyclicAMIPolyPatch_H
#define Foam_cyclicAMIPolyPatch_H
#include "AMIInterpolation.H"
#include "coupledPolyPatch.H"
#include "AMIPatchToPatchInterpolation.H"
#include "polyBoundaryMesh.H"
#include "coupleGroupIdentifier.H"
#include "faceAreaWeightAMI.H"
#include "cylindricalCS.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class cyclicAMIPolyPatch Declaration
\*---------------------------------------------------------------------------*/
class cyclicAMIPolyPatch
:
public coupledPolyPatch
{
// Private Member Functions
//- Return normal of face at max distance from rotation axis
vector findFaceNormalMaxRadius(const pointField& faceCentres) const;
void calcTransforms
(
const primitivePatch& half0,
const pointField& half0Ctrs,
const vectorField& half0Areas,
const pointField& half1Ctrs,
const vectorField& half1Areas
);
protected:
// Protected Data
//- Name of other half
mutable word nbrPatchName_;
//- Optional patchGroup to find neighbPatch
const coupleGroupIdentifier coupleGroup_;
//- Index of other half
mutable label nbrPatchID_;
//- Particle displacement fraction accross AMI
const scalar fraction_;
// Transformations
// For rotation
//- Axis of rotation for rotational cyclics
vector rotationAxis_;
//- Point on axis of rotation for rotational cyclics
point rotationCentre_;
//- Flag to show whether the rotation angle is defined
bool rotationAngleDefined_;
//- Rotation angle
scalar rotationAngle_;
// For translation
//- Translation vector
vector separationVector_;
// Triggering periodic interpolation
//- Periodic patch name
word periodicPatchName_;
//- Periodic patch
mutable label periodicPatchID_;
//- AMI interpolation class
mutable autoPtr AMIPtr_;
//- Dictionary used during projection surface construction
const dictionary surfDict_;
//- Projection surface
mutable autoPtr surfPtr_;
// Change of topology as AMI is updated
//- Flag to indicate that new AMI faces will created
// Set by the call to changeTopology
mutable bool createAMIFaces_;
//- Move face centres (default = no)
bool moveFaceCentres_;
mutable bool updatingAMI_;
labelListList srcFaceIDs_;
labelListList tgtFaceIDs_;
//- Temporary storage for AMI face areas
mutable vectorField faceAreas0_;
//- Temporary storage for AMI face centres
mutable vectorField faceCentres0_;
// Protected Member Functions
// Topology change
//- Collect faces to remove in the topoChange container
virtual bool removeAMIFaces(polyTopoChange& topoChange);
//- Collect faces to add in the topoChange container
virtual bool addAMIFaces(polyTopoChange& topoChange);
//- Set properties of newly inserted faces after topological changes
virtual void setAMIFaces();
//- Helper to re-apply the geometric scaling lost during mesh
//- updates
virtual void restoreScaledGeometry();
//- Create and return pointer to the projection surface
const autoPtr& surfPtr() const;
//- Create a coordinate system from the periodic patch (or nullptr)
autoPtr cylindricalCS() const;
//- Reset the AMI interpolator, supply patch points
virtual void resetAMI(const UList& points) const;
//- Reset the AMI interpolator, use current patch points
virtual void resetAMI() const;
//- Recalculate the transformation tensors
virtual void calcTransforms();
//- Initialise the calculation of the patch geometry
virtual void initGeometry(PstreamBuffers&);
//- Calculate the patch geometry
virtual void calcGeometry(PstreamBuffers&);
//- Initialise the patches for moving points
virtual void initMovePoints(PstreamBuffers& pBufs, const pointField&);
//- Correct patches after moving points
virtual void movePoints(PstreamBuffers& pBufs, const pointField&);
//- Initialise the update of the patch topology
virtual void initUpdateMesh(PstreamBuffers&);
//- Update of the patch topology
virtual void updateMesh(PstreamBuffers&);
//- Clear geometry
virtual void clearGeom();
public:
//- Runtime type information
TypeName("cyclicAMI");
// Constructors
//- Construct from (base coupled patch) components
cyclicAMIPolyPatch
(
const word& name,
const label size,
const label start,
const label index,
const polyBoundaryMesh& bm,
const word& patchType,
const transformType transform = UNKNOWN,
const word& defaultAMIMethod = faceAreaWeightAMI::typeName
);
//- Construct from dictionary
cyclicAMIPolyPatch
(
const word& name,
const dictionary& dict,
const label index,
const polyBoundaryMesh& bm,
const word& patchType,
const word& defaultAMIMethod = faceAreaWeightAMI::typeName
);
//- Construct as copy, resetting the boundary mesh
cyclicAMIPolyPatch(const cyclicAMIPolyPatch&, const polyBoundaryMesh&);
//- Construct given the original patch and resetting the
// face list and boundary mesh information
cyclicAMIPolyPatch
(
const cyclicAMIPolyPatch& pp,
const polyBoundaryMesh& bm,
const label index,
const label newSize,
const label newStart,
const word& nbrPatchName
);
//- Construct given the original patch and a map
cyclicAMIPolyPatch
(
const cyclicAMIPolyPatch& pp,
const polyBoundaryMesh& bm,
const label index,
const labelUList& mapAddressing,
const label newStart
);
//- Construct and return a clone, resetting the boundary mesh
virtual autoPtr clone(const polyBoundaryMesh& bm) const
{
return autoPtr::NewFrom(*this, bm);
}
//- Construct and return a clone, resetting the face list
//- and boundary mesh
virtual autoPtr clone
(
const polyBoundaryMesh& bm,
const label index,
const label newSize,
const label newStart
) const
{
return autoPtr
(
new cyclicAMIPolyPatch
(
*this,
bm,
index,
newSize,
newStart,
nbrPatchName_
)
);
}
//- Construct and return a clone, resetting the face list
// and boundary mesh
virtual autoPtr clone
(
const polyBoundaryMesh& bm,
const label index,
const labelUList& mapAddressing,
const label newStart
) const
{
return autoPtr
(
new cyclicAMIPolyPatch
(
*this,
bm,
index,
mapAddressing,
newStart
)
);
}
//- Destructor
virtual ~cyclicAMIPolyPatch() = default;
// Member Functions
// Implicit treatment functions
//- Return number of new internal of this polyPatch faces
virtual void newInternalProcFaces(label&, label&) const;
//- Return nbrCells
virtual const labelUList& nbrCells() const
{
return neighbPatch().faceCells();
}
//- Return nbr patch ID
virtual label neighbPolyPatchID() const
{
return neighbPatch().index();
}
//- Return collocated faces map
virtual refPtr mapCollocatedFaces() const
{
const labelListList& sourceFaces = AMI().srcAddress();
return refPtr(new labelListList(sourceFaces));
}
//- Return implicit master
virtual bool masterImplicit() const
{
return owner();
}
// Access
//- Tolerance used e.g. for area calculations/limits
static const scalar tolerance_;
//- Flag to indicate whether the AMI can be reset
inline bool canResetAMI() const;
//- Return access to the createAMIFaces flag
inline bool createAMIFaces() const;
//- Return access to the updated flag
inline bool updatingAMI() const;
//- Return true if this patch changes the mesh topology
// True when createAMIFaces is true
virtual bool changeTopology() const;
//- Set topology changes in the polyTopoChange object
virtual bool setTopology(polyTopoChange& topoChange);
//- Is patch 'coupled'. Note that on AMI the geometry is not
//- coupled but the fields are!
virtual bool coupled() const
{
return false;
}
//- Neighbour patch name
inline const word& neighbPatchName() const;
//- Neighbour patch ID
virtual label neighbPatchID() const;
//- Particle fraction increase between AMI pathces
inline scalar fraction() const;
//- Does this side own the patch?
virtual bool owner() const;
//- Return a reference to the neighbour patch
virtual const cyclicAMIPolyPatch& neighbPatch() const;
//- Periodic patch ID (or -1)
label periodicPatchID() const;
//- Return a reference to the AMI interpolator
const AMIPatchToPatchInterpolation& AMI() const;
//- Helper function to return the weights
inline const scalarListList& weights() const;
//- Helper function to return the weights sum
inline const scalarField& weightsSum() const;
//- Return true if applying the low weight correction
bool applyLowWeightCorrection() const;
//- Return access to the initial face areas
// Used for topology change
inline vectorField& faceAreas0() const;
//- Return access to the initial face centres
// Used for topology change
inline vectorField& faceCentres0() const;
// Transformations
//- Axis of rotation for rotational cyclic AMI
inline const vector& rotationAxis() const;
//- Point on axis of rotation for rotational cyclic AMI
inline const point& rotationCentre() const;
//- Translation vector for translational cyclic AMI
inline const vector& separationVector() const;
//- Transform patch-based positions from nbr side to this side
virtual void transformPosition(pointField&) const;
//- Transform a patch-based position from nbr side to this side
virtual void transformPosition
(
point& l,
const label facei
) const;
//- Transform a patch-based position from this side to nbr side
virtual void reverseTransformPosition
(
point& l,
const label facei
) const;
//- Transform a patch-based direction from this side to
//- nbr side
virtual void reverseTransformDirection
(
vector& d,
const label facei
) const;
// Interpolations
//- Interpolate field
template
tmp> interpolate
(
const Field& fld,
const UList& defaultValues = UList()
) const;
//- Interpolate tmp field
template
tmp> interpolate
(
const tmp>& tFld,
const UList& defaultValues = UList()
) const;
//- Interpolate without periodic
template
tmp> interpolateUntransformed
(
const Field& fld,
const UList& defaultValues
) const;
//- Low-level interpolate List
template
void interpolate
(
const UList& fld,
const CombineOp& cop,
List& result,
const UList& defaultValues = UList()
) const;
// Interpolations (non-blocking). Subject to change
template
void initInterpolateUntransformed
(
const Field& fld,
labelRange& sendRequests,
PtrList>& sendBuffers,
labelRange& recvRequests,
PtrList>& recvBuffers
) const;
template
void initInterpolate
(
const Field& fld,
labelRange& sendRequests,
PtrList>& sendBuffers,
labelRange& recvRequests,
PtrList>& recvBuffers
) const;
template
tmp> interpolate
(
const Field& localFld,
const labelRange& requests, // The receive requests
const PtrList>& recvBuffers,
const UList& defaultValues
) const;
//- Calculate the patch geometry
virtual void calcGeometry
(
const primitivePatch& referPatch,
const pointField& thisCtrs,
const vectorField& thisAreas,
const pointField& thisCc,
const pointField& nbrCtrs,
const vectorField& nbrAreas,
const pointField& nbrCc
);
//- Initialize ordering for primitivePatch. Does not
//- refer to *this (except for name() and type() etc.)
virtual void initOrder
(
PstreamBuffers&,
const primitivePatch&
) const;
//- Return new ordering for primitivePatch.
// Ordering is -faceMap: for every face
// index of the new face -rotation:for every new face the clockwise
// shift of the original face. Return false if nothing changes
// (faceMap is identity, rotation is 0), true otherwise.
virtual bool order
(
PstreamBuffers&,
const primitivePatch&,
labelList& faceMap,
labelList& rotation
) const;
//- Return face index on neighbour patch which shares point p
//- following trajectory vector n
label pointFace
(
const label facei,
const vector& n,
point& p
) const;
//- Write the polyPatch data as a dictionary
virtual void write(Ostream&) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "cyclicAMIPolyPatchI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "cyclicAMIPolyPatchTemplates.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //