void timeVaryingFixedDisplacementFvPatchVectorField::updateCoeffs()
{
if (this->updated())
{
return;
}
vectorField disp
(
patch().size(),
timeSeries_(this->db().time().timeOutputValue())
);
if (fieldName() == "DU")
{
const fvPatchField<vector>& U =
patch().lookupPatchField<volVectorField, vector>("U");
disp -= U;
}
else if (fieldName() != "U")
{
FatalError
<< "The displacement field should be U or DU"
<< exit(FatalError);
}
fvPatchField<vector>::operator==
(
disp
);
fixedDisplacementFvPatchVectorField::updateCoeffs();
}
void Foam::timeVaryingUniformInletOutletFvPatchField<Type>::updateCoeffs()
{
if (this->updated())
{
return;
}
this->refValue() = timeSeries_(this->db().time().timeOutputValue());
inletOutletFvPatchField<Type>::updateCoeffs();
}
void Foam::timeVaryingFlowRateInletVelocityFvPatchVectorField::
updateCoeffs()
{
if (updated())
{
return;
}
flowRate() = timeSeries_(this->db().time().timeOutputValue());
flowRateInletVelocityFvPatchVectorField::updateCoeffs();
}
// Update the coefficients associated with the patch field
void timeVaryingSolidTractionFvPatchVectorField::updateCoeffs()
{
if (updated())
{
return;
}
traction() = timeSeries_(this->db().time().timeOutputValue());
solidTractionFvPatchVectorField::updateCoeffs();
}
void Foam::timeVaryingUniformFixedValueFvPatchField<Type>::updateCoeffs()
{
if (this->updated())
{
return;
}
fvPatchField<Type>::operator==
(
timeSeries_(this->db().time().timeOutputValue())
);
fixedValueFvPatchField<Type>::updateCoeffs();
}
void timeVaryingFixedDisplacementZeroShearFvPatchVectorField::updateCoeffs()
{
if (this->updated())
{
return;
}
// set refValue
vectorField disp
(
patch().size(),
timeSeries_(this->db().time().timeOutputValue())
);
if (fieldName_ == "DU")
{
const fvPatchField<vector>& U =
patch().lookupPatchField<volVectorField, vector>("U");
disp -= U;
}
else if (fieldName_ != "U")
{
FatalError
<< "The displacement field should be U or DU"
<< exit(FatalError);
}
this->refValue() = disp;
// set value fraction to fix reference patch normal
// only done at initialisation above
//vectorField n = patch().nf();
//this->valueFraction() = sqr(n);
bool incremental(fieldName_ == "DU");
refGrad() = tractionBoundaryGradient::snGrad
(
vectorField(patch().size(), vector::zero),
scalarField(patch().size(), 0),
fieldName_,
"U",
patch(),
orthotropic_,
nonLinear_,
incremental
);
directionMixedFvPatchVectorField::updateCoeffs();
}
Foam::timeVaryingUniformInletOutletFvPatchField<Type>::
timeVaryingUniformInletOutletFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
inletOutletFvPatchField<Type>(p, iF),
timeSeries_(dict)
{
this->refValue() = timeSeries_(this->db().time().timeOutputValue());
this->refGrad() = pTraits<Type>::zero;
this->valueFraction() = 0.0;
if (dict.found("value"))
{
fvPatchField<Type>::operator==(Field<Type>("value", dict, p.size()));
}
else
{
fvPatchField<Type>::operator=(this->refValue());
}
}
void Foam::timeVaryingUniformTotalPressureFvPatchScalarField::updateCoeffs
(
const vectorField& Up
)
{
if (updated())
{
return;
}
p0_ = timeSeries_(this->db().time().timeOutputValue());
const fvsPatchField<scalar>& phip =
patch().lookupPatchField<surfaceScalarField, scalar>(phiName_);
if (psiName_ == "none" && rhoName_ == "none")
{
operator==(p0_ - 0.5*(1.0 - pos(phip))*magSqr(Up));
}
else if (rhoName_ == "none")
{
const fvPatchField<scalar>& psip =
patch().lookupPatchField<volScalarField, scalar>(psiName_);
if (gamma_ > 1.0)
{
scalar gM1ByG = (gamma_ - 1.0)/gamma_;
operator==
(
p0_
/pow
(
(1.0 + 0.5*psip*gM1ByG*(1.0 - pos(phip))*magSqr(Up)),
1.0/gM1ByG
)
);
}
else
{
operator==(p0_/(1.0 + 0.5*psip*(1.0 - pos(phip))*magSqr(Up)));
}
}
else if (psiName_ == "none")
{
const fvPatchField<scalar>& rho =
patch().lookupPatchField<volScalarField, scalar>(rhoName_);
operator==(p0_ - 0.5*rho*(1.0 - pos(phip))*magSqr(Up));
}
else
{
FatalErrorIn
(
"timeVaryingUniformTotalPressureFvPatchScalarField::updateCoeffs()"
) << " rho or psi set inconsitently, rho = " << rhoName_
<< ", psi = " << psiName_ << ".\n"
<< " Set either rho or psi or neither depending on the "
"definition of total pressure.\n"
<< " Set the unused variables to 'none'.\n"
<< " on patch " << this->patch().name()
<< " of field " << this->dimensionedInternalField().name()
<< " in file " << this->dimensionedInternalField().objectPath()
<< exit(FatalError);
}
fixedValueFvPatchScalarField::updateCoeffs();
}
timeVaryingFixedDisplacementZeroShearFvPatchVectorField::
timeVaryingFixedDisplacementZeroShearFvPatchVectorField
(
const fvPatch& p,
const DimensionedField<vector, volMesh>& iF,
const dictionary& dict
)
:
directionMixedFvPatchVectorField(p, iF),
fieldName_(dimensionedInternalField().name()),
nonLinear_(nonLinearGeometry::OFF),
orthotropic_(false),
timeSeries_(dict)
{
//- check if traction boundary is for non linear solver
if (dict.found("nonLinear"))
{
nonLinear_ = nonLinearGeometry::nonLinearNames_.read
(
dict.lookup("nonLinear")
);
if (nonLinear_ == nonLinearGeometry::UPDATED_LAGRANGIAN)
{
Info << "\tnonLinear set to updated Lagrangian"
<< endl;
}
else if (nonLinear_ == nonLinearGeometry::TOTAL_LAGRANGIAN)
{
Info << "\tnonLinear set to total Lagrangian"
<< endl;
}
}
if (dict.found("orthotropic"))
{
orthotropic_ = Switch(dict.lookup("orthotropic"));
Info << "\t\torthotropic set to " << orthotropic_ << endl;
}
//- the leastSquares has zero non-orthogonal correction
//- on the boundary
//- so the gradient scheme should be extendedLeastSquares
if
(
Foam::word
(
dimensionedInternalField().mesh().schemesDict().gradScheme
(
"grad(" + fieldName_ + ")"
)
) != "extendedLeastSquares"
)
{
Warning << "The gradScheme for " << fieldName_
<< " should be \"extendedLeastSquares 0\" for the boundary "
<< "non-orthogonal correction to be right" << endl;
}
this->refGrad() = vector::zero;
vectorField n = patch().nf();
this->valueFraction() = sqr(n);
if (dict.found("value"))
{
Field<vector>::operator=(vectorField("value", dict, p.size()));
}
else
{
FatalError
<< "value entry not found for patch " << patch().name() << endl;
}
this->refValue() = timeSeries_(this->db().time().timeOutputValue());
Field<vector> normalValue = transform(valueFraction(), refValue());
Field<vector> gradValue =
this->patchInternalField() + refGrad()/this->patch().deltaCoeffs();
Field<vector> transformGradValue =
transform(I - valueFraction(), gradValue);
Field<vector>::operator=(normalValue + transformGradValue);
}
