Foam::tmp<Foam::fvPatchField<Type> > Foam::fvPatchField<Type>::New
(
const word& patchFieldType,
const word& actualPatchType,
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF
)
{
if (debug)
{
Info<< "fvPatchField<Type>::New(const word&, const word&, "
"const fvPatch&, const DimensionedField<Type, volMesh>&) :"
" patchFieldType="
<< patchFieldType
<< " : " << p.type()
<< endl;
}
typename patchConstructorTable::iterator cstrIter =
patchConstructorTablePtr_->find(patchFieldType);
if (cstrIter == patchConstructorTablePtr_->end())
{
FatalErrorIn
(
"fvPatchField<Type>::New(const word&, const word&, const fvPatch&,"
"const DimensionedField<Type, volMesh>&)"
) << "Unknown patchField type "
<< patchFieldType << nl << nl
<< "Valid patchField types are :" << endl
<< patchConstructorTablePtr_->sortedToc()
<< exit(FatalError);
}
if
(
actualPatchType == word::null
|| actualPatchType != p.type()
)
{
typename patchConstructorTable::iterator patchTypeCstrIter =
patchConstructorTablePtr_->find(p.type());
if (patchTypeCstrIter != patchConstructorTablePtr_->end())
{
return patchTypeCstrIter()(p, iF);
}
else
{
return cstrIter()(p, iF);
}
}
else
{
return cstrIter()(p, iF);
}
}
Foam::tmp<Foam::fvsPatchField<Type>> Foam::fvsPatchField<Type>::New
(
const fvPatch& p,
const DimensionedField<Type, surfaceMesh>& iF,
const dictionary& dict
)
{
if (debug)
{
InfoInFunction << "Constructing fvsPatchField<Type>" << endl;
}
const word patchFieldType(dict.get<word>("type"));
auto cstrIter = dictionaryConstructorTablePtr_->cfind(patchFieldType);
if (!cstrIter.found())
{
if (!disallowGenericFvsPatchField)
{
cstrIter = dictionaryConstructorTablePtr_->cfind("generic");
}
if (!cstrIter.found())
{
FatalIOErrorInFunction(dict)
<< "Unknown patchField type " << patchFieldType
<< " for patch type " << p.type() << nl << nl
<< "Valid patchField types :" << endl
<< dictionaryConstructorTablePtr_->sortedToc()
<< exit(FatalIOError);
}
}
if
(
!dict.found("patchType")
|| dict.get<word>("patchType") != p.type()
)
{
auto patchTypeCstrIter
= dictionaryConstructorTablePtr_->cfind(p.type());
if (patchTypeCstrIter.found() && patchTypeCstrIter() != cstrIter())
{
FatalIOErrorInFunction(dict)
<< "inconsistent patch and patchField types for \n"
" patch type " << p.type()
<< " and patchField type " << patchFieldType
<< exit(FatalIOError);
}
}
return cstrIter()(p, iF, dict);
}
overlapGgiFvsPatchField<Type>::overlapGgiFvsPatchField
(
const fvPatch& p,
const DimensionedField<Type, surfaceMesh>& iF,
const dictionary& dict
)
:
coupledFvsPatchField<Type>(p, iF, dict, true),
overlapGgiPatch_(refCast<const overlapGgiFvPatch>(p))
{
if (!isType<overlapGgiFvPatch>(p))
{
FatalIOErrorIn
(
"overlapGgiFvsPatchField<Type>::overlapGgiFvsPatchField\n"
"(\n"
" const fvPatch& p,\n"
" const DimensionedField<Type, surfaceMesh>& iF,\n"
" const dictionary& dict\n"
")\n",
dict
) << "patch " << this->patch().index() << " not overlapGgi type. "
<< "Patch type = " << p.type()
<< exit(FatalIOError);
}
}
Foam::processorFvPatchField<Type>::processorFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
coupledFvPatchField<Type>(p, iF, dict, dict.found("value")),
procPatch_(refCast<const processorFvPatch>(p)),
sendBuf_(0),
receiveBuf_(0),
outstandingSendRequest_(-1),
outstandingRecvRequest_(-1),
scalarSendBuf_(0),
scalarReceiveBuf_(0)
{
if (!isA<processorFvPatch>(p))
{
FatalIOErrorInFunction
(
dict
) << "\n patch type '" << p.type()
<< "' not constraint type '" << typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << this->internalField().name()
<< " in file " << this->internalField().objectPath()
<< exit(FatalIOError);
}
// If the value is not supplied set to the internal field
if (!dict.found("value"))
{
fvPatchField<Type>::operator=(this->patchInternalField());
}
}
Foam::cyclicAMIFvPatchField<Type>::cyclicAMIFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
cyclicAMILduInterfaceField(),
coupledFvPatchField<Type>(p, iF, dict),
cyclicAMIPatch_(refCast<const cyclicAMIFvPatch>(p))
{
if (!isA<cyclicAMIFvPatch>(p))
{
FatalIOErrorInFunction
(
dict
) << " patch type '" << p.type()
<< "' not constraint type '" << typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << this->internalField().name()
<< " in file " << this->internalField().objectPath()
<< exit(FatalIOError);
}
if (!dict.found("value") && this->coupled())
{
this->evaluate(Pstream::blocking);
}
}
Foam::tmp<Foam::fvsPatchField<Type>> Foam::fvsPatchField<Type>::New
(
const fvsPatchField<Type>& ptf,
const fvPatch& p,
const DimensionedField<Type, surfaceMesh>& iF,
const fvPatchFieldMapper& pfMapper
)
{
if (debug)
{
InfoInFunction << "Constructing fvsPatchField<Type>" << endl;
}
auto cstrIter = patchMapperConstructorTablePtr_->cfind(ptf.type());
if (!cstrIter.found())
{
FatalErrorInFunction
<< "Unknown patchField type " << ptf.type() << nl << nl
<< "Valid patchField types :" << endl
<< patchMapperConstructorTablePtr_->sortedToc()
<< exit(FatalError);
}
auto patchTypeCstrIter = patchMapperConstructorTablePtr_->cfind(p.type());
if (patchTypeCstrIter.found())
{
return patchTypeCstrIter()(ptf, p, iF, pfMapper);
}
else
{
return cstrIter()(ptf, p, iF, pfMapper);
}
}
wedgeFvPatchField<Type>::wedgeFvPatchField
(
const wedgeFvPatchField<Type>& ptf,
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const fvPatchFieldMapper& mapper
)
:
transformFvPatchField<Type>(ptf, p, iF, mapper)
{
if (!isType<wedgeFvPatch>(this->patch()))
{
FatalErrorIn
(
"wedgeFvPatchField<Type>::wedgeFvPatchField\n"
"(\n"
" const wedgeFvPatchField<Type>& ptf,\n"
" const fvPatch& p,\n"
" const DimensionedField<Type, volMesh>& iF,\n"
" const fvPatchFieldMapper& mapper\n"
")\n"
) << "\n patch type '" << p.type()
<< "' not constraint type '" << typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << this->dimensionedInternalField().name()
<< " in file " << this->dimensionedInternalField().objectPath()
<< exit(FatalIOError);
}
}
regionCouplingFvsPatchField<Type>::regionCouplingFvsPatchField
(
const fvPatch& p,
const DimensionedField<Type, surfaceMesh>& iF,
const dictionary& dict
)
:
coupledFvsPatchField<Type>(p, iF, dict),
regionCouplePatch_(refCast<const regionCoupleFvPatch>(p)),
remoteFieldName_(dict.lookup("remoteField")),
matrixUpdateBuffer_()
{
if (!isType<regionCoupleFvPatch>(p))
{
FatalIOErrorIn
(
"regionCouplingFvsPatchField<Type>::regionCouplingFvsPatchField\n"
"(\n"
" const fvPatch& p,\n"
" const DimensionedField<Type, surfaceMesh>& iF,\n"
" const dictionary& dict\n"
")\n",
dict
) << "patch " << this->patch().index() << " not regionCouple type. "
<< "Patch type = " << p.type()
<< exit(FatalIOError);
}
}
wedgeFvsPatchField<Type>::wedgeFvsPatchField
(
const fvPatch& p,
const DimensionedField<Type, surfaceMesh>& iF,
const dictionary& dict
)
:
fvsPatchField<Type>(p, iF, dict)
{
if (!isType<wedgeFvPatch>(p))
{
FatalIOErrorIn
(
"wedgeFvsPatchField<Type>::wedgeFvsPatchField\n"
"(\n"
" const fvPatch& p,\n"
" const Field<Type>& field,\n"
" dictionary& dict\n"
")\n",
dict
) << "patch " << this->patch().index() << " not wedge type. "
<< "Patch type = " << p.type()
<< exit(FatalIOError);
}
}
Foam::cyclicAMIFvPatchField<Type>::cyclicAMIFvPatchField
(
const cyclicAMIFvPatchField<Type>& ptf,
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const fvPatchFieldMapper& mapper
)
:
cyclicAMILduInterfaceField(),
coupledFvPatchField<Type>(ptf, p, iF, mapper),
cyclicAMIPatch_(refCast<const cyclicAMIFvPatch>(p))
{
if (!isA<cyclicAMIFvPatch>(this->patch()))
{
FatalErrorIn
(
"cyclicAMIFvPatchField<Type>::cyclicAMIFvPatchField"
"("
"const cyclicAMIFvPatchField<Type>& ,"
"const fvPatch&, "
"const DimensionedField<Type, volMesh>&, "
"const fvPatchFieldMapper&"
")"
) << " patch type '" << p.type()
<< "' not constraint type '" << typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << this->dimensionedInternalField().name()
<< " in file " << this->dimensionedInternalField().objectPath()
<< exit(FatalIOError);
}
}
Foam::processorFvPatchField<Type>::processorFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
coupledFvPatchField<Type>(p, iF, dict),
procPatch_(refCast<const processorFvPatch>(p)),
sendBuf_(0),
receiveBuf_(0),
outstandingSendRequest_(-1),
outstandingRecvRequest_(-1),
scalarSendBuf_(0),
scalarReceiveBuf_(0)
{
if (!isA<processorFvPatch>(p))
{
FatalIOErrorIn
(
"processorFvPatchField<Type>::processorFvPatchField\n"
"(\n"
" const fvPatch& p,\n"
" const Field<Type>& field,\n"
" const dictionary& dict\n"
")\n",
dict
) << "\n patch type '" << p.type()
<< "' not constraint type '" << typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << this->dimensionedInternalField().name()
<< " in file " << this->dimensionedInternalField().objectPath()
<< exit(FatalIOError);
}
}
cyclicFvsPatchField<Type>::cyclicFvsPatchField
(
const fvPatch& p,
const DimensionedField<Type, surfaceMesh>& iF,
const dictionary& dict
)
:
coupledFvsPatchField<Type>(p, iF, dict),
cyclicPatch_(refCast<const cyclicFvPatch>(p))
{
if (!isType<cyclicFvPatch>(p))
{
FatalIOErrorIn
(
"cyclicFvsPatchField<Type>::cyclicFvsPatchField\n"
"(\n"
" const fvPatch& p,\n"
" const Field<Type>& field,\n"
" const dictionary& dict\n"
")\n",
dict
) << "patch " << this->patch().index() << " not cyclic type. "
<< "Patch type = " << p.type()
<< exit(FatalIOError);
}
}
emptyFvPatchField<Type>::emptyFvPatchField
(
const emptyFvPatchField<Type>&,
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const fvPatchFieldMapper&
)
:
fvPatchField<Type>(p, iF, Field<Type>(0))
{
if (!isType<emptyFvPatch>(p))
{
FatalErrorIn
(
"emptyFvPatchField<Type>::emptyFvPatchField\n"
"(\n"
" const emptyFvPatchField<Type>&,\n"
" const fvPatch& p,\n"
" const DimensionedField<Type, volMesh>& iF,\n"
" const fvPatchFieldMapper& mapper\n"
")\n"
) << "\n patch type '" << p.type()
<< "' not constraint type '" << typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << this->dimensionedInternalField().name()
<< " in file " << this->dimensionedInternalField().objectPath()
<< exit(FatalIOError);
}
}
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();
}
Foam::turbulentTemperatureCoupledBaffleFvPatchScalarField::
turbulentTemperatureCoupledBaffleFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const dictionary& dict
)
:
fixedValueFvPatchScalarField(p, iF, dict),
neighbourFieldName_(dict.lookup("neighbourFieldName")),
KName_(dict.lookup("K"))
{
if (!isA<directMappedPatchBase>(this->patch().patch()))
{
FatalErrorIn
(
"turbulentTemperatureCoupledBaffleFvPatchScalarField::"
"turbulentTemperatureCoupledBaffleFvPatchScalarField\n"
"(\n"
" const fvPatch& p,\n"
" const DimensionedField<scalar, volMesh>& iF,\n"
" const dictionary& dict\n"
")\n"
) << "\n patch type '" << p.type()
<< "' not type '" << directMappedPatchBase::typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << dimensionedInternalField().name()
<< " in file " << dimensionedInternalField().objectPath()
<< exit(FatalError);
}
}
Foam::symmetryPlaneFvPatchField<Type>::symmetryPlaneFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
basicSymmetryFvPatchField<Type>(p, iF, dict),
symmetryPlanePatch_(refCast<const symmetryPlaneFvPatch>(p))
{
if (!isType<symmetryPlaneFvPatch>(p))
{
FatalIOErrorIn
(
"symmetryPlaneFvPatchField<Type>::symmetryPlaneFvPatchField\n"
"(\n"
" const fvPatch& p,\n"
" const Field<Type>& field,\n"
" const dictionary& dict\n"
")\n",
dict
) << "\n patch type '" << p.type()
<< "' not constraint type '" << typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << this->dimensionedInternalField().name()
<< " in file " << this->dimensionedInternalField().objectPath()
<< exit(FatalIOError);
}
}
processorCyclicFvPatchField<Type>::processorCyclicFvPatchField
(
const processorCyclicFvPatchField<Type>& ptf,
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const fvPatchFieldMapper& mapper
)
:
//coupledFvPatchField<Type>(ptf, p, iF, mapper),
processorFvPatchField<Type>(ptf, p, iF, mapper),
procPatch_(refCast<const processorCyclicFvPatch>(p))
{
if (!isType<processorCyclicFvPatch>(this->patch()))
{
FatalErrorIn
(
"processorCyclicFvPatchField<Type>::processorCyclicFvPatchField\n"
"(\n"
" const processorCyclicFvPatchField<Type>& ptf,\n"
" const fvPatch& p,\n"
" const DimensionedField<Type, volMesh>& iF,\n"
" const fvPatchFieldMapper& mapper\n"
")\n"
) << "\n patch type '" << p.type()
<< "' not constraint type '" << typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << this->dimensionedInternalField().name()
<< " in file " << this->dimensionedInternalField().objectPath()
<< exit(FatalIOError);
}
}
Foam::tmp<Foam::fvPatchField<Type>>
Foam::fvPatchField<Type>::NewCalculatedType
(
const fvPatch& p
)
{
typename patchConstructorTable::iterator patchTypeCstrIter =
patchConstructorTablePtr_->find(p.type());
if (patchTypeCstrIter != patchConstructorTablePtr_->end())
{
return patchTypeCstrIter()
(
p,
DimensionedField<Type, volMesh>::null()
);
}
else
{
return tmp<fvPatchField<Type>>
(
new calculatedFvPatchField<Type>
(
p,
DimensionedField<Type, volMesh>::null()
)
);
}
}
Foam::cyclicAMIFvsPatchField<Type>::cyclicAMIFvsPatchField
(
const fvPatch& p,
const DimensionedField<Type, surfaceMesh>& iF,
const dictionary& dict
)
:
coupledFvsPatchField<Type>(p, iF, dict),
cyclicAMIPatch_(refCast<const cyclicAMIFvPatch>(p))
{
if (!isA<cyclicAMIFvPatch>(p))
{
FatalIOErrorIn
(
"cyclicAMIFvsPatchField<Type>::cyclicAMIFvsPatchField"
"("
"const fvPatch&, "
"const Field<Type>&, "
"const dictionary&"
")",
dict
) << "patch " << this->patch().index() << " not cyclicAMI type. "
<< "Patch type = " << p.type()
<< exit(FatalIOError);
}
}
wedgeFvPatchField<Type>::wedgeFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
transformFvPatchField<Type>(p, iF, dict)
{
if (!isType<wedgeFvPatch>(p))
{
FatalIOErrorIn
(
"wedgeFvPatchField<Type>::wedgeFvPatchField\n"
"(\n"
" const fvPatch& p,\n"
" const Field<Type>& field,\n"
" dictionary& dict\n"
")\n",
dict
) << "\n patch type '" << p.type()
<< "' not constraint type '" << typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << this->dimensionedInternalField().name()
<< " in file " << this->dimensionedInternalField().objectPath()
<< exit(FatalIOError);
}
evaluate();
}
cyclicFvPatchField<Type>::cyclicFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
coupledFvPatchField<Type>(p, iF, dict),
cyclicPatch_(refCast<const cyclicFvPatch>(p))
{
if (!isType<cyclicFvPatch>(p))
{
FatalIOErrorIn
(
"cyclicFvPatchField<Type>::cyclicFvPatchField\n"
"(\n"
" const fvPatch& p,\n"
" const Field<Type>& field,\n"
" const dictionary& dict\n"
")\n",
dict
) << "\n patch type '" << p.type()
<< "' not constraint type '" << typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << this->dimensionedInternalField().name()
<< " in file " << this->dimensionedInternalField().objectPath()
<< exit(FatalIOError);
}
this->evaluate(Pstream::blocking);
}
filmPyrolysisRadiativeCoupledMixedFvPatchScalarField::
filmPyrolysisRadiativeCoupledMixedFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const dictionary& dict
)
:
mixedFvPatchScalarField(p, iF),
temperatureCoupledBase(patch(), dict),
filmRegionName_
(
dict.lookupOrDefault<word>("filmRegion", "surfaceFilmProperties")
),
pyrolysisRegionName_
(
dict.lookupOrDefault<word>("pyrolysisRegion", "pyrolysisProperties")
),
TnbrName_(dict.lookup("Tnbr")),
QrName_(dict.lookup("Qr")),
convectiveScaling_(dict.lookupOrDefault<scalar>("convectiveScaling", 1.0)),
filmDeltaDry_(readScalar(dict.lookup("filmDeltaDry"))),
filmDeltaWet_(readScalar(dict.lookup("filmDeltaWet")))
{
if (!isA<mappedPatchBase>(this->patch().patch()))
{
FatalErrorIn
(
"filmPyrolysisRadiativeCoupledMixedFvPatchScalarField::"
"filmPyrolysisRadiativeCoupledMixedFvPatchScalarField\n"
"(\n"
" const fvPatch& p,\n"
" const DimensionedField<scalar, volMesh>& iF,\n"
" const dictionary& dict\n"
")\n"
) << "\n patch type '" << p.type()
<< "' not type '" << mappedPatchBase::typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << dimensionedInternalField().name()
<< " in file " << dimensionedInternalField().objectPath()
<< exit(FatalError);
}
fvPatchScalarField::operator=(scalarField("value", dict, p.size()));
if (dict.found("refValue"))
{
// Full restart
refValue() = scalarField("refValue", dict, p.size());
refGrad() = scalarField("refGradient", dict, p.size());
valueFraction() = scalarField("valueFraction", dict, p.size());
}
else
{
// Start from user entered data. Assume fixedValue.
refValue() = *this;
refGrad() = 0.0;
valueFraction() = 1.0;
}
}
Foam::processorCyclicFvPatchField<Type>::processorCyclicFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
processorFvPatchField<Type>(p, iF, dict),
procPatch_(refCast<const processorCyclicFvPatch>(p))
{
if (!isType<processorCyclicFvPatch>(p))
{
FatalIOErrorInFunction
(
dict
) << "\n patch type '" << p.type()
<< "' not constraint type '" << typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << this->internalField().name()
<< " in file " << this->internalField().objectPath()
<< exit(FatalIOError);
}
if (Pstream::defaultCommsType == Pstream::commsTypes::scheduled)
{
WarningInFunction
<< "Scheduled communication with split cyclics not supported."
<< endl;
}
}
Foam::tmp<Foam::fvsPatchField<Type>> Foam::fvsPatchField<Type>::New
(
const word& patchFieldType,
const word& actualPatchType,
const fvPatch& p,
const DimensionedField<Type, surfaceMesh>& iF
)
{
if (debug)
{
InfoInFunction << "Constructing fvsPatchField<Type>" << endl;
}
auto cstrIter = patchConstructorTablePtr_->cfind(patchFieldType);
if (!cstrIter.found())
{
FatalErrorInFunction
<< "Unknown patchField type "
<< patchFieldType << nl << nl
<< "Valid patchField types :" << endl
<< patchConstructorTablePtr_->sortedToc()
<< exit(FatalError);
}
if
(
actualPatchType == word::null
|| actualPatchType != p.type()
)
{
auto patchTypeCstrIter = patchConstructorTablePtr_->cfind(p.type());
if (patchTypeCstrIter.found())
{
return patchTypeCstrIter()(p, iF);
}
else
{
return cstrIter()(p, iF);
}
}
else
{
return cstrIter()(p, iF);
}
}
CFDHAMfluidMoistureCoupledMixedFvPatchScalarField::
CFDHAMfluidMoistureCoupledMixedFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const dictionary& dict
)
:
mixedFvPatchScalarField(p, iF),
temperatureCoupledBase(patch(), dict),
wnbrName_(dict.lookupOrDefault<word>("wnbr", "none")),
TnbrName_(dict.lookupOrDefault<word>("Tnbr", "none")),
QrNbrName_(dict.lookupOrDefault<word>("QrNbr", "none")),
QrName_(dict.lookupOrDefault<word>("Qr", "none")),
QsNbrName_(dict.lookupOrDefault<word>("QsNbr", "none")),
QsName_(dict.lookupOrDefault<word>("Qs", "none"))
{
if (!isA<mappedPatchBase>(this->patch().patch()))
{
FatalErrorIn
(
"CFDHAMfluidMoistureCoupledMixedFvPatchScalarField::"
"CFDHAMfluidMoistureCoupledMixedFvPatchScalarField\n"
"(\n"
" const fvPatch& p,\n"
" const DimensionedField<scalar, volMesh>& iF,\n"
" const dictionary& dict\n"
")\n"
) << "\n patch type '" << p.type()
<< "' not type '" << mappedPatchBase::typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << dimensionedInternalField().name()
<< " in file " << dimensionedInternalField().objectPath()
<< exit(FatalError);
}
fvPatchScalarField::operator=(scalarField("value", dict, p.size()));
if (dict.found("refValue"))
{
// Full restart
refValue() = scalarField("refValue", dict, p.size());
refGrad() = scalarField("refGradient", dict, p.size());
valueFraction() = scalarField("valueFraction", dict, p.size());
}
else
{
// Start from user entered data. Assume fixedValue.
refValue() = *this;
refGrad() = 0.0;
valueFraction() = 1.0;
}
}
surfaceChargeCoupledFvPatchScalarField::
surfaceChargeCoupledFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const dictionary& dict
)
:
mixedFvPatchScalarField(p, iF),
temperatureCoupledBase(patch(), dict),
neighbourFieldName_(dict.lookup("neighbourFieldName")),
surfCharge_(readScalar(dict.lookup("surfaceCharge"))),
myEpr_(readScalar(dict.lookup("myEpr"))),
nbrEpr_(readScalar(dict.lookup("nbrEpr")))
{
if (!isA<mappedPatchBase>(this->patch().patch()))
{
FatalErrorIn
(
"surfaceChargeCoupledFvPatchScalarField::"
"surfaceChargeCoupledFvPatchScalarField\n"
"(\n"
" const fvPatch& p,\n"
" const DimensionedField<scalar, volMesh>& iF,\n"
" const dictionary& dict\n"
")\n"
) << "\n patch type '" << p.type()
<< "' not type '" << mappedPatchBase::typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << dimensionedInternalField().name()
<< " in file " << dimensionedInternalField().objectPath()
<< exit(FatalError);
}
fvPatchScalarField::operator=(scalarField("value", dict, p.size()));
if (dict.found("refValue"))
{
// Full restart
refValue() = scalarField("refValue", dict, p.size());
refGrad() = scalarField("refGradient", dict, p.size());
valueFraction() = scalarField("valueFraction", dict, p.size());
}
else
{
// Start from user entered data. Assume fixedValue.
refValue() = *this;
refGrad() = 0.0;
valueFraction() = 1.0;
}
}
Foam::symmetryPlaneFvsPatchField<Type>::symmetryPlaneFvsPatchField
(
const fvPatch& p,
const DimensionedField<Type, surfaceMesh>& iF,
const dictionary& dict
)
:
fvsPatchField<Type>(p, iF, dict)
{
if (!isType<symmetryPlaneFvPatch>(p))
{
FatalIOErrorInFunction(dict)
<< "patch " << this->patch().index() << " not symmetryPlane type. "
<< "Patch type = " << p.type()
<< exit(FatalIOError);
}
}
tmp<fvsPatchField<Type> > fvsPatchField<Type>::New
(
const word& patchFieldType,
const fvPatch& p,
const DimensionedField<Type, surfaceMesh>& iF
)
{
if (debug)
{
Info<< "fvsPatchField<Type>::New(const word&, const fvPatch&, "
"const DimensionedField<Type, surfaceMesh>&) : "
"constructing fvsPatchField<Type>"
<< endl;
}
typename patchConstructorTable::iterator cstrIter =
patchConstructorTablePtr_->find(patchFieldType);
if (cstrIter == patchConstructorTablePtr_->end())
{
if (cstrIter == patchConstructorTablePtr_->end())
{
FatalErrorIn
(
"fvsPatchField<Type>::New(const word&, const fvPatch&, "
"const DimensionedField<Type, surfaceMesh>)"
) << "Unknown patch field type " << patchFieldType
<< endl << endl
<< "Valid patchField types are :" << endl
<< patchConstructorTablePtr_->toc()
<< exit(FatalError);
}
}
typename patchConstructorTable::iterator patchTypeCstrIter =
patchConstructorTablePtr_->find(p.type());
if (patchTypeCstrIter != patchConstructorTablePtr_->end())
{
return patchTypeCstrIter()(p, iF);
}
else
{
return cstrIter()(p, iF);
}
}
Foam::processorFvPatchField<Type>::processorFvPatchField
(
const processorFvPatchField<Type>& ptf,
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const fvPatchFieldMapper& mapper
)
:
coupledFvPatchField<Type>(ptf, p, iF, mapper),
procPatch_(refCast<const processorFvPatch>(p)),
sendBuf_(0),
receiveBuf_(0),
outstandingSendRequest_(-1),
outstandingRecvRequest_(-1),
scalarSendBuf_(0),
scalarReceiveBuf_(0)
{
if (!isA<processorFvPatch>(this->patch()))
{
FatalErrorIn
(
"processorFvPatchField<Type>::processorFvPatchField\n"
"(\n"
" const processorFvPatchField<Type>& ptf,\n"
" const fvPatch& p,\n"
" const DimensionedField<Type, volMesh>& iF,\n"
" const fvPatchFieldMapper& mapper\n"
")\n"
) << "\n patch type '" << p.type()
<< "' not constraint type '" << typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << this->dimensionedInternalField().name()
<< " in file " << this->dimensionedInternalField().objectPath()
<< exit(FatalIOError);
}
if (debug && !ptf.ready())
{
FatalErrorIn("processorFvPatchField<Type>::processorFvPatchField(..)")
<< "On patch " << procPatch_.name() << " outstanding request."
<< abort(FatalError);
}
}
Foam::processorCyclicFvsPatchField<Type>::processorCyclicFvsPatchField
(
const fvPatch& p,
const DimensionedField<Type, surfaceMesh>& iF,
const dictionary& dict
)
:
coupledFvsPatchField<Type>(p, iF, dict),
procPatch_(refCast<const processorCyclicFvPatch>(p))
{
if (!isType<processorCyclicFvPatch>(p))
{
FatalIOErrorInFunction
(
dict
) << "patch " << this->patch().index() << " not processor type. "
<< "Patch type = " << p.type()
<< exit(FatalIOError);
}
}