Foam::dynamicInkJetFvMesh::dynamicInkJetFvMesh(const IOobject& io)
:
dynamicFvMesh(io),
dynamicMeshCoeffs_
(
IOdictionary
(
IOobject
(
"dynamicMeshDict",
io.time().constant(),
*this,
IOobject::MUST_READ,
IOobject::NO_WRITE
)
).subDict(typeName + "Coeffs")
),
amplitude_(readScalar(dynamicMeshCoeffs_.lookup("amplitude"))),
frequency_(readScalar(dynamicMeshCoeffs_.lookup("frequency"))),
refPlaneX_(readScalar(dynamicMeshCoeffs_.lookup("refPlaneX"))),
stationaryPoints_
(
IOobject
(
"points",
io.time().constant(),
meshSubDir,
*this,
IOobject::MUST_READ,
IOobject::NO_WRITE
)
)
{
Info<< "Performing a dynamic mesh calculation: " << endl
<< "amplitude: " << amplitude_
<< " frequency: " << frequency_
<< " refPlaneX: " << refPlaneX_ << endl;
}
Foam::objectRegistry::objectRegistry
(
const IOobject& io,
const label nIoObjects
)
:
regIOobject(io),
HashTable<regIOobject*>(nIoObjects),
time_(io.time()),
parent_(io.db()),
dbDir_(parent_.dbDir()/local()/name()),
event_(1)
{
writeOpt() = IOobject::AUTO_WRITE;
}
Foam::autoPtr<Foam::dynamicFvMesh> Foam::dynamicFvMesh::New
(
const IOobject& io,
const dictionary& dict,
const word& defaultMeshTypeName
)
{
word dynamicFvMeshTypeName(defaultMeshTypeName);
if (dict.readIfPresent("dynamicFvMesh", dynamicFvMeshTypeName))
{
Info<< "Selecting dynamicFvMesh " << dynamicFvMeshTypeName << endl;
}
const_cast<Time&>(io.time()).libs().open
(
dict,
"dynamicFvMeshLibs",
IOobjectConstructorTablePtr_
);
if (!IOobjectConstructorTablePtr_)
{
FatalErrorInFunction
<< "dynamicFvMesh table is empty"
<< exit(FatalError);
}
IOobjectConstructorTable::iterator cstrIter =
IOobjectConstructorTablePtr_->find(dynamicFvMeshTypeName);
if (cstrIter == IOobjectConstructorTablePtr_->end())
{
FatalErrorInFunction
<< "Unknown dynamicFvMesh type "
<< dynamicFvMeshTypeName << nl << nl
<< "Valid dynamicFvMesh types are :" << endl
<< IOobjectConstructorTablePtr_->sortedToc()
<< exit(FatalError);
}
return autoPtr<dynamicFvMesh>(cstrIter()(io));
}
Foam::autoPtr<Foam::dynamicFvMesh> Foam::dynamicFvMesh::New(const IOobject& io)
{
wordList libNames(1);
libNames[0]=word("mesquiteMotionSolver");
forAll(libNames,i) {
const word libName("lib"+libNames[i]+".so");
bool ok=dlLibraryTable::open(libName);
if(!ok) {
WarningIn("dynamicFvMesh::New(const IOobject& io)")
<< "Loading of dynamic mesh library " << libName
<< " unsuccesful. Some dynamic mesh methods may not be "
<< " available"
<< endl;
}
}
// Enclose the creation of the dynamicMesh to ensure it is
// deleted before the dynamicFvMesh is created otherwise the dictionary
// is entered in the database twice
IOdictionary dynamicMeshDict
(
IOobject
(
"dynamicMeshDict",
io.time().constant(),
(io.name() == dynamicFvMesh::defaultRegion ? "" : io.name() ),
io.db(),
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
)
);
word dynamicFvMeshTypeName(dynamicMeshDict.lookup("dynamicFvMesh"));
Info<< "Selecting dynamicFvMesh " << dynamicFvMeshTypeName << endl;
dlLibraryTable::open
(
dynamicMeshDict,
"dynamicFvMeshLibs",
IOobjectConstructorTablePtr_
);
if (!IOobjectConstructorTablePtr_)
{
FatalErrorIn
(
"dynamicFvMesh::New(const IOobject&)"
) << "dynamicFvMesh table is empty"
<< exit(FatalError);
}
IOobjectConstructorTable::iterator cstrIter =
IOobjectConstructorTablePtr_->find(dynamicFvMeshTypeName);
if (cstrIter == IOobjectConstructorTablePtr_->end())
{
FatalErrorIn
(
"dynamicFvMesh::New(const IOobject&)"
) << "Unknown dynamicFvMesh type " << dynamicFvMeshTypeName
<< endl << endl
<< "Valid dynamicFvMesh types are :" << endl
<< IOobjectConstructorTablePtr_->toc()
<< exit(FatalError);
}
return autoPtr<dynamicFvMesh>(cstrIter()(io));
}
Foam::dynamicBodyFvMesh::dynamicBodyFvMesh(const IOobject& io)
:
dynamicFvMesh(io),
dynamicMeshCoeffs_
(
IOdictionary
(
IOobject
(
"dynamicMeshDict",
io.time().constant(),
*this,
IOobject::MUST_READ,
IOobject::NO_WRITE
)
).subDict(typeName + "Coeffs")
),
motionPtr_(motionSolver::New(*this)),
bodyPatchName_
(
dynamicMeshCoeffs_.lookup("bodyPatchName")
),
bodyPatchID_(-1),
translationDirection_
(
dynamicMeshCoeffs_.lookup("translationDirection")
),
translationAmplitude_
(
readScalar(dynamicMeshCoeffs_.lookup("translationAmplitude"))
),
translationFrequency_
(
readScalar(dynamicMeshCoeffs_.lookup("translationFrequency"))
),
initialRotationOrigin_
(
dynamicMeshCoeffs_.lookup("initialRotationOrigin")
),
rotationAxis_
(
dynamicMeshCoeffs_.lookup("rotationAxis")
),
rotationAmplitude_
(
readScalar(dynamicMeshCoeffs_.lookup("rotationAmplitude"))
),
rotationFrequency_
(
readScalar(dynamicMeshCoeffs_.lookup("rotationFrequency"))
)
{
bodyPatchID_ = boundaryMesh().findPatchID(bodyPatchName_);
if (bodyPatchID_<0)
{
FatalErrorIn
(
"dynamicBodyFvMesh::dynamicBodyFvMesh(const IOobject& io)"
)
<< "Can't find patch: " << bodyPatchName_
<< exit(FatalError);
}
translationDirection_ /= mag(translationDirection_) + SMALL;
rotationAxis_ /= mag(rotationAxis_) + SMALL;
}
Foam::solidBodyMotionFvMesh::solidBodyMotionFvMesh(const IOobject& io)
:
dynamicFvMesh(io),
dynamicMeshCoeffs_
(
IOdictionary
(
IOobject
(
"dynamicMeshDict",
io.time().constant(),
*this,
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE,
false
)
).subDict(typeName + "Coeffs")
),
SBMFPtr_(solidBodyMotionFunction::New(dynamicMeshCoeffs_, io.time())),
undisplacedPoints_
(
IOobject
(
"points",
io.time().constant(),
meshSubDir,
*this,
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
)
),
zoneID_(-1),
pointIDs_()
{
if (undisplacedPoints_.size() != nPoints())
{
FatalIOErrorIn
(
"solidBodyMotionFvMesh::solidBodyMotionFvMesh(const IOobject&)",
dynamicMeshCoeffs_
) << "Read " << undisplacedPoints_.size()
<< " undisplaced points from " << undisplacedPoints_.objectPath()
<< " but the current mesh has " << nPoints()
<< exit(FatalError);
}
word cellZoneName =
dynamicMeshCoeffs_.lookupOrDefault<word>("cellZone", "none");
if (cellZoneName != "none")
{
zoneID_ = cellZones().findZoneID(cellZoneName);
Info<< "Applying solid body motion to cellZone " << cellZoneName
<< endl;
const cellZone& cz = cellZones()[zoneID_];
// collect point IDs of points in cell zone
boolList movePts(nPoints(), false);
forAll(cz, i)
{
label cellI = cz[i];
const cell& c = cells()[cellI];
forAll(c, j)
{
const face& f = faces()[c[j]];
forAll(f, k)
{
label pointI = f[k];
movePts[pointI] = true;
}
}
Foam::solidBodyMotionFvMesh::solidBodyMotionFvMesh(const IOobject& io)
:
dynamicFvMesh(io),
dynamicMeshCoeffs_
(
IOdictionary
(
IOobject
(
"dynamicMeshDict",
io.time().constant(),
*this,
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE,
false
)
).subDict(typeName + "Coeffs")
),
SBMFPtr_(solidBodyMotionFunction::New(dynamicMeshCoeffs_, io.time())),
undisplacedPoints_
(
IOobject
(
"points",
io.time().constant(),
meshSubDir,
*this,
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
)
),
pointIDs_(),
moveAllCells_(false),
UName_(dynamicMeshCoeffs_.lookupOrDefault<word>("UName", "U"))
{
if (undisplacedPoints_.size() != nPoints())
{
FatalIOErrorIn
(
"solidBodyMotionFvMesh::solidBodyMotionFvMesh(const IOobject&)",
dynamicMeshCoeffs_
) << "Read " << undisplacedPoints_.size()
<< " undisplaced points from " << undisplacedPoints_.objectPath()
<< " but the current mesh has " << nPoints()
<< exit(FatalIOError);
}
word cellZoneName =
dynamicMeshCoeffs_.lookupOrDefault<word>("cellZone", "none");
word cellSetName =
dynamicMeshCoeffs_.lookupOrDefault<word>("cellSet", "none");
if ((cellZoneName != "none") && (cellSetName != "none"))
{
FatalIOErrorIn
(
"solidBodyMotionFvMesh::solidBodyMotionFvMesh(const IOobject&)",
dynamicMeshCoeffs_
)
<< "Either cellZone OR cellSet can be supplied, but not both. "
<< "If neither is supplied, all cells will be included"
<< exit(FatalIOError);
}
labelList cellIDs;
if (cellZoneName != "none")
{
Info<< "Applying solid body motion to cellZone " << cellZoneName
<< endl;
label zoneID = cellZones().findZoneID(cellZoneName);
if (zoneID == -1)
{
FatalErrorIn
(
"solidBodyMotionFvMesh::solidBodyMotionFvMesh(const IOobject&)"
)
<< "Unable to find cellZone " << cellZoneName
<< ". Valid celLZones are:"
<< cellZones().names()
<< exit(FatalError);
}
cellIDs = cellZones()[zoneID];
}
if (cellSetName != "none")
{
Info<< "Applying solid body motion to cellSet " << cellSetName
<< endl;
cellSet set(*this, cellSetName);
cellIDs = set.toc();
}
label nCells = returnReduce(cellIDs.size(), sumOp<label>());
moveAllCells_ = nCells == 0;
if (moveAllCells_)
{
Info<< "Applying solid body motion to entire mesh" << endl;
}
else
{
// collect point IDs of points in cell zone
boolList movePts(nPoints(), false);
forAll(cellIDs, i)
{
label cellI = cellIDs[i];
const cell& c = cells()[cellI];
forAll(c, j)
{
const face& f = faces()[c[j]];
forAll(f, k)
{
label pointI = f[k];
movePts[pointI] = true;
}
}
}
dynamicSolidFvMesh::dynamicSolidFvMesh(const IOobject& io)
:
dynamicFvMesh(io),
fvMesh_(refCast<const fvMesh>(*this)),
pointDisplacement_
(
IOobject
(
"pointDisplacement",
io.time().timeName(),
meshSubDir,
*this,
IOobject::NO_READ,
IOobject::NO_WRITE
),
pointMesh::New(fvMesh_),
dimensionedVector
(
"pointDisplacement",
pointDisplacement_.dimensions(),
vector::zero
)
),
stationaryPoints_
(
IOobject
(
"points",
io.time().constant(),
meshSubDir,
*this,
IOobject::NO_READ,
IOobject::NO_WRITE
)
),
// pointLocation_(NULL),
points0_
(
pointIOField
(
IOobject
(
"points",
io.time().constant(),
meshSubDir,
*this,
IOobject::NO_READ,
IOobject::NO_WRITE
)
)
)
{
// // if (io.headerOk())
// // {
// pointLocation_.reset
// (
// new pointVectorField
// (
// io,
// pointMesh::New(fvMesh_)
// )
// );
//
// if (debug)
// {
// Info<< "displacementLaplacianFvMotionSolver :"
// << " Read pointVectorField "
// << io.name() << " to be used for boundary conditions on points."
// << nl
// << "Boundary conditions:"
// << pointLocation_().boundaryField().types() << endl;
// }
// // }
}
Foam::subsetMotionSolverFvMesh::subsetMotionSolverFvMesh(const IOobject& io)
:
dynamicFvMesh(io),
movingMeshCoeffs_
(
IOdictionary
(
IOobject
(
"dynamicMeshDict",
io.time().constant(),
*this,
IOobject::MUST_READ,
IOobject::NO_WRITE
)
).subDict(typeName + "Coeffs")
),
subsetMesh_
(
IOobject
(
"motion",
io.time().constant(),
*this,
IOobject::NO_READ,
IOobject::NO_WRITE
),
*this
),
motionPtr_(NULL),
alpha_(readScalar(movingMeshCoeffs_.lookup("alpha")))
{
// Create subset
word setName = movingMeshCoeffs_.lookup("set");
cellSet currentSet
(
IOobject
(
setName,
io.time().constant(),
polyMesh::meshSubDir/"sets",
*this,
IOobject::MUST_READ,
IOobject::NO_WRITE
)
);
subsetMesh_.setLargeCellSubset(currentSet, -1);
// Create motion solver on the subset
motionPtr_ = motionSolver::New(subsetMesh_.subMesh());
// Read motion under-relaxation
if (alpha_ < 0 || alpha_ > 1.0)
{
FatalErrorIn
(
"subsetMotionSolverFvMesh::subsetMotionSolverFvMesh"
"(const IOobject& io)"
) << "Ill-defined motion under-relaxation: "
<< "should be between 0 and 1."
<< " Alpha = " << alpha_ << abort(FatalError);
}
}
Foam::fileName Foam::fileOperations::masterFileOperation::filePath
(
const bool checkGlobal,
const IOobject& io,
pathType& searchType,
word& newInstancePath
)
{
newInstancePath = word::null;
if (io.instance().isAbsolute())
{
fileName objectPath = io.instance()/io.name();
if (Foam::isFile(objectPath))
{
searchType = fileOperation::ABSOLUTE;
return objectPath;
}
else
{
searchType = fileOperation::NOTFOUND;
return fileName::null;
}
}
else
{
fileName path = io.path();
fileName objectPath = path/io.name();
if (Foam::isFile(objectPath))
{
searchType = fileOperation::OBJECT;
return objectPath;
}
else
{
if
(
checkGlobal
&& io.time().processorCase()
&& (
io.instance() == io.time().system()
|| io.instance() == io.time().constant()
)
)
{
fileName parentObjectPath =
io.rootPath()/io.time().globalCaseName()
/io.instance()/io.db().dbDir()/io.local()/io.name();
if (Foam::isFile(parentObjectPath))
{
searchType = fileOperation::PARENTOBJECT;
return parentObjectPath;
}
}
//- The big problem with findInstance is that it itself needs file
// access through the fileHandler. Since this routine is only called on the
// master we'll get a deadlock.
// if (!Foam::isDir(path))
// {
// newInstancePath = io.time().findInstancePath
// (
// instant(io.instance())
// );
//
// if (newInstancePath.size())
// {
// fileName fName
// (
// io.rootPath()/io.caseName()
// /newInstancePath/io.db().dbDir()/io.local()/io.name()
// );
//
// if (Foam::isFile(fName))
// {
// searchType = fileOperation::FINDINSTANCE;
// return fName;
// }
// }
// }
// Try constant & local
{
newInstancePath = io.time().constant();
fileName fName
(
io.rootPath()
/io.caseName()
/newInstancePath
/io.db().dbDir()
/io.local()
/io.name()
);
//DebugVar(fName);
if (Foam::isFile(fName))
{
searchType = fileOperation::FINDINSTANCE;
return fName;
}
}
}
return fileName::null;
}
}
Foam::fileName Foam::fileOperations::masterFileOperation::objectPath
(
const IOobject& io,
const pathType& searchType,
const word& instancePath
)
{
// Replacement for IOobject::objectPath()
switch (searchType)
{
case fileOperation::ABSOLUTE:
{
return io.instance()/io.name();
}
break;
case fileOperation::OBJECT:
{
return io.path()/io.name();
}
break;
case fileOperation::PROCESSORSOBJECT:
{
return processorsPath(io, io.instance())/io.name();
}
break;
case fileOperation::PARENTOBJECT:
{
return
io.rootPath()/io.time().globalCaseName()
/io.instance()/io.db().dbDir()/io.local()/io.name();
}
break;
case fileOperation::FINDINSTANCE:
{
return
io.rootPath()/io.caseName()
/instancePath/io.db().dbDir()/io.local()/io.name();
}
break;
case fileOperation::PROCESSORSFINDINSTANCE:
{
return processorsPath(io, instancePath)/io.name();
}
break;
case fileOperation::NOTFOUND:
{
return fileName::null;
}
break;
default:
{
NotImplemented;
return fileName::null;
}
}
}
Foam::searchableExtrudedCircle::searchableExtrudedCircle
(
const IOobject& io,
const dictionary& dict
)
:
searchableSurface(io),
eMeshPtr_
(
edgeMesh::New
(
IOobject
(
dict.lookup("file"), // name
io.time().constant(), // instance
"geometry", // local
io.time(), // registry
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
).objectPath()
)
),
radius_(readScalar(dict.lookup("radius")))
{
const edgeMesh& eMesh = eMeshPtr_();
const pointField& points = eMesh.points();
const edgeList& edges = eMesh.edges();
bounds() = boundBox(points, false);
vector halfSpan(0.5*bounds().span());
point ctr(bounds().midpoint());
bounds().min() = ctr - mag(halfSpan)*vector(1, 1, 1);
bounds().max() = ctr + mag(halfSpan)*vector(1, 1, 1);
// Calculate bb of all points
treeBoundBox bb(bounds());
// Slightly extended bb. Slightly off-centred just so on symmetric
// geometry there are less face/edge aligned items.
bb.min() -= point(ROOTVSMALL, ROOTVSMALL, ROOTVSMALL);
bb.max() += point(ROOTVSMALL, ROOTVSMALL, ROOTVSMALL);
edgeTree_.reset
(
new indexedOctree<treeDataEdge>
(
treeDataEdge
(
false, // do not cache bb
edges,
points,
identity(edges.size())
),
bb, // overall search domain
8, // maxLevel
10, // leafsize
3.0 // duplicity
)
);
}
Foam::multiSolidBodyMotionFvMesh::multiSolidBodyMotionFvMesh(const IOobject& io)
:
dynamicFvMesh(io),
dynamicMeshCoeffs_
(
IOdictionary
(
IOobject
(
"dynamicMeshDict",
io.time().constant(),
*this,
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE,
false
)
).subDict(typeName + "Coeffs")
),
undisplacedPoints_
(
IOobject
(
"points",
io.time().constant(),
meshSubDir,
*this,
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
)
)
{
if (undisplacedPoints_.size() != nPoints())
{
FatalIOErrorInFunction
(
dynamicMeshCoeffs_
) << "Read " << undisplacedPoints_.size()
<< " undisplaced points from " << undisplacedPoints_.objectPath()
<< " but the current mesh has " << nPoints()
<< exit(FatalIOError);
}
zoneIDs_.setSize(dynamicMeshCoeffs_.size());
SBMFs_.setSize(dynamicMeshCoeffs_.size());
pointIDs_.setSize(dynamicMeshCoeffs_.size());
label zoneI = 0;
forAllConstIter(dictionary, dynamicMeshCoeffs_, iter)
{
if (iter().isDict())
{
zoneIDs_[zoneI] = cellZones().findZoneID(iter().keyword());
if (zoneIDs_[zoneI] == -1)
{
FatalIOErrorInFunction
(
dynamicMeshCoeffs_
) << "Cannot find cellZone named " << iter().keyword()
<< ". Valid zones are " << cellZones().names()
<< exit(FatalIOError);
}
const dictionary& subDict = iter().dict();
SBMFs_.set
(
zoneI,
solidBodyMotionFunction::New(subDict, io.time())
);
// Collect points of cell zone.
const cellZone& cz = cellZones()[zoneIDs_[zoneI]];
boolList movePts(nPoints(), false);
forAll(cz, i)
{
label celli = cz[i];
const cell& c = cells()[celli];
forAll(c, j)
{
const face& f = faces()[c[j]];
forAll(f, k)
{
label pointi = f[k];
movePts[pointi] = true;
}
}
}
