Foam::tmp<Foam::fvMatrix<Type>>
Foam::fvm::SuSp
(
const DimensionedField<scalar, volMesh>& susp,
const GeometricField<Type, fvPatchField, volMesh>& vf
)
{
const fvMesh& mesh = vf.mesh();
tmp<fvMatrix<Type>> tfvm
(
new fvMatrix<Type>
(
vf,
dimVol*susp.dimensions()*vf.dimensions()
)
);
fvMatrix<Type>& fvm = tfvm.ref();
fvm.diag() += mesh.V()*max(susp.field(), scalar(0));
fvm.source() -= mesh.V()*min(susp.field(), scalar(0))
*vf.primitiveField();
return tfvm;
}
Foam::timeVaryingMappedTotalPressureFvPatchScalarField::
timeVaryingMappedTotalPressureFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const dictionary& dict
)
:
timeVaryingMappedFixedValueFvPatchScalarField(p, iF, dict),
UName_(dict.lookupOrDefault<word>("UName", "U")),
phiName_(dict.lookupOrDefault<word>("phiName", "phi")),
rhoName_(dict.lookupOrDefault<word>("rhoName", "none")),
rho_
(
iF.dimensions() == dimPressure/dimDensity && rhoName_ == "rho"
? readScalar(dict.lookup("rho"))
: 1
),
psiName_(dict.lookupOrDefault<word>("psiName", "none")),
gamma_
(
iF.dimensions() == dimPressure && psiName_ != "none"
? readScalar(dict.lookup("gamma"))
: 1
)
{}
tmp<DimensionedField<scalar, GeoMesh> > pow
(
const DimensionedField<scalar, GeoMesh>& dsf1,
const tmp<DimensionedField<scalar, GeoMesh> >& tdsf2
)
{
const DimensionedField<scalar, GeoMesh>& dsf2 = tdsf2();
tmp<DimensionedField<scalar, GeoMesh> > tPow =
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New
(
tdsf2,
"pow(" + dsf1.name() + ',' + dsf2.name() + ')',
pow
(
dsf1.dimensions(),
dimensionedScalar("1", 1.0, dsf2.dimensions())
)
);
pow(tPow().getField(), dsf1.getField(), dsf2.getField());
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf2);
return tPow;
}
Foam::tmp<Foam::DimensionedField<Type, Foam::volMesh>>
Foam::dimFieldDecomposer::decomposeField
(
const DimensionedField<Type, volMesh>& field
) const
{
// Create and map the internal field values
Field<Type> mappedField(field, cellAddressing_);
// Create the field for the processor
return tmp<DimensionedField<Type, volMesh>>
(
new DimensionedField<Type, volMesh>
(
IOobject
(
field.name(),
procMesh_.time().timeName(),
procMesh_,
IOobject::NO_READ,
IOobject::NO_WRITE,
false
),
procMesh_,
field.dimensions(),
mappedField
)
);
}
tmp<DimensionedField<scalar, GeoMesh> > pow
(
const DimensionedField<scalar, GeoMesh>& dsf1,
const DimensionedField<scalar, GeoMesh>& dsf2
)
{
tmp<DimensionedField<scalar, GeoMesh> > tPow
(
new DimensionedField<scalar, GeoMesh>
(
IOobject
(
"pow(" + dsf1.name() + ',' + dsf2.name() + ')',
dsf1.instance(),
dsf1.db()
),
dsf1.mesh(),
pow
(
dsf1.dimensions(),
dimensionedScalar("1", 1.0, dsf2.dimensions())
)
)
);
pow(tPow().getField(), dsf1.getField(), dsf2.getField());
return tPow;
}
tmp<DimensionedField<scalar, GeoMesh> > atan2
(
const DimensionedField<scalar, GeoMesh>& dsf1,
const DimensionedField<scalar, GeoMesh>& dsf2
)
{
tmp<DimensionedField<scalar, GeoMesh> > tAtan2
(
new DimensionedField<scalar, GeoMesh>
(
IOobject
(
"atan2(" + dsf1.name() + ',' + dsf2.name() + ')',
dsf1.instance(),
dsf1.db()
),
dsf1.mesh(),
atan2(dsf1.dimensions(), dsf2.dimensions())
)
);
atan2(tAtan2().getField(), dsf1.getField(), dsf2.getField());
return tAtan2;
}
DimensionedField<Type, GeoMesh>::DimensionedField
(
const word& newName,
const DimensionedField<Type, GeoMesh>& df
)
:
regIOobject(IOobject(newName, df.time().timeName(), df.db())),
Field<Type>(df),
mesh_(df.mesh_),
dimensions_(df.dimensions_)
{}
dimensioned<Type> domainIntegrate
(
const DimensionedField<Type, volMesh>& df
)
{
return dimensioned<Type>
(
"domainIntegrate(" + df.name() + ')',
dimVol*df.dimensions(),
gSum(fvc::volumeIntegrate(df))
);
}
domainScalingFvPatchField<Type>::domainScalingFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
domainScalingLduInterfaceField(),
coupledFvPatchField<Type>(p, iF, dict),
domainScalingPatch_(refCast<const domainScalingFvPatch>(p)),
fieldName_(iF.name())
{
if (!isType<domainScalingFvPatch>(p))
{
FatalIOErrorIn
(
"domainScalingFvPatchField<Type>::domainScalingFvPatchField\n"
"(\n"
" const fvPatch& p,\n"
" const DimensionedField<Type, volMesh>& iF,\n"
" const dictionary& dict\n"
")\n",
dict
) << "patch " << this->patch().index() << " not domainScalingFvPatchField type. "
<< "Patch type = " << p.type()
<< exit(FatalIOError);
}
// Same as in the cyclic interface
this->evaluate();
}
timeVaryingMappedFixedValueFvPatchField<Type>::
timeVaryingMappedFixedValueFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF
)
:
fixedValueFvPatchField<Type>(p, iF),
fieldTableName_(iF.name()),
setAverage_(false),
referenceCS_(NULL),
nearestVertex_(0),
nearestVertexWeight_(0),
sampleTimes_(0),
startSampleTime_(-1),
startSampledValues_(0),
startAverage_(pTraits<Type>::zero),
endSampleTime_(-1),
endSampledValues_(0),
endAverage_(pTraits<Type>::zero)
{
if (debug)
{
Pout<< "timeVaryingMappedFixedValue :"
<< " construct from fvPatch and internalField" << endl;
}
}
timeVaryingMappedFixedValueFvPatchField<Type>::
timeVaryingMappedFixedValueFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
fixedValueFvPatchField<Type>(p, iF),
fieldTableName_(iF.name()),
setAverage_(readBool(dict.lookup("setAverage"))),
referenceCS_(NULL),
nearestVertex_(0),
nearestVertexWeight_(0),
sampleTimes_(0),
startSampleTime_(-1),
startSampledValues_(0),
startAverage_(pTraits<Type>::zero),
endSampleTime_(-1),
endSampledValues_(0),
endAverage_(pTraits<Type>::zero)
{
if (debug)
{
Pout<< "timeVaryingMappedFixedValue : construct from dictionary"
<< endl;
}
if (dict.found("fieldTableName"))
{
dict.lookup("fieldTableName") >> fieldTableName_;
}
timeVaryingMappedFixedValueFvPatchField<Type>::
timeVaryingMappedFixedValueFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
fixedValueFvPatchField<Type>(p, iF),
fieldTableName_(iF.name()),
setAverage_(readBool(dict.lookup("setAverage"))),
perturb_(dict.lookupOrDefault("perturb", 1E-5)),
referenceCS_(NULL),
nearestVertex_(0),
nearestVertexWeight_(0),
sampleTimes_(0),
startSampleTime_(-1),
startSampledValues_(0),
startAverage_(pTraits<Type>::zero),
endSampleTime_(-1),
endSampledValues_(0),
endAverage_(pTraits<Type>::zero)
{
dict.readIfPresent("fieldTableName", fieldTableName_);
if (dict.found("value"))
{
fvPatchField<Type>::operator==(Field<Type>("value", dict, p.size()));
}
else
{
updateCoeffs();
}
}
fixedGradientFvPatchField<Type>::fixedGradientFvPatchField
(
const fixedGradientFvPatchField<Type>& ptf,
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const fvPatchFieldMapper& mapper
)
:
fvPatchField<Type>(ptf, p, iF, mapper),
gradient_(ptf.gradient_, mapper)
{
if (&iF && mapper.hasUnmapped())
{
WarningIn
(
"fixedGradientFvPatchField<Type>::fixedGradientFvPatchField\n"
"(\n"
" const fixedGradientFvPatchField<Type>&,\n"
" const fvPatch&,\n"
" const DimensionedField<Type, volMesh>&,\n"
" const fvPatchFieldMapper&\n"
")\n"
) << "On field " << iF.name() << " patch " << p.name()
<< " patchField " << this->type()
<< " : mapper does not map all values." << nl
<< " To avoid this warning fully specify the mapping in derived"
<< " patch fields." << endl;
}
}
Foam::
timeVaryingMappedFixedValuePointPatchField<Type>::
timeVaryingMappedFixedValuePointPatchField
(
const pointPatch& p,
const DimensionedField<Type, pointMesh>& iF,
const dictionary& dict
)
:
fixedValuePointPatchField<Type>(p, iF),
fieldTableName_(iF.name()),
setAverage_(readBool(dict.lookup("setAverage"))),
perturb_(dict.lookupOrDefault("perturb", 1E-5)),
mapperPtr_(NULL),
sampleTimes_(0),
startSampleTime_(-1),
startSampledValues_(0),
startAverage_(pTraits<Type>::zero),
endSampleTime_(-1),
endSampledValues_(0),
endAverage_(pTraits<Type>::zero)
{
dict.readIfPresent("fieldTableName", fieldTableName_);
updateCoeffs();
}
Foam::timeVaryingMappedFixedValueFvPatchField<Type>::
timeVaryingMappedFixedValueFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
fixedValueFvPatchField<Type>(p, iF),
fieldTableName_(iF.name()),
setAverage_(readBool(dict.lookup("setAverage"))),
perturb_(dict.lookupOrDefault("perturb", 1e-5)),
mapMethod_
(
dict.lookupOrDefault<word>
(
"mapMethod",
"planarInterpolation"
)
),
mapperPtr_(NULL),
sampleTimes_(0),
startSampleTime_(-1),
startSampledValues_(0),
startAverage_(Zero),
endSampleTime_(-1),
endSampledValues_(0),
endAverage_(Zero),
offset_(Function1<Type>::New("offset", dict))
{
if
(
mapMethod_ != "planarInterpolation"
&& mapMethod_ != "nearest"
)
{
FatalIOErrorInFunction
(
dict
) << "mapMethod should be one of 'planarInterpolation'"
<< ", 'nearest'" << exit(FatalIOError);
}
dict.readIfPresent("fieldTableName", fieldTableName_);
if (dict.found("value"))
{
fvPatchField<Type>::operator==(Field<Type>("value", dict, p.size()));
}
else
{
// Note: we use evaluate() here to trigger updateCoeffs followed
// by re-setting of fvatchfield::updated_ flag. This is
// so if first use is in the next time step it retriggers
// a new update.
this->evaluate(Pstream::blocking);
}
}
Foam::
timeVaryingMappedFixedValuePointPatchField<Type>::
timeVaryingMappedFixedValuePointPatchField
(
const pointPatch& p,
const DimensionedField<Type, pointMesh>& iF,
const dictionary& dict
)
:
fixedValuePointPatchField<Type>(p, iF),
fieldTableName_(iF.name()),
setAverage_(readBool(dict.lookup("setAverage"))),
perturb_(dict.lookupOrDefault("perturb", 1e-5)),
mapMethod_
(
dict.lookupOrDefault<word>
(
"mapMethod",
"planarInterpolation"
)
),
mapperPtr_(NULL),
sampleTimes_(0),
startSampleTime_(-1),
startSampledValues_(0),
startAverage_(pTraits<Type>::zero),
endSampleTime_(-1),
endSampledValues_(0),
endAverage_(pTraits<Type>::zero),
offset_()
{
if (dict.found("offset"))
{
offset_ = DataEntry<Type>::New("offset", dict);
}
dict.readIfPresent("fieldTableName", fieldTableName_);
if (dict.found("value"))
{
fixedValuePointPatchField<Type>::operator==
(
Field<Type>("value", dict, p.size())
);
}
else
{
// Note: use evaluate to do updateCoeffs followed by a reset
// of the pointPatchField::updated_ flag. This is
// so if first use is in the next time step it retriggers
// a new update.
pointPatchField<Type>::evaluate(Pstream::blocking);
}
}
domainScalingFvPatchField<Type>::domainScalingFvPatchField
(
const domainScalingFvPatchField<Type>& ptf,
const DimensionedField<Type, volMesh>& iF
)
:
domainScalingLduInterfaceField(),
coupledFvPatchField<Type>(ptf, iF),
domainScalingPatch_(refCast<const domainScalingFvPatch>(ptf.patch())),
fieldName_(iF.name())
{
}
tmp<DimensionedField<typename powProduct<Type, r>::type, GeoMesh> >
pow
(
const DimensionedField<Type, GeoMesh>& df,
typename powProduct<Type, r>::type
)
{
typedef typename powProduct<Type, r>::type powProductType;
tmp<DimensionedField<powProductType, GeoMesh> > tPow
(
new DimensionedField<powProductType, GeoMesh>
(
IOobject
(
"pow(" + df.name() + ',' + name(r) + ')',
df.instance(),
df.db()
),
df.mesh(),
pow(df.dimensions(), r)
)
);
pow<Type, r, GeoMesh>(tPow().field(), df.field());
return tPow;
}
tmp
<
DimensionedField
<typename DimensionedField<Type, GeoMesh>::cmptType, GeoMesh>
>
cmptAv(const DimensionedField<Type, GeoMesh>& df)
{
typedef typename DimensionedField<Type, GeoMesh>::cmptType cmptType;
tmp<DimensionedField<cmptType, GeoMesh> > CmptAv
(
new DimensionedField<scalar, GeoMesh>
(
IOobject
(
"cmptAv(" + df.name() + ')',
df.instance(),
df.db()
),
df.mesh(),
df.dimensions()
)
);
cmptAv(CmptAv().field(), df.field());
return CmptAv;
}
tmp<DimensionedField<scalar, GeoMesh> > atan2
(
const dimensionedScalar& ds,
const DimensionedField<scalar, GeoMesh>& dsf
)
{
tmp<DimensionedField<scalar, GeoMesh> > tAtan2
(
new DimensionedField<scalar, GeoMesh>
(
IOobject
(
"atan2(" + ds.name() + ',' + dsf.name() + ')',
dsf.instance(),
dsf.db()
),
dsf.mesh(),
atan2(ds, dsf.dimensions())
)
);
atan2(tAtan2().getField(), ds.value(), dsf.getField());
return tAtan2;
}
tmp<DimensionedField<scalar, GeoMesh> > stabilise
(
const DimensionedField<scalar, GeoMesh>& dsf,
const dimensioned<scalar>& ds
)
{
tmp<DimensionedField<scalar, GeoMesh> > tRes
(
new DimensionedField<scalar, GeoMesh>
(
IOobject
(
"stabilise(" + dsf.name() + ',' + ds.name() + ')',
dsf.instance(),
dsf.db()
),
dsf.mesh(),
dsf.dimensions() + ds.dimensions()
)
);
stabilise(tRes().getField(), dsf.getField(), ds.value());
return tRes;
}
tmp<DimensionedField<scalar, GeoMesh> > pow
(
const dimensionedScalar& ds,
const DimensionedField<scalar, GeoMesh>& dsf
)
{
tmp<DimensionedField<scalar, GeoMesh> > tPow
(
new DimensionedField<scalar, GeoMesh>
(
IOobject
(
"pow(" + ds.name() + ',' + dsf.name() + ')',
dsf.instance(),
dsf.db()
),
dsf.mesh(),
pow(ds, dsf.dimensions())
)
);
pow(tPow().getField(), ds.value(), dsf.getField());
return tPow;
}
regionCouplingFvPatchField<Type>::regionCouplingFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF
)
:
coupledFvPatchField<Type>(p, iF),
regionCouplePatch_(refCast<const regionCoupleFvPatch>(p)),
remoteFieldName_(iF.name()),
matrixUpdateBuffer_(),
originalPatchField_(),
curTimeIndex_(-1)
{}
tmp<DimensionedField<scalar, GeoMesh> > atan2
(
const DimensionedField<scalar, GeoMesh>& dsf1,
const tmp<DimensionedField<scalar, GeoMesh> >& tdsf2
)
{
const DimensionedField<scalar, GeoMesh>& dsf2 = tdsf2();
tmp<DimensionedField<scalar, GeoMesh> > tAtan2 =
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New
(
tdsf2,
"atan2(" + dsf1.name() + ',' + dsf2.name() + ')',
atan2(dsf1.dimensions(), dsf2.dimensions())
);
atan2(tAtan2().getField(), dsf1.getField(), dsf2.getField());
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::clear(tdsf2);
return tAtan2;
}
tmp<volScalarField> swakPsiChemistryModelPluginFunction::wrapDimField(
const DimensionedField<scalar,volMesh> &dimField
)
{
tmp<volScalarField> result(
new volScalarField(
IOobject(
dimField.name(),
mesh().time().timeName(),
mesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh(),
dimensionedScalar(dimField.name(),dimField.dimensions(),0),
"zeroGradient"
)
);
result->dimensionedInternalField()=dimField;
return result;
}
Foam::tmp<Foam::fvMatrix<Type>>
Foam::fvm::Sp
(
const DimensionedField<scalar, volMesh>& sp,
const GeometricField<Type, fvPatchField, volMesh>& vf
)
{
const fvMesh& mesh = vf.mesh();
tmp<fvMatrix<Type>> tfvm
(
new fvMatrix<Type>
(
vf,
dimVol*sp.dimensions()*vf.dimensions()
)
);
fvMatrix<Type>& fvm = tfvm.ref();
fvm.diag() += mesh.V()*sp.field();
return tfvm;
}
selfContainedDirectMappedFixedValueFvPatchField<Type>::
selfContainedDirectMappedFixedValueFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF
)
:
directMappedPatchBase(p.patch()),
fixedValueFvPatchField<Type>(p, iF),
fieldName_(iF.name()),
setAverage_(false),
average_(pTraits<Type>::zero),
interpolationScheme_(interpolationCell<Type>::typeName)
{}
Foam::tmp<Foam::fvMatrix<Type>>
Foam::fvm::Su
(
const DimensionedField<Type, volMesh>& su,
const GeometricField<Type, fvPatchField, volMesh>& vf
)
{
const fvMesh& mesh = vf.mesh();
tmp<fvMatrix<Type>> tfvm
(
new fvMatrix<Type>
(
vf,
dimVol*su.dimensions()
)
);
fvMatrix<Type>& fvm = tfvm.ref();
fvm.source() -= mesh.V()*su.field();
return tfvm;
}
selfContainedDirectMappedFixedValueFvPatchField<Type>::
selfContainedDirectMappedFixedValueFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
directMappedPatchBase(p.patch(), dict),
fixedValueFvPatchField<Type>(p, iF, dict),
fieldName_(dict.lookupOrDefault<word>("fieldName", iF.name())),
setAverage_(readBool(dict.lookup("setAverage"))),
average_(pTraits<Type>(dict.lookup("average"))),
interpolationScheme_(interpolationCell<Type>::typeName)
{
if (mode() == directMappedPatchBase::NEARESTCELL)
{
dict.lookup("interpolationScheme") >> interpolationScheme_;
}
Foam::fixedValueFvPatchField<Type>::fixedValueFvPatchField
(
const fixedValueFvPatchField<Type>& ptf,
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const fvPatchFieldMapper& mapper
)
:
fvPatchField<Type>(ptf, p, iF, mapper)
{
if (notNull(iF) && mapper.hasUnmapped())
{
WarningInFunction
<< "On field " << iF.name() << " patch " << p.name()
<< " patchField " << this->type()
<< " : mapper does not map all values." << nl
<< " To avoid this warning fully specify the mapping in derived"
<< " patch fields." << endl;
}
}