Foam::leastSquaresVectors::leastSquaresVectors(const fvMesh& mesh)
:
MeshObject<fvMesh, Foam::MoveableMeshObject, leastSquaresVectors>(mesh),
pVectors_
(
IOobject
(
"LeastSquaresP",
mesh_.pointsInstance(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE,
false
),
mesh_,
dimensionedVector(dimless/dimLength, Zero)
),
nVectors_
(
IOobject
(
"LeastSquaresN",
mesh_.pointsInstance(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE,
false
),
mesh_,
dimensionedVector(dimless/dimLength, Zero)
)
{
calcLeastSquaresVectors();
}
void Foam::fv::tabulatedAccelerationSource::addSup
(
const RhoFieldType& rho,
fvMatrix<vector>& eqn,
const label fieldi
)
{
Vector<vector> acceleration(motion_.acceleration());
// If gravitational force is present combine with the linear acceleration
if (mesh_.foundObject<uniformDimensionedVectorField>("g"))
{
uniformDimensionedVectorField& g =
mesh_.lookupObjectRef<uniformDimensionedVectorField>("g");
const uniformDimensionedScalarField& hRef =
mesh_.lookupObject<uniformDimensionedScalarField>("hRef");
g = g0_ - dimensionedVector("a", dimAcceleration, acceleration.x());
dimensionedScalar ghRef
(
mag(g.value()) > SMALL
? g & (cmptMag(g.value())/mag(g.value()))*hRef
: dimensionedScalar("ghRef", g.dimensions()*dimLength, 0)
);
mesh_.lookupObjectRef<volScalarField>("gh") = (g & mesh_.C()) - ghRef;
mesh_.lookupObjectRef<surfaceScalarField>("ghf") =
(g & mesh_.Cf()) - ghRef;
}
// ... otherwise include explicitly in the momentum equation
else
{
eqn -= rho*dimensionedVector("a", dimAcceleration, acceleration.x());
}
dimensionedVector Omega
(
"Omega",
dimensionSet(0, 0, -1, 0, 0),
acceleration.y()
);
dimensionedVector dOmegaDT
(
"dOmegaDT",
dimensionSet(0, 0, -2, 0, 0),
acceleration.z()
);
eqn -=
(
rho*(2*Omega ^ eqn.psi()) // Coriolis force
+ rho*(Omega ^ (Omega ^ mesh_.C())) // Centrifugal force
+ rho*(dOmegaDT ^ mesh_.C()) // Angular tabulatedAcceleration force
);
}
porosityCoefficient::porosityCoefficient
(
const dictionary & poroProp
)
:
poroProperties_( poroProp ),
linearCoefficient_( dimensionedVector("null", dimless, vector::zero ) ),
quadraticCoefficient_( dimensionedVector("null", dimless, vector::zero ) )
{
}
bool Foam::patchDistMethods::advectionDiffusion::correct
(
volScalarField& y,
volVectorField& n
)
{
if (!predicted_)
{
pdmPredictor_->correct(y);
predicted_ = true;
}
volVectorField ny
(
IOobject
(
"ny",
mesh_.time().timeName(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE,
false
),
mesh_,
dimensionedVector("ny", dimless, vector::zero),
patchTypes<vector>(mesh_, patchIDs_)
);
const fvPatchList& patches = mesh_.boundary();
forAllConstIter(labelHashSet, patchIDs_, iter)
{
label patchi = iter.key();
ny.boundaryField()[patchi] == -patches[patchi].nf();
}
tmp<volVectorField> noCouple::expMomSource() const
{
tmp<volVectorField> tsource
(
new volVectorField
(
IOobject
(
"f_explicitCouple",
particleCloud_.mesh().time().timeName(),
particleCloud_.mesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
particleCloud_.mesh(),
dimensionedVector
(
"zero",
dimensionSet(1, -2, -2, 0, 0), // N/m3
vector::zero
)
)
);
return tsource;
}
Foam::displacementSBRStressFvMotionSolver::displacementSBRStressFvMotionSolver
(
const polyMesh& mesh,
const IOdictionary& dict
)
:
displacementMotionSolver(mesh, dict, dict.lookup("solver")),
fvMotionSolver(mesh),
cellDisplacement_
(
IOobject
(
"cellDisplacement",
mesh.time().timeName(),
mesh,
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
fvMesh_,
dimensionedVector
(
"cellDisplacement",
pointDisplacement().dimensions(),
Zero
),
cellMotionBoundaryTypes<vector>(pointDisplacement().boundaryField())
),
diffusivityPtr_
(
motionDiffusivity::New(fvMesh_, coeffDict().lookup("diffusivity"))
)
{}
Foam::velocityLaplacianFvMotionSolver::velocityLaplacianFvMotionSolver
(
const polyMesh& mesh,
const IOdictionary& dict
)
:
velocityMotionSolver(mesh, dict, typeName),
fvMotionSolverCore(mesh),
cellMotionU_
(
IOobject
(
"cellMotionU",
mesh.time().timeName(),
mesh,
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
fvMesh_,
dimensionedVector
(
"cellMotionU",
pointMotionU_.dimensions(),
Zero
),
cellMotionBoundaryTypes<vector>(pointMotionU_.boundaryField())
),
diffusivityPtr_
(
motionDiffusivity::New(fvMesh_, coeffDict().lookup("diffusivity"))
)
{}
Foam::tmp<Foam::surfaceVectorField>
Foam::dugdaleCohesiveLaw::interfaceTraction
(
surfaceVectorField n,
volVectorField U,
volTensorField gradU,
volScalarField mu,
volScalarField lambda
) const
{
notImplemented(type() + "::interfaceTraction()");
tmp<surfaceVectorField> tresult
(
new surfaceVectorField
(
IOobject
(
"interfaceTraction",
mesh().time().timeName(),
mesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh(),
dimensionedVector("zero", dimForce/dimArea, vector(0, 0, 0))
)
);
return tresult;
}
void Foam::wallDist::constructn() const
{
n_ = tmp<volVectorField>
(
new volVectorField
(
IOobject
(
"n" & patchTypeName_,
mesh().time().timeName(),
mesh()
),
mesh(),
dimensionedVector("n" & patchTypeName_, dimless, vector::zero),
patchDistMethod::patchTypes<vector>(mesh(), patchIDs_)
)
);
const fvPatchList& patches = mesh().boundary();
forAllConstIter(labelHashSet, patchIDs_, iter)
{
label patchi = iter.key();
n_().boundaryField()[patchi] == patches[patchi].nf();
}
int main(int argc, char *argv[])
{
# include "setRootCase.H"
# include "createTime.H"
# include "createMesh.H"
pointMesh pMesh(mesh);
pointVectorField U
(
IOobject
(
"U",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
pMesh,
dimensionedVector("fvmU", dimLength, vector::zero),
pointPatchVectorField::calculatedType()
);
pointVectorField V(U + 2*U);
Info<< "End\n" << endl;
return 0;
}
Foam::relativeVelocityModel::relativeVelocityModel
(
const dictionary& dict,
const incompressibleTwoPhaseInteractingMixture& mixture
)
:
mixture_(mixture),
alphac_(mixture.alpha2()),
alphad_(mixture.alpha1()),
rhoc_(mixture.rhoc()),
rhod_(mixture.rhod()),
Udm_
(
IOobject
(
"Udm",
alphac_.time().timeName(),
alphac_.mesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
alphac_.mesh(),
dimensionedVector("Udm", dimVelocity, Zero)
)
{}
virtualMassForce::virtualMassForce
(
const dictionary& multiphaseSurfaceForcesDict,
const multiphase::transport& mtm,
const PtrList<volScalarField>& alpha,
const volScalarField& beta
)
:
multiphaseSurfaceForcesDict_(multiphaseSurfaceForcesDict),
alpha_(alpha),
beta_(beta),
mtm_(mtm),
virtualMassForce_
(
IOobject
(
"virtualMassForce",
beta.time().timeName(),
beta.mesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
beta.mesh(),
dimensionedVector("zero", dimensionSet(0, 0, 0, 0, 0), vector(0.0, 0.0, 0.0))
)
{}
Foam::anisotropicFilter::anisotropicFilter
(
const fvMesh& mesh,
scalar widthCoeff
)
:
LESfilter(mesh),
widthCoeff_(widthCoeff),
coeff_
(
IOobject
(
"anisotropicFilterCoeff",
mesh.time().timeName(),
mesh
),
mesh,
dimensionedVector("zero", dimLength*dimLength, vector::zero),
calculatedFvPatchVectorField::typeName
)
{
for (direction d=0; d<vector::nComponents; d++)
{
coeff_.internalField().replace
(
d,
(2.0/widthCoeff_)*mesh.V()
/fvc::surfaceSum(mag(mesh.Sf().component(d)))().internalField()
);
}
}
tmp<volVectorField> meshMotionModel::f() const
{
tmp<volVectorField> tmp
(
new volVectorField
(
IOobject
(
"xxx",
particleCloud_.mesh().time().timeName(),
particleCloud_.mesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
particleCloud_.mesh(),
dimensionedVector
(
"zero",
dimensionSet(0, 1, -1, 0, 0),
vector::zero
)
)
);
return tmp;
}
Foam::relativeVelocityModel::relativeVelocityModel
(
const dictionary& dict,
const incompressibleTwoPhaseInteractingMixture& mixture
)
:
mixture_(mixture),
alphac_(mixture.alpha2()),
alphad_(mixture.alpha1()),
rhoc_(mixture.rhoc()),
rhod_(mixture.rhod()),
Udm_
(
IOobject
(
"Udm",
alphac_.time().timeName(),
alphac_.mesh()
),
alphac_.mesh(),
dimensionedVector("Udm", dimVelocity, vector::zero),
mixture.U().boundaryField().types()
)
{}
Foam::anisotropicFilter::anisotropicFilter
(
const fvMesh& mesh,
const dictionary& bd
)
:
LESfilter(mesh),
widthCoeff_(readScalar(bd.subDict(type() + "Coeffs").lookup("widthCoeff"))),
coeff_
(
IOobject
(
"anisotropicFilterCoeff",
mesh.time().timeName(),
mesh
),
mesh,
dimensionedVector("zero", dimLength*dimLength, Zero),
calculatedFvPatchScalarField::typeName
)
{
for (direction d=0; d<vector::nComponents; d++)
{
coeff_.internalField().replace
(
d,
(1/widthCoeff_)*
sqr
(
2.0*mesh.V()
/fvc::surfaceSum(mag(mesh.Sf().component(d)))().internalField()
)
);
}
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
dimensionedVector momCoupleModel::returnIntegralSourceField() const
{
FatalError<<"the solver calls for returnIntegralSourceField()\n"
<<", please set 'momCoupleModel' to type 'explicitCouple' to access this data.\n"
<< abort(FatalError);
return dimensionedVector("0", dimensionSet(1, 1, -2, 0, 0), vector::zero); // Newton
}
Foam::displacementSBRStressFvMotionSolver::displacementSBRStressFvMotionSolver
(
const polyMesh& mesh,
Istream& msData
)
:
fvMotionSolver(mesh),
points0_
(
pointIOField
(
IOobject
(
"points",
time().constant(),
polyMesh::meshSubDir,
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
)
)
),
pointDisplacement_
(
IOobject
(
"pointDisplacement",
fvMesh_.time().timeName(),
fvMesh_,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
pointMesh_
),
cellDisplacement_
(
IOobject
(
"cellDisplacement",
mesh.time().timeName(),
mesh,
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
fvMesh_,
dimensionedVector
(
"cellDisplacement",
pointDisplacement_.dimensions(),
vector::zero
),
cellMotionBoundaryTypes<vector>(pointDisplacement_.boundaryField())
),
diffusivityPtr_
(
motionDiffusivity::New(*this, lookup("diffusivity"))
)
{}
dimensionedVector eigenValues(const dimensionedSymmTensor& dt)
{
return dimensionedVector
(
"eigenValues("+dt.name()+')',
dt.dimensions(),
eigenValues(dt.value())
);
}
Foam::vorticity::vorticity
(
const word& name,
const objectRegistry& obr,
const dictionary& dict,
const bool loadFromFiles
)
:
name_(name),
obr_(obr),
active_(true),
UName_("U"),
outputName_(typeName)
{
// Check if the available mesh is an fvMesh, otherwise deactivate
if (!isA<fvMesh>(obr_))
{
active_ = false;
WarningIn
(
"vorticity::vorticity"
"("
"const word&, "
"const objectRegistry&, "
"const dictionary&, "
"const bool"
")"
) << "No fvMesh available, deactivating " << name_ << nl
<< endl;
}
read(dict);
if (active_)
{
const fvMesh& mesh = refCast<const fvMesh>(obr_);
volVectorField* vorticityPtr
(
new volVectorField
(
IOobject
(
outputName_,
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh,
dimensionedVector("0", dimless/dimTime, vector::zero)
)
);
mesh.objectRegistry::store(vorticityPtr);
}
}
dimensionedVector operator*(const dimensionedTensor& dt)
{
return dimensionedVector
(
"*"+dt.name(),
dt.dimensions(),
*dt.value()
);
}
void Foam::CellAverageParticleVelocity<CloudType>::preEvolve()
{
if (UpPtr_.valid())
{
UpPtr_->internalField() = vector::zero;
}
else
{
const fvMesh& mesh = this->owner().mesh();
UpPtr_.reset
(
new volVectorField
(
IOobject
(
this->owner().name() + "Up",
mesh.time().timeName(),
mesh,
IOobject::MUST_READ,
IOobject::AUTO_WRITE
),
mesh,
dimensionedVector("zeroVector", dimVelocity, vector::zero)
)
);
}
if (pVolPtr_.valid())
{
pVolPtr_->internalField() = scalar(0);
}
else
{
const fvMesh& mesh = this->owner().mesh();
pVolPtr_.reset
(
new volScalarField
(
IOobject
(
this->owner().name() + "pVol",
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh,
dimensionedScalar("zeroVolume", dimVolume, scalar(0))
)
);
}
}
Foam::tmp<Foam::volVectorField> Foam::liftModels::noLift::F() const
{
return
Cl()
*dimensionedVector
(
"zero",
dimensionSet(1, -2, -2, 0, 0),
vector::zero
);
}
void Foam::fv::interRegionExplicitPorositySource::addSup
(
fvMatrix<vector>& eqn,
const label fieldI
)
{
initialise();
const fvMesh& nbrMesh = mesh_.time().lookupObject<fvMesh>(nbrRegionName_);
const volVectorField& U = eqn.psi();
volVectorField UNbr
(
IOobject
(
name_ + ":UNbr",
nbrMesh.time().timeName(),
nbrMesh,
IOobject::NO_READ,
IOobject::NO_WRITE
),
nbrMesh,
dimensionedVector("zero", U.dimensions(), vector::zero)
);
// map local velocity onto neighbour region
meshInterp().mapSrcToTgt
(
U.internalField(),
plusEqOp<vector>(),
UNbr.internalField()
);
fvMatrix<vector> nbrEqn(UNbr, eqn.dimensions());
porosityPtr_->addResistance(nbrEqn);
// convert source from neighbour to local region
fvMatrix<vector> porosityEqn(U, eqn.dimensions());
scalarField& Udiag = porosityEqn.diag();
vectorField& Usource = porosityEqn.source();
Udiag.setSize(eqn.diag().size(), 0.0);
Usource.setSize(eqn.source().size(), vector::zero);
meshInterp().mapTgtToSrc(nbrEqn.diag(), plusEqOp<scalar>(), Udiag);
meshInterp().mapTgtToSrc(nbrEqn.source(), plusEqOp<vector>(), Usource);
eqn -= porosityEqn;
}
// Construct from components
forceModel::forceModel
(
const dictionary& dict,
cfdemCloud& sm
)
:
dict_(dict),
particleCloud_(sm),
treatExplicit_(false),
treatDEM_(false),
impParticleForces_
( IOobject
(
"impParticleForces",
sm.mesh().time().timeName(),
sm.mesh(),
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
sm.mesh(),
dimensionedVector("zero", dimensionSet(1,1,-2,0,0), vector(0,0,0)) // N
),
expParticleForces_
( IOobject
(
"expParticleForces",
sm.mesh().time().timeName(),
sm.mesh(),
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
sm.mesh(),
dimensionedVector("zero", dimensionSet(1,1,-2,0,0), vector(0,0,0)) // N
),
coupleForce_(true),
modelType_(sm.modelType()),
scale_(1.)
{}
// Construct from components
Foam::reflectionVectors::reflectionVectors(const Foam::fvMesh& mesh)
:
n_
(
IOobject
(
"reflectionVectors",
mesh.time().timeName(),
mesh
),
mesh,
dimensionedVector("n", dimless, vector::zero)
)
{
correct();
}
Foam::SurfaceFilmModel<CloudType>::SurfaceFilmModel(CloudType& owner)
:
dict_(dictionary::null),
owner_(owner),
g_(dimensionedVector("zero", dimAcceleration, vector::zero)),
coeffDict_(dictionary::null),
ejectedParcelType_(0),
injectorCellsPatch_(0),
massParcelPatch_(0),
diameterParcelPatch_(0),
UFilmPatch_(0),
rhoFilmPatch_(0),
deltaFilmPatch_(0),
nParcelsTransferred_(0),
nParcelsInjected_(0)
{}
Foam::tmp<Foam::volVectorField>
Foam::turbulentDispersionModels::noTurbulentDispersion::F() const
{
const fvMesh& mesh(this->pair_.phase1().mesh());
return
tmp<volVectorField>
(
new volVectorField
(
IOobject
(
"zero",
mesh.time().timeName(),
mesh
),
mesh,
dimensionedVector("zero", dimF, vector::zero)
)
);
}
void Foam::regionModels::singleLayerRegion::constructMeshObjects()
{
// construct patch normal vectors
nHatPtr_.reset
(
new volVectorField
(
IOobject
(
"nHat",
time_.timeName(),
regionMesh(),
IOobject::READ_IF_PRESENT,
NO_WRITE
),
regionMesh(),
dimensionedVector("zero", dimless, vector::zero),
zeroGradientFvPatchField<vector>::typeName
)
);
// construct patch areas
magSfPtr_.reset
(
new volScalarField
(
IOobject
(
"magSf",
time_.timeName(),
regionMesh(),
IOobject::READ_IF_PRESENT,
NO_WRITE
),
regionMesh(),
dimensionedScalar("zero", dimArea, 0.0),
zeroGradientFvPatchField<scalar>::typeName
)
);
}
Foam::tmp<Foam::volVectorField>
Foam::wallLubricationModels::noWallLubrication::F() const
{
const fvMesh& mesh(this->pair_.phase1().mesh());
return tmp<volVectorField>
(
new volVectorField
(
IOobject
(
"noWallLubrication:F",
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE,
false
),
mesh,
dimensionedVector("zero", dimF, Zero)
)
);
}