zhyang-dev/OpenFOAM-12
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' of github.com:OpenFOAM/OpenFOAM-dev

Browse Source
This commit is contained in:
Chris Greenshields
2018-07-18 16:48:32 +01:00
parent c562a46a33 aea61ccdbf
commit d7d345922a
64 changed files with 800 additions and 1076 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/finiteVolume/fvMesh/fvPatches/constraint/cyclicACMI/cyclicACMIFvPatch.H
View File

@ -87,9 +87,9 @@ public:
// Access
//- Return a reference to the AMI interpolators
virtual const PtrList<AMIPatchToPatchInterpolation>& AMIs() const
virtual const PtrList<AMIInterpolation>& AMIs() const
{
const PtrList<AMIPatchToPatchInterpolation>& AMIs =
const PtrList<AMIInterpolation>& AMIs =
cyclicAMIFvPatch::AMIs();
updateAreas();

2
src/finiteVolume/fvMesh/fvPatches/constraint/cyclicAMI/cyclicAMIFvPatch.H
View File

@ -122,7 +122,7 @@ public:
}
//- Return a reference to the AMI interpolators
virtual const PtrList<AMIPatchToPatchInterpolation>& AMIs() const
virtual const PtrList<AMIInterpolation>& AMIs() const
{
return cyclicAMIPolyPatch_.AMIs();
}

2
src/finiteVolume/fvMesh/fvPatches/derived/regionCoupled/regionCoupledBaseFvPatch.H
View File

@ -139,7 +139,7 @@ public:
}
//- Return a reference to the AMI interpolator
virtual const AMIPatchToPatchInterpolation& AMI() const
virtual const AMIInterpolation& AMI() const
{
return regionCoupledBase_.AMI();
}

478
src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.C
View File

@ -31,9 +31,15 @@ License
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
Foam::word
Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolationMethodToWord
namespace Foam
{
defineTypeNameAndDebug(AMIInterpolation, 0);
}
// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
Foam::word Foam::AMIInterpolation::interpolationMethodToWord
(
const interpolationMethod& im
)
@ -79,12 +85,8 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolationMethodToWord
}
template<class SourcePatch, class TargetPatch>
typename Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolationMethod
Foam::AMIInterpolation<SourcePatch, TargetPatch>::wordTointerpolationMethod
(
const word& im
)
typename Foam::AMIInterpolation::interpolationMethod
Foam::AMIInterpolation::wordTointerpolationMethod(const word& im)
{
interpolationMethod method = imDirect;
@ -134,12 +136,9 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::wordTointerpolationMethod
}
template<class SourcePatch, class TargetPatch>
template<class Patch>
Foam::tmp<Foam::scalarField>
Foam::AMIInterpolation<SourcePatch, TargetPatch>::patchMagSf
Foam::tmp<Foam::scalarField> Foam::AMIInterpolation::patchMagSf
(
const Patch& patch,
const primitivePatch& patch,
const faceAreaIntersect::triangulationMode triMode
)
{
@ -178,8 +177,7 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::patchMagSf
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
void Foam::AMIInterpolation<SourcePatch, TargetPatch>::projectPointsToSurface
void Foam::AMIInterpolation::projectPointsToSurface
(
const searchableSurface& surf,
pointField& pts
@ -220,8 +218,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::projectPointsToSurface
}
template<class SourcePatch, class TargetPatch>
void Foam::AMIInterpolation<SourcePatch, TargetPatch>::sumWeights
void Foam::AMIInterpolation::sumWeights
(
const scalarListList& wght,
scalarField& wghtSum
@ -237,8 +234,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::sumWeights
}
template<class SourcePatch, class TargetPatch>
void Foam::AMIInterpolation<SourcePatch, TargetPatch>::sumWeights
void Foam::AMIInterpolation::sumWeights
(
const UPtrList<scalarListList>& wghts,
scalarField& wghtSum
@ -260,8 +256,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::sumWeights
}
template<class SourcePatch, class TargetPatch>
void Foam::AMIInterpolation<SourcePatch, TargetPatch>::reportSumWeights
void Foam::AMIInterpolation::reportSumWeights
(
const scalarField& patchAreas,
const word& patchName,
@ -298,8 +293,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::reportSumWeights
}
template<class SourcePatch, class TargetPatch>
void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
void Foam::AMIInterpolation::normaliseWeights
(
scalarListList& wght,
const scalarField& wghtSum
@ -317,8 +311,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
}
template<class SourcePatch, class TargetPatch>
void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
void Foam::AMIInterpolation::normaliseWeights
(
UPtrList<scalarListList>& wghts,
const scalarField& wghtSum
@ -339,8 +332,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
}
template<class SourcePatch, class TargetPatch>
void Foam::AMIInterpolation<SourcePatch, TargetPatch>::agglomerate
void Foam::AMIInterpolation::agglomerate
(
const autoPtr<mapDistribute>& targetMapPtr,
const scalarField& fineSrcMagSf,
@ -594,11 +586,10 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::agglomerate
}
template<class SourcePatch, class TargetPatch>
void Foam::AMIInterpolation<SourcePatch, TargetPatch>::constructFromSurface
void Foam::AMIInterpolation::constructFromSurface
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const autoPtr<searchableSurface>& surfPtr,
const bool report
)
@ -607,7 +598,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::constructFromSurface
{
// Create new patches for source and target
pointField srcPoints = srcPatch.points();
SourcePatch srcPatch0
primitivePatch srcPatch0
(
SubList<face>
(
@ -628,7 +619,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::constructFromSurface
}
pointField tgtPoints = tgtPatch.points();
TargetPatch tgtPatch0
primitivePatch tgtPatch0
(
SubList<face>
(
@ -666,11 +657,10 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::constructFromSurface
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
Foam::AMIInterpolation::AMIInterpolation
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const faceAreaIntersect::triangulationMode& triMode,
const bool requireMatch,
const interpolationMethod& method,
@ -698,11 +688,10 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
}
template<class SourcePatch, class TargetPatch>
Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
Foam::AMIInterpolation::AMIInterpolation
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const faceAreaIntersect::triangulationMode& triMode,
const bool requireMatch,
const word& methodName,
@ -730,11 +719,10 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
}
template<class SourcePatch, class TargetPatch>
Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
Foam::AMIInterpolation::AMIInterpolation
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const autoPtr<searchableSurface>& surfPtr,
const faceAreaIntersect::triangulationMode& triMode,
const bool requireMatch,
@ -763,11 +751,10 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
}
template<class SourcePatch, class TargetPatch>
Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
Foam::AMIInterpolation::AMIInterpolation
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const autoPtr<searchableSurface>& surfPtr,
const faceAreaIntersect::triangulationMode& triMode,
const bool requireMatch,
@ -796,10 +783,9 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
}
template<class SourcePatch, class TargetPatch>
Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
Foam::AMIInterpolation::AMIInterpolation
(
const AMIInterpolation<SourcePatch, TargetPatch>& fineAMI,
const AMIInterpolation& fineAMI,
const labelList& sourceRestrictAddressing,
const labelList& targetRestrictAddressing,
const bool report
@ -911,18 +897,16 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
Foam::AMIInterpolation<SourcePatch, TargetPatch>::~AMIInterpolation()
Foam::AMIInterpolation::~AMIInterpolation()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
void Foam::AMIInterpolation::update
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const bool report
)
{
@ -987,7 +971,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
tgtFaceIDs
);
TargetPatch
primitivePatch
newTgtPatch
(
SubList<face>
@ -1000,9 +984,9 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
scalarField newTgtMagSf(patchMagSf(newTgtPatch, triMode_));
// Calculate AMI interpolation
autoPtr<AMIMethod<SourcePatch, TargetPatch>> AMIPtr
autoPtr<AMIMethod> AMIPtr
(
AMIMethod<SourcePatch, TargetPatch>::New
AMIMethod::New
(
methodName_,
srcPatch,
@ -1099,9 +1083,9 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
else
{
// Calculate AMI interpolation
autoPtr<AMIMethod<SourcePatch, TargetPatch>> AMIPtr
autoPtr<AMIMethod> AMIPtr
(
AMIMethod<SourcePatch, TargetPatch>::New
AMIMethod::New
(
methodName_,
srcPatch,
@ -1136,7 +1120,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
if (debug)
{
Info<< "AMIInterpolation : Constructed addressing and weights" << nl
Info<< "AMIIPatchToPatchnterpolation :"
<< "Constructed addressing and weights" << nl
<< " triMode :"
<< faceAreaIntersect::triangulationModeNames_[triMode_] << nl
<< " singlePatchProc:" << singlePatchProc_ << nl
@ -1147,22 +1132,14 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
}
template<class SourcePatch, class TargetPatch>
void Foam::AMIInterpolation<SourcePatch, TargetPatch>::sumWeights
(
AMIInterpolation<SourcePatch, TargetPatch>& AMI
)
void Foam::AMIInterpolation::sumWeights(AMIInterpolation& AMI)
{
sumWeights(AMI.srcWeights_, AMI.srcWeightsSum_);
sumWeights(AMI.tgtWeights_, AMI.tgtWeightsSum_);
}
template<class SourcePatch, class TargetPatch>
void Foam::AMIInterpolation<SourcePatch, TargetPatch>::sumWeights
(
PtrList<AMIInterpolation<SourcePatch, TargetPatch>>& AMIs
)
void Foam::AMIInterpolation::sumWeights(PtrList<AMIInterpolation>& AMIs)
{
UPtrList<scalarListList> srcWeights(AMIs.size());
forAll(AMIs, i)
@ -1192,11 +1169,7 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::sumWeights
}
template<class SourcePatch, class TargetPatch>
void Foam::AMIInterpolation<SourcePatch, TargetPatch>::reportSumWeights
(
AMIInterpolation<SourcePatch, TargetPatch>& AMI
)
void Foam::AMIInterpolation::reportSumWeights(AMIInterpolation& AMI)
{
reportSumWeights
(
@ -1216,22 +1189,14 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::reportSumWeights
}
template<class SourcePatch, class TargetPatch>
void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
(
AMIInterpolation<SourcePatch, TargetPatch>& AMI
)
void Foam::AMIInterpolation::normaliseWeights(AMIInterpolation& AMI)
{
normaliseWeights(AMI.srcWeights_, AMI.srcWeightsSum_);
normaliseWeights(AMI.tgtWeights_, AMI.tgtWeightsSum_);
}
template<class SourcePatch, class TargetPatch>
void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
(
UPtrList<AMIInterpolation<SourcePatch, TargetPatch>>& AMIs
)
void Foam::AMIInterpolation::normaliseWeights(UPtrList<AMIInterpolation>& AMIs)
{
UPtrList<scalarListList> srcWeights(AMIs.size());
forAll(AMIs, i)
@ -1251,323 +1216,10 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
}
template<class SourcePatch, class TargetPatch>
template<class Type, class CombineOp>
void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
Foam::label Foam::AMIInterpolation::srcPointFace
(
const UList<Type>& fld,
const CombineOp& cop,
List<Type>& result,
const UList<Type>& defaultValues
) const
{
if (fld.size() != srcAddress_.size())
{
FatalErrorInFunction
<< "Supplied field size is not equal to source patch size" << nl
<< " source patch = " << srcAddress_.size() << nl
<< " target patch = " << tgtAddress_.size() << nl
<< " supplied field = " << fld.size()
<< abort(FatalError);
}
if (lowWeightCorrection_ > 0)
{
if (defaultValues.size() != tgtAddress_.size())
{
FatalErrorInFunction
<< "Employing default values when sum of weights falls below "
<< lowWeightCorrection_
<< " but supplied default field size is not equal to target "
<< "patch size" << nl
<< " default values = " << defaultValues.size() << nl
<< " target patch = " << tgtAddress_.size() << nl
<< abort(FatalError);
}
}
result.setSize(tgtAddress_.size());
if (singlePatchProc_ == -1)
{
const mapDistribute& map = srcMapPtr_();
List<Type> work(fld);
map.distribute(work);
forAll(result, facei)
{
if (tgtWeightsSum_[facei] < lowWeightCorrection_)
{
result[facei] = defaultValues[facei];
}
else
{
const labelList& faces = tgtAddress_[facei];
const scalarList& weights = tgtWeights_[facei];
forAll(faces, i)
{
cop(result[facei], facei, work[faces[i]], weights[i]);
}
}
}
}
else
{
forAll(result, facei)
{
if (tgtWeightsSum_[facei] < lowWeightCorrection_)
{
result[facei] = defaultValues[facei];
}
else
{
const labelList& faces = tgtAddress_[facei];
const scalarList& weights = tgtWeights_[facei];
forAll(faces, i)
{
cop(result[facei], facei, fld[faces[i]], weights[i]);
}
}
}
}
}
template<class SourcePatch, class TargetPatch>
template<class Type, class CombineOp>
void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
(
const UList<Type>& fld,
const CombineOp& cop,
List<Type>& result,
const UList<Type>& defaultValues
) const
{
if (fld.size() != tgtAddress_.size())
{
FatalErrorInFunction
<< "Supplied field size is not equal to target patch size" << nl
<< " source patch = " << srcAddress_.size() << nl
<< " target patch = " << tgtAddress_.size() << nl
<< " supplied field = " << fld.size()
<< abort(FatalError);
}
if (lowWeightCorrection_ > 0)
{
if (defaultValues.size() != srcAddress_.size())
{
FatalErrorInFunction
<< "Employing default values when sum of weights falls below "
<< lowWeightCorrection_
<< " but supplied default field size is not equal to target "
<< "patch size" << nl
<< " default values = " << defaultValues.size() << nl
<< " source patch = " << srcAddress_.size() << nl
<< abort(FatalError);
}
}
result.setSize(srcAddress_.size());
if (singlePatchProc_ == -1)
{
const mapDistribute& map = tgtMapPtr_();
List<Type> work(fld);
map.distribute(work);
forAll(result, facei)
{
if (srcWeightsSum_[facei] < lowWeightCorrection_)
{
result[facei] = defaultValues[facei];
}
else
{
const labelList& faces = srcAddress_[facei];
const scalarList& weights = srcWeights_[facei];
forAll(faces, i)
{
cop(result[facei], facei, work[faces[i]], weights[i]);
}
}
}
}
else
{
forAll(result, facei)
{
if (srcWeightsSum_[facei] < lowWeightCorrection_)
{
result[facei] = defaultValues[facei];
}
else
{
const labelList& faces = srcAddress_[facei];
const scalarList& weights = srcWeights_[facei];
forAll(faces, i)
{
cop(result[facei], facei, fld[faces[i]], weights[i]);
}
}
}
}
}
template<class SourcePatch, class TargetPatch>
template<class Type, class CombineOp>
Foam::tmp<Foam::Field<Type>>
Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
(
const Field<Type>& fld,
const CombineOp& cop,
const UList<Type>& defaultValues
) const
{
tmp<Field<Type>> tresult
(
new Field<Type>
(
srcAddress_.size(),
Zero
)
);
interpolateToSource
(
fld,
multiplyWeightedOp<Type, CombineOp>(cop),
tresult.ref(),
defaultValues
);
return tresult;
}
template<class SourcePatch, class TargetPatch>
template<class Type, class CombineOp>
Foam::tmp<Foam::Field<Type>>
Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
(
const tmp<Field<Type>>& tFld,
const CombineOp& cop,
const UList<Type>& defaultValues
) const
{
return interpolateToSource(tFld(), cop, defaultValues);
}
template<class SourcePatch, class TargetPatch>
template<class Type, class CombineOp>
Foam::tmp<Foam::Field<Type>>
Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
(
const Field<Type>& fld,
const CombineOp& cop,
const UList<Type>& defaultValues
) const
{
tmp<Field<Type>> tresult
(
new Field<Type>
(
tgtAddress_.size(),
Zero
)
);
interpolateToTarget
(
fld,
multiplyWeightedOp<Type, CombineOp>(cop),
tresult.ref(),
defaultValues
);
return tresult;
}
template<class SourcePatch, class TargetPatch>
template<class Type, class CombineOp>
Foam::tmp<Foam::Field<Type>>
Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
(
const tmp<Field<Type>>& tFld,
const CombineOp& cop,
const UList<Type>& defaultValues
) const
{
return interpolateToTarget(tFld(), cop, defaultValues);
}
template<class SourcePatch, class TargetPatch>
template<class Type>
Foam::tmp<Foam::Field<Type>>
Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
(
const Field<Type>& fld,
const UList<Type>& defaultValues
) const
{
return interpolateToSource(fld, plusEqOp<Type>(), defaultValues);
}
template<class SourcePatch, class TargetPatch>
template<class Type>
Foam::tmp<Foam::Field<Type>>
Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
(
const tmp<Field<Type>>& tFld,
const UList<Type>& defaultValues
) const
{
return interpolateToSource(tFld(), plusEqOp<Type>(), defaultValues);
}
template<class SourcePatch, class TargetPatch>
template<class Type>
Foam::tmp<Foam::Field<Type>>
Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
(
const Field<Type>& fld,
const UList<Type>& defaultValues
) const
{
return interpolateToTarget(fld, plusEqOp<Type>(), defaultValues);
}
template<class SourcePatch, class TargetPatch>
template<class Type>
Foam::tmp<Foam::Field<Type>>
Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
(
const tmp<Field<Type>>& tFld,
const UList<Type>& defaultValues
) const
{
return interpolateToTarget(tFld(), plusEqOp<Type>(), defaultValues);
}
template<class SourcePatch, class TargetPatch>
Foam::label Foam::AMIInterpolation<SourcePatch, TargetPatch>::srcPointFace
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const vector& n,
const label tgtFacei,
point& tgtPoint
@ -1612,11 +1264,10 @@ const
}
template<class SourcePatch, class TargetPatch>
Foam::label Foam::AMIInterpolation<SourcePatch, TargetPatch>::tgtPointFace
Foam::label Foam::AMIInterpolation::tgtPointFace
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const vector& n,
const label srcFacei,
point& srcPoint
@ -1661,11 +1312,10 @@ const
}
template<class SourcePatch, class TargetPatch>
void Foam::AMIInterpolation<SourcePatch, TargetPatch>::writeFaceConnectivity
void Foam::AMIInterpolation::writeFaceConnectivity
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const labelListList& srcAddress
)
const

115
src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.H
View File

@ -41,8 +41,8 @@ Description
SourceFiles
AMIInterpolation.C
AMIInterpolationName.C
AMIInterpolationParallelOps.C
AMIInterpolationTemplates.C
\*---------------------------------------------------------------------------*/
@ -64,32 +64,13 @@ namespace Foam
{
/*---------------------------------------------------------------------------*\
Class AMIInterpolationName Declaration
Class AMIInterpolation Declaration
\*---------------------------------------------------------------------------*/
TemplateName(AMIInterpolation);
/*---------------------------------------------------------------------------*\
Class AMIInterpolation Declaration
\*---------------------------------------------------------------------------*/
template<class SourcePatch, class TargetPatch>
class AMIInterpolation
:
public AMIInterpolationName
{
public:
// Public typedefs
// Typedef to SourcePatch type this AMIInterplation is instantiated on
typedef SourcePatch sourcePatchType;
// Typedef to TargetPatch type this AMIInterplation is instantiated on
typedef TargetPatch targetPatchType;
// Public data types
//- Enumeration specifying interpolation method
@ -115,10 +96,9 @@ public:
);
//- Calculate the patch face magnitudes for the given tri-mode
template<class Patch>
static tmp<scalarField> patchMagSf
(
const Patch& patch,
const primitivePatch& patch,
const faceAreaIntersect::triangulationMode triMode
);
@ -200,8 +180,8 @@ private:
//- Calculate if patches are on multiple processors
label calcDistribution
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch
) const;
label calcOverlappingProcs
@ -214,7 +194,7 @@ private:
void distributePatches
(
const mapDistribute& map,
const TargetPatch& pp,
const primitivePatch& pp,
const globalIndex& gi,
List<faceList>& faces,
List<pointField>& points,
@ -224,7 +204,7 @@ private:
void distributeAndMergePatches
(
const mapDistribute& map,
const TargetPatch& tgtPatch,
const primitivePatch& tgtPatch,
const globalIndex& gi,
faceList& tgtFaces,
pointField& tgtPoints,
@ -233,8 +213,8 @@ private:
autoPtr<mapDistribute> calcProcMap
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch
) const;
@ -312,21 +292,25 @@ private:
void constructFromSurface
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const autoPtr<searchableSurface>& surfPtr,
const bool report
);
public:
//- Runtime type information
TypeName("cyclicAMI");
// Constructors
//- Construct from components
AMIInterpolation
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const faceAreaIntersect::triangulationMode& triMode,
const bool requireMatch = true,
const interpolationMethod& method = imFaceAreaWeight,
@ -338,8 +322,8 @@ public:
//- Construct from components
AMIInterpolation
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const faceAreaIntersect::triangulationMode& triMode,
const bool requireMatch = true,
const word& methodName =
@ -352,8 +336,8 @@ public:
//- Construct from components, with projection surface
AMIInterpolation
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const autoPtr<searchableSurface>& surf,
const faceAreaIntersect::triangulationMode& triMode,
const bool requireMatch = true,
@ -366,8 +350,8 @@ public:
//- Construct from components, with projection surface
AMIInterpolation
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const autoPtr<searchableSurface>& surf,
const faceAreaIntersect::triangulationMode& triMode,
const bool requireMatch = true,
@ -378,11 +362,12 @@ public:
const bool report = true
);
//- Construct from agglomeration of AMIInterpolation. Agglomeration
// passed in as new coarse size and addressing from fine from coarse
//- Construct from agglomeration of AMIInterpolation.
// Agglomeration passed in as new coarse size and addressing from fine
// from coarse
AMIInterpolation
(
const AMIInterpolation<SourcePatch, TargetPatch>& fineAMI,
const AMIInterpolation& fineAMI,
const labelList& sourceRestrictAddressing,
const labelList& neighbourRestrictAddressing,
const bool report = false
@ -390,7 +375,7 @@ public:
//- Destructor
~AMIInterpolation();
virtual ~AMIInterpolation();
// Member Functions
@ -469,42 +454,27 @@ public:
//- Update addressing and weights
void update
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const bool report
);
//- Sum the weights on both sides of an AMI
static void sumWeights
(
AMIInterpolation<SourcePatch, TargetPatch>& AMI
);
static void sumWeights(AMIInterpolation& AMI);
//- As above, but for multiple AMI-s
static void sumWeights
(
PtrList<AMIInterpolation<SourcePatch, TargetPatch>>& AMIs
);
static void sumWeights(PtrList<AMIInterpolation>& AMIs);
//- Print out information relating to the weights sum. Values close
// to one are ideal. This information acts as a measure of the
// quality of the AMI.
static void reportSumWeights
(
AMIInterpolation<SourcePatch, TargetPatch>& AMI
);
static void reportSumWeights(AMIInterpolation& AMI);
//- Normalise the weights on both sides of an AMI
static void normaliseWeights
(
AMIInterpolation<SourcePatch, TargetPatch>& AMI
);
static void normaliseWeights(AMIInterpolation& AMI);
//- As above, but for multiple AMI-s
static void normaliseWeights
(
UPtrList<AMIInterpolation<SourcePatch, TargetPatch>>& AMIs
);
static void normaliseWeights(UPtrList<AMIInterpolation>& AMIs);
// Evaluation
@ -608,8 +578,8 @@ public:
//- Return source patch face index of point on target patch face
label srcPointFace
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const vector& n,
const label tgtFacei,
point& tgtPoint
@ -619,8 +589,8 @@ public:
//- Return target patch face index of point on source patch face
label tgtPointFace
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const vector& n,
const label srcFacei,
point& srcPoint
@ -633,8 +603,8 @@ public:
//- Write face connectivity as OBJ file
void writeFaceConnectivity
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const labelListList& srcAddress
) const;
};
@ -651,8 +621,7 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "AMIInterpolation.C"
#include "AMIInterpolationParallelOps.C"
#include "AMIInterpolationTemplates.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

69
src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolationI.H
View File

@ -23,138 +23,103 @@ License
\*---------------------------------------------------------------------------*/
template<class SourcePatch, class TargetPatch>
inline Foam::label
Foam::AMIInterpolation<SourcePatch, TargetPatch>::singlePatchProc() const
inline Foam::label Foam::AMIInterpolation::singlePatchProc() const
{
return singlePatchProc_;
}
template<class SourcePatch, class TargetPatch>
inline Foam::scalar
Foam::AMIInterpolation<SourcePatch, TargetPatch>::lowWeightCorrection() const
inline Foam::scalar Foam::AMIInterpolation::lowWeightCorrection() const
{
return lowWeightCorrection_;
}
template<class SourcePatch, class TargetPatch>
inline bool
Foam::AMIInterpolation<SourcePatch, TargetPatch>::
applyLowWeightCorrection() const
inline bool Foam::AMIInterpolation::applyLowWeightCorrection() const
{
return lowWeightCorrection_ > 0;
}
template<class SourcePatch, class TargetPatch>
inline const Foam::scalarField&
Foam::AMIInterpolation<SourcePatch, TargetPatch>::srcMagSf() const
inline const Foam::scalarField& Foam::AMIInterpolation::srcMagSf() const
{
return srcMagSf_;
}
template<class SourcePatch, class TargetPatch>
inline const Foam::labelListList&
Foam::AMIInterpolation<SourcePatch, TargetPatch>::srcAddress() const
inline const Foam::labelListList& Foam::AMIInterpolation::srcAddress() const
{
return srcAddress_;
}
template<class SourcePatch, class TargetPatch>
inline const Foam::scalarListList&
Foam::AMIInterpolation<SourcePatch, TargetPatch>::srcWeights() const
inline const Foam::scalarListList& Foam::AMIInterpolation::srcWeights() const
{
return srcWeights_;
}
template<class SourcePatch, class TargetPatch>
inline Foam::scalarListList&
Foam::AMIInterpolation<SourcePatch, TargetPatch>::srcWeights()
inline Foam::scalarListList& Foam::AMIInterpolation::srcWeights()
{
return srcWeights_;
}
template<class SourcePatch, class TargetPatch>
inline const Foam::scalarField&
Foam::AMIInterpolation<SourcePatch, TargetPatch>::srcWeightsSum() const
inline const Foam::scalarField& Foam::AMIInterpolation::srcWeightsSum() const
{
return srcWeightsSum_;
}
template<class SourcePatch, class TargetPatch>
inline Foam::scalarField&
Foam::AMIInterpolation<SourcePatch, TargetPatch>::srcWeightsSum()
inline Foam::scalarField& Foam::AMIInterpolation::srcWeightsSum()
{
return srcWeightsSum_;
}
template<class SourcePatch, class TargetPatch>
inline const Foam::mapDistribute&
Foam::AMIInterpolation<SourcePatch, TargetPatch>::srcMap() const
inline const Foam::mapDistribute& Foam::AMIInterpolation::srcMap() const
{
return srcMapPtr_();
}
template<class SourcePatch, class TargetPatch>
inline const Foam::scalarField&
Foam::AMIInterpolation<SourcePatch, TargetPatch>::tgtMagSf() const
inline const Foam::scalarField& Foam::AMIInterpolation::tgtMagSf() const
{
return tgtMagSf_;
}
template<class SourcePatch, class TargetPatch>
inline const Foam::labelListList&
Foam::AMIInterpolation<SourcePatch, TargetPatch>::tgtAddress() const
inline const Foam::labelListList& Foam::AMIInterpolation::tgtAddress() const
{
return tgtAddress_;
}
template<class SourcePatch, class TargetPatch>
inline const Foam::scalarListList&
Foam::AMIInterpolation<SourcePatch, TargetPatch>::tgtWeights() const
inline const Foam::scalarListList& Foam::AMIInterpolation::tgtWeights() const
{
return tgtWeights_;
}
template<class SourcePatch, class TargetPatch>
inline Foam::scalarListList&
Foam::AMIInterpolation<SourcePatch, TargetPatch>::tgtWeights()
inline Foam::scalarListList& Foam::AMIInterpolation::tgtWeights()
{
return tgtWeights_;
}
template<class SourcePatch, class TargetPatch>
inline const Foam::scalarField&
Foam::AMIInterpolation<SourcePatch, TargetPatch>::tgtWeightsSum() const
inline const Foam::scalarField& Foam::AMIInterpolation::tgtWeightsSum() const
{
return tgtWeightsSum_;
}
template<class SourcePatch, class TargetPatch>
inline Foam::scalarField&
Foam::AMIInterpolation<SourcePatch, TargetPatch>::tgtWeightsSum()
inline Foam::scalarField& Foam::AMIInterpolation::tgtWeightsSum()
{
return tgtWeightsSum_;
}
template<class SourcePatch, class TargetPatch>
inline const Foam::mapDistribute&
Foam::AMIInterpolation<SourcePatch, TargetPatch>::tgtMap() const
inline const Foam::mapDistribute& Foam::AMIInterpolation::tgtMap() const
{
return tgtMapPtr_();
}

36
src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolationName.C
View File

@ -1,36 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
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 <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "AMIInterpolation.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(AMIInterpolationName, 0);
}
// ************************************************************************* //

29
src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolationParallelOps.C
View File

@ -29,11 +29,10 @@ License
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
Foam::label Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcDistribution
Foam::label Foam::AMIInterpolation::calcDistribution
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch
) const
{
label proci = 0;
@ -81,9 +80,7 @@ Foam::label Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcDistribution
}
template<class SourcePatch, class TargetPatch>
Foam::label
Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcOverlappingProcs
Foam::label Foam::AMIInterpolation::calcOverlappingProcs
(
const List<treeBoundBoxList>& procBb,
const treeBoundBox& bb,
@ -113,11 +110,10 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcOverlappingProcs
}
template<class SourcePatch, class TargetPatch>
void Foam::AMIInterpolation<SourcePatch, TargetPatch>::distributePatches
void Foam::AMIInterpolation::distributePatches
(
const mapDistribute& map,
const TargetPatch& pp,
const primitivePatch& pp,
const globalIndex& gi,
List<faceList>& faces,
List<pointField>& points,
@ -209,12 +205,10 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::distributePatches
}
template<class SourcePatch, class TargetPatch>
void Foam::AMIInterpolation<SourcePatch, TargetPatch>::
distributeAndMergePatches
void Foam::AMIInterpolation::distributeAndMergePatches
(
const mapDistribute& map,
const TargetPatch& tgtPatch,
const primitivePatch& tgtPatch,
const globalIndex& gi,
faceList& tgtFaces,
pointField& tgtPoints,
@ -325,12 +319,11 @@ distributeAndMergePatches
}
template<class SourcePatch, class TargetPatch>
Foam::autoPtr<Foam::mapDistribute>
Foam::AMIInterpolation<SourcePatch, TargetPatch>::calcProcMap
Foam::AMIInterpolation::calcProcMap
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch
) const
{
// Get decomposition of patch

336
src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolationTemplates.C Normal file
View File

@ -0,0 +1,336 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
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 <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "AMIInterpolation.H"
#include "AMIMethod.H"
#include "meshTools.H"
#include "mapDistribute.H"
#include "flipOp.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<class Type, class CombineOp>
void Foam::AMIInterpolation::interpolateToTarget
(
const UList<Type>& fld,
const CombineOp& cop,
List<Type>& result,
const UList<Type>& defaultValues
) const
{
if (fld.size() != srcAddress_.size())
{
FatalErrorInFunction
<< "Supplied field size is not equal to source patch size" << nl
<< " source patch = " << srcAddress_.size() << nl
<< " target patch = " << tgtAddress_.size() << nl
<< " supplied field = " << fld.size()
<< abort(FatalError);
}
if (lowWeightCorrection_ > 0)
{
if (defaultValues.size() != tgtAddress_.size())
{
FatalErrorInFunction
<< "Employing default values when sum of weights falls below "
<< lowWeightCorrection_
<< " but supplied default field size is not equal to target "
<< "patch size" << nl
<< " default values = " << defaultValues.size() << nl
<< " target patch = " << tgtAddress_.size() << nl
<< abort(FatalError);
}
}
result.setSize(tgtAddress_.size());
if (singlePatchProc_ == -1)
{
const mapDistribute& map = srcMapPtr_();
List<Type> work(fld);
map.distribute(work);
forAll(result, facei)
{
if (tgtWeightsSum_[facei] < lowWeightCorrection_)
{
result[facei] = defaultValues[facei];
}
else
{
const labelList& faces = tgtAddress_[facei];
const scalarList& weights = tgtWeights_[facei];
forAll(faces, i)
{
cop(result[facei], facei, work[faces[i]], weights[i]);
}
}
}
}
else
{
forAll(result, facei)
{
if (tgtWeightsSum_[facei] < lowWeightCorrection_)
{
result[facei] = defaultValues[facei];
}
else
{
const labelList& faces = tgtAddress_[facei];
const scalarList& weights = tgtWeights_[facei];
forAll(faces, i)
{
cop(result[facei], facei, fld[faces[i]], weights[i]);
}
}
}
}
}
template<class Type, class CombineOp>
void Foam::AMIInterpolation::interpolateToSource
(
const UList<Type>& fld,
const CombineOp& cop,
List<Type>& result,
const UList<Type>& defaultValues
) const
{
if (fld.size() != tgtAddress_.size())
{
FatalErrorInFunction
<< "Supplied field size is not equal to target patch size" << nl
<< " source patch = " << srcAddress_.size() << nl
<< " target patch = " << tgtAddress_.size() << nl
<< " supplied field = " << fld.size()
<< abort(FatalError);
}
if (lowWeightCorrection_ > 0)
{
if (defaultValues.size() != srcAddress_.size())
{
FatalErrorInFunction
<< "Employing default values when sum of weights falls below "
<< lowWeightCorrection_
<< " but supplied default field size is not equal to target "
<< "patch size" << nl
<< " default values = " << defaultValues.size() << nl
<< " source patch = " << srcAddress_.size() << nl
<< abort(FatalError);
}
}
result.setSize(srcAddress_.size());
if (singlePatchProc_ == -1)
{
const mapDistribute& map = tgtMapPtr_();
List<Type> work(fld);
map.distribute(work);
forAll(result, facei)
{
if (srcWeightsSum_[facei] < lowWeightCorrection_)
{
result[facei] = defaultValues[facei];
}
else
{
const labelList& faces = srcAddress_[facei];
const scalarList& weights = srcWeights_[facei];
forAll(faces, i)
{
cop(result[facei], facei, work[faces[i]], weights[i]);
}
}
}
}
else
{
forAll(result, facei)
{
if (srcWeightsSum_[facei] < lowWeightCorrection_)
{
result[facei] = defaultValues[facei];
}
else
{
const labelList& faces = srcAddress_[facei];
const scalarList& weights = srcWeights_[facei];
forAll(faces, i)
{
cop(result[facei], facei, fld[faces[i]], weights[i]);
}
}
}
}
}
template<class Type, class CombineOp>
Foam::tmp<Foam::Field<Type>>
Foam::AMIInterpolation::interpolateToSource
(
const Field<Type>& fld,
const CombineOp& cop,
const UList<Type>& defaultValues
) const
{
tmp<Field<Type>> tresult
(
new Field<Type>
(
srcAddress_.size(),
Zero
)
);
interpolateToSource
(
fld,
multiplyWeightedOp<Type, CombineOp>(cop),
tresult.ref(),
defaultValues
);
return tresult;
}
template<class Type, class CombineOp>
Foam::tmp<Foam::Field<Type>>
Foam::AMIInterpolation::interpolateToSource
(
const tmp<Field<Type>>& tFld,
const CombineOp& cop,
const UList<Type>& defaultValues
) const
{
return interpolateToSource(tFld(), cop, defaultValues);
}
template<class Type, class CombineOp>
Foam::tmp<Foam::Field<Type>>
Foam::AMIInterpolation::interpolateToTarget
(
const Field<Type>& fld,
const CombineOp& cop,
const UList<Type>& defaultValues
) const
{
tmp<Field<Type>> tresult
(
new Field<Type>
(
tgtAddress_.size(),
Zero
)
);
interpolateToTarget
(
fld,
multiplyWeightedOp<Type, CombineOp>(cop),
tresult.ref(),
defaultValues
);
return tresult;
}
template<class Type, class CombineOp>
Foam::tmp<Foam::Field<Type>>
Foam::AMIInterpolation::interpolateToTarget
(
const tmp<Field<Type>>& tFld,
const CombineOp& cop,
const UList<Type>& defaultValues
) const
{
return interpolateToTarget(tFld(), cop, defaultValues);
}
template<class Type>
Foam::tmp<Foam::Field<Type>>
Foam::AMIInterpolation::interpolateToSource
(
const Field<Type>& fld,
const UList<Type>& defaultValues
) const
{
return interpolateToSource(fld, plusEqOp<Type>(), defaultValues);
}
template<class Type>
Foam::tmp<Foam::Field<Type>>
Foam::AMIInterpolation::interpolateToSource
(
const tmp<Field<Type>>& tFld,
const UList<Type>& defaultValues
) const
{
return interpolateToSource(tFld(), plusEqOp<Type>(), defaultValues);
}
template<class Type>
Foam::tmp<Foam::Field<Type>>
Foam::AMIInterpolation::interpolateToTarget
(
const Field<Type>& fld,
const UList<Type>& defaultValues
) const
{
return interpolateToTarget(fld, plusEqOp<Type>(), defaultValues);
}
template<class Type>
Foam::tmp<Foam::Field<Type>>
Foam::AMIInterpolation::interpolateToTarget
(
const tmp<Field<Type>>& tFld,
const UList<Type>& defaultValues
) const
{
return interpolateToTarget(tFld(), plusEqOp<Type>(), defaultValues);
}
// ************************************************************************* //

45
src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/AMIMethod/AMIMethod.C
View File

@ -28,10 +28,18 @@ License
#include "mapDistribute.H"
#include "unitConversion.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(AMIMethod, 0);
defineRunTimeSelectionTable(AMIMethod, components);
}
// * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
void Foam::AMIMethod<SourcePatch, TargetPatch>::checkPatches() const
void Foam::AMIMethod::checkPatches() const
{
if (debug && (!srcPatch_.size() || !tgtPatch_.size()))
{
@ -67,8 +75,7 @@ void Foam::AMIMethod<SourcePatch, TargetPatch>::checkPatches() const
}
template<class SourcePatch, class TargetPatch>
bool Foam::AMIMethod<SourcePatch, TargetPatch>::initialise
bool Foam::AMIMethod::initialise
(
labelListList& srcAddress,
scalarListList& srcWeights,
@ -142,8 +149,7 @@ bool Foam::AMIMethod<SourcePatch, TargetPatch>::initialise
}
template<class SourcePatch, class TargetPatch>
void Foam::AMIMethod<SourcePatch, TargetPatch>::writeIntersectionOBJ
void Foam::AMIMethod::writeIntersectionOBJ
(
const scalar area,
const face& f1,
@ -194,8 +200,7 @@ void Foam::AMIMethod<SourcePatch, TargetPatch>::writeIntersectionOBJ
}
template<class SourcePatch, class TargetPatch>
void Foam::AMIMethod<SourcePatch, TargetPatch>::resetTree()
void Foam::AMIMethod::resetTree()
{
// Clear the old octree
treePtr_.clear();
@ -225,8 +230,7 @@ void Foam::AMIMethod<SourcePatch, TargetPatch>::resetTree()
}
template<class SourcePatch, class TargetPatch>
Foam::label Foam::AMIMethod<SourcePatch, TargetPatch>::findTargetFace
Foam::label Foam::AMIMethod::findTargetFace
(
const label srcFacei
) const
@ -256,11 +260,10 @@ Foam::label Foam::AMIMethod<SourcePatch, TargetPatch>::findTargetFace
}
template<class SourcePatch, class TargetPatch>
void Foam::AMIMethod<SourcePatch, TargetPatch>::appendNbrFaces
void Foam::AMIMethod::appendNbrFaces
(
const label facei,
const TargetPatch& patch,
const primitivePatch& patch,
const DynamicList<label>& visitedFaces,
DynamicList<label>& faceIDs
) const
@ -310,8 +313,7 @@ void Foam::AMIMethod<SourcePatch, TargetPatch>::appendNbrFaces
}
template<class SourcePatch, class TargetPatch>
Foam::scalar Foam::AMIMethod<SourcePatch, TargetPatch>::maxWalkAngle() const
Foam::scalar Foam::AMIMethod::maxWalkAngle() const
{
return degToRad(89);
}
@ -319,11 +321,10 @@ Foam::scalar Foam::AMIMethod<SourcePatch, TargetPatch>::maxWalkAngle() const
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
Foam::AMIMethod<SourcePatch, TargetPatch>::AMIMethod
Foam::AMIMethod::AMIMethod
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const scalarField& srcMagSf,
const scalarField& tgtMagSf,
const faceAreaIntersect::triangulationMode& triMode,
@ -344,15 +345,13 @@ Foam::AMIMethod<SourcePatch, TargetPatch>::AMIMethod
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
Foam::AMIMethod<SourcePatch, TargetPatch>::~AMIMethod()
Foam::AMIMethod::~AMIMethod()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
bool Foam::AMIMethod<SourcePatch, TargetPatch>::conformal() const
bool Foam::AMIMethod::conformal() const
{
return true;
}

76
src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/AMIMethod/AMIMethod.H
View File

@ -41,6 +41,7 @@ SourceFiles
#include "indexedOctree.H"
#include "treeDataPrimitivePatch.H"
#include "treeBoundBoxList.H"
#include "primitivePatch.H"
#include "runTimeSelectionTables.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -52,10 +53,8 @@ namespace Foam
Class AMIMethod Declaration
\*---------------------------------------------------------------------------*/
template<class SourcePatch, class TargetPatch>
class AMIMethod
{
private:
// Private Member Functions
@ -70,16 +69,16 @@ private:
protected:
//- Local typedef to octree tree-type
typedef treeDataPrimitivePatch<TargetPatch> treeType;
typedef treeDataPrimitivePatch<primitivePatch> treeType;
// Protected data
//- Reference to source patch
const SourcePatch& srcPatch_;
const primitivePatch& srcPatch_;
//- Reference to target patch
const TargetPatch& tgtPatch_;
const primitivePatch& tgtPatch_;
//- Flag to indicate that the two patches are co-directional and
// that the orientation of the target patch should be reversed
@ -147,7 +146,7 @@ protected:
void appendNbrFaces
(
const label facei,
const TargetPatch& patch,
const primitivePatch& patch,
const DynamicList<label>& visitedFaces,
DynamicList<label>& faceIDs
) const;
@ -161,6 +160,7 @@ public:
//- Runtime type information
TypeName("AMIMethod");
//- Declare runtime constructor selection table
declareRunTimeSelectionTable
(
@ -168,8 +168,8 @@ public:
AMIMethod,
components,
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const scalarField& srcMagSf,
const scalarField& tgtMagSf,
const faceAreaIntersect::triangulationMode& triMode,
@ -187,24 +187,28 @@ public:
)
);
//- Construct from components
AMIMethod
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const scalarField& srcMagSf,
const scalarField& tgtMagSf,
const faceAreaIntersect::triangulationMode& triMode,
const bool reverseTarget,
const bool requireMatch
);
// Constructors
//- Construct from components
AMIMethod
(
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const scalarField& srcMagSf,
const scalarField& tgtMagSf,
const faceAreaIntersect::triangulationMode& triMode,
const bool reverseTarget,
const bool requireMatch
);
//- Selector
static autoPtr<AMIMethod> New
(
const word& methodName,
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const scalarField& srcMagSf,
const scalarField& tgtMagSf,
const faceAreaIntersect::triangulationMode& triMode,
@ -248,42 +252,12 @@ public:
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define makeAMIMethod(AMIType) \
\
typedef AMIMethod<AMIType::sourcePatchType,AMIType::targetPatchType> \
AMIMethod##AMIType; \
\
defineNamedTemplateTypeNameAndDebug(AMIMethod##AMIType, 0); \
defineTemplateRunTimeSelectionTable(AMIMethod##AMIType, components);
#define makeAMIMethodType(AMIType, Method) \
\
typedef Method<AMIType::sourcePatchType,AMIType::targetPatchType> \
Method##AMIType; \
\
defineNamedTemplateTypeNameAndDebug(Method##AMIType, 0); \
\
AMIMethod<AMIType::sourcePatchType,AMIType::targetPatchType>:: \
addcomponentsConstructorToTable<Method##AMIType> \
add##Method##AMIType##ConstructorToTable_;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "AMIMethodI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "AMIMethod.C"
#include "AMIMethodNew.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

4
src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/AMIMethod/AMIMethodI.H
View File

@ -23,9 +23,7 @@ License
\*---------------------------------------------------------------------------*/
template<class SourcePatch, class TargetPatch>
inline const Foam::labelList&
Foam::AMIMethod<SourcePatch, TargetPatch>::srcNonOverlap() const
inline const Foam::labelList& Foam::AMIMethod::srcNonOverlap() const
{
return srcNonOverlap_;
}

12
src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/AMIMethod/AMIMethodNew.C
View File

@ -23,15 +23,15 @@ License
\*---------------------------------------------------------------------------*/
#include "AMIMethod.H"
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
Foam::autoPtr<Foam::AMIMethod<SourcePatch, TargetPatch>>
Foam::AMIMethod<SourcePatch, TargetPatch>::New
Foam::autoPtr<Foam::AMIMethod> Foam::AMIMethod::New
(
const word& methodName,
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const scalarField& srcMagSf,
const scalarField& tgtMagSf,
const faceAreaIntersect::triangulationMode& triMode,
@ -56,7 +56,7 @@ Foam::AMIMethod<SourcePatch, TargetPatch>::New
<< componentsConstructorTablePtr_->sortedToc() << exit(FatalError);
}
return autoPtr<AMIMethod<SourcePatch, TargetPatch>>
return autoPtr<AMIMethod>
(
cstrIter()
(

31
src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/directAMI/directAMI.C
View File

@ -24,11 +24,20 @@ License
\*---------------------------------------------------------------------------*/
#include "directAMI.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(directAMI, 0);
addToRunTimeSelectionTable(AMIMethod, directAMI, components);
}
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
void Foam::directAMI<SourcePatch, TargetPatch>::appendToDirectSeeds
void Foam::directAMI::appendToDirectSeeds
(
labelList& mapFlag,
labelList& srcTgtSeed,
@ -155,8 +164,7 @@ void Foam::directAMI<SourcePatch, TargetPatch>::appendToDirectSeeds
}
template<class SourcePatch, class TargetPatch>
void Foam::directAMI<SourcePatch, TargetPatch>::restartAdvancingFront
void Foam::directAMI::restartAdvancingFront
(
labelList& mapFlag,
DynamicList<label>& nonOverlapFaces,
@ -187,11 +195,10 @@ void Foam::directAMI<SourcePatch, TargetPatch>::restartAdvancingFront
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
Foam::directAMI<SourcePatch, TargetPatch>::directAMI
Foam::directAMI::directAMI
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const scalarField& srcMagSf,
const scalarField& tgtMagSf,
const faceAreaIntersect::triangulationMode& triMode,
@ -199,7 +206,7 @@ Foam::directAMI<SourcePatch, TargetPatch>::directAMI
const bool requireMatch
)
:
AMIMethod<SourcePatch, TargetPatch>
AMIMethod
(
srcPatch,
tgtPatch,
@ -214,15 +221,13 @@ Foam::directAMI<SourcePatch, TargetPatch>::directAMI
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
Foam::directAMI<SourcePatch, TargetPatch>::~directAMI()
Foam::directAMI::~directAMI()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
void Foam::directAMI<SourcePatch, TargetPatch>::calculate
void Foam::directAMI::calculate
(
labelListList& srcAddress,
scalarListList& srcWeights,

13
src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/directAMI/directAMI.H
View File

@ -46,10 +46,9 @@ namespace Foam
Class directAMI Declaration
\*---------------------------------------------------------------------------*/
template<class SourcePatch, class TargetPatch>
class directAMI
:
public AMIMethod<SourcePatch, TargetPatch>
public AMIMethod
{
private:
@ -107,8 +106,8 @@ public:
//- Construct from components
directAMI
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const scalarField& srcMagSf,
const scalarField& tgtMagSf,
const faceAreaIntersect::triangulationMode& triMode,
@ -144,12 +143,6 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "directAMI.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

44
src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/faceAreaWeightAMI/faceAreaWeightAMI.C
View File

@ -24,11 +24,20 @@ License
\*---------------------------------------------------------------------------*/
#include "faceAreaWeightAMI.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(faceAreaWeightAMI, 0);
addToRunTimeSelectionTable(AMIMethod, faceAreaWeightAMI, components);
}
// * * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
void Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::calcAddressing
void Foam::faceAreaWeightAMI::calcAddressing
(
List<DynamicList<label>>& srcAddr,
List<DynamicList<scalar>>& srcWght,
@ -105,8 +114,7 @@ void Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::calcAddressing
}
template<class SourcePatch, class TargetPatch>
bool Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::processSourceFace
bool Foam::faceAreaWeightAMI::processSourceFace
(
const label srcFacei,
const label tgtStartFacei,
@ -181,8 +189,7 @@ bool Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::processSourceFace
}
template<class SourcePatch, class TargetPatch>
void Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::setNextFaces
void Foam::faceAreaWeightAMI::setNextFaces
(
label& startSeedI,
label& srcFacei,
@ -296,8 +303,7 @@ void Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::setNextFaces
}
template<class SourcePatch, class TargetPatch>
Foam::scalar Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::interArea
Foam::scalar Foam::faceAreaWeightAMI::interArea
(
const label srcFacei,
const label tgtFacei
@ -359,9 +365,7 @@ Foam::scalar Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::interArea
}
template<class SourcePatch, class TargetPatch>
void Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::
restartUncoveredSourceFace
void Foam::faceAreaWeightAMI::restartUncoveredSourceFace
(
List<DynamicList<label>>& srcAddr,
List<DynamicList<scalar>>& srcWght,
@ -456,9 +460,8 @@ restartUncoveredSourceFace
}
template<class SourcePatch, class TargetPatch>
Foam::scalar
Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::minWeight() const
Foam::faceAreaWeightAMI::minWeight() const
{
return faceAreaIntersect::tolerance();
}
@ -466,11 +469,10 @@ Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::minWeight() const
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::faceAreaWeightAMI
Foam::faceAreaWeightAMI::faceAreaWeightAMI
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const scalarField& srcMagSf,
const scalarField& tgtMagSf,
const faceAreaIntersect::triangulationMode& triMode,
@ -479,7 +481,7 @@ Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::faceAreaWeightAMI
const bool restartUncoveredSourceFace
)
:
AMIMethod<SourcePatch, TargetPatch>
AMIMethod
(
srcPatch,
tgtPatch,
@ -495,15 +497,13 @@ Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::faceAreaWeightAMI
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::~faceAreaWeightAMI()
Foam::faceAreaWeightAMI::~faceAreaWeightAMI()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
void Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::calculate
void Foam::faceAreaWeightAMI::calculate
(
labelListList& srcAddress,
scalarListList& srcWeights,

13
src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/faceAreaWeightAMI/faceAreaWeightAMI.H
View File

@ -46,10 +46,9 @@ namespace Foam
Class faceAreaWeightAMI Declaration
\*---------------------------------------------------------------------------*/
template<class SourcePatch, class TargetPatch>
class faceAreaWeightAMI
:
public AMIMethod<SourcePatch, TargetPatch>
public AMIMethod
{
private:
@ -141,8 +140,8 @@ public:
//- Construct from components
faceAreaWeightAMI
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const scalarField& srcMagSf,
const scalarField& tgtMagSf,
const faceAreaIntersect::triangulationMode& triMode,
@ -179,12 +178,6 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "faceAreaWeightAMI.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

38
src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/mapNearestAMI/mapNearestAMI.C
View File

@ -24,14 +24,23 @@ License
\*---------------------------------------------------------------------------*/
#include "mapNearestAMI.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(mapNearestAMI, 0);
addToRunTimeSelectionTable(AMIMethod, mapNearestAMI, components);
}
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
void Foam::mapNearestAMI<SourcePatch, TargetPatch>::findNearestFace
void Foam::mapNearestAMI::findNearestFace
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const label& srcFacei,
label& tgtFacei
) const
@ -72,8 +81,7 @@ void Foam::mapNearestAMI<SourcePatch, TargetPatch>::findNearestFace
}
template<class SourcePatch, class TargetPatch>
void Foam::mapNearestAMI<SourcePatch, TargetPatch>::setNextNearestFaces
void Foam::mapNearestAMI::setNextNearestFaces
(
boolList& mapFlag,
label& startSeedI,
@ -120,8 +128,7 @@ void Foam::mapNearestAMI<SourcePatch, TargetPatch>::setNextNearestFaces
}
template<class SourcePatch, class TargetPatch>
Foam::label Foam::mapNearestAMI<SourcePatch, TargetPatch>::findMappedSrcFace
Foam::label Foam::mapNearestAMI::findMappedSrcFace
(
const label tgtFacei,
const List<DynamicList<label>>& tgtToSrc
@ -167,11 +174,10 @@ Foam::label Foam::mapNearestAMI<SourcePatch, TargetPatch>::findMappedSrcFace
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
Foam::mapNearestAMI<SourcePatch, TargetPatch>::mapNearestAMI
Foam::mapNearestAMI::mapNearestAMI
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const scalarField& srcMagSf,
const scalarField& tgtMagSf,
const faceAreaIntersect::triangulationMode& triMode,
@ -179,7 +185,7 @@ Foam::mapNearestAMI<SourcePatch, TargetPatch>::mapNearestAMI
const bool requireMatch
)
:
AMIMethod<SourcePatch, TargetPatch>
AMIMethod
(
srcPatch,
tgtPatch,
@ -194,15 +200,13 @@ Foam::mapNearestAMI<SourcePatch, TargetPatch>::mapNearestAMI
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
Foam::mapNearestAMI<SourcePatch, TargetPatch>::~mapNearestAMI()
Foam::mapNearestAMI::~mapNearestAMI()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
void Foam::mapNearestAMI<SourcePatch, TargetPatch>::calculate
void Foam::mapNearestAMI::calculate
(
labelListList& srcAddress,
scalarListList& srcWeights,

17
src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/mapNearestAMI/mapNearestAMI.H
View File

@ -46,10 +46,9 @@ namespace Foam
Class mapNearestAMI Declaration
\*---------------------------------------------------------------------------*/
template<class SourcePatch, class TargetPatch>
class mapNearestAMI
:
public AMIMethod<SourcePatch, TargetPatch>
public AMIMethod
{
private:
@ -67,8 +66,8 @@ private:
//- Find nearest target face for source face srcFacei
void findNearestFace
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const label& srcFacei,
label& tgtFacei
) const;
@ -111,8 +110,8 @@ public:
//- Construct from components
mapNearestAMI
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const scalarField& srcMagSf,
const scalarField& tgtMagSf,
const faceAreaIntersect::triangulationMode& triMode,
@ -148,12 +147,6 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "mapNearestAMI.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

37
src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/partialFaceAreaWeightAMI/partialFaceAreaWeightAMI.C
View File

@ -24,11 +24,20 @@ License
\*---------------------------------------------------------------------------*/
#include "partialFaceAreaWeightAMI.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(partialFaceAreaWeightAMI, 0);
addToRunTimeSelectionTable(AMIMethod, partialFaceAreaWeightAMI, components);
}
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
void Foam::partialFaceAreaWeightAMI<SourcePatch, TargetPatch>::setNextFaces
void Foam::partialFaceAreaWeightAMI::setNextFaces
(
label& startSeedI,
label& srcFacei,
@ -39,7 +48,7 @@ void Foam::partialFaceAreaWeightAMI<SourcePatch, TargetPatch>::setNextFaces
const bool errorOnNotFound
) const
{
faceAreaWeightAMI<SourcePatch, TargetPatch>::setNextFaces
faceAreaWeightAMI::setNextFaces
(
startSeedI,
srcFacei,
@ -54,12 +63,10 @@ void Foam::partialFaceAreaWeightAMI<SourcePatch, TargetPatch>::setNextFaces
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
Foam::partialFaceAreaWeightAMI<SourcePatch, TargetPatch>::
partialFaceAreaWeightAMI
Foam::partialFaceAreaWeightAMI::partialFaceAreaWeightAMI
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const scalarField& srcMagSf,
const scalarField& tgtMagSf,
const faceAreaIntersect::triangulationMode& triMode,
@ -67,7 +74,7 @@ partialFaceAreaWeightAMI
const bool requireMatch
)
:
faceAreaWeightAMI<SourcePatch, TargetPatch>
faceAreaWeightAMI
(
srcPatch,
tgtPatch,
@ -82,23 +89,19 @@ partialFaceAreaWeightAMI
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
Foam::partialFaceAreaWeightAMI<SourcePatch, TargetPatch>::
~partialFaceAreaWeightAMI()
Foam::partialFaceAreaWeightAMI::~partialFaceAreaWeightAMI()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
bool Foam::partialFaceAreaWeightAMI<SourcePatch, TargetPatch>::conformal() const
bool Foam::partialFaceAreaWeightAMI::conformal() const
{
return false;
}
template<class SourcePatch, class TargetPatch>
void Foam::partialFaceAreaWeightAMI<SourcePatch, TargetPatch>::calculate
void Foam::partialFaceAreaWeightAMI::calculate
(
labelListList& srcAddress,
scalarListList& srcWeights,
@ -130,7 +133,7 @@ void Foam::partialFaceAreaWeightAMI<SourcePatch, TargetPatch>::calculate
List<DynamicList<label>> tgtAddr(this->tgtPatch_.size());
List<DynamicList<scalar>> tgtWght(tgtAddr.size());
faceAreaWeightAMI<SourcePatch, TargetPatch>::calcAddressing
faceAreaWeightAMI::calcAddressing
(
srcAddr,
srcWght,

13
src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/partialFaceAreaWeightAMI/partialFaceAreaWeightAMI.H
View File

@ -46,10 +46,9 @@ namespace Foam
Class partialFaceAreaWeightAMI Declaration
\*---------------------------------------------------------------------------*/
template<class SourcePatch, class TargetPatch>
class partialFaceAreaWeightAMI
:
public faceAreaWeightAMI<SourcePatch, TargetPatch>
public faceAreaWeightAMI
{
private:
@ -88,8 +87,8 @@ public:
//- Construct from components
partialFaceAreaWeightAMI
(
const SourcePatch& srcPatch,
const TargetPatch& tgtPatch,
const primitivePatch& srcPatch,
const primitivePatch& tgtPatch,
const scalarField& srcMagSf,
const scalarField& tgtMagSf,
const faceAreaIntersect::triangulationMode& triMode,
@ -131,12 +130,6 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "partialFaceAreaWeightAMI.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

51
src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/sweptFaceAreaWeightAMI/sweptFaceAreaWeightAMI.C
View File

@ -27,23 +27,27 @@ License
#include "cut.H"
#include "linearEqn.H"
#include "quadraticEqn.H"
#include "unitConversion.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
const Foam::scalar Foam::sweptFaceAreaWeightAMI<SourcePatch, TargetPatch>::
minCutRatio_ = 10*small;
namespace Foam
{
defineTypeNameAndDebug(sweptFaceAreaWeightAMI, 0);
addToRunTimeSelectionTable(AMIMethod, sweptFaceAreaWeightAMI, components);
}
template<class SourcePatch, class TargetPatch>
const Foam::scalar Foam::sweptFaceAreaWeightAMI<SourcePatch, TargetPatch>::
maxDot_ = - cos(degToRad(89.9));
const Foam::scalar Foam::sweptFaceAreaWeightAMI::minCutRatio_ = 10*small;
const Foam::scalar Foam::sweptFaceAreaWeightAMI::maxDot_ =
- cos(degToRad(89.9));
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
template<unsigned Size>
void Foam::sweptFaceAreaWeightAMI<SourcePatch, TargetPatch>::writeCutTrisVTK
void Foam::sweptFaceAreaWeightAMI::writeCutTrisVTK
(
const cutTriList<Size>& tris,
const word& name
@ -75,8 +79,7 @@ void Foam::sweptFaceAreaWeightAMI<SourcePatch, TargetPatch>::writeCutTrisVTK
}
template<class SourcePatch, class TargetPatch>
void Foam::sweptFaceAreaWeightAMI<SourcePatch, TargetPatch>::writeFaceOBJ
void Foam::sweptFaceAreaWeightAMI::writeFaceOBJ
(
const face& f,
const pointField& ps,
@ -100,8 +103,7 @@ void Foam::sweptFaceAreaWeightAMI<SourcePatch, TargetPatch>::writeFaceOBJ
}
template<class SourcePatch, class TargetPatch>
void Foam::sweptFaceAreaWeightAMI<SourcePatch, TargetPatch>::writeProjectionOBJ
void Foam::sweptFaceAreaWeightAMI::writeProjectionOBJ
(
const label srcN,
const FixedList<point, 4>& srcTri,
@ -153,9 +155,7 @@ void Foam::sweptFaceAreaWeightAMI<SourcePatch, TargetPatch>::writeProjectionOBJ
}
template<class SourcePatch, class TargetPatch>
Foam::label
Foam::sweptFaceAreaWeightAMI<SourcePatch, TargetPatch>::getSourceProjection
Foam::label Foam::sweptFaceAreaWeightAMI::getSourceProjection
(
FixedList<point, 4>& srcTri,
FixedList<point, 4>& srcNrm,
@ -271,8 +271,7 @@ Foam::sweptFaceAreaWeightAMI<SourcePatch, TargetPatch>::getSourceProjection
}
template<class SourcePatch, class TargetPatch>
Foam::plane Foam::sweptFaceAreaWeightAMI<SourcePatch, TargetPatch>::getCutPlane
Foam::plane Foam::sweptFaceAreaWeightAMI::getCutPlane
(
const point& p0,
const point& p1,
@ -355,8 +354,7 @@ Foam::plane Foam::sweptFaceAreaWeightAMI<SourcePatch, TargetPatch>::getCutPlane
// * * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
Foam::scalar Foam::sweptFaceAreaWeightAMI<SourcePatch, TargetPatch>::interArea
Foam::scalar Foam::sweptFaceAreaWeightAMI::interArea
(
const label srcFacei,
const label tgtFacei
@ -562,7 +560,7 @@ Foam::scalar Foam::sweptFaceAreaWeightAMI<SourcePatch, TargetPatch>::interArea
if (debugPrint)
{
const scalar standardAreaMag =
faceAreaWeightAMI<SourcePatch, TargetPatch>::interArea
faceAreaWeightAMI::interArea
(
srcFacei,
tgtFacei
@ -576,17 +574,13 @@ Foam::scalar Foam::sweptFaceAreaWeightAMI<SourcePatch, TargetPatch>::interArea
}
template<class SourcePatch, class TargetPatch>
Foam::scalar
Foam::sweptFaceAreaWeightAMI<SourcePatch, TargetPatch>::minWeight() const
Foam::scalar Foam::sweptFaceAreaWeightAMI::minWeight() const
{
return small;
}
template<class SourcePatch, class TargetPatch>
Foam::scalar
Foam::sweptFaceAreaWeightAMI<SourcePatch, TargetPatch>::maxWalkAngle() const
Foam::scalar Foam::sweptFaceAreaWeightAMI::maxWalkAngle() const
{
return degToRad(180);
}
@ -594,10 +588,7 @@ Foam::sweptFaceAreaWeightAMI<SourcePatch, TargetPatch>::maxWalkAngle() const
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class SourcePatch, class TargetPatch>
Foam::sweptFaceAreaWeightAMI<SourcePatch, TargetPatch>::~sweptFaceAreaWeightAMI
(
)
Foam::sweptFaceAreaWeightAMI::~sweptFaceAreaWeightAMI()
{}

11
src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/sweptFaceAreaWeightAMI/sweptFaceAreaWeightAMI.H
View File

@ -103,10 +103,9 @@ namespace Foam
Class sweptFaceAreaWeightAMI Declaration
\*---------------------------------------------------------------------------*/
template<class SourcePatch, class TargetPatch>
class sweptFaceAreaWeightAMI
:
public faceAreaWeightAMI<SourcePatch, TargetPatch>
public faceAreaWeightAMI
{
private:
@ -248,7 +247,7 @@ public:
// Constructors
//- Use parent constructors
using faceAreaWeightAMI<SourcePatch, TargetPatch>::faceAreaWeightAMI;
using faceAreaWeightAMI::faceAreaWeightAMI;
//- Destructor
@ -262,12 +261,6 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "sweptFaceAreaWeightAMI.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

49
src/meshTools/AMIInterpolation/AMIInterpolation/AMIPatchToPatchInterpolation.C
View File

@ -1,49 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2013-2018 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
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 <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "AMIPatchToPatchInterpolation.H"
#include "AMIMethod.H"
#include "directAMI.H"
#include "mapNearestAMI.H"
#include "faceAreaWeightAMI.H"
#include "partialFaceAreaWeightAMI.H"
#include "sweptFaceAreaWeightAMI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
makeAMIMethod(AMIPatchToPatchInterpolation);
makeAMIMethodType(AMIPatchToPatchInterpolation, directAMI);
makeAMIMethodType(AMIPatchToPatchInterpolation, mapNearestAMI);
makeAMIMethodType(AMIPatchToPatchInterpolation, faceAreaWeightAMI);
makeAMIMethodType(AMIPatchToPatchInterpolation, partialFaceAreaWeightAMI);
makeAMIMethodType(AMIPatchToPatchInterpolation, sweptFaceAreaWeightAMI);
}
// ************************************************************************* //

50
src/meshTools/AMIInterpolation/AMIInterpolation/AMIPatchToPatchInterpolation.H
View File

@ -1,50 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
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 <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#ifndef AMIPatchToPatchInterpolation_H
#define AMIPatchToPatchInterpolation_H
#include "AMIInterpolation.H"
#include "PrimitivePatch.H"
#include "face.H"
#include "SubList.H"
#include "pointField.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
typedef AMIInterpolation
<
PrimitivePatch<face, SubList, const pointField&>,
PrimitivePatch<face, SubList, const pointField&>
> AMIPatchToPatchInterpolation;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

2
src/meshTools/AMIInterpolation/GAMG/interfaces/cyclicAMIGAMGInterface/cyclicAMIGAMGInterface.C
View File

@ -161,7 +161,7 @@ Foam::cyclicAMIGAMGInterface::cyclicAMIGAMGInterface
AMIs_.set
(
i,
new AMIPatchToPatchInterpolation
new AMIInterpolation
(
fineCyclicAMIInterface_.AMIs()[i],
faceRestrictAddressing_,

4
src/meshTools/AMIInterpolation/GAMG/interfaces/cyclicAMIGAMGInterface/cyclicAMIGAMGInterface.H
View File

@ -59,7 +59,7 @@ class cyclicAMIGAMGInterface
const cyclicAMILduInterface& fineCyclicAMIInterface_;
//- AMI interfaces
PtrList<AMIPatchToPatchInterpolation> AMIs_;
PtrList<AMIInterpolation> AMIs_;
//- AMI transformations
List<vectorTensorTransform> AMITransforms_;
@ -136,7 +136,7 @@ public:
}
//- Return a reference to the AMI interpolators
virtual const PtrList<AMIPatchToPatchInterpolation>& AMIs() const
virtual const PtrList<AMIInterpolation>& AMIs() const
{
return AMIs_;
}

6
src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatch.C
View File

@ -78,7 +78,7 @@ void Foam::cyclicACMIPolyPatch::resetAMI() const
// face is fully covered)
cyclicAMIPolyPatch::resetAMI();
AMIPatchToPatchInterpolation& AMI = this->AMIs_[0];
AMIInterpolation& AMI = this->AMIs_[0];
srcMask_ =
min(scalar(1) - tolerance_, max(tolerance_, AMI.srcWeightsSum()));
@ -218,7 +218,7 @@ Foam::cyclicACMIPolyPatch::cyclicACMIPolyPatch
patchType,
transform,
false,
AMIPatchToPatchInterpolation::imPartialFaceAreaWeight
AMIInterpolation::imPartialFaceAreaWeight
),
nonOverlapPatchName_(word::null),
nonOverlapPatchID_(-1),
@ -248,7 +248,7 @@ Foam::cyclicACMIPolyPatch::cyclicACMIPolyPatch
bm,
patchType,
false,
AMIPatchToPatchInterpolation::imPartialFaceAreaWeight
AMIInterpolation::imPartialFaceAreaWeight
),
nonOverlapPatchName_(dict.lookup("nonOverlapPatch")),
nonOverlapPatchID_(-1),

2
src/meshTools/AMIInterpolation/patches/cyclicACMI/cyclicACMIPolyPatch/cyclicACMIPolyPatch.H
View File

@ -36,7 +36,7 @@ SourceFiles
#define cyclicACMIPolyPatch_H
#include "cyclicAMIPolyPatch.H"
#include "AMIPatchToPatchInterpolation.H"
#include "AMIInterpolation.H"
#include "polyBoundaryMesh.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

5
src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMILduInterfaceField/cyclicAMILduInterface.H
View File

@ -36,7 +36,7 @@ SourceFiles
#define cyclicAMILduInterface_H
#include "primitiveFieldsFwd.H"
#include "AMIPatchToPatchInterpolation.H"
#include "AMIInterpolation.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -81,8 +81,7 @@ public:
virtual const cyclicAMILduInterface& neighbPatch() const = 0;
//- Return a reference to the AMI interpolators
virtual const PtrList<AMIPatchToPatchInterpolation>&
AMIs() const = 0;
virtual const PtrList<AMIInterpolation>& AMIs() const = 0;
// Return a reference to the AMI transformations
virtual const List<vectorTensorTransform>&

13
src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.C
View File

@ -26,6 +26,7 @@ License
#include "cyclicAMIPolyPatch.H"
#include "SubField.H"
#include "Time.H"
#include "unitConversion.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -328,7 +329,7 @@ void Foam::cyclicAMIPolyPatch::resetAMI() const
AMIs_.set
(
0,
new AMIPatchToPatchInterpolation
new AMIInterpolation
(
*this,
nbrPatch0,
@ -484,7 +485,7 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
const word& patchType,
const transformType transform,
const bool AMIRequireMatch,
const AMIPatchToPatchInterpolation::interpolationMethod AMIMethod
const AMIInterpolation::interpolationMethod AMIMethod
)
:
coupledPolyPatch(name, size, start, index, bm, patchType, transform),
@ -517,7 +518,7 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
const polyBoundaryMesh& bm,
const word& patchType,
const bool AMIRequireMatch,
const AMIPatchToPatchInterpolation::interpolationMethod AMIMethod
const AMIInterpolation::interpolationMethod AMIMethod
)
:
coupledPolyPatch(name, dict, index, bm, patchType),
@ -537,7 +538,7 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
AMIMethod_
(
dict.found("method")
? AMIPatchToPatchInterpolation::wordTointerpolationMethod
? AMIInterpolation::wordTointerpolationMethod
(
dict.lookup("method")
)
@ -801,7 +802,7 @@ Foam::cyclicAMIPolyPatch::surfPtr() const
}
const Foam::PtrList<Foam::AMIPatchToPatchInterpolation>&
const Foam::PtrList<Foam::AMIInterpolation>&
Foam::cyclicAMIPolyPatch::AMIs() const
{
if (!owner())
@ -1231,7 +1232,7 @@ void Foam::cyclicAMIPolyPatch::write(Ostream& os) const
}
os.writeKeyword("method")
<< AMIPatchToPatchInterpolation::interpolationMethodToWord(AMIMethod_)
<< AMIInterpolation::interpolationMethodToWord(AMIMethod_)
<< token::END_STATEMENT << nl;
if (!surfDict_.empty())

16
src/meshTools/AMIInterpolation/patches/cyclicAMI/cyclicAMIPolyPatch/cyclicAMIPolyPatch.H
View File

@ -36,7 +36,7 @@ SourceFiles
#define cyclicAMIPolyPatch_H
#include "coupledPolyPatch.H"
#include "AMIPatchToPatchInterpolation.H"
#include "AMIInterpolation.H"
#include "polyBoundaryMesh.H"
#include "coupleGroupIdentifier.H"
@ -106,7 +106,7 @@ protected:
//- AMI interpolation classes
mutable PtrList<AMIPatchToPatchInterpolation> AMIs_;
mutable PtrList<AMIInterpolation> AMIs_;
//- AMI transforms (from source to target)
mutable List<vectorTensorTransform> AMITransforms_;
@ -121,7 +121,7 @@ protected:
const scalar AMILowWeightCorrection_;
//- AMI Method
const AMIPatchToPatchInterpolation::interpolationMethod AMIMethod_;
const AMIInterpolation::interpolationMethod AMIMethod_;
//- Projection surface
mutable autoPtr<searchableSurface> surfPtr_;
@ -179,8 +179,8 @@ public:
const word& patchType,
const transformType transform = UNKNOWN,
const bool AMIRequireMatch = true,
const AMIPatchToPatchInterpolation::interpolationMethod AMIMethod =
AMIPatchToPatchInterpolation::imFaceAreaWeight
const AMIInterpolation::interpolationMethod AMIMethod =
AMIInterpolation::imFaceAreaWeight
);
//- Construct from dictionary
@ -192,8 +192,8 @@ public:
const polyBoundaryMesh& bm,
const word& patchType,
const bool AMIRequireMatch = true,
const AMIPatchToPatchInterpolation::interpolationMethod AMIMethod =
AMIPatchToPatchInterpolation::imFaceAreaWeight
const AMIInterpolation::interpolationMethod AMIMethod =
AMIInterpolation::imFaceAreaWeight
);
//- Construct as copy, resetting the boundary mesh
@ -307,7 +307,7 @@ public:
const autoPtr<searchableSurface>& surfPtr() const;
//- Return a reference to the AMI interpolators
const PtrList<AMIPatchToPatchInterpolation>& AMIs() const;
const PtrList<AMIInterpolation>& AMIs() const;
//- Return a reference to the AMI transforms
const List<vectorTensorTransform>& AMITransforms() const;

28
src/meshTools/AMIInterpolation/patches/cyclicRepeatAMI/cyclicRepeatAMIPolyPatch/cyclicRepeatAMIPolyPatch.C
View File

@ -228,15 +228,15 @@ void Foam::cyclicRepeatAMIPolyPatch::resetAMI() const
// Do the three bounding AMI interpolations
thisPoints = TLeft.transformPosition(localPoints());
thisPatch.movePoints(thisPoints);
autoPtr<AMIPatchToPatchInterpolation> AMILeftPtr
autoPtr<AMIInterpolation> AMILeftPtr
(
new AMIPatchToPatchInterpolation
new AMIInterpolation
(
thisPatch,
nbrPatch,
faceAreaIntersect::tmMesh,
false,
AMIPatchToPatchInterpolation::imPartialFaceAreaWeight,
AMIInterpolation::imPartialFaceAreaWeight,
AMILowWeightCorrection_,
AMIReverse_,
false
@ -248,15 +248,15 @@ void Foam::cyclicRepeatAMIPolyPatch::resetAMI() const
thisPoints = T.transformPosition(localPoints());
thisPatch.movePoints(thisPoints);
autoPtr<AMIPatchToPatchInterpolation> AMIPtr
autoPtr<AMIInterpolation> AMIPtr
(
new AMIPatchToPatchInterpolation
new AMIInterpolation
(
thisPatch,
nbrPatch,
faceAreaIntersect::tmMesh,
false,
AMIPatchToPatchInterpolation::imPartialFaceAreaWeight,
AMIInterpolation::imPartialFaceAreaWeight,
AMILowWeightCorrection_,
AMIReverse_,
false
@ -268,15 +268,15 @@ void Foam::cyclicRepeatAMIPolyPatch::resetAMI() const
thisPoints = TRight.transformPosition(localPoints());
thisPatch.movePoints(thisPoints);
autoPtr<AMIPatchToPatchInterpolation> AMIRightPtr
autoPtr<AMIInterpolation> AMIRightPtr
(
new AMIPatchToPatchInterpolation
new AMIInterpolation
(
thisPatch,
nbrPatch,
faceAreaIntersect::tmMesh,
false,
AMIPatchToPatchInterpolation::imPartialFaceAreaWeight,
AMIInterpolation::imPartialFaceAreaWeight,
AMILowWeightCorrection_,
AMIReverse_,
false
@ -301,9 +301,9 @@ void Foam::cyclicRepeatAMIPolyPatch::resetAMI() const
AMITransforms_[1] = sLeft > sRight ? T : TRight;
// Sum and normalise the two AMI interpolators
AMIPatchToPatchInterpolation::sumWeights(AMIs_);
AMIPatchToPatchInterpolation::reportSumWeights(AMIs_[0]);
AMIPatchToPatchInterpolation::normaliseWeights(AMIs_);
AMIInterpolation::sumWeights(AMIs_);
AMIInterpolation::reportSumWeights(AMIs_[0]);
AMIInterpolation::normaliseWeights(AMIs_);
}
@ -330,7 +330,7 @@ Foam::cyclicRepeatAMIPolyPatch::cyclicRepeatAMIPolyPatch
patchType,
transform,
false,
AMIPatchToPatchInterpolation::imFaceAreaWeight
AMIInterpolation::imFaceAreaWeight
),
transformPatchName_(word::null),
transformPatchID_(-1)
@ -357,7 +357,7 @@ Foam::cyclicRepeatAMIPolyPatch::cyclicRepeatAMIPolyPatch
bm,
patchType,
false,
AMIPatchToPatchInterpolation::imFaceAreaWeight
AMIInterpolation::imFaceAreaWeight
),
transformPatchName_(dict.lookup("transformPatch")),
transformPatchID_(-1)

2
src/meshTools/AMIInterpolation/patches/cyclicRepeatAMI/cyclicRepeatAMIPolyPatch/cyclicRepeatAMIPolyPatch.H
View File

@ -36,7 +36,7 @@ SourceFiles
#define cyclicRepeatAMIPolyPatch_H
#include "cyclicAMIPolyPatch.H"
#include "AMIPatchToPatchInterpolation.H"
#include "AMIInterpolation.H"
#include "polyBoundaryMesh.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

27
src/meshTools/Make/files
View File

@ -218,15 +218,26 @@ triSurface/triSurfaceTools/pointToPointPlanarInterpolation.C
twoDPointCorrector/twoDPointCorrector.C
AMI=AMIInterpolation
$(AMI)/AMIInterpolation/AMIInterpolationName.C
$(AMI)/AMIInterpolation/AMIPatchToPatchInterpolation.C
$(AMI)/AMIInterpolation/AMIInterpolation.C
$(AMI)/AMIInterpolation/AMIInterpolationParallelOps.C
$(AMI)/faceAreaIntersect/faceAreaIntersect.C
$(AMI)/GAMG/interfaces/cyclicAMIGAMGInterface/cyclicAMIGAMGInterface.C
$(AMI)/GAMG/interfaceFields/cyclicAMIGAMGInterfaceField/cyclicAMIGAMGInterfaceField.C
$(AMI)/GAMG/interfaces/cyclicACMIGAMGInterface/cyclicACMIGAMGInterface.C
$(AMI)/GAMG/interfaceFields/cyclicACMIGAMGInterfaceField/cyclicACMIGAMGInterfaceField.C
$(AMI)/GAMG/interfaces/cyclicRepeatAMIGAMGInterface/cyclicRepeatAMIGAMGInterface.C
$(AMI)/GAMG/interfaceFields/cyclicRepeatAMIGAMGInterfaceField/cyclicRepeatAMIGAMGInterfaceField.C
AMIGAMG=$(AMI)/GAMG
$(AMIGAMG)/interfaces/cyclicAMIGAMGInterface/cyclicAMIGAMGInterface.C
$(AMIGAMG)/interfaceFields/cyclicAMIGAMGInterfaceField/cyclicAMIGAMGInterfaceField.C
$(AMIGAMG)/interfaces/cyclicACMIGAMGInterface/cyclicACMIGAMGInterface.C
$(AMIGAMG)/interfaceFields/cyclicACMIGAMGInterfaceField/cyclicACMIGAMGInterfaceField.C
$(AMIGAMG)/interfaces/cyclicRepeatAMIGAMGInterface/cyclicRepeatAMIGAMGInterface.C
$(AMIGAMG)/interfaceFields/cyclicRepeatAMIGAMGInterfaceField/cyclicRepeatAMIGAMGInterfaceField.C
AMIMethod=$(AMI)/AMIInterpolation/AMIMethod
$(AMIMethod)/AMIMethod/AMIMethod.C
$(AMIMethod)/AMIMethod/AMIMethodNew.C
$(AMIMethod)/directAMI/directAMI.C
$(AMIMethod)/faceAreaWeightAMI/faceAreaWeightAMI.C
$(AMIMethod)/mapNearestAMI/mapNearestAMI.C
$(AMIMethod)/partialFaceAreaWeightAMI/partialFaceAreaWeightAMI.C
$(AMIMethod)/sweptFaceAreaWeightAMI/sweptFaceAreaWeightAMI.C
AMICycPatches=$(AMI)/patches/cyclicAMI
$(AMICycPatches)/cyclicAMILduInterfaceField/cyclicAMILduInterface.C

4
src/meshTools/mappedPatches/mappedPolyPatch/mappedPatchBase.C
View File

@ -846,14 +846,14 @@ void Foam::mappedPatchBase::calcAMI() const
// Construct/apply AMI interpolation to determine addressing and weights
AMIPtr_.reset
(
new AMIPatchToPatchInterpolation
new AMIInterpolation
(
patch_,
samplePolyPatch(), // nbrPatch0,
surfPtr(),
faceAreaIntersect::tmMesh,
true,
AMIPatchToPatchInterpolation::imFaceAreaWeight,
AMIInterpolation::imFaceAreaWeight,
-1,
AMIReverse_
)

6
src/meshTools/mappedPatches/mappedPolyPatch/mappedPatchBase.H
View File

@ -85,7 +85,7 @@ SourceFiles
#include "pointField.H"
#include "Tuple2.H"
#include "pointIndexHit.H"
#include "AMIPatchToPatchInterpolation.H"
#include "AMIInterpolation.H"
#include "coupleGroupIdentifier.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -230,7 +230,7 @@ protected:
// AMI interpolator (only for NEARESTPATCHFACEAMI)
//- Pointer to AMI interpolator
mutable autoPtr<AMIPatchToPatchInterpolation> AMIPtr_;
mutable autoPtr<AMIInterpolation> AMIPtr_;
//- Flag to indicate that slave patch should be reversed for AMI
const bool AMIReverse_;
@ -385,7 +385,7 @@ public:
inline const mapDistribute& map() const;
//- Return reference to the AMI interpolator
inline const AMIPatchToPatchInterpolation& AMI
inline const AMIInterpolation& AMI
(
const bool forceUpdate = false
) const;

2
src/meshTools/mappedPatches/mappedPolyPatch/mappedPatchBaseI.H
View File

@ -152,7 +152,7 @@ inline const Foam::mapDistribute& Foam::mappedPatchBase::map() const
}
inline const Foam::AMIPatchToPatchInterpolation& Foam::mappedPatchBase::AMI
inline const Foam::AMIInterpolation& Foam::mappedPatchBase::AMI
(
bool forceUpdate
) const

2
src/meshTools/regionCoupled/GAMG/interfaces/regionCoupledGAMGInterface/regionCoupledBaseGAMGInterface.C
View File

@ -181,7 +181,7 @@ Foam::regionCoupledBaseGAMGInterface::regionCoupledBaseGAMGInterface
amiPtr_.reset
(
new AMIPatchToPatchInterpolation
new AMIInterpolation
(
fineRegionCoupledLduInterface_.AMI(),
faceRestrictAddressing_,

4
src/meshTools/regionCoupled/GAMG/interfaces/regionCoupledGAMGInterface/regionCoupledBaseGAMGInterface.H
View File

@ -60,7 +60,7 @@ class regionCoupledBaseGAMGInterface
const regionCoupledLduInterface& fineRegionCoupledLduInterface_;
//- AMI interface
// autoPtr<AMIPatchToPatchInterpolation> amiPtr_;
// autoPtr<AMIInterpolation> amiPtr_;
// Private Member Functions
@ -128,7 +128,7 @@ public:
);
}
// virtual const AMIPatchToPatchInterpolation& AMI() const
// virtual const AMIInterpolation& AMI() const
//{
// return amiPtr_();
//}

4
src/meshTools/regionCoupled/patches/regionCoupledLduInterface/regionCoupledLduInterface.H
View File

@ -36,7 +36,7 @@ SourceFiles
#define regionCoupledLduInterface_H
#include "primitiveFieldsFwd.H"
#include "AMIPatchToPatchInterpolation.H"
#include "AMIInterpolation.H"
#include "polyMesh.H"
@ -83,7 +83,7 @@ public:
virtual const regionCoupledLduInterface& neighbPatch() const = 0;
//- Return AMI
// virtual const AMIPatchToPatchInterpolation& AMI() const = 0;
// virtual const AMIInterpolation& AMI() const = 0;
//- Return nbrMesh
virtual const polyMesh& nbrMesh() const = 0;

6
src/meshTools/regionCoupled/patches/regionCoupledPolyPatch/regionCoupledBase.C
View File

@ -85,14 +85,14 @@ void Foam::regionCoupledBase::resetAMI() const
// Construct/apply AMI interpolation to determine addressing and weights
AMIPtr_.reset
(
new AMIPatchToPatchInterpolation
new AMIInterpolation
(
patch_,
nbrPatch0,
surfPtr(),
faceAreaIntersect::tmMesh,
true,
AMIPatchToPatchInterpolation::imFaceAreaWeight,
AMIInterpolation::imFaceAreaWeight,
-1,
AMIReverse_
)
@ -279,7 +279,7 @@ surfPtr() const
}
const Foam::AMIPatchToPatchInterpolation& Foam::regionCoupledBase::AMI() const
const Foam::AMIInterpolation& Foam::regionCoupledBase::AMI() const
{
if (!owner())
{

6
src/meshTools/regionCoupled/patches/regionCoupledPolyPatch/regionCoupledBase.H
View File

@ -37,7 +37,7 @@ SourceFiles
#ifndef regionCoupledBase_H
#define regionCoupledBase_H
#include "AMIPatchToPatchInterpolation.H"
#include "AMIInterpolation.H"
#include "polyBoundaryMesh.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -71,7 +71,7 @@ private:
const bool sameRegion_;
//- AMI interpolation class
mutable autoPtr<AMIPatchToPatchInterpolation> AMIPtr_;
mutable autoPtr<AMIInterpolation> AMIPtr_;
//- Flag to indicate that slave patch should be reversed for AMI
const bool AMIReverse_;
@ -154,7 +154,7 @@ public:
const autoPtr<searchableSurface>& surfPtr() const;
//- Return a reference to the AMI interpolator
const AMIPatchToPatchInterpolation& AMI() const;
const AMIInterpolation& AMI() const;
// Interpolations

12
src/regionModels/regionModel/regionModel/regionModel.C
View File

@ -186,7 +186,7 @@ bool Foam::regionModels::regionModel::read(const dictionary& dict)
}
const Foam::AMIPatchToPatchInterpolation&
const Foam::AMIInterpolation&
Foam::regionModels::regionModel::interRegionAMI
(
const regionModel& nbrRegion,
@ -212,13 +212,13 @@ Foam::regionModels::regionModel::interRegionAMI
interRegionAMI_[nbrRegionID].set
(
regionPatchi,
new AMIPatchToPatchInterpolation
new AMIInterpolation
(
p,
nbrP,
faceAreaIntersect::tmMesh,
true,
AMIPatchToPatchInterpolation::imFaceAreaWeight,
AMIInterpolation::imFaceAreaWeight,
-1,
flip
)
@ -246,7 +246,7 @@ Foam::regionModels::regionModel::interRegionAMI
interRegionAMI_.set
(
nbrRegionID,
new PtrList<AMIPatchToPatchInterpolation>(nPatch)
new PtrList<AMIInterpolation>(nPatch)
);
int oldTag = UPstream::msgType();
@ -255,13 +255,13 @@ Foam::regionModels::regionModel::interRegionAMI
interRegionAMI_[nbrRegionID].set
(
regionPatchi,
new AMIPatchToPatchInterpolation
new AMIInterpolation
(
p,
nbrP,
faceAreaIntersect::tmMesh,
true,
AMIPatchToPatchInterpolation::imFaceAreaWeight,
AMIInterpolation::imFaceAreaWeight,
-1,
flip
)

5
src/regionModels/regionModel/regionModel/regionModel.H
View File

@ -128,8 +128,7 @@ protected:
mutable wordList interRegionAMINames_;
//- List of AMI objects per coupled region
mutable PtrList<PtrList<AMIPatchToPatchInterpolation>>
interRegionAMI_;
mutable PtrList<PtrList<AMIInterpolation>> interRegionAMI_;
// Protected member functions
@ -141,7 +140,7 @@ protected:
virtual bool read(const dictionary& dict);
//- Create or return a new inter-region AMI object
virtual const AMIPatchToPatchInterpolation& interRegionAMI
virtual const AMIInterpolation& interRegionAMI
(
const regionModel& nbrRegion,
const label regionPatchi,

6
src/regionModels/regionModel/regionModel/regionModelTemplates.C
View File

@ -37,7 +37,7 @@ Foam::regionModels::regionModel::mapRegionPatchField
int oldTag = UPstream::msgType();
UPstream::msgType() = oldTag + 1;
const AMIPatchToPatchInterpolation& ami =
const AMIInterpolation& ami =
interRegionAMI(nbrRegion, regionPatchi, nbrPatchi, flip);
tmp<Field<Type>> tresult(ami.interpolateToSource(nbrField));
@ -69,7 +69,7 @@ Foam::regionModels::regionModel::mapRegionPatchField
int oldTag = UPstream::msgType();
UPstream::msgType() = oldTag + 1;
const AMIPatchToPatchInterpolation& ami =
const AMIInterpolation& ami =
interRegionAMI(nbrRegion, regionPatchi, nbrPatchi, flip);
const fieldType& nbrField =
@ -121,7 +121,7 @@ Foam::regionModels::regionModel::mapRegionPatchInternalField
int oldTag = UPstream::msgType();
UPstream::msgType() = oldTag + 1;
const AMIPatchToPatchInterpolation& ami =
const AMIInterpolation& ami =
interRegionAMI(nbrRegion, regionPatchi, nbrPatchi, flip);
const fieldType& nbrField =

36
src/sampling/meshToMesh/meshToMesh.C
View File

@ -56,7 +56,7 @@ namespace Foam
template<>
void Foam::meshToMesh::mapAndOpSrcToTgt
(
const AMIPatchToPatchInterpolation& AMI,
const AMIInterpolation& AMI,
const Field<scalar>& srcField,
Field<scalar>& tgtField,
const plusEqOp<scalar>& cop
@ -67,7 +67,7 @@ void Foam::meshToMesh::mapAndOpSrcToTgt
template<>
void Foam::meshToMesh::mapAndOpSrcToTgt
(
const AMIPatchToPatchInterpolation& AMI,
const AMIInterpolation& AMI,
const Field<vector>& srcField,
Field<vector>& tgtField,
const plusEqOp<vector>& cop
@ -78,7 +78,7 @@ void Foam::meshToMesh::mapAndOpSrcToTgt
template<>
void Foam::meshToMesh::mapAndOpSrcToTgt
(
const AMIPatchToPatchInterpolation& AMI,
const AMIInterpolation& AMI,
const Field<sphericalTensor>& srcField,
Field<sphericalTensor>& tgtField,
const plusEqOp<sphericalTensor>& cop
@ -89,7 +89,7 @@ void Foam::meshToMesh::mapAndOpSrcToTgt
template<>
void Foam::meshToMesh::mapAndOpSrcToTgt
(
const AMIPatchToPatchInterpolation& AMI,
const AMIInterpolation& AMI,
const Field<symmTensor>& srcField,
Field<symmTensor>& tgtField,
const plusEqOp<symmTensor>& cop
@ -100,7 +100,7 @@ void Foam::meshToMesh::mapAndOpSrcToTgt
template<>
void Foam::meshToMesh::mapAndOpSrcToTgt
(
const AMIPatchToPatchInterpolation& AMI,
const AMIInterpolation& AMI,
const Field<tensor>& srcField,
Field<tensor>& tgtField,
const plusEqOp<tensor>& cop
@ -111,7 +111,7 @@ void Foam::meshToMesh::mapAndOpSrcToTgt
template<>
void Foam::meshToMesh::mapAndOpTgtToSrc
(
const AMIPatchToPatchInterpolation& AMI,
const AMIInterpolation& AMI,
Field<scalar>& srcField,
const Field<scalar>& tgtField,
const plusEqOp<scalar>& cop
@ -122,7 +122,7 @@ void Foam::meshToMesh::mapAndOpTgtToSrc
template<>
void Foam::meshToMesh::mapAndOpTgtToSrc
(
const AMIPatchToPatchInterpolation& AMI,
const AMIInterpolation& AMI,
Field<vector>& srcField,
const Field<vector>& tgtField,
const plusEqOp<vector>& cop
@ -133,7 +133,7 @@ void Foam::meshToMesh::mapAndOpTgtToSrc
template<>
void Foam::meshToMesh::mapAndOpTgtToSrc
(
const AMIPatchToPatchInterpolation& AMI,
const AMIInterpolation& AMI,
Field<sphericalTensor>& srcField,
const Field<sphericalTensor>& tgtField,
const plusEqOp<sphericalTensor>& cop
@ -144,7 +144,7 @@ void Foam::meshToMesh::mapAndOpTgtToSrc
template<>
void Foam::meshToMesh::mapAndOpTgtToSrc
(
const AMIPatchToPatchInterpolation& AMI,
const AMIInterpolation& AMI,
Field<symmTensor>& srcField,
const Field<symmTensor>& tgtField,
const plusEqOp<symmTensor>& cop
@ -155,7 +155,7 @@ void Foam::meshToMesh::mapAndOpTgtToSrc
template<>
void Foam::meshToMesh::mapAndOpTgtToSrc
(
const AMIPatchToPatchInterpolation& AMI,
const AMIInterpolation& AMI,
Field<tensor>& srcField,
const Field<tensor>& tgtField,
const plusEqOp<tensor>& cop
@ -458,24 +458,24 @@ void Foam::meshToMesh::calculate(const word& methodName)
}
Foam::AMIPatchToPatchInterpolation::interpolationMethod
Foam::AMIInterpolation::interpolationMethod
Foam::meshToMesh::interpolationMethodAMI(const interpolationMethod method)
{
switch (method)
{
case imDirect:
{
return AMIPatchToPatchInterpolation::imDirect;
return AMIInterpolation::imDirect;
break;
}
case imMapNearest:
{
return AMIPatchToPatchInterpolation::imMapNearest;
return AMIInterpolation::imMapNearest;
break;
}
case imCellVolumeWeight:
{
return AMIPatchToPatchInterpolation::imFaceAreaWeight;
return AMIInterpolation::imFaceAreaWeight;
break;
}
default:
@ -486,7 +486,7 @@ Foam::meshToMesh::interpolationMethodAMI(const interpolationMethod method)
}
}
return AMIPatchToPatchInterpolation::imDirect;
return AMIInterpolation::imDirect;
}
@ -519,7 +519,7 @@ void Foam::meshToMesh::calculatePatchAMIs(const word& AMIMethodName)
patchAMIs_.set
(
i,
new AMIPatchToPatchInterpolation
new AMIInterpolation
(
srcPP,
tgtPP,
@ -659,7 +659,7 @@ Foam::meshToMesh::meshToMesh
constructNoCuttingPatches
(
interpolationMethodNames_[method],
AMIPatchToPatchInterpolation::interpolationMethodToWord
AMIInterpolation::interpolationMethodToWord
(
interpolationMethodAMI(method)
),
@ -723,7 +723,7 @@ Foam::meshToMesh::meshToMesh
constructFromCuttingPatches
(
interpolationMethodNames_[method],
AMIPatchToPatchInterpolation::interpolationMethodToWord
AMIInterpolation::interpolationMethodToWord
(
interpolationMethodAMI(method)
),

37
src/sampling/meshToMesh/meshToMesh.H
View File

@ -47,7 +47,7 @@ SourceFiles
#include "mapDistribute.H"
#include "volFieldsFwd.H"
#include "NamedEnum.H"
#include "AMIPatchToPatchInterpolation.H"
#include "AMIInterpolation.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -92,7 +92,7 @@ private:
List<label> tgtPatchID_;
//- List of AMIs between source and target patches
PtrList<AMIPatchToPatchInterpolation> patchAMIs_;
PtrList<AMIInterpolation> patchAMIs_;
//- Cutting patches whose values are set using a zero-gradient condition
List<label> cuttingPatches_;
@ -134,7 +134,7 @@ private:
template<class Type, class CombineOp>
void mapAndOpSrcToTgt
(
const AMIPatchToPatchInterpolation& AMI,
const AMIInterpolation& AMI,
const Field<Type>& srcField,
Field<Type>& tgtField,
const CombineOp& cop
@ -145,7 +145,7 @@ private:
template<class Type, class CombineOp>
void mapAndOpTgtToSrc
(
const AMIPatchToPatchInterpolation& AMI,
const AMIInterpolation& AMI,
Field<Type>& srcField,
const Field<Type>& tgtField,
const CombineOp& cop
@ -195,7 +195,7 @@ private:
);
//- Return the list of AMIs between source and target patches
inline const PtrList<AMIPatchToPatchInterpolation>&
inline const PtrList<AMIInterpolation>&
patchAMIs() const;
@ -338,11 +338,8 @@ public:
inline scalar V() const;
//- Conversion between mesh and patch interpolation methods
static AMIPatchToPatchInterpolation::interpolationMethod
interpolationMethodAMI
(
const interpolationMethod method
);
static AMIInterpolation::interpolationMethod
interpolationMethodAMI(const interpolationMethod method);
// Evaluation
@ -551,7 +548,7 @@ public:
template<>
void meshToMesh::mapAndOpSrcToTgt
(
const AMIPatchToPatchInterpolation& AMI,
const AMIInterpolation& AMI,
const Field<scalar>& srcField,
Field<scalar>& tgtField,
const plusEqOp<scalar>& cop
@ -559,7 +556,7 @@ void meshToMesh::mapAndOpSrcToTgt
template<>
void meshToMesh::mapAndOpSrcToTgt
(
const AMIPatchToPatchInterpolation& AMI,
const AMIInterpolation& AMI,
const Field<vector>& srcField,
Field<vector>& tgtField,
const plusEqOp<vector>& cop
@ -567,7 +564,7 @@ void meshToMesh::mapAndOpSrcToTgt
template<>
void meshToMesh::mapAndOpSrcToTgt
(
const AMIPatchToPatchInterpolation& AMI,
const AMIInterpolation& AMI,
const Field<sphericalTensor>& srcField,
Field<sphericalTensor>& tgtField,
const plusEqOp<sphericalTensor>& cop
@ -575,7 +572,7 @@ void meshToMesh::mapAndOpSrcToTgt
template<>
void meshToMesh::mapAndOpSrcToTgt
(
const AMIPatchToPatchInterpolation& AMI,
const AMIInterpolation& AMI,
const Field<symmTensor>& srcField,
Field<symmTensor>& tgtField,
const plusEqOp<symmTensor>& cop
@ -583,7 +580,7 @@ void meshToMesh::mapAndOpSrcToTgt
template<>
void meshToMesh::mapAndOpSrcToTgt
(
const AMIPatchToPatchInterpolation& AMI,
const AMIInterpolation& AMI,
const Field<tensor>& srcField,
Field<tensor>& tgtField,
const plusEqOp<tensor>& cop
@ -593,7 +590,7 @@ void meshToMesh::mapAndOpSrcToTgt
template<>
void meshToMesh::mapAndOpTgtToSrc
(
const AMIPatchToPatchInterpolation& AMI,
const AMIInterpolation& AMI,
Field<scalar>& srcField,
const Field<scalar>& tgtField,
const plusEqOp<scalar>& cop
@ -601,7 +598,7 @@ void meshToMesh::mapAndOpTgtToSrc
template<>
void meshToMesh::mapAndOpTgtToSrc
(
const AMIPatchToPatchInterpolation& AMI,
const AMIInterpolation& AMI,
Field<vector>& srcField,
const Field<vector>& tgtField,
const plusEqOp<vector>& cop
@ -609,7 +606,7 @@ void meshToMesh::mapAndOpTgtToSrc
template<>
void meshToMesh::mapAndOpTgtToSrc
(
const AMIPatchToPatchInterpolation& AMI,
const AMIInterpolation& AMI,
Field<sphericalTensor>& srcField,
const Field<sphericalTensor>& tgtField,
const plusEqOp<sphericalTensor>& cop
@ -617,7 +614,7 @@ void meshToMesh::mapAndOpTgtToSrc
template<>
void meshToMesh::mapAndOpTgtToSrc
(
const AMIPatchToPatchInterpolation& AMI,
const AMIInterpolation& AMI,
Field<symmTensor>& srcField,
const Field<symmTensor>& tgtField,
const plusEqOp<symmTensor>& cop
@ -625,7 +622,7 @@ void meshToMesh::mapAndOpTgtToSrc
template<>
void meshToMesh::mapAndOpTgtToSrc
(
const AMIPatchToPatchInterpolation& AMI,
const AMIInterpolation& AMI,
Field<tensor>& srcField,
const Field<tensor>& tgtField,
const plusEqOp<tensor>& cop

2
src/sampling/meshToMesh/meshToMeshI.H
View File

@ -73,7 +73,7 @@ inline Foam::scalar Foam::meshToMesh::V() const
}
inline const Foam::PtrList<Foam::AMIPatchToPatchInterpolation>&
inline const Foam::PtrList<Foam::AMIInterpolation>&
Foam::meshToMesh::patchAMIs() const
{
return patchAMIs_;

8
src/sampling/meshToMesh/meshToMeshTemplates.C
View File

@ -320,7 +320,7 @@ Foam::tmp<Foam::Field<Type>> Foam::meshToMesh::mapTgtToSrc
template<class Type, class CombineOp>
void Foam::meshToMesh::mapAndOpSrcToTgt
(
const AMIPatchToPatchInterpolation& AMI,
const AMIInterpolation& AMI,
const Field<Type>& srcField,
Field<Type>& tgtField,
const CombineOp& cop
@ -348,7 +348,7 @@ void Foam::meshToMesh::mapSrcToTgt
{
mapSrcToTgt(field, cop, result.primitiveFieldRef());
const PtrList<AMIPatchToPatchInterpolation>& AMIList = patchAMIs();
const PtrList<AMIInterpolation>& AMIList = patchAMIs();
typename GeometricField<Type, fvPatchField, volMesh>::
Boundary& resultBf = result.boundaryFieldRef();
@ -528,7 +528,7 @@ Foam::meshToMesh::mapSrcToTgt
template<class Type, class CombineOp>
void Foam::meshToMesh::mapAndOpTgtToSrc
(
const AMIPatchToPatchInterpolation& AMI,
const AMIInterpolation& AMI,
Field<Type>& srcField,
const Field<Type>& tgtField,
const CombineOp& cop
@ -556,7 +556,7 @@ void Foam::meshToMesh::mapTgtToSrc
{
mapTgtToSrc(field, cop, result.primitiveFieldRef());
const PtrList<AMIPatchToPatchInterpolation>& AMIList = patchAMIs();
const PtrList<AMIInterpolation>& AMIList = patchAMIs();
forAll(AMIList, i)
{

4
wmake/rules/linux64Gcc/c
View File

@ -12,5 +12,5 @@ ctoo = $(WM_SCHEDULER) $(cc) $(cFLAGS) -c $< -o $@
LINK_LIBS = $(cDBUG)
LINKLIBSO = $(cc) -shared
LINKEXE = $(cc) -Xlinker --add-needed -Xlinker -z -Xlinker nodefs
LINKLIBSO = $(cc) -fuse-ld=bfd -shared
LINKEXE = $(cc) -fuse-ld=bfd -Xlinker --add-needed -Xlinker -z -Xlinker nodefs

4
wmake/rules/linux64Gcc/c++
View File

@ -21,5 +21,5 @@ cpptoo = $(Ctoo)
LINK_LIBS = $(c++DBUG)
LINKLIBSO = $(CC) $(c++FLAGS) -shared -Xlinker --add-needed -Xlinker --no-as-needed
LINKEXE = $(CC) $(c++FLAGS) -Xlinker --add-needed -Xlinker --no-as-needed
LINKLIBSO = $(CC) $(c++FLAGS) -fuse-ld=bfd -shared -Xlinker --add-needed -Xlinker --no-as-needed
LINKEXE = $(CC) $(c++FLAGS) -fuse-ld=bfd -Xlinker --add-needed -Xlinker --no-as-needed

4
wmake/rules/linux64GccKNL/c
View File

@ -12,5 +12,5 @@ ctoo = $(WM_SCHEDULER) $(cc) $(cFLAGS) -c $< -o $@
LINK_LIBS = $(cDBUG)
LINKLIBSO = $(cc) -shared
LINKEXE = $(cc) -Xlinker --add-needed -Xlinker -z -Xlinker nodefs
LINKLIBSO = $(cc) -fuse-ld=bfd -shared
LINKEXE = $(cc) -fuse-ld=bfd -Xlinker --add-needed -Xlinker -z -Xlinker nodefs

4
wmake/rules/linux64GccKNL/c++
View File

@ -21,5 +21,5 @@ cpptoo = $(Ctoo)
LINK_LIBS = $(c++DBUG)
LINKLIBSO = $(CC) $(c++FLAGS) -shared -Xlinker --add-needed -Xlinker --no-as-needed
LINKEXE = $(CC) $(c++FLAGS) -Xlinker --add-needed -Xlinker --no-as-needed
LINKLIBSO = $(CC) $(c++FLAGS) -fuse-ld=bfd -shared -Xlinker --add-needed -Xlinker --no-as-needed
LINKEXE = $(CC) $(c++FLAGS) -fuse-ld=bfd -Xlinker --add-needed -Xlinker --no-as-needed

4
wmake/rules/linuxARM7Gcc/c
View File

@ -12,5 +12,5 @@ ctoo = $(WM_SCHEDULER) $(cc) $(cFLAGS) -c $< -o $@
LINK_LIBS = $(cDBUG)
LINKLIBSO = $(cc) -shared
LINKEXE = $(cc) -Xlinker --add-needed -Xlinker -z -Xlinker nodefs
LINKLIBSO = $(cc) -fuse-ld=bfd -shared
LINKEXE = $(cc) -fuse-ld=bfd -Xlinker --add-needed -Xlinker -z -Xlinker nodefs

4
wmake/rules/linuxARM7Gcc/c++
View File

@ -21,5 +21,5 @@ cpptoo = $(Ctoo)
LINK_LIBS = $(c++DBUG)
LINKLIBSO = $(CC) $(c++FLAGS) -shared -Xlinker --add-needed -Xlinker --no-as-needed
LINKEXE = $(CC) $(c++FLAGS) -Xlinker --add-needed -Xlinker --no-as-needed
LINKLIBSO = $(CC) $(c++FLAGS) -fuse-ld=bfd -shared -Xlinker --add-needed -Xlinker --no-as-needed
LINKEXE = $(CC) $(c++FLAGS) -fuse-ld=bfd -Xlinker --add-needed -Xlinker --no-as-needed

4
wmake/rules/linuxGcc/c
View File

@ -12,5 +12,5 @@ ctoo = $(WM_SCHEDULER) $(cc) $(cFLAGS) -c $< -o $@
LINK_LIBS = $(cDBUG)
LINKLIBSO = $(cc) -shared
LINKEXE = $(cc) -Xlinker --add-needed -Xlinker -z -Xlinker nodefs
LINKLIBSO = $(cc) -fuse-ld=bfd -shared
LINKEXE = $(cc) -fuse-ld=bfd -Xlinker --add-needed -Xlinker -z -Xlinker nodefs

4
wmake/rules/linuxGcc/c++
View File

@ -21,5 +21,5 @@ cpptoo = $(Ctoo)
LINK_LIBS = $(c++DBUG)
LINKLIBSO = $(CC) $(c++FLAGS) -shared -Xlinker --add-needed -Xlinker --no-as-needed
LINKEXE = $(CC) $(c++FLAGS) -Xlinker --add-needed -Xlinker --no-as-needed
LINKLIBSO = $(CC) $(c++FLAGS) -fuse-ld=bfd -shared -Xlinker --add-needed -Xlinker --no-as-needed
LINKEXE = $(CC) $(c++FLAGS) -fuse-ld=bfd -Xlinker --add-needed -Xlinker --no-as-needed

4
wmake/rules/linuxIA64Gcc/c
View File

@ -12,5 +12,5 @@ ctoo = $(WM_SCHEDULER) $(cc) $(cFLAGS) -c $< -o $@
LINK_LIBS = $(cDBUG)
LINKLIBSO = $(cc) -shared
LINKEXE = $(cc) -Xlinker --add-needed -Xlinker -z -Xlinker nodefs
LINKLIBSO = $(cc) -fuse-ld=bfd -shared
LINKEXE = $(cc) -fuse-ld=bfd -Xlinker --add-needed -Xlinker -z -Xlinker nodefs

4
wmake/rules/linuxIA64Gcc/c++
View File

@ -21,5 +21,5 @@ cpptoo = $(Ctoo)
LINK_LIBS = $(c++DBUG)
LINKLIBSO = $(CC) $(c++FLAGS) -shared
LINKEXE = $(CC) $(c++FLAGS) -Xlinker --add-needed
LINKLIBSO = $(CC) $(c++FLAGS) -fuse-ld=bfd -shared
LINKEXE = $(CC) $(c++FLAGS) -fuse-ld=bfd -Xlinker --add-needed

4
wmake/rules/linuxPPC64Gcc/c
View File

@ -12,5 +12,5 @@ ctoo = $(WM_SCHEDULER) $(cc) $(cFLAGS) -c $< -o $@
LINK_LIBS = $(cDBUG)
LINKLIBSO = $(cc) -shared
LINKEXE = $(cc) -Xlinker --add-needed -Xlinker -z -Xlinker nodefs
LINKLIBSO = $(cc) -fuse-ld=bfd -shared
LINKEXE = $(cc) -fuse-ld=bfd -Xlinker --add-needed -Xlinker -z -Xlinker nodefs

4
wmake/rules/linuxPPC64Gcc/c++
View File

@ -21,5 +21,5 @@ cpptoo = $(Ctoo)
LINK_LIBS = $(c++DBUG)
LINKLIBSO = $(CC) $(c++FLAGS) -shared
LINKEXE = $(CC) $(c++FLAGS) -Xlinker --add-needed
LINKLIBSO = $(CC) $(c++FLAGS) -fuse-ld=bfd -shared
LINKEXE = $(CC) $(c++FLAGS) -fuse-ld=bfd -Xlinker --add-needed

4
wmake/rules/linuxPPC64leGcc/c
View File

@ -12,5 +12,5 @@ ctoo = $(WM_SCHEDULER) $(cc) $(cFLAGS) -c $< -o $@
LINK_LIBS = $(cDBUG)
LINKLIBSO = $(cc) -shared
LINKEXE = $(cc) -Xlinker --add-needed -Xlinker -z -Xlinker nodefs
LINKLIBSO = $(cc) -fuse-ld=bfd -shared
LINKEXE = $(cc) -fuse-ld=bfd -Xlinker --add-needed -Xlinker -z -Xlinker nodefs

4
wmake/rules/linuxPPC64leGcc/c++
View File

@ -21,5 +21,5 @@ cpptoo = $(Ctoo)
LINK_LIBS = $(c++DBUG)
LINKLIBSO = $(CC) $(c++FLAGS) -shared -Xlinker --add-needed -Xlinker --no-as-needed
LINKEXE = $(CC) $(c++FLAGS) -Xlinker --add-needed -Xlinker --no-as-needed
LINKLIBSO = $(CC) $(c++FLAGS) -fuse-ld=bfd -shared -Xlinker --add-needed -Xlinker --no-as-needed
LINKEXE = $(CC) $(c++FLAGS) -fuse-ld=bfd -Xlinker --add-needed -Xlinker --no-as-needed