void Foam::calculateGlobalVariables::executeAndWriteToGlobal()
{
// this also sets the variables
driver_->clearVariables();
forAll(toGlobalVariables_,i) {
const word &name=toGlobalVariables_[i];
if(debug) {
Info << "Getting variable " << name << endl;
}
GlobalVariablesRepository::getGlobalVariables(
obr_
).addValue(
name,
toGlobalNamespace_,
const_cast<const CommonValueExpressionDriver&>(
driver_()
).variable(name)
);
if(debug) {
Pout << "Has value "
<< const_cast<const CommonValueExpressionDriver&>(
driver_()
).variable(name) << endl;
}
}
}
void swakExpressionFunctionObject::write()
{
if(verbose()) {
Info << "Expression " << name() << " : ";
}
driver_->clearVariables();
driver_->parse(expression_);
word rType=driver_->CommonValueExpressionDriver::getResultType();
if(rType==pTraits<scalar>::typeName) {
writeTheData<scalar>(driver_());
} else if(rType==pTraits<vector>::typeName) {
writeTheData<vector>(driver_());
} else if(rType==pTraits<tensor>::typeName) {
writeTheData<tensor>(driver_());
} else if(rType==pTraits<symmTensor>::typeName) {
writeTheData<symmTensor>(driver_());
} else if(rType==pTraits<sphericalTensor>::typeName) {
writeTheData<sphericalTensor>(driver_());
} else {
WarningIn("swakExpressionFunctionObject::write()")
<< "Don't know how to handle type " << rType
<< endl;
}
if(verbose()) {
Info << endl;
}
// make sure that the stored Variables are consistently written
driver_->tryWrite();
}
void Foam::expressionField::execute()
{
if(active_) {
FieldValueExpressionDriver &driver=driver_();
driver.clearVariables();
driver.parse(expression_);
if(driver.resultIsVector()) {
storeField(
driver.getVector(),
vectorField_
);
} else if(driver.resultIsScalar()) {
storeField(
driver.getScalar(),
scalarField_
);
} else {
WarningIn("Foam::expressionField::execute()")
<< "Expression '" << expression_
<< "' evaluated to an unsupported type"
<< endl;
}
}
}
CommonValueExpressionDriver &swakDataEntry<Type>::driver()
{
if(!driver_.valid()) {
driver_=CommonValueExpressionDriver::New(
data_()
);
driver_->createWriterAndRead(
"dataEntry_"+data_->name().name()+"_"+this->name()
);
}
return driver_();
}
bool
#else
void
#endif
Foam::expressionField::write()
{
Dbug << "write()" << endl;
if(active_) {
Info << "Creating expression field " << name_ << " ..." << flush;
FieldValueExpressionDriver &driver=driver_();
bool oldDimsetDebug=dimensionSet::debug;
dimensionSet::debug=false;
driver.clearVariables();
driver.parse(expression_);
dimensionSet::debug=oldDimsetDebug;
Info << " type:" << driver.getResultType() << endl;
if(driver.resultIsTyp<volVectorField>()) {
storeField(
driver.getResult<volVectorField>()
);
} else if(driver.resultIsTyp<volScalarField>()) {
storeField(
driver.getResult<volScalarField>()
);
} else if(driver.resultIsTyp<volTensorField>()) {
storeField(
driver.getResult<volTensorField>()
);
} else if(driver.resultIsTyp<volSymmTensorField>()) {
storeField(
driver.getResult<volSymmTensorField>()
);
} else if(driver.resultIsTyp<volSphericalTensorField>()) {
storeField(
driver.getResult<volSphericalTensorField>()
);
} else if(driver.resultIsTyp<surfaceVectorField>()) {
storeField(
driver.getResult<surfaceVectorField>()
);
} else if(driver.resultIsTyp<surfaceScalarField>()) {
storeField(
driver.getResult<surfaceScalarField>()
);
} else if(driver.resultIsTyp<surfaceTensorField>()) {
storeField(
driver.getResult<surfaceTensorField>()
);
} else if(driver.resultIsTyp<surfaceSymmTensorField>()) {
storeField(
driver.getResult<surfaceSymmTensorField>()
);
} else if(driver.resultIsTyp<surfaceSphericalTensorField>()) {
storeField(
driver.getResult<surfaceSphericalTensorField>()
);
} else if(driver.resultIsTyp<pointVectorField>()) {
storeField(
driver.getResult<pointVectorField>()
);
} else if(driver.resultIsTyp<pointScalarField>()) {
storeField(
driver.getResult<pointScalarField>()
);
} else if(driver.resultIsTyp<pointTensorField>()) {
storeField(
driver.getResult<pointTensorField>()
);
} else if(driver.resultIsTyp<pointSymmTensorField>()) {
storeField(
driver.getResult<pointSymmTensorField>()
);
} else if(driver.resultIsTyp<pointSphericalTensorField>()) {
storeField(
driver.getResult<pointSphericalTensorField>()
);
} else {
WarningIn("Foam::expressionField::execute()")
<< "Expression '" << expression_
<< "' evaluated to an unsupported type "
<< driver.typ()
<< endl;
}
}
driver_->tryWrite();
Dbug << "write() - end" << endl;
#ifdef FOAM_IOFILTER_WRITE_NEEDS_BOOL
return true;
#endif
}
void Foam::solveAreaLaplacianPDE::solve()
{
if(active_) {
const faMesh& mesh = driver_->aMesh();
dictionary sol=mesh.solutionDict().subDict(fieldName_+"LaplacianPDE");
FaFieldValueExpressionDriver &driver=driver_();
int nCorr=sol.lookupOrDefault<int>("nCorrectors", 0);
if(
nCorr==0
&&
steady_
) {
WarningIn("Foam::solveTransportPDE::solve()")
<< name_ << " is steady. It is recommended to have in "
<< sol.name() << " a nCorrectors>0"
<< endl;
}
for (int corr=0; corr<=nCorr; corr++) {
driver.clearVariables();
driver.parse(lambdaExpression_);
if(!driver.resultIsTyp<areaScalarField>()) {
FatalErrorIn("Foam::solveAreaLaplacianPDE::solve()")
<< lambdaExpression_ << " does not evaluate to a scalar"
<< endl
<< exit(FatalError);
}
areaScalarField lambdaField(driver.getResult<areaScalarField>());
lambdaField.dimensions().reset(lambdaDimension_);
driver.parse(sourceExpression_);
if(!driver.resultIsTyp<areaScalarField>()) {
FatalErrorIn("Foam::solveAreaLaplacianPDE::solve()")
<< sourceExpression_ << " does not evaluate to a scalar"
<< endl
<< exit(FatalError);
}
areaScalarField sourceField(driver.getResult<areaScalarField>());
sourceField.dimensions().reset(sourceDimension_);
areaScalarField &f=theField();
faMatrix<scalar> eq(
-fam::laplacian(lambdaField,f,"laplacian(lambda,"+f.name()+")")
==
sourceField
);
if(!steady_) {
driver.parse(rhoExpression_);
if(!driver.resultIsTyp<areaScalarField>()) {
FatalErrorIn("Foam::solveAreaLaplacianPDE::solve()")
<< rhoExpression_ << " does not evaluate to a scalar"
<< endl
<< exit(FatalError);
}
areaScalarField rhoField(driver.getResult<areaScalarField>());
rhoField.dimensions().reset(rhoDimension_);
faMatrix<scalar> ddtMatrix=fam::ddt(f);
if(
!ddtMatrix.diagonal()
&&
!ddtMatrix.symmetric()
&&
!ddtMatrix.asymmetric()
) {
// Adding would fail
} else {
eq+=rhoField*ddtMatrix;
}
}
if(sourceImplicitExpression_!="") {
driver.parse(sourceImplicitExpression_);
if(!driver.resultIsTyp<areaScalarField>()) {
FatalErrorIn("Foam::solveAreaLaplacianPDE::solve()")
<< sourceImplicitExpression_ << " does not evaluate to a scalar"
<< endl
<< exit(FatalError);
}
areaScalarField sourceImplicitField(driver.getResult<areaScalarField>());
sourceImplicitField.dimensions().reset(sourceImplicitDimension_);
eq-=fam::Sp(sourceImplicitField,f);
}
if(doRelax(corr==nCorr)) {
eq.relax();
}
int nNonOrthCorr=sol.lookupOrDefault<int>("nNonOrthogonalCorrectors", 0);
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
eq.solve();
}
}
}
}
void Foam::solveLaplacianPDE::solve()
{
if(active_) {
const fvMesh& mesh = refCast<const fvMesh>(obr_);
dictionary sol=mesh.solutionDict().subDict(fieldName_+"LaplacianPDE");
FieldValueExpressionDriver &driver=driver_();
int nCorr=sol.lookupOrDefault<int>("nCorrectors", 0);
if(
nCorr==0
&&
steady_
) {
WarningIn("Foam::solveTransportPDE::solve()")
<< name_ << " is steady. It is recommended to have in "
<< sol.name() << " a nCorrectors>0"
<< endl;
}
for (int corr=0; corr<=nCorr; corr++) {
driver.clearVariables();
driver.parse(lambdaExpression_);
if(!driver.resultIsTyp<volScalarField>()) {
FatalErrorIn("Foam::solveLaplacianPDE::solve()")
<< lambdaExpression_ << " does not evaluate to a scalar"
<< endl
<< exit(FatalError);
}
volScalarField lambdaField(driver.getResult<volScalarField>());
lambdaField.dimensions().reset(lambdaDimension_);
driver.parse(sourceExpression_);
if(!driver.resultIsTyp<volScalarField>()) {
FatalErrorIn("Foam::solveLaplacianPDE::solve()")
<< sourceExpression_ << " does not evaluate to a scalar"
<< endl
<< exit(FatalError);
}
volScalarField sourceField(driver.getResult<volScalarField>());
sourceField.dimensions().reset(sourceDimension_);
volScalarField &f=theField();
fvMatrix<scalar> eq(
-fvm::laplacian(lambdaField,f,"laplacian(lambda,"+f.name()+")")
==
sourceField
);
autoPtr<volScalarField> rhoField;
if(needsRhoField()) {
driver.parse(rhoExpression_);
if(!driver.resultIsTyp<volScalarField>()) {
FatalErrorIn("Foam::solveLaplacianPDE::solve()")
<< rhoExpression_ << " does not evaluate to a scalar"
<< endl
<< exit(FatalError);
}
rhoField.set(
new volScalarField(
driver.getResult<volScalarField>()
)
);
rhoField().dimensions().reset(rhoDimension_);
}
#ifdef FOAM_HAS_FVOPTIONS
if(needsRhoField()) {
eq-=fvOptions()(rhoField(),f);
}
#endif
if(!steady_) {
fvMatrix<scalar> ddtMatrix(fvm::ddt(f));
if(
!ddtMatrix.diagonal()
&&
!ddtMatrix.symmetric()
&&
!ddtMatrix.asymmetric()
) {
// Adding would fail
} else {
eq+=rhoField()*ddtMatrix;
}
}
if(sourceImplicitExpression_!="") {
driver.parse(sourceImplicitExpression_);
if(!driver.resultIsTyp<volScalarField>()) {
FatalErrorIn("Foam::solveLaplacianPDE::solve()")
<< sourceImplicitExpression_ << " does not evaluate to a scalar"
<< endl
<< exit(FatalError);
}
volScalarField sourceImplicitField(driver.getResult<volScalarField>());
sourceImplicitField.dimensions().reset(sourceImplicitDimension_);
if(sourceImplicitUseSuSp_) {
eq-=fvm::SuSp(sourceImplicitField,f);
} else {
eq-=fvm::Sp(sourceImplicitField,f);
}
}
if(doRelax(corr==nCorr)) {
eq.relax();
}
#ifdef FOAM_HAS_FVOPTIONS
fvOptions().constrain(eq);
#endif
int nNonOrthCorr=sol.lookupOrDefault<int>("nNonOrthogonalCorrectors", 0);
bool converged=true;
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{
volScalarField fallback(
"fallback"+f.name(),
f
);
#ifdef FOAM_LDUMATRIX_SOLVERPERFORMANCE
lduMatrix::solverPerformance perf=eq.solve();
#elif defined(FOAM_LDUSOLVERPERFORMANCE)
lduSolverPerformance perf=eq.solve();
#else
solverPerformance perf=eq.solve();
#endif
if(
!perf.converged()
&&
restoreNonConvergedSteady()
) {
WarningIn("Foam::solveTransportPDE::solve()")
<< "Solution for " << f.name()
<< " not converged. Restoring"
<< endl;
f=fallback;
converged=false;
break;
}
}
#ifdef FOAM_HAS_FVOPTIONS
fvOptions().correct(f);
#endif
if(!converged) {
break;
}
}
}
}
