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) ) ); }