Foam::IOobject Foam::fv::IOoptionList::createIOobject
(
const fvMesh& mesh
) const
{
IOobject io
(
"fvOptions",
mesh.time().system(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
);
if (io.headerOk())
{
Info<< "Creating fintite volume options from " << io.name() << nl
<< endl;
io.readOpt() = IOobject::MUST_READ_IF_MODIFIED;
return io;
}
else
{
Info<< "No finite volume options present" << nl << endl;
io.readOpt() = IOobject::NO_READ;
return io;
}
}
Foam::IOList<T>::IOList(const IOobject& io)
:
regIOobject(io)
{
// Temporary warning
if (io.readOpt() == IOobject::MUST_READ_IF_MODIFIED)
{
WarningIn("IOList::IOList(const IOobject&)")
<< "IOList " << name()
<< " constructed with IOobject::MUST_READ_IF_MODIFIED"
" but IOList does not support automatic rereading."
<< endl;
}
if
(
(
io.readOpt() == IOobject::MUST_READ
|| io.readOpt() == IOobject::MUST_READ_IF_MODIFIED
)
|| (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
)
{
readStream(typeName) >> *this;
close();
}
Foam::binaryOperationSearchableSurface::binaryOperationSearchableSurface
(
const IOobject& io,
const dictionary& dict
)
:
searchableSurface(io),
aName_(dict.lookupOrDefault<word>("aName","A")),
bName_(dict.lookupOrDefault<word>("bName","B")),
a_(
searchableSurface::New
(
word(dict.subDict("a").lookup("type")),
IOobject(
name()+"_"+word(dict.lookup("type"))+"_"+aName_,
io.instance(),
io.db(),
io.readOpt(),
io.writeOpt()
),
dict.subDict("a")
)
),
b_(
searchableSurface::New
(
word(dict.subDict("b").lookup("type")),
IOobject(
name()+"_"+word(dict.lookup("type"))+"_"+bName_,
io.instance(),
io.db(),
io.readOpt(),
io.writeOpt()
),
dict.subDict("b")
)
),
nrARegions_(
a().regions().size()
),
nrBRegions_(
b().regions().size()
)
{
if(aName_==bName_) {
FatalErrorIn("binaryOperationSearchableSurface::binaryOperationSearchableSurface")
<< "'aName' and 'bName' have the same value " << aName_
<< " for " << name()
<< endl
<< exit(FatalError);
}
if(regions().size()!=size()) {
FatalErrorIn("binaryOperationSearchableSurface::binaryOperationSearchableSurface")
<< "Number of regions " << regions().size() << " not equal to size "
<< size() << nl << "Regions: " << regions()
<< endl
<< exit(FatalError);
}
}
Foam::IOobject Foam::IOporosityModelList::createIOobject
(
const fvMesh& mesh
) const
{
IOobject io
(
"porosityProperties",
mesh.time().constant(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
);
if (io.typeHeaderOk<IOdictionary>(true))
{
Info<< "Creating porosity model list from " << io.name() << nl << endl;
io.readOpt() = IOobject::MUST_READ_IF_MODIFIED;
return io;
}
else
{
Info<< "No porosity models present" << nl << endl;
io.readOpt() = IOobject::NO_READ;
return io;
}
}
Foam::IOdictionary::IOdictionary(const IOobject& io, const dictionary& dict)
:
regIOobject(io)
{
// Temporary warning
if (debug && io.readOpt() == IOobject::MUST_READ)
{
WarningIn
(
"IOdictionary::IOdictionary(const IOobject& const dictionary&)"
) << "Dictionary " << name()
<< " constructed with IOobject::MUST_READ"
" instead of IOobject::MUST_READ_IF_MODIFIED." << nl
<< "Use MUST_READ_IF_MODIFIED if you need automatic rereading."
<< endl;
}
// Everyone check or just master
bool masterOnly =
regIOobject::fileModificationChecking == timeStampMaster
|| regIOobject::fileModificationChecking == inotifyMaster;
// Check if header is ok for READ_IF_PRESENT
bool isHeaderOk = false;
if (io.readOpt() == IOobject::READ_IF_PRESENT)
{
if (masterOnly)
{
if (Pstream::master())
{
isHeaderOk = headerOk();
}
Pstream::scatter(isHeaderOk);
}
else
{
isHeaderOk = headerOk();
}
}
if
(
(
io.readOpt() == IOobject::MUST_READ
|| io.readOpt() == IOobject::MUST_READ_IF_MODIFIED
)
|| isHeaderOk
)
{
readFile(masterOnly);
}
else
{
dictionary::operator=(dict);
}
dictionary::name() = IOobject::objectPath();
}
Foam::IOobject Foam::IOMRFZoneList::createIOobject
(
const fvMesh& mesh
) const
{
IOobject io
(
"MRFProperties",
mesh.time().constant(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
);
if (io.headerOk())
{
Info<< "Creating MRF zone list from " << io.name() << endl;
io.readOpt() = IOobject::MUST_READ_IF_MODIFIED;
return io;
}
else
{
Info<< "No MRF models present" << nl << endl;
io.readOpt() = IOobject::NO_READ;
return io;
}
}
Foam::IOList<T>::IOList(const IOobject& io)
:
regIOobject(io)
{
if
(
io.readOpt() == IOobject::MUST_READ
|| (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
)
{
readStream(typeName) >> *this;
close();
}
Foam::featureEdgeMesh::featureEdgeMesh(const IOobject& io)
:
regIOobject(io),
edgeMesh(pointField(0), edgeList(0))
{
if
(
io.readOpt() == IOobject::MUST_READ
|| (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
)
{
readStream(typeName) >> *this;
close();
}
Foam::IOPtrList<T>::IOPtrList(const IOobject& io)
:
regIOobject(io)
{
if
(
io.readOpt() == IOobject::MUST_READ
|| (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
)
{
PtrList<T>::read(readStream(typeName), INew<T>());
close();
}
}
IOPatchToPatchInterpolation<FromPatch, ToPatch>::IOPatchToPatchInterpolation
(
const IOobject& io,
const FromPatch& fromPatch,
const ToPatch& toPatch,
intersection::algorithm alg,
const intersection::direction dir
)
:
regIOobject(io),
PatchToPatchInterpolation<FromPatch, ToPatch>(fromPatch, toPatch, alg, dir)
{
if (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
{
Istream& is = readStream(typeName);
labelList* paPtr = new labelList(is);
FieldField<Field, scalar>* pwPtr = new FieldField<Field, scalar>(is);
scalarField* pdPtr = new scalarField(is);
labelList* faPtr = new labelList(is);
FieldField<Field, scalar>* fwPtr = new FieldField<Field, scalar>(is);
scalarField* fdPtr = new scalarField(is);
Info << "Setting weights from file" << endl;
this->setWeights(paPtr, pwPtr, pdPtr, faPtr, fwPtr, fdPtr);
}
}
Foam::IOPtrList<T>::IOPtrList(const IOobject& io, const INew& inewt)
:
regIOobject(io)
{
if
(
(
io.readOpt() == IOobject::MUST_READ
|| io.readOpt() == IOobject::MUST_READ_IF_MODIFIED
)
|| (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
)
{
PtrList<T>::read(readStream(typeName), inewt);
close();
}
}
Foam::IOEquationReader::IOEquationReader
(
const IOobject& io,
const bool showDataSourceInfo
)
:
regIOobject(io),
showDataSourceInfo_(showDataSourceInfo)
{
if
(
io.readOpt() == IOobject::MUST_READ
|| (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
)
{
readStream(typeName) >> *this;
close();
}
Foam::IOPtrList<T>::IOPtrList(const IOobject& io, const Xfer<PtrList<T> >& list)
:
regIOobject(io)
{
PtrList<T>::transfer(list());
if
(
(
io.readOpt() == IOobject::MUST_READ
|| io.readOpt() == IOobject::MUST_READ_IF_MODIFIED
)
|| (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
)
{
PtrList<T>::read(readStream(typeName), INew<T>());
close();
}
}
Foam::IOField<Type>::IOField(const IOobject& io)
:
regIOobject(io)
{
// Check for MUST_READ_IF_MODIFIED
warnNoRereading<IOField<Type>>();
if
(
(
io.readOpt() == IOobject::MUST_READ
|| io.readOpt() == IOobject::MUST_READ_IF_MODIFIED
)
|| (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
)
{
readStream(typeName) >> *this;
close();
}
Foam::IOPtrList<T>::IOPtrList(const IOobject& io, const label s)
:
regIOobject(io),
PtrList<T>(s)
{
if (io.readOpt() != IOobject::NO_READ)
{
FatalErrorIn("IOPtrList<T>::IOPtrList(const IOobject&, const label)")
<< "NO_READ must be set if specifying size" << nl
<< exit(FatalError);
}
}
Foam::IOPtrList<T>::IOPtrList(const IOobject& io, const PtrList<T>& list)
:
regIOobject(io)
{
if
(
(
io.readOpt() == IOobject::MUST_READ
|| io.readOpt() == IOobject::MUST_READ_IF_MODIFIED
)
|| (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
)
{
PtrList<T>::read(readStream(typeName), INew<T>());
close();
}
else
{
PtrList<T>::operator=(list);
}
}
Foam::IOReferencer<Type>::IOReferencer
(
const IOobject& io
)
:
regIOobject(io),
typePtr_(NULL)
{
if
(
io.readOpt() != IOobject::NO_READ
|| io.writeOpt() != IOobject::NO_WRITE
)
{
FatalErrorIn("IOReferencer<Type>::IOReferencer")
<< "IOReferencer can only be NO_READ, NO_WRITE."
<< abort(FatalError);
}
}
Foam::binaryOperationSearchableSurface::binaryOperationSearchableSurface
(
const IOobject& io,
const dictionary& dict
)
:
searchableSurface(io),
aName_(dict.lookupOrDefault<word>("aName","A")),
bName_(dict.lookupOrDefault<word>("bName","B")),
a_(
searchableSurface::New
(
word(dict.subDict("a").lookup("type")),
IOobject(
name()+"_"+word(dict.lookup("type"))+"_"+aName_,
io.instance(),
io.db(),
io.readOpt(),
io.writeOpt()
),
dict.subDict("a")
)
),
b_(
searchableSurface::New
(
word(dict.subDict("b").lookup("type")),
IOobject(
name()+"_"+word(dict.lookup("type"))+"_"+bName_,
io.instance(),
io.db(),
io.readOpt(),
io.writeOpt()
),
dict.subDict("b")
)
),
nrARegions_(
a().regions().size()
),
nrBRegions_(
b().regions().size()
)
{
if(aName_==bName_) {
FatalErrorIn("binaryOperationSearchableSurface::binaryOperationSearchableSurface")
<< "'aName' and 'bName' have the same value " << aName_
<< " for " << name()
<< endl
<< exit(FatalError);
}
if(regions().size()!=size()) {
FatalErrorIn("binaryOperationSearchableSurface::binaryOperationSearchableSurface")
<< "Number of regions " << regions().size() << " not equal to size "
<< size() << nl << "Regions: " << regions()
<< endl
<< exit(FatalError);
}
#ifdef FOAM_SEARCHABLE_SURF_HAS_BOUND_METHOD
pointField pts(4);
pts[0]=a().bounds().min();
pts[1]=a().bounds().max();
pts[2]=b().bounds().min();
pts[3]=b().bounds().max();
bounds()=boundBox(pts);
#endif
}
Foam::polyMesh::polyMesh
(
const IOobject& io,
const Xfer<pointField>& points,
const Xfer<faceList>& faces,
const Xfer<labelList>& owner,
const Xfer<labelList>& neighbour,
const bool syncPar
)
:
objectRegistry(io),
primitiveMesh(),
points_
(
IOobject
(
"points",
instance(),
meshSubDir,
*this,
io.readOpt(),
IOobject::AUTO_WRITE
),
points
),
faces_
(
IOobject
(
"faces",
instance(),
meshSubDir,
*this,
io.readOpt(),
IOobject::AUTO_WRITE
),
faces
),
owner_
(
IOobject
(
"owner",
instance(),
meshSubDir,
*this,
io.readOpt(),
IOobject::AUTO_WRITE
),
owner
),
neighbour_
(
IOobject
(
"neighbour",
instance(),
meshSubDir,
*this,
io.readOpt(),
IOobject::AUTO_WRITE
),
neighbour
),
clearedPrimitives_(false),
boundary_
(
IOobject
(
"boundary",
instance(),
meshSubDir,
*this,
io.readOpt(),
IOobject::AUTO_WRITE
),
*this,
polyPatchList()
),
bounds_(points_, syncPar),
comm_(UPstream::worldComm),
geometricD_(Vector<label>::zero),
solutionD_(Vector<label>::zero),
tetBasePtIsPtr_(NULL),
cellTreePtr_(NULL),
pointZones_
(
IOobject
(
"pointZones",
instance(),
meshSubDir,
*this,
io.readOpt(),
IOobject::NO_WRITE
),
*this,
PtrList<pointZone>()
),
faceZones_
(
IOobject
(
"faceZones",
instance(),
meshSubDir,
*this,
io.readOpt(),
IOobject::NO_WRITE
),
*this,
PtrList<faceZone>()
),
cellZones_
(
IOobject
(
"cellZones",
instance(),
meshSubDir,
*this,
io.readOpt(),
IOobject::NO_WRITE
),
*this,
PtrList<cellZone>()
),
globalMeshDataPtr_(NULL),
moving_(false),
topoChanging_(false),
curMotionTimeIndex_(time().timeIndex()),
oldPointsPtr_(NULL)
{
// Check if the faces and cells are valid
forAll(faces_, facei)
{
const face& curFace = faces_[facei];
if (min(curFace) < 0 || max(curFace) > points_.size())
{
FatalErrorIn
(
"polyMesh::polyMesh\n"
"(\n"
" const IOobject& io,\n"
" const pointField& points,\n"
" const faceList& faces,\n"
" const cellList& cells\n"
")\n"
) << "Face " << facei << "contains vertex labels out of range: "
<< curFace << " Max point index = " << points_.size()
<< abort(FatalError);
}
}
// Set the primitive mesh
initMesh();
}
Foam::extendedFeatureEdgeMesh::extendedFeatureEdgeMesh(const IOobject& io)
:
regIOobject(io),
edgeMesh(pointField(0), edgeList(0)),
concaveStart_(0),
mixedStart_(0),
nonFeatureStart_(0),
internalStart_(0),
flatStart_(0),
openStart_(0),
multipleStart_(0),
normals_(0),
edgeDirections_(0),
edgeNormals_(0),
featurePointNormals_(0),
featurePointEdges_(0),
regionEdges_(0),
pointTree_(),
edgeTree_(),
edgeTreesByType_()
{
if
(
io.readOpt() == IOobject::MUST_READ
|| io.readOpt() == IOobject::MUST_READ_IF_MODIFIED
|| (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
)
{
if (readOpt() == IOobject::MUST_READ_IF_MODIFIED)
{
WarningIn
(
"extendedFeatureEdgeMesh::extendedFeatureEdgeMesh"
"(const IOobject&)"
) << "Specified IOobject::MUST_READ_IF_MODIFIED but class"
<< " does not support automatic rereading."
<< endl;
}
Istream& is = readStream(typeName);
is >> *this
>> concaveStart_
>> mixedStart_
>> nonFeatureStart_
>> internalStart_
>> flatStart_
>> openStart_
>> multipleStart_
>> normals_
>> edgeNormals_
>> featurePointNormals_
>> featurePointEdges_
>> regionEdges_;
close();
{
// Calculate edgeDirections
const edgeList& eds(edges());
const pointField& pts(points());
edgeDirections_.setSize(eds.size());
forAll(eds, eI)
{
edgeDirections_[eI] = eds[eI].vec(pts);
}
edgeDirections_ /= mag(edgeDirections_);
}
}