Merge branch 'master' of ssh://dm/home/dm4/OpenFOAM/repositories/OpenFOAM-dev

This commit is contained in:
Henry 2014-01-14 23:10:18 +00:00
commit e39100093f
17 changed files with 496 additions and 124 deletions

View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -30,6 +30,15 @@ License
#include "dlLibraryTable.H" #include "dlLibraryTable.H"
#include "PstreamReduceOps.H" #include "PstreamReduceOps.H"
#include "OSspecific.H" #include "OSspecific.H"
#include "regIOobject.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
namespace Foam
{
defineTypeNameAndDebug(codedBase, 0);
}
// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * // // * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
@ -169,7 +178,9 @@ void Foam::codedBase::createLibrary
const dynamicCodeContext& context const dynamicCodeContext& context
) const ) const
{ {
bool create = Pstream::master(); bool create =
Pstream::master()
|| (regIOobject::fileModificationSkew <= 0); // not NFS
if (create) if (create)
{ {
@ -206,6 +217,71 @@ void Foam::codedBase::createLibrary
// all processes must wait for compile to finish // all processes must wait for compile to finish
if (regIOobject::fileModificationSkew > 0)
{
//- Since the library has only been compiled on the master the
// other nodes need to pick this library up through NFS
// We do this by just polling a few times using the
// fileModificationSkew.
const fileName libPath = dynCode.libPath();
off_t mySize = Foam::fileSize(libPath);
off_t masterSize = mySize;
Pstream::scatter(masterSize);
if (debug)
{
Pout<< endl<< "on processor " << Pstream::myProcNo()
<< " have masterSize:" << masterSize
<< " and localSize:" << mySize
<< endl;
}
if (mySize < masterSize)
{
if (debug)
{
Pout<< "Local file " << libPath
<< " not of same size (" << mySize
<< ") as master ("
<< masterSize << "). Waiting for "
<< regIOobject::fileModificationSkew
<< " seconds." << endl;
}
Foam::sleep(regIOobject::fileModificationSkew);
// Recheck local size
mySize = Foam::fileSize(libPath);
if (mySize < masterSize)
{
FatalIOErrorIn
(
"functionEntries::codeStream::execute(..)",
context.dict()
) << "Cannot read (NFS mounted) library " << nl
<< libPath << nl
<< "on processor " << Pstream::myProcNo()
<< " detected size " << mySize
<< " whereas master size is " << masterSize
<< " bytes." << nl
<< "If your case is not NFS mounted"
<< " (so distributed) set fileModificationSkew"
<< " to 0"
<< exit(FatalIOError);
}
}
if (debug)
{
Pout<< endl<< "on processor " << Pstream::myProcNo()
<< " after waiting: have masterSize:" << masterSize
<< " and localSize:" << mySize
<< endl;
}
}
reduce(create, orOp<bool>()); reduce(create, orOp<bool>());
} }

View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -119,6 +119,10 @@ protected:
public: public:
//- Runtime type information
ClassName("codedBase");
// Constructors // Constructors
//- Construct null //- Construct null

View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -31,6 +31,7 @@ License
#include "OBJstream.H" #include "OBJstream.H"
#include "DynamicField.H" #include "DynamicField.H"
#include "edgeMeshFormatsCore.H" #include "edgeMeshFormatsCore.H"
#include "IOmanip.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * // // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -1459,23 +1460,41 @@ void Foam::extendedEdgeMesh::writeStats(Ostream& os) const
{ {
edgeMesh::writeStats(os); edgeMesh::writeStats(os);
os << indent << "point offsets :" << nl; os << indent << "point classification (size and offset) :" << nl;
os << incrIndent; os << incrIndent;
os << indent << "convex feature points : " << convexStart_ << nl; os << indent << "convex feature points : "
os << indent << "concave feature points : " << concaveStart_ << nl; << setw(8) << concaveStart_-convexStart_
os << indent << "mixed feature points : " << mixedStart_ << nl; << setw(8) << convexStart_ << nl;
os << indent << "other (non-feature) points : " << nonFeatureStart_ << nl; os << indent << "concave feature points : "
<< setw(8) << mixedStart_-concaveStart_
<< setw(8) << concaveStart_ << nl;
os << indent << "mixed feature points : "
<< setw(8) << nonFeatureStart_-mixedStart_
<< setw(8) << mixedStart_ << nl;
os << indent << "other (non-feature) points : "
<< setw(8) << points().size()-nonFeatureStart_
<< setw(8) << nonFeatureStart_ << nl;
os << decrIndent; os << decrIndent;
os << indent << "edge offsets :" << nl; os << indent << "edge classification (size and offset) :" << nl;
os << incrIndent; os << incrIndent;
os << indent << "external (convex angle) edges : " << externalStart_ os << indent << "external (convex angle) edges : "
<< setw(8) << internalStart_-externalStart_
<< setw(8) << externalStart_
<< nl; << nl;
os << indent << "internal (concave angle) edges : " << internalStart_ os << indent << "internal (concave angle) edges : "
<< setw(8) << flatStart_-internalStart_
<< setw(8) << internalStart_
<< nl; << nl;
os << indent << "flat region edges : " << flatStart_ << nl; os << indent << "flat region edges : "
os << indent << "open edges : " << openStart_ << nl; << setw(8) << openStart_-flatStart_
os << indent << "multiply connected edges : " << multipleStart_ << setw(8) << flatStart_ << nl;
os << indent << "open edges : "
<< setw(8) << multipleStart_-openStart_
<< setw(8) << openStart_ << nl;
os << indent << "multiply connected edges : "
<< setw(8) << edges().size()-multipleStart_
<< setw(8) << multipleStart_
<< nl; << nl;
os << decrIndent; os << decrIndent;
} }

View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -23,9 +23,6 @@ License
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#include "cyclicAMIFvPatchField.H"
#include "transformField.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type> template<class Type>
@ -157,7 +154,15 @@ Foam::cyclicAMIFvPatchField<Type>::patchNeighbourField() const
Field<Type> pnf(iField, nbrFaceCells); Field<Type> pnf(iField, nbrFaceCells);
tmp<Field<Type> > tpnf(new Field<Type>(cyclicAMIPatch_.interpolate(pnf))); tmp<Field<Type> > tpnf;
if (cyclicAMIPatch_.applyLowWeightCorrection())
{
tpnf = cyclicAMIPatch_.interpolate(pnf, this->patchInternalField()());
}
else
{
tpnf = cyclicAMIPatch_.interpolate(pnf);
}
if (doTransform()) if (doTransform())
{ {
@ -203,7 +208,15 @@ void Foam::cyclicAMIFvPatchField<Type>::updateInterfaceMatrix
// Transform according to the transformation tensors // Transform according to the transformation tensors
transformCoupleField(pnf, cmpt); transformCoupleField(pnf, cmpt);
pnf = cyclicAMIPatch_.interpolate(pnf); if (cyclicAMIPatch_.applyLowWeightCorrection())
{
scalarField pif(psiInternal, cyclicAMIPatch_.faceCells());
pnf = cyclicAMIPatch_.interpolate(pnf, pif);
}
else
{
pnf = cyclicAMIPatch_.interpolate(pnf);
}
// Multiply the field by coefficients and add into the result // Multiply the field by coefficients and add into the result
const labelUList& faceCells = cyclicAMIPatch_.faceCells(); const labelUList& faceCells = cyclicAMIPatch_.faceCells();
@ -232,7 +245,15 @@ void Foam::cyclicAMIFvPatchField<Type>::updateInterfaceMatrix
// Transform according to the transformation tensors // Transform according to the transformation tensors
transformCoupleField(pnf); transformCoupleField(pnf);
pnf = cyclicAMIPatch_.interpolate(pnf); if (cyclicAMIPatch_.applyLowWeightCorrection())
{
Field<Type> pif(psiInternal, cyclicAMIPatch_.faceCells());
pnf = cyclicAMIPatch_.interpolate(pnf, pif);
}
else
{
pnf = cyclicAMIPatch_.interpolate(pnf);
}
// Multiply the field by coefficients and add into the result // Multiply the field by coefficients and add into the result
const labelUList& faceCells = cyclicAMIPatch_.faceCells(); const labelUList& faceCells = cyclicAMIPatch_.faceCells();

View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -55,7 +55,11 @@ void Foam::cyclicAMIFvPatch::makeWeights(scalarField& w) const
const scalarField nbrDeltas const scalarField nbrDeltas
( (
interpolate(nbrPatch.nf() & nbrPatch.fvPatch::delta()) interpolate
(
nbrPatch.nf() & nbrPatch.fvPatch::delta(),
scalarField(this->size(), 1.0)
)
); );
forAll(deltas, faceI) forAll(deltas, faceI)
@ -82,7 +86,14 @@ Foam::tmp<Foam::vectorField> Foam::cyclicAMIFvPatch::delta() const
{ {
const vectorField patchD(fvPatch::delta()); const vectorField patchD(fvPatch::delta());
const vectorField nbrPatchD(interpolate(nbrPatch.fvPatch::delta())); const vectorField nbrPatchD
(
interpolate
(
nbrPatch.fvPatch::delta(),
vectorField(this->size(), vector::zero)
)
);
tmp<vectorField> tpdv(new vectorField(patchD.size())); tmp<vectorField> tpdv(new vectorField(patchD.size()));
vectorField& pdv = tpdv(); vectorField& pdv = tpdv();

View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -154,16 +154,29 @@ public:
//- Return delta (P to N) vectors across coupled patch //- Return delta (P to N) vectors across coupled patch
virtual tmp<vectorField> delta() const; virtual tmp<vectorField> delta() const;
template<class Type> bool applyLowWeightCorrection() const
tmp<Field<Type> > interpolate(const Field<Type>& fld) const
{ {
return cyclicAMIPolyPatch_.interpolate(fld); return cyclicAMIPolyPatch_.applyLowWeightCorrection();
} }
template<class Type> template<class Type>
tmp<Field<Type> > interpolate(const tmp<Field<Type> >& tFld) const tmp<Field<Type> > interpolate
(
const Field<Type>& fld,
const UList<Type>& defaultValues = UList<Type>()
) const
{ {
return cyclicAMIPolyPatch_.interpolate(tFld); return cyclicAMIPolyPatch_.interpolate(fld, defaultValues);
}
template<class Type>
tmp<Field<Type> > interpolate
(
const tmp<Field<Type> >& tFld,
const UList<Type>& defaultValues = UList<Type>()
) const
{
return cyclicAMIPolyPatch_.interpolate(tFld, defaultValues);
} }

View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -201,11 +201,14 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
scalarListList& wght, scalarListList& wght,
scalarField& wghtSum, scalarField& wghtSum,
const bool conformal, const bool conformal,
const bool output const bool output,
const scalar lowWeightTol
) )
{ {
// Normalise the weights // Normalise the weights
wghtSum.setSize(wght.size()); wghtSum.setSize(wght.size());
label nLowWeight = 0;
forAll(wght, faceI) forAll(wght, faceI)
{ {
scalarList& w = wght[faceI]; scalarList& w = wght[faceI];
@ -225,6 +228,11 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
} }
wghtSum[faceI] = t; wghtSum[faceI] = t;
if (t < lowWeightTol)
{
nLowWeight++;
}
} }
@ -241,6 +249,13 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
<< gAverage(wghtSum) << endl; << gAverage(wghtSum) << endl;
} }
} }
if (debug && nLowWeight)
{
Pout<< "AMI: Identified " << nLowWeight
<< " faces with weights less than " << lowWeightTol
<< endl;
}
} }
@ -502,7 +517,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::agglomerate
srcWeights, srcWeights,
srcWeightsSum, srcWeightsSum,
true, true,
false false,
-1
); );
} }
@ -516,12 +532,14 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
const TargetPatch& tgtPatch, const TargetPatch& tgtPatch,
const faceAreaIntersect::triangulationMode& triMode, const faceAreaIntersect::triangulationMode& triMode,
const interpolationMethod& method, const interpolationMethod& method,
const scalar lowWeightCorrection,
const bool reverseTarget const bool reverseTarget
) )
: :
method_(method), method_(method),
reverseTarget_(reverseTarget), reverseTarget_(reverseTarget),
singlePatchProc_(-999), singlePatchProc_(-999),
lowWeightCorrection_(lowWeightCorrection),
srcAddress_(), srcAddress_(),
srcWeights_(), srcWeights_(),
srcWeightsSum_(), srcWeightsSum_(),
@ -544,12 +562,14 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
const autoPtr<searchableSurface>& surfPtr, const autoPtr<searchableSurface>& surfPtr,
const faceAreaIntersect::triangulationMode& triMode, const faceAreaIntersect::triangulationMode& triMode,
const interpolationMethod& method, const interpolationMethod& method,
const scalar lowWeightCorrection,
const bool reverseTarget const bool reverseTarget
) )
: :
method_(method), method_(method),
reverseTarget_(reverseTarget), reverseTarget_(reverseTarget),
singlePatchProc_(-999), singlePatchProc_(-999),
lowWeightCorrection_(lowWeightCorrection),
srcAddress_(), srcAddress_(),
srcWeights_(), srcWeights_(),
srcWeightsSum_(), srcWeightsSum_(),
@ -632,6 +652,7 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::AMIInterpolation
method_(fineAMI.method_), method_(fineAMI.method_),
reverseTarget_(fineAMI.reverseTarget_), reverseTarget_(fineAMI.reverseTarget_),
singlePatchProc_(fineAMI.singlePatchProc_), singlePatchProc_(fineAMI.singlePatchProc_),
lowWeightCorrection_(-1.0),
srcAddress_(), srcAddress_(),
srcWeights_(), srcWeights_(),
srcWeightsSum_(), srcWeightsSum_(),
@ -908,7 +929,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
srcWeights_, srcWeights_,
srcWeightsSum_, srcWeightsSum_,
AMIPtr->conformal(), AMIPtr->conformal(),
true true,
lowWeightCorrection_
); );
normaliseWeights normaliseWeights
( (
@ -918,7 +940,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
tgtWeights_, tgtWeights_,
tgtWeightsSum_, tgtWeightsSum_,
AMIPtr->conformal(), AMIPtr->conformal(),
true true,
lowWeightCorrection_
); );
// cache maps and reset addresses // cache maps and reset addresses
@ -965,7 +988,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
srcWeights_, srcWeights_,
srcWeightsSum_, srcWeightsSum_,
AMIPtr->conformal(), AMIPtr->conformal(),
true true,
lowWeightCorrection_
); );
normaliseWeights normaliseWeights
( (
@ -975,7 +999,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::update
tgtWeights_, tgtWeights_,
tgtWeightsSum_, tgtWeightsSum_,
AMIPtr->conformal(), AMIPtr->conformal(),
true true,
lowWeightCorrection_
); );
} }
@ -998,7 +1023,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
( (
const UList<Type>& fld, const UList<Type>& fld,
const CombineOp& cop, const CombineOp& cop,
List<Type>& result List<Type>& result,
const UList<Type>& defaultValues
) const ) const
{ {
if (fld.size() != srcAddress_.size()) if (fld.size() != srcAddress_.size())
@ -1009,7 +1035,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
"(" "("
"const UList<Type>&, " "const UList<Type>&, "
"const CombineOp&, " "const CombineOp&, "
"List<Type>&" "List<Type>&, "
"const UList<Type>&"
") const" ") const"
) << "Supplied field size is not equal to source patch size" << nl ) << "Supplied field size is not equal to source patch size" << nl
<< " source patch = " << srcAddress_.size() << nl << " source patch = " << srcAddress_.size() << nl
@ -1018,6 +1045,29 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
<< abort(FatalError); << abort(FatalError);
} }
if (lowWeightCorrection_ > 0)
{
if (defaultValues.size() != tgtAddress_.size())
{
FatalErrorIn
(
"AMIInterpolation::interpolateToTarget"
"("
"const UList<Type>&, "
"const CombineOp&, "
"List<Type>&, "
"const UList<Type>&"
") const"
) << "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()); result.setSize(tgtAddress_.size());
if (singlePatchProc_ == -1) if (singlePatchProc_ == -1)
@ -1029,12 +1079,19 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
forAll(result, faceI) forAll(result, faceI)
{ {
const labelList& faces = tgtAddress_[faceI]; if (tgtWeightsSum_[faceI] < lowWeightCorrection_)
const scalarList& weights = tgtWeights_[faceI];
forAll(faces, i)
{ {
cop(result[faceI], faceI, work[faces[i]], weights[i]); 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]);
}
} }
} }
} }
@ -1042,12 +1099,19 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
{ {
forAll(result, faceI) forAll(result, faceI)
{ {
const labelList& faces = tgtAddress_[faceI]; if (tgtWeightsSum_[faceI] < lowWeightCorrection_)
const scalarList& weights = tgtWeights_[faceI];
forAll(faces, i)
{ {
cop(result[faceI], faceI, fld[faces[i]], weights[i]); 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]);
}
} }
} }
} }
@ -1060,7 +1124,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
( (
const UList<Type>& fld, const UList<Type>& fld,
const CombineOp& cop, const CombineOp& cop,
List<Type>& result List<Type>& result,
const UList<Type>& defaultValues
) const ) const
{ {
if (fld.size() != tgtAddress_.size()) if (fld.size() != tgtAddress_.size())
@ -1071,7 +1136,8 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
"(" "("
"const UList<Type>&, " "const UList<Type>&, "
"const CombineOp&, " "const CombineOp&, "
"List<Type>&" "List<Type>&, "
"const UList<Type>&"
") const" ") const"
) << "Supplied field size is not equal to target patch size" << nl ) << "Supplied field size is not equal to target patch size" << nl
<< " source patch = " << srcAddress_.size() << nl << " source patch = " << srcAddress_.size() << nl
@ -1080,6 +1146,29 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
<< abort(FatalError); << abort(FatalError);
} }
if (lowWeightCorrection_ > 0)
{
if (defaultValues.size() != srcAddress_.size())
{
FatalErrorIn
(
"AMIInterpolation::interpolateToSource"
"("
"const UList<Type>&, "
"const CombineOp&, "
"List<Type>&, "
"const UList<Type>&"
") const"
) << "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()); result.setSize(srcAddress_.size());
if (singlePatchProc_ == -1) if (singlePatchProc_ == -1)
@ -1091,12 +1180,19 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
forAll(result, faceI) forAll(result, faceI)
{ {
const labelList& faces = srcAddress_[faceI]; if (srcWeightsSum_[faceI] < lowWeightCorrection_)
const scalarList& weights = srcWeights_[faceI];
forAll(faces, i)
{ {
cop(result[faceI], faceI, work[faces[i]], weights[i]); 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]);
}
} }
} }
} }
@ -1104,12 +1200,19 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
{ {
forAll(result, faceI) forAll(result, faceI)
{ {
const labelList& faces = srcAddress_[faceI]; if (srcWeightsSum_[faceI] < lowWeightCorrection_)
const scalarList& weights = srcWeights_[faceI];
forAll(faces, i)
{ {
cop(result[faceI], faceI, fld[faces[i]], weights[i]); 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]);
}
} }
} }
} }
@ -1122,7 +1225,8 @@ Foam::tmp<Foam::Field<Type> >
Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
( (
const Field<Type>& fld, const Field<Type>& fld,
const CombineOp& cop const CombineOp& cop,
const UList<Type>& defaultValues
) const ) const
{ {
tmp<Field<Type> > tresult tmp<Field<Type> > tresult
@ -1138,7 +1242,8 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
( (
fld, fld,
multiplyWeightedOp<Type, CombineOp>(cop), multiplyWeightedOp<Type, CombineOp>(cop),
tresult() tresult(),
defaultValues
); );
return tresult; return tresult;
@ -1151,10 +1256,11 @@ Foam::tmp<Foam::Field<Type> >
Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
( (
const tmp<Field<Type> >& tFld, const tmp<Field<Type> >& tFld,
const CombineOp& cop const CombineOp& cop,
const UList<Type>& defaultValues
) const ) const
{ {
return interpolateToSource(tFld(), cop); return interpolateToSource(tFld(), cop, defaultValues);
} }
@ -1164,7 +1270,8 @@ Foam::tmp<Foam::Field<Type> >
Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
( (
const Field<Type>& fld, const Field<Type>& fld,
const CombineOp& cop const CombineOp& cop,
const UList<Type>& defaultValues
) const ) const
{ {
tmp<Field<Type> > tresult tmp<Field<Type> > tresult
@ -1180,7 +1287,8 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
( (
fld, fld,
multiplyWeightedOp<Type, CombineOp>(cop), multiplyWeightedOp<Type, CombineOp>(cop),
tresult() tresult(),
defaultValues
); );
return tresult; return tresult;
@ -1193,10 +1301,11 @@ Foam::tmp<Foam::Field<Type> >
Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
( (
const tmp<Field<Type> >& tFld, const tmp<Field<Type> >& tFld,
const CombineOp& cop const CombineOp& cop,
const UList<Type>& defaultValues
) const ) const
{ {
return interpolateToTarget(tFld(), cop); return interpolateToTarget(tFld(), cop, defaultValues);
} }
@ -1205,10 +1314,11 @@ template<class Type>
Foam::tmp<Foam::Field<Type> > Foam::tmp<Foam::Field<Type> >
Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
( (
const Field<Type>& fld const Field<Type>& fld,
const UList<Type>& defaultValues
) const ) const
{ {
return interpolateToSource(fld, plusEqOp<Type>()); return interpolateToSource(fld, plusEqOp<Type>(), defaultValues);
} }
@ -1217,10 +1327,11 @@ template<class Type>
Foam::tmp<Foam::Field<Type> > Foam::tmp<Foam::Field<Type> >
Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToSource
( (
const tmp<Field<Type> >& tFld const tmp<Field<Type> >& tFld,
const UList<Type>& defaultValues
) const ) const
{ {
return interpolateToSource(tFld(), plusEqOp<Type>()); return interpolateToSource(tFld(), plusEqOp<Type>(), defaultValues);
} }
@ -1229,10 +1340,11 @@ template<class Type>
Foam::tmp<Foam::Field<Type> > Foam::tmp<Foam::Field<Type> >
Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
( (
const Field<Type>& fld const Field<Type>& fld,
const UList<Type>& defaultValues
) const ) const
{ {
return interpolateToTarget(fld, plusEqOp<Type>()); return interpolateToTarget(fld, plusEqOp<Type>(), defaultValues);
} }
@ -1241,10 +1353,11 @@ template<class Type>
Foam::tmp<Foam::Field<Type> > Foam::tmp<Foam::Field<Type> >
Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget Foam::AMIInterpolation<SourcePatch, TargetPatch>::interpolateToTarget
( (
const tmp<Field<Type> >& tFld const tmp<Field<Type> >& tFld,
const UList<Type>& defaultValues
) const ) const
{ {
return interpolateToTarget(tFld(), plusEqOp<Type>()); return interpolateToTarget(tFld(), plusEqOp<Type>(), defaultValues);
} }

View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -120,6 +120,9 @@ private:
// cases // cases
label singlePatchProc_; label singlePatchProc_;
//- Threshold weight below which interpolation is deactivated
scalar lowWeightCorrection_;
// Source patch // Source patch
@ -238,7 +241,8 @@ private:
scalarListList& wght, scalarListList& wght,
scalarField& wghtSum, scalarField& wghtSum,
const bool conformal, const bool conformal,
const bool output const bool output,
const scalar lowWeightTol
); );
@ -273,6 +277,7 @@ public:
const TargetPatch& tgtPatch, const TargetPatch& tgtPatch,
const faceAreaIntersect::triangulationMode& triMode, const faceAreaIntersect::triangulationMode& triMode,
const interpolationMethod& method = imFaceAreaWeight, const interpolationMethod& method = imFaceAreaWeight,
const scalar lowWeightCorrection = -1,
const bool reverseTarget = false const bool reverseTarget = false
); );
@ -284,6 +289,7 @@ public:
const autoPtr<searchableSurface>& surf, const autoPtr<searchableSurface>& surf,
const faceAreaIntersect::triangulationMode& triMode, const faceAreaIntersect::triangulationMode& triMode,
const interpolationMethod& method = imFaceAreaWeight, const interpolationMethod& method = imFaceAreaWeight,
const scalar lowWeightCorrection = -1,
const bool reverseTarget = false const bool reverseTarget = false
); );
@ -313,7 +319,13 @@ public:
//- Set to -1, or the processor holding all faces (both sides) of //- Set to -1, or the processor holding all faces (both sides) of
// the AMI // the AMI
label singlePatchProc() const; inline label singlePatchProc() const;
//- Threshold weight below which interpolation is deactivated
inline scalar lowWeightCorrection() const;
//- Return true if employing a 'lowWeightCorrection'
inline bool applyLowWeightCorrection() const;
// Source patch // Source patch
@ -379,7 +391,8 @@ public:
( (
const UList<Type>& fld, const UList<Type>& fld,
const CombineOp& cop, const CombineOp& cop,
List<Type>& result List<Type>& result,
const UList<Type>& defaultValues = UList<Type>::null()
) const; ) const;
//- Interpolate from source to target with supplied op //- Interpolate from source to target with supplied op
@ -389,7 +402,8 @@ public:
( (
const UList<Type>& fld, const UList<Type>& fld,
const CombineOp& cop, const CombineOp& cop,
List<Type>& result List<Type>& result,
const UList<Type>& defaultValues = UList<Type>::null()
) const; ) const;
@ -398,7 +412,8 @@ public:
tmp<Field<Type> > interpolateToSource tmp<Field<Type> > interpolateToSource
( (
const Field<Type>& fld, const Field<Type>& fld,
const CombineOp& cop const CombineOp& cop,
const UList<Type>& defaultValues = UList<Type>::null()
) const; ) const;
//- Interpolate from target tmp field to source with supplied op //- Interpolate from target tmp field to source with supplied op
@ -406,7 +421,8 @@ public:
tmp<Field<Type> > interpolateToSource tmp<Field<Type> > interpolateToSource
( (
const tmp<Field<Type> >& tFld, const tmp<Field<Type> >& tFld,
const CombineOp& cop const CombineOp& cop,
const UList<Type>& defaultValues = UList<Type>::null()
) const; ) const;
//- Interpolate from source to target with supplied op //- Interpolate from source to target with supplied op
@ -414,7 +430,8 @@ public:
tmp<Field<Type> > interpolateToTarget tmp<Field<Type> > interpolateToTarget
( (
const Field<Type>& fld, const Field<Type>& fld,
const CombineOp& cop const CombineOp& cop,
const UList<Type>& defaultValues = UList<Type>::null()
) const; ) const;
//- Interpolate from source tmp field to target with supplied op //- Interpolate from source tmp field to target with supplied op
@ -422,35 +439,40 @@ public:
tmp<Field<Type> > interpolateToTarget tmp<Field<Type> > interpolateToTarget
( (
const tmp<Field<Type> >& tFld, const tmp<Field<Type> >& tFld,
const CombineOp& cop const CombineOp& cop,
const UList<Type>& defaultValues = UList<Type>::null()
) const; ) const;
//- Interpolate from target to source //- Interpolate from target to source
template<class Type> template<class Type>
tmp<Field<Type> > interpolateToSource tmp<Field<Type> > interpolateToSource
( (
const Field<Type>& fld const Field<Type>& fld,
const UList<Type>& defaultValues = UList<Type>::null()
) const; ) const;
//- Interpolate from target tmp field //- Interpolate from target tmp field
template<class Type> template<class Type>
tmp<Field<Type> > interpolateToSource tmp<Field<Type> > interpolateToSource
( (
const tmp<Field<Type> >& tFld const tmp<Field<Type> >& tFld,
const UList<Type>& defaultValues = UList<Type>::null()
) const; ) const;
//- Interpolate from source to target //- Interpolate from source to target
template<class Type> template<class Type>
tmp<Field<Type> > interpolateToTarget tmp<Field<Type> > interpolateToTarget
( (
const Field<Type>& fld const Field<Type>& fld,
const UList<Type>& defaultValues = UList<Type>::null()
) const; ) const;
//- Interpolate from source tmp field //- Interpolate from source tmp field
template<class Type> template<class Type>
tmp<Field<Type> > interpolateToTarget tmp<Field<Type> > interpolateToTarget
( (
const tmp<Field<Type> >& tFld const tmp<Field<Type> >& tFld,
const UList<Type>& defaultValues = UList<Type>::null()
) const; ) const;

View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -31,6 +31,23 @@ Foam::AMIInterpolation<SourcePatch, TargetPatch>::singlePatchProc() const
} }
template<class SourcePatch, class TargetPatch>
inline Foam::scalar
Foam::AMIInterpolation<SourcePatch, TargetPatch>::lowWeightCorrection() const
{
return lowWeightCorrection_;
}
template<class SourcePatch, class TargetPatch>
inline bool
Foam::AMIInterpolation<SourcePatch, TargetPatch>::
applyLowWeightCorrection() const
{
return lowWeightCorrection_ > 0;
}
template<class SourcePatch, class TargetPatch> template<class SourcePatch, class TargetPatch>
inline const Foam::scalarField& inline const Foam::scalarField&
Foam::AMIInterpolation<SourcePatch, TargetPatch>::srcMagSf() const Foam::AMIInterpolation<SourcePatch, TargetPatch>::srcMagSf() const

View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -175,7 +175,22 @@ void Foam::cyclicAMIPointPatchField<Type>::swapAddSeparated
Field<Type> nbrFcFld(nbrPpi().pointToFaceInterpolate(nbrPtFld)); Field<Type> nbrFcFld(nbrPpi().pointToFaceInterpolate(nbrPtFld));
// interpolate to owner // interpolate to owner
nbrFcFld = cyclicAMIPatch_.cyclicAMIPatch().interpolate(nbrFcFld); if (cyclicAMIPatch_.cyclicAMIPatch().applyLowWeightCorrection())
{
Field<Type> fcFld(ppi().pointToFaceInterpolate(ptFld));
nbrFcFld =
cyclicAMIPatch_.cyclicAMIPatch().interpolate
(
nbrFcFld,
fcFld
);
}
else
{
nbrFcFld =
cyclicAMIPatch_.cyclicAMIPatch().interpolate(nbrFcFld);
}
// add to internal field // add to internal field
this->addToInternalField this->addToInternalField
@ -190,11 +205,25 @@ void Foam::cyclicAMIPointPatchField<Type>::swapAddSeparated
Field<Type> fcFld(ppi().pointToFaceInterpolate(ptFld)); Field<Type> fcFld(ppi().pointToFaceInterpolate(ptFld));
// interpolate to neighbour // interpolate to neighbour
fcFld = if (cyclicAMIPatch_.cyclicAMIPatch().applyLowWeightCorrection())
cyclicAMIPatch_.cyclicAMIPatch().neighbPatch().interpolate {
( Field<Type> nbrFcFld(nbrPpi().pointToFaceInterpolate(nbrPtFld));
fcFld
); fcFld =
cyclicAMIPatch_.cyclicAMIPatch().neighbPatch().interpolate
(
fcFld,
nbrFcFld
);
}
else
{
fcFld =
cyclicAMIPatch_.cyclicAMIPatch().neighbPatch().interpolate
(
fcFld
);
}
// add to internal field // add to internal field
nbr.addToInternalField nbr.addToInternalField

View File

@ -359,6 +359,7 @@ void Foam::cyclicAMIPolyPatch::resetAMI
surfPtr(), surfPtr(),
faceAreaIntersect::tmMesh, faceAreaIntersect::tmMesh,
AMIMethod, AMIMethod,
AMILowWeightCorrection_,
AMIReverse_ AMIReverse_
) )
); );
@ -470,6 +471,7 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
separationVector_(vector::zero), separationVector_(vector::zero),
AMIPtr_(NULL), AMIPtr_(NULL),
AMIReverse_(false), AMIReverse_(false),
AMILowWeightCorrection_(-1.0),
surfPtr_(NULL), surfPtr_(NULL),
surfDict_(fileName("surface")) surfDict_(fileName("surface"))
{ {
@ -498,6 +500,7 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
separationVector_(vector::zero), separationVector_(vector::zero),
AMIPtr_(NULL), AMIPtr_(NULL),
AMIReverse_(dict.lookupOrDefault<bool>("flipNormals", false)), AMIReverse_(dict.lookupOrDefault<bool>("flipNormals", false)),
AMILowWeightCorrection_(dict.lookupOrDefault("lowWeightCorrection", -1.0)),
surfPtr_(NULL), surfPtr_(NULL),
surfDict_(dict.subOrEmptyDict("surface")) surfDict_(dict.subOrEmptyDict("surface"))
{ {
@ -606,6 +609,7 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
separationVector_(pp.separationVector_), separationVector_(pp.separationVector_),
AMIPtr_(NULL), AMIPtr_(NULL),
AMIReverse_(pp.AMIReverse_), AMIReverse_(pp.AMIReverse_),
AMILowWeightCorrection_(pp.AMILowWeightCorrection_),
surfPtr_(NULL), surfPtr_(NULL),
surfDict_(pp.surfDict_) surfDict_(pp.surfDict_)
{ {
@ -635,6 +639,7 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
separationVector_(pp.separationVector_), separationVector_(pp.separationVector_),
AMIPtr_(NULL), AMIPtr_(NULL),
AMIReverse_(pp.AMIReverse_), AMIReverse_(pp.AMIReverse_),
AMILowWeightCorrection_(pp.AMILowWeightCorrection_),
surfPtr_(NULL), surfPtr_(NULL),
surfDict_(pp.surfDict_) surfDict_(pp.surfDict_)
{ {
@ -678,6 +683,7 @@ Foam::cyclicAMIPolyPatch::cyclicAMIPolyPatch
separationVector_(pp.separationVector_), separationVector_(pp.separationVector_),
AMIPtr_(NULL), AMIPtr_(NULL),
AMIReverse_(pp.AMIReverse_), AMIReverse_(pp.AMIReverse_),
AMILowWeightCorrection_(pp.AMILowWeightCorrection_),
surfPtr_(NULL), surfPtr_(NULL),
surfDict_(pp.surfDict_) surfDict_(pp.surfDict_)
{} {}
@ -793,6 +799,19 @@ const Foam::AMIPatchToPatchInterpolation& Foam::cyclicAMIPolyPatch::AMI() const
} }
bool Foam::cyclicAMIPolyPatch::applyLowWeightCorrection() const
{
if (owner())
{
return AMI().applyLowWeightCorrection();
}
else
{
return neighbPatch().AMI().applyLowWeightCorrection();
}
}
void Foam::cyclicAMIPolyPatch::transformPosition(pointField& l) const void Foam::cyclicAMIPolyPatch::transformPosition(pointField& l) const
{ {
if (!parallel()) if (!parallel())
@ -970,7 +989,6 @@ void Foam::cyclicAMIPolyPatch::write(Ostream& os) const
{ {
os.writeKeyword("rotationAngle") << radToDeg(rotationAngle_) os.writeKeyword("rotationAngle") << radToDeg(rotationAngle_)
<< token::END_STATEMENT << nl; << token::END_STATEMENT << nl;
} }
break; break;
@ -997,6 +1015,12 @@ void Foam::cyclicAMIPolyPatch::write(Ostream& os) const
<< token::END_STATEMENT << nl; << token::END_STATEMENT << nl;
} }
if (AMILowWeightCorrection_ > 0)
{
os.writeKeyword("lowWeightCorrection") << AMILowWeightCorrection_
<< token::END_STATEMENT << nl;
}
if (!surfDict_.empty()) if (!surfDict_.empty())
{ {
os.writeKeyword(surfDict_.dictName()); os.writeKeyword(surfDict_.dictName());

View File

@ -97,6 +97,9 @@ private:
//- Flag to indicate that slave patch should be reversed for AMI //- Flag to indicate that slave patch should be reversed for AMI
const bool AMIReverse_; const bool AMIReverse_;
//- Low weight correction threshold for AMI
const scalar AMILowWeightCorrection_;
//- Projection surface //- Projection surface
mutable autoPtr<searchableSurface> surfPtr_; mutable autoPtr<searchableSurface> surfPtr_;
@ -298,6 +301,9 @@ public:
//- Return a reference to the AMI interpolator //- Return a reference to the AMI interpolator
const AMIPatchToPatchInterpolation& AMI() const; const AMIPatchToPatchInterpolation& AMI() const;
//- Return true if applying the low weight correction
bool applyLowWeightCorrection() const;
// Transformations // Transformations
@ -325,13 +331,18 @@ public:
//- Interpolate field //- Interpolate field
template<class Type> template<class Type>
tmp<Field<Type> > interpolate(const Field<Type>& fld) const; tmp<Field<Type> > interpolate
(
const Field<Type>& fld,
const UList<Type>& defaultValues = UList<Type>()
) const;
//- Interpolate tmp field //- Interpolate tmp field
template<class Type> template<class Type>
tmp<Field<Type> > interpolate tmp<Field<Type> > interpolate
( (
const tmp<Field<Type> >& tFld const tmp<Field<Type> >& tFld,
const UList<Type>& defaultValues = UList<Type>()
) const; ) const;
//- Low-level interpolate List //- Low-level interpolate List
@ -340,7 +351,8 @@ public:
( (
const UList<Type>& fld, const UList<Type>& fld,
const CombineOp& cop, const CombineOp& cop,
List<Type>& result List<Type>& result,
const UList<Type>& defaultValues = UList<Type>()
) const; ) const;

View File

@ -2,7 +2,7 @@
========= | ========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | \\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation \\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\/ M anipulation | \\/ M anipulation |
------------------------------------------------------------------------------- -------------------------------------------------------------------------------
License License
@ -28,16 +28,17 @@ License
template<class Type> template<class Type>
Foam::tmp<Foam::Field<Type> > Foam::cyclicAMIPolyPatch::interpolate Foam::tmp<Foam::Field<Type> > Foam::cyclicAMIPolyPatch::interpolate
( (
const Field<Type>& fld const Field<Type>& fld,
const UList<Type>& defaultValues
) const ) const
{ {
if (owner()) if (owner())
{ {
return AMI().interpolateToSource(fld); return AMI().interpolateToSource(fld, defaultValues);
} }
else else
{ {
return neighbPatch().AMI().interpolateToTarget(fld); return neighbPatch().AMI().interpolateToTarget(fld, defaultValues);
} }
} }
@ -45,17 +46,11 @@ Foam::tmp<Foam::Field<Type> > Foam::cyclicAMIPolyPatch::interpolate
template<class Type> template<class Type>
Foam::tmp<Foam::Field<Type> > Foam::cyclicAMIPolyPatch::interpolate Foam::tmp<Foam::Field<Type> > Foam::cyclicAMIPolyPatch::interpolate
( (
const tmp<Field<Type> >& tFld const tmp<Field<Type> >& tFld,
const UList<Type>& defaultValues
) const ) const
{ {
if (owner()) return interpolate(tFld(), defaultValues);
{
return AMI().interpolateToSource(tFld);
}
else
{
return neighbPatch().AMI().interpolateToTarget(tFld);
}
} }
@ -64,16 +59,29 @@ void Foam::cyclicAMIPolyPatch::interpolate
( (
const UList<Type>& fld, const UList<Type>& fld,
const CombineOp& cop, const CombineOp& cop,
List<Type>& result List<Type>& result,
const UList<Type>& defaultValues
) const ) const
{ {
if (owner()) if (owner())
{ {
AMI().interpolateToSource(fld, cop, result); AMI().interpolateToSource
(
fld,
cop,
result,
defaultValues
);
} }
else else
{ {
neighbPatch().AMI().interpolateToTarget(fld, cop, result); neighbPatch().AMI().interpolateToTarget
(
fld,
cop,
result,
defaultValues
);
} }
} }

View File

@ -354,7 +354,8 @@ void Foam::meshToMesh::mapSrcToTgt
( (
srcField, srcField,
multiplyWeightedOp<Type, CombineOp>(cop), multiplyWeightedOp<Type, CombineOp>(cop),
tgtField tgtField,
UList<Type>::null()
); );
} }
@ -385,7 +386,7 @@ Foam::meshToMesh::mapSrcToTgt
( (
IOobject IOobject
( (
type() + ".interpolate(" + field.name() + ")", type() + ":interpolate(" + field.name() + ")",
tgtMesh.time().timeName(), tgtMesh.time().timeName(),
tgtMesh, tgtMesh,
IOobject::NO_READ, IOobject::NO_READ,
@ -498,7 +499,7 @@ Foam::meshToMesh::mapTgtToSrc
( (
IOobject IOobject
( (
type() + ".interpolate(" + field.name() + ")", type() + ":interpolate(" + field.name() + ")",
srcMesh.time().timeName(), srcMesh.time().timeName(),
srcMesh, srcMesh,
IOobject::NO_READ, IOobject::NO_READ,

View File

@ -8,6 +8,6 @@ cd ${0%/*} || exit 1 # run from this directory
./Allrun-pre ./Allrun-pre
## Run simulation ## Run simulation
#./Allrun-simulation ./Allrun-simulation
# ----------------------------------------------------------------- end-of-file # ----------------------------------------------------------------- end-of-file

View File

@ -31,7 +31,7 @@ runApplication setFields
runApplication decomposePar -force runApplication decomposePar -force
# Run # Run
runParallel $application 8 runParallel $application $nProcs
# Reconstruct # Reconstruct
runApplication reconstructPar -noFunctionObjects runApplication reconstructPar -noFunctionObjects

View File

@ -81,6 +81,7 @@ baffles
matchTolerance 0.0001; matchTolerance 0.0001;
neighbourPatch AMI2; neighbourPatch AMI2;
transform noOrdering; transform noOrdering;
lowWeightCorrection 0.2;
// Note: since imperfect meshing around feature edge make // Note: since imperfect meshing around feature edge make
// sure to project both sides onto 'proper' geometry to // sure to project both sides onto 'proper' geometry to
// avoid errors leading to zero weights // avoid errors leading to zero weights
@ -99,6 +100,7 @@ baffles
matchTolerance 0.0001; matchTolerance 0.0001;
neighbourPatch AMI1; neighbourPatch AMI1;
transform noOrdering; transform noOrdering;
lowWeightCorrection 0.2;
surface surface
{ {
type triSurfaceMesh; type triSurfaceMesh;