myMovingWallVelocityFvPatchVectorField::myMovingWallVelocityFvPatchVectorField(
const fvPatch & p,
const DimensionedField<vector, volMesh> & iF
)
:
fixedValueFvPatchVectorField( p, iF ),
myTimeIndex_( dimensionedInternalField().mesh().time().timeIndex() ),
Fc_( p.patch().size(), vector::zero ),
oldFc_( p.patch().size(), vector::zero ),
oldoldFc_( p.patch().size(), vector::zero )
{}
myMovingWallVelocityFvPatchVectorField::myMovingWallVelocityFvPatchVectorField(
const myMovingWallVelocityFvPatchVectorField & ptf,
const fvPatch & p,
const DimensionedField<vector, volMesh> & iF,
const fvPatchFieldMapper & mapper
)
:
fixedValueFvPatchVectorField( ptf, p, iF, mapper ),
myTimeIndex_( ptf.myTimeIndex_ ),
Fc_( p.patch().size(), vector::zero ),
oldFc_( p.patch().size(), vector::zero ),
oldoldFc_( p.patch().size(), vector::zero )
{}
Foam::activeBaffleVelocityFvPatchVectorField::
activeBaffleVelocityFvPatchVectorField
(
const fvPatch& p,
const DimensionedField<vector, volMesh>& iF,
const dictionary& dict
)
:
fixedValueFvPatchVectorField(p, iF),
pName_("p"),
cyclicPatchName_(dict.lookup("cyclicPatch")),
cyclicPatchLabel_(p.patch().boundaryMesh().findPatchID(cyclicPatchName_)),
orientation_(readLabel(dict.lookup("orientation"))),
initWallSf_(p.Sf()),
initCyclicSf_(p.boundaryMesh()[cyclicPatchLabel_].Sf()),
openFraction_(readScalar(dict.lookup("openFraction"))),
openingTime_(readScalar(dict.lookup("openingTime"))),
maxOpenFractionDelta_(readScalar(dict.lookup("maxOpenFractionDelta"))),
curTimeIndex_(-1)
{
fvPatchVectorField::operator=(vector::zero);
if (dict.found("p"))
{
dict.lookup("p") >> pName_;
}
void implicitExtrapolationFvPatchField<Type>::setExtraData(const fvPatch& p){
const fvMesh& m = p.boundaryMesh().mesh();
const faceList& meshFaces = m.faces();
const cellList cells = m.cells();
const labelList& faceCells = p.faceCells();
const volVectorField& centers = m.C();
forAll(faceCells,i){
const label curCellLabel = faceCells[i];
const label curPatchFaceLabel = p.patch().start() + i;
const label secondFace = cells[curCellLabel].opposingFaceLabel(curPatchFaceLabel,meshFaces);
secondFacesIDs[i] = secondFace;
const label ownerSecondFace = m.owner()[secondFace];
const label neighbourSecondFace = m.neighbour()[secondFace];
if (curCellLabel == ownerSecondFace){
secondNormalCellIsOwner[i] = 0;
}
else{
secondNormalCellIsOwner[i] = 1;
}
secondDeltas[i] = mag(centers[ownerSecondFace] - centers[neighbourSecondFace]);
}
}
thermalBaffle1DFvPatchScalarField<solidType>::
thermalBaffle1DFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const dictionary& dict
)
:
mappedPatchBase
(
p.patch(),
p.boundaryMesh().mesh().name(),
NEARESTPATCHFACE,
dict.lookup("samplePatch"),
0.0
),
mixedFvPatchScalarField(p, iF),
TName_("T"),
baffleActivated_(dict.lookupOrDefault<bool>("baffleActivated", true)),
thickness_(),
Qs_(p.size(), 0),
solidDict_(dict),
solidPtr_(),
QrPrevious_(p.size(), 0.0),
QrRelaxation_(dict.lookupOrDefault<scalar>("relaxation", 0)),
QrName_(dict.lookupOrDefault<word>("Qr", "none"))
{
fvPatchScalarField::operator=(scalarField("value", dict, p.size()));
if (dict.found("thickness"))
{
thickness_ = scalarField("thickness", dict, p.size());
}
if (dict.found("Qs"))
{
Qs_ = scalarField("Qs", dict, p.size());
}
if (dict.found("QrPrevious"))
{
QrPrevious_ = scalarField("QrPrevious", dict, p.size());
}
if (dict.found("refValue") && baffleActivated_)
{
// 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 zeroGradient.
refValue() = *this;
refGrad() = 0.0;
valueFraction() = 0.0;
}
}
Foam::mappedFieldFvPatchField<Type>::mappedFieldFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF
)
:
fixedValueFvPatchField<Type>(p, iF),
mappedPatchBase(p.patch()),
mappedPatchFieldBase<Type>(*this, *this)
{}
Foam::mappedFieldFvPatchField<Type>::mappedFieldFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
fixedValueFvPatchField<Type>(p, iF, dict),
mappedPatchBase(p.patch(), dict),
mappedPatchFieldBase<Type>(*this, *this, dict)
{}
Foam::mappedFieldFvPatchField<Type>::mappedFieldFvPatchField
(
const mappedFieldFvPatchField<Type>& ptf,
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const fvPatchFieldMapper& mapper
)
:
fixedValueFvPatchField<Type>(ptf, p, iF, mapper),
mappedPatchBase(p.patch(), ptf),
mappedPatchFieldBase<Type>(*this, *this, ptf)
{}
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)
{}
selfContainedDirectMappedFixedValueFvPatchField<Type>::
selfContainedDirectMappedFixedValueFvPatchField
(
const selfContainedDirectMappedFixedValueFvPatchField<Type>& ptf,
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const fvPatchFieldMapper& mapper
)
:
directMappedPatchBase(p.patch(), ptf),
fixedValueFvPatchField<Type>(ptf, p, iF, mapper),
fieldName_(ptf.fieldName_),
setAverage_(ptf.setAverage_),
average_(ptf.average_),
interpolationScheme_(ptf.interpolationScheme_)
{}
thermalBaffle1DFvPatchScalarField<solidType>::
thermalBaffle1DFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF
)
:
mappedPatchBase(p.patch()),
mixedFvPatchScalarField(p, iF),
TName_("T"),
baffleActivated_(true),
thickness_(p.size()),
Qs_(p.size()),
solidDict_(),
solidPtr_(NULL),
QrPrevious_(p.size()),
QrRelaxation_(0),
QrName_("undefined-Qr")
{}
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_;
}
thermalBaffle1DFvPatchScalarField<solidType>::
thermalBaffle1DFvPatchScalarField
(
const thermalBaffle1DFvPatchScalarField& ptf,
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const fvPatchFieldMapper& mapper
)
:
mappedPatchBase(p.patch(), ptf),
mixedFvPatchScalarField(ptf, p, iF, mapper),
TName_(ptf.TName_),
baffleActivated_(ptf.baffleActivated_),
thickness_(ptf.thickness_, mapper),
Qs_(ptf.Qs_, mapper),
solidDict_(ptf.solidDict_),
solidPtr_(ptf.solidPtr_),
QrPrevious_(ptf.QrPrevious_, mapper),
QrRelaxation_(ptf.QrRelaxation_),
QrName_(ptf.QrName_)
{}
//template<class type>
secondNormalBoundaryCells::secondNormalBoundaryCells(const fvPatch& p):
secondNormalFaceIsOwner(p.size()),
secondDeltas(p.size()),
secondFaces(p.size()),
secondInternalCoeffs(p.size()){
const fvMesh& m = p.boundaryMesh().mesh();
const faceList& meshFaces = m.faces();
const cellList cells = m.cells();
const labelList& faceCells = p.faceCells();
const volVectorField& centers = m.C();
const labelList& neighbours = m.neighbour();
const labelList& owners = m.owner();
forAll(faceCells,i){
const label curCellLabel = faceCells[i];
const label curPatchFaceLabel = p.patch().start() + i;
const label secondFace = cells[curCellLabel].opposingFaceLabel(curPatchFaceLabel,meshFaces);
secondFaces[i] = secondFace;
if (curCellLabel == m.owner()[secondFace]){
secondNormalFaceIsOwner[i] = false;
secondDeltas[i] = mag(centers[curCellLabel] - centers[neighbours[secondFace]]);
}
else{
secondNormalFaceIsOwner[i] = true;
secondDeltas[i] = mag(centers[curCellLabel] - centers[owners[secondFace]]);
}
}
}
Foam::activePressureForceBaffleVelocityFvPatchVectorField::
activePressureForceBaffleVelocityFvPatchVectorField
(
const fvPatch& p,
const DimensionedField<vector, volMesh>& iF,
const dictionary& dict
)
:
fixedValueFvPatchVectorField(p, iF),
pName_(dict.lookupOrDefault<word>("p", "p")),
cyclicPatchName_(dict.lookup("cyclicPatch")),
cyclicPatchLabel_(p.patch().boundaryMesh().findPatchID(cyclicPatchName_)),
orientation_(readLabel(dict.lookup("orientation"))),
initWallSf_(0),
initCyclicSf_(0),
nbrCyclicSf_(0),
openFraction_(readScalar(dict.lookup("openFraction"))),
openingTime_(readScalar(dict.lookup("openingTime"))),
maxOpenFractionDelta_(readScalar(dict.lookup("maxOpenFractionDelta"))),
curTimeIndex_(-1),
minThresholdValue_(readScalar(dict.lookup("minThresholdValue"))),
fBased_(readBool(dict.lookup("forceBased"))),
baffleActivated_(0)
{
fvPatchVectorField::operator=(vector::zero);
if (p.size() > 0)
{
initWallSf_ = p.Sf();
initCyclicSf_ = p.boundaryMesh()[cyclicPatchLabel_].Sf();
nbrCyclicSf_ = refCast<const cyclicFvPatch>
(
p.boundaryMesh()[cyclicPatchLabel_]
).neighbFvPatch().Sf();
}
if (dict.found("p"))
{
dict.lookup("p") >> pName_;
}
Foam::mappedFieldFvPatchField<Type>::mappedFieldFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
// mappedPatchBase
const word& sampleRegion,
const sampleMode sampleMode,
const word& samplePatch,
const scalar distance,
// My settings
const word& fieldName,
const bool setAverage,
const Type average,
const word& interpolationScheme
)
:
fixedValueFvPatchField<Type>(p, iF),
mappedPatchBase
(
p.patch(),
sampleRegion,
sampleMode,
samplePatch,
distance
),
mappedPatchFieldBase<Type>
(
*this,
*this,
fieldName,
setAverage,
average,
interpolationScheme
)
{}
myMovingWallVelocityFvPatchVectorField::myMovingWallVelocityFvPatchVectorField(
const fvPatch & p,
const DimensionedField<vector, volMesh> & iF,
const dictionary & dict
)
:
fixedValueFvPatchVectorField( p, iF ),
myTimeIndex_( dimensionedInternalField().mesh().time().timeIndex() ),
Fc_( p.patch().size(), vector::zero ),
oldFc_( p.patch().size(), vector::zero ),
oldoldFc_( p.patch().size(), vector::zero )
{
fvPatchVectorField::operator=( vectorField( "value", dict, p.size() ) );
Fc_ = p.patch().faceCentres();
oldFc_ = p.patch().faceCentres();
oldoldFc_ = p.patch().faceCentres();
}
Foam::tmp<Foam::Field<Type>> Foam::levelSetAverage
(
const fvPatch& patch,
const scalarField& levelF,
const scalarField& levelP,
const Field<Type>& positiveF,
const Field<Type>& positiveP,
const Field<Type>& negativeF,
const Field<Type>& negativeP
)
{
typedef typename outerProduct<Type, vector>::type sumType;
tmp<Field<Type>> tResult(new Field<Type>(patch.size(), Zero));
Field<Type>& result = tResult.ref();
forAll(result, fI)
{
const face& f = patch.patch().localFaces()[fI];
vector a = vector::zero;
sumType r = Zero;
for(label eI = 0; eI < f.size(); ++ eI)
{
const edge e = f.faceEdge(eI);
const FixedList<point, 3>
tri =
{
patch.patch().faceCentres()[fI],
patch.patch().localPoints()[e[0]],
patch.patch().localPoints()[e[1]]
};
const FixedList<scalar, 3>
level =
{
levelF[fI],
levelP[e[0]],
levelP[e[1]]
};
const cut::areaIntegrateOp<Type>
positive = FixedList<Type, 3>
({
positiveF[fI],
positiveP[e[0]],
positiveP[e[1]]
});
const cut::areaIntegrateOp<Type>
negative = FixedList<Type, 3>
({
negativeF[fI],
negativeP[e[0]],
negativeP[e[1]]
});
a += cut::areaOp()(tri);
r += triCut(tri, level, positive, negative);
}
result[fI] = a/magSqr(a) & r;
}
return tResult;
}