// Check for any unset patches
forAll(bmesh_, patchi)
{
if (!this->set(patchi))
{
if (bmesh_[patchi].type() == cyclicPolyPatch::typeName)
{
FatalIOErrorInFunction
(
dict
) << "Cannot find patchField entry for cyclic "
<< bmesh_[patchi].name() << endl
<< "Is your field uptodate with split cyclics?" << endl
<< "Run foamUpgradeCyclics to convert mesh and fields"
<< " to split cyclics." << exit(FatalIOError);
}
else
{
FatalIOErrorInFunction
(
dict
) << "Cannot find patchField entry for "
<< bmesh_[patchi].name() << exit(FatalIOError);
}
}
}
void Foam::dynamicCode::checkSecurity
(
const char* title,
const dictionary& dict
)
{
if (isAdministrator())
{
FatalIOErrorInFunction(dict)
<< "This code should not be executed by someone with administrator"
<< " rights due to security reasons." << nl
<< "(it writes a shared library which then gets loaded "
<< "using dlopen)"
<< exit(FatalIOError);
}
if (!allowSystemOperations)
{
FatalIOErrorInFunction(dict)
<< "Loading a shared library using case-supplied code is not"
<< " enabled by default" << nl
<< "because of security issues. If you trust the code you can"
<< " enable this" << nl
<< "facility be adding to the InfoSwitches setting in the system"
<< " controlDict:" << nl << nl
<< " allowSystemOperations 1" << nl << nl
<< "The system controlDict is either" << nl << nl
<< " ~/.OpenFOAM/$WM_PROJECT_VERSION/controlDict" << nl << nl
<< "or" << nl << nl
<< " $WM_PROJECT_DIR/etc/controlDict" << nl
<< endl
<< exit(FatalIOError);
}
}
forAll(patchFaces, facei)
{
face& f = patchFaces[facei];
// Replace (<block> <face>) face description
// with the corresponding block face
if (f.size() == 2)
{
const label bi = f[0];
const label fi = f[1];
if (bi >= size())
{
FatalIOErrorInFunction(source)
<< "Block index out of range for patch face " << f << nl
<< " Number of blocks = " << size()
<< ", index = " << f[0] << nl
<< " on patch " << patchName << ", face " << facei
<< exit(FatalIOError);
}
else if (fi >= operator[](bi).blockShape().faces().size())
{
FatalIOErrorInFunction(source)
<< "Block face index out of range for patch face " << f
<< nl
<< " Number of block faces = "
<< operator[](bi).blockShape().faces().size()
<< ", index = " << f[1] << nl
<< " on patch " << patchName << ", face " << facei
<< exit(FatalIOError);
}
else
{
f = operator[](bi).blockShape().faces()[fi];
}
}
else
{
forAll(f, fp)
{
if (f[fp] < 0)
{
FatalIOErrorInFunction(source)
<< "Negative point label " << f[fp] << nl
<< " on patch " << patchName << ", face " << facei
<< exit(FatalIOError);
}
else if (f[fp] >= points.size())
{
FatalIOErrorInFunction(source)
<< "Point label " << f[fp]
<< " out of range 0.." << points.size() - 1 << nl
<< " on patch " << patchName << ", face " << facei
<< exit(FatalIOError);
}
}
}
}
Foam::string Foam::functionEntries::negEntry::negateVariable
(
const dictionary& parentDict,
Istream& is
)
{
// Read variable name as a word including the '$'
const word varWord(is);
if (varWord[0] != '$')
{
FatalIOErrorInFunction
(
parentDict
) << "Expected variable name beginning with a '$' but found '"
<< varWord << "'" << exit(FatalIOError);
return string::null;
}
// Strip the leading '$' from the variable name
const string varName = varWord(1, varWord.size()-1);
// Lookup the variable name in the parent dictionary....
const entry* ePtr = parentDict.lookupScopedEntryPtr(varName, true, false);
if (ePtr && ePtr->isStream())
{
const token variable(ePtr->stream());
// Convert to a string
OStringStream os(is.format());
os << variable;
const string str(os.str());
// Negate
if (str[0] == '-')
{
return str(1, str.size() - 1);
}
else
{
return '-' + str;
}
}
else
{
FatalIOErrorInFunction
(
parentDict
) << "Illegal dictionary variable name " << varName << endl
<< "Valid dictionary entries are " << parentDict.toc()
<< exit(FatalIOError);
return string::null;
}
}
Foam::string Foam::stringOps::getVariable
(
const word& name,
const dictionary& dict,
const bool allowEnvVars,
const bool allowEmpty
)
{
string value;
const entry* ePtr = dict.lookupScopedEntryPtr
(
name,
true,
false
);
if (ePtr)
{
OStringStream buf;
// Force floating point numbers to be printed with at least
// some decimal digits.
buf << fixed;
buf.precision(IOstream::defaultPrecision());
// fail for non-primitiveEntry
dynamicCast<const primitiveEntry>
(
*ePtr
).write(buf, true);
value = buf.str();
}
else if (allowEnvVars)
{
value = getEnv(name);
if (value.empty())
{
FatalIOErrorInFunction
(
dict
) << "Cannot find dictionary or environment variable "
<< name << exit(FatalIOError);
}
}
else
{
FatalIOErrorInFunction
(
dict
) << "Cannot find dictionary variable "
<< name << exit(FatalIOError);
}
return value;
}
Foam::tmp<Foam::fvsPatchField<Type>> Foam::fvsPatchField<Type>::New
(
const fvPatch& p,
const DimensionedField<Type, surfaceMesh>& iF,
const dictionary& dict
)
{
if (debug)
{
InfoInFunction << "Constructing fvsPatchField<Type>" << endl;
}
const word patchFieldType(dict.get<word>("type"));
auto cstrIter = dictionaryConstructorTablePtr_->cfind(patchFieldType);
if (!cstrIter.found())
{
if (!disallowGenericFvsPatchField)
{
cstrIter = dictionaryConstructorTablePtr_->cfind("generic");
}
if (!cstrIter.found())
{
FatalIOErrorInFunction(dict)
<< "Unknown patchField type " << patchFieldType
<< " for patch type " << p.type() << nl << nl
<< "Valid patchField types :" << endl
<< dictionaryConstructorTablePtr_->sortedToc()
<< exit(FatalIOError);
}
}
if
(
!dict.found("patchType")
|| dict.get<word>("patchType") != p.type()
)
{
auto patchTypeCstrIter
= dictionaryConstructorTablePtr_->cfind(p.type());
if (patchTypeCstrIter.found() && patchTypeCstrIter() != cstrIter())
{
FatalIOErrorInFunction(dict)
<< "inconsistent patch and patchField types for \n"
" patch type " << p.type()
<< " and patchField type " << patchFieldType
<< exit(FatalIOError);
}
}
return cstrIter()(p, iF, dict);
}
void Foam::codedBase::unloadLibrary
(
const fileName& libPath,
const string& globalFuncName,
const dictionary& contextDict
) const
{
void* lib = 0;
if (libPath.empty())
{
return;
}
lib = libs().findLibrary(libPath);
if (!lib)
{
return;
}
// provision for manual execution of code before unloading
if (dlSymFound(lib, globalFuncName))
{
loaderFunctionType function =
reinterpret_cast<loaderFunctionType>
(
dlSym(lib, globalFuncName)
);
if (function)
{
(*function)(false); // force unload
}
else
{
FatalIOErrorInFunction
(
contextDict
) << "Failed looking up symbol " << globalFuncName << nl
<< "from " << libPath << exit(FatalIOError);
}
}
if (!libs().close(libPath, false))
{
FatalIOErrorInFunction
(
contextDict
) << "Failed unloading library " << libPath
<< exit(FatalIOError);
}
}
Foam::sampledIsoSurface::sampledIsoSurface
(
const word& name,
const polyMesh& mesh,
const dictionary& dict
)
:
sampledSurface(name, mesh, dict),
isoField_(dict.lookup("isoField")),
isoVal_(readScalar(dict.lookup("isoValue"))),
mergeTol_(dict.lookupOrDefault("mergeTol", 1e-6)),
regularise_(dict.lookupOrDefault("regularise", true)),
average_(dict.lookupOrDefault("average", false)),
zoneID_(dict.lookupOrDefault("zone", word::null), mesh.cellZones()),
exposedPatchName_(word::null),
surfPtr_(nullptr),
facesPtr_(nullptr),
prevTimeIndex_(-1),
storedVolFieldPtr_(nullptr),
volFieldPtr_(nullptr),
pointFieldPtr_(nullptr)
{
if (!sampledSurface::interpolate())
{
FatalIOErrorInFunction
(
dict
) << "Non-interpolated iso surface not supported since triangles"
<< " span across cells." << exit(FatalIOError);
}
if (zoneID_.index() != -1)
{
dict.lookup("exposedPatchName") >> exposedPatchName_;
if (mesh.boundaryMesh().findPatchID(exposedPatchName_) == -1)
{
FatalIOErrorInFunction
(
dict
) << "Cannot find patch " << exposedPatchName_
<< " in which to put exposed faces." << endl
<< "Valid patches are " << mesh.boundaryMesh().names()
<< exit(FatalIOError);
}
if (debug && zoneID_.index() != -1)
{
Info<< "Restricting to cellZone " << zoneID_.name()
<< " with exposed internal faces into patch "
<< exposedPatchName_ << endl;
}
}
Foam::Istream& Foam::ISstream::readVerbatim(string& str)
{
static const int maxLen = 8000;
static const int errLen = 80; // truncate error message for readability
static char buf[maxLen];
char c;
int nChar = 0;
while (get(c))
{
if (c == token::HASH)
{
char nextC;
get(nextC);
if (nextC == token::END_BLOCK)
{
buf[nChar] = '\0';
str = buf;
return *this;
}
else
{
putback(nextC);
}
}
buf[nChar++] = c;
if (nChar == maxLen)
{
buf[errLen] = '\0';
FatalIOErrorInFunction(*this)
<< "string \"" << buf << "...\"\n"
<< " is too long (max. " << maxLen << " characters)"
<< exit(FatalIOError);
return *this;
}
}
// don't worry about a dangling backslash if string terminated prematurely
buf[errLen] = buf[nChar] = '\0';
FatalIOErrorInFunction(*this)
<< "problem while reading string \"" << buf << "...\""
<< exit(FatalIOError);
return *this;
}
tmp<convectionScheme<Type> > convectionScheme<Type>::New
(
const fvMesh& mesh,
const typename multivariateSurfaceInterpolationScheme<Type>::
fieldTable& fields,
const surfaceScalarField& faceFlux,
Istream& schemeData
)
{
if (fv::debug)
{
Info<< "convectionScheme<Type>::New"
"(const fvMesh&, "
"const typename multivariateSurfaceInterpolationScheme<Type>"
"::fieldTable&, const surfaceScalarField&, Istream&) : "
"constructing convectionScheme<Type>"
<< endl;
}
if (schemeData.eof())
{
FatalIOErrorInFunction
(
schemeData
) << "Convection scheme not specified" << endl << endl
<< "Valid convection schemes are :" << endl
<< MultivariateConstructorTablePtr_->sortedToc()
<< exit(FatalIOError);
}
const word schemeName(schemeData);
typename MultivariateConstructorTable::iterator cstrIter =
MultivariateConstructorTablePtr_->find(schemeName);
if (cstrIter == MultivariateConstructorTablePtr_->end())
{
FatalIOErrorInFunction
(
schemeData
) << "Unknown convection scheme " << schemeName << nl << nl
<< "Valid convection schemes are :" << endl
<< MultivariateConstructorTablePtr_->sortedToc()
<< exit(FatalIOError);
}
return cstrIter()(mesh, fields, faceFlux, schemeData);
}
Foam::autoPtr<Foam::cellZone> Foam::cellZone::New
(
const word& name,
const dictionary& dict,
const label index,
const cellZoneMesh& zm
)
{
if (debug)
{
Info<< "cellZone::New(const word&, const dictionary&, const label, "
"const cellZoneMesh&) : constructing cellZone " << name
<< endl;
}
const word zoneType(dict.lookup("type"));
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(zoneType);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalIOErrorInFunction
(
dict
) << "Unknown cellZone type "
<< zoneType << nl << nl
<< "Valid cellZone types are:" << nl
<< dictionaryConstructorTablePtr_->sortedToc()
<< exit(FatalIOError);
}
return autoPtr<cellZone>(cstrIter()(name, dict, index, zm));
}
Foam::fvsPatchField<Type>::fvsPatchField
(
const fvPatch& p,
const DimensionedField<Type, surfaceMesh>& iF,
const dictionary& dict
)
:
Field<Type>(p.size()),
patch_(p),
internalField_(iF)
{
if (dict.found("value"))
{
fvsPatchField<Type>::operator=
(
Field<Type>("value", dict, p.size())
);
}
else
{
FatalIOErrorInFunction(dict)
<< "essential 'value' entry not provided"
<< exit(FatalIOError);
}
}
Foam::processorFvPatchField<Type>::processorFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
coupledFvPatchField<Type>(p, iF, dict),
procPatch_(refCast<const processorFvPatch>(p)),
sendBuf_(0),
receiveBuf_(0),
outstandingSendRequest_(-1),
outstandingRecvRequest_(-1),
scalarSendBuf_(0),
scalarReceiveBuf_(0)
{
if (!isA<processorFvPatch>(p))
{
FatalIOErrorInFunction
(
dict
) << "\n patch type '" << p.type()
<< "' not constraint type '" << typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << this->internalField().name()
<< " in file " << this->internalField().objectPath()
<< exit(FatalIOError);
}
}
bool Foam::functionEntries::includeEntry::execute
(
dictionary& parentDict,
Istream& is
)
{
const fileName rawFName(is);
const fileName fName
(
includeFileName(is.name().path(), rawFName, parentDict)
);
IFstream ifs(fName);
if (ifs)
{
if (Foam::functionEntries::includeEntry::log)
{
Info<< fName << endl;
}
parentDict.read(ifs);
return true;
}
else
{
FatalIOErrorInFunction
(
is
) << "Cannot open include file "
<< (ifs.name().size() ? ifs.name() : rawFName)
<< " while reading dictionary " << parentDict.name()
<< exit(FatalIOError);
return false;
}
}
Foam::autoPtr<Foam::coordinateRotation> Foam::coordinateRotation::New
(
const dictionary& dict
)
{
if (debug)
{
Pout<< "coordinateRotation::New(const dictionary&) : "
<< "constructing coordinateRotation"
<< endl;
}
word rotType = dict.lookup("type");
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(rotType);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalIOErrorInFunction
(
dict
) << "Unknown coordinateRotation type "
<< rotType << nl << nl
<< "Valid coordinateRotation types are :" << nl
<< dictionaryConstructorTablePtr_->sortedToc()
<< exit(FatalIOError);
}
return autoPtr<coordinateRotation>(cstrIter()(dict));
}
Foam::cyclicAMIFvPatchField<Type>::cyclicAMIFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
cyclicAMILduInterfaceField(),
coupledFvPatchField<Type>(p, iF, dict),
cyclicAMIPatch_(refCast<const cyclicAMIFvPatch>(p))
{
if (!isA<cyclicAMIFvPatch>(p))
{
FatalIOErrorInFunction
(
dict
) << " patch type '" << p.type()
<< "' not constraint type '" << typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << this->internalField().name()
<< " in file " << this->internalField().objectPath()
<< exit(FatalIOError);
}
if (!dict.found("value") && this->coupled())
{
this->evaluate(Pstream::blocking);
}
}
Foam::autoPtr<Foam::lduInterface> Foam::lduInterface::New
(
const dictionary& dict,
const label index
)
{
word patchType(dict.lookup("type"));
if (debug)
{
InfoInFunction << "Constructing lduInterface " << patchType << endl;
}
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(patchType);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalIOErrorInFunction
(
dict
) << "Unknown lduInterface type "
<< patchType << nl << nl
<< "Valid lduInterface types are :" << endl
<< dictionaryConstructorTablePtr_->sortedToc()
<< exit(FatalIOError);
}
return autoPtr<lduInterface>(cstrIter()(dict, index));
}
Foam::autoPtr<Foam::lduInterface> Foam::lduInterface::New
(
const word& patchType,
Istream& is
)
{
if (debug)
{
InfoInFunction << "Constructing lduInterface " << patchType << endl;
}
IstreamConstructorTable::iterator cstrIter =
IstreamConstructorTablePtr_->find(patchType);
if (cstrIter == IstreamConstructorTablePtr_->end())
{
FatalIOErrorInFunction
(
is
) << "Unknown lduInterface type "
<< patchType << nl << nl
<< "Valid lduInterface types are :" << endl
<< IstreamConstructorTablePtr_->sortedToc()
<< exit(FatalIOError);
}
return autoPtr<lduInterface>(cstrIter()(is));
}
Foam::projectEdge::projectEdge
(
const dictionary& dict,
const label index,
const searchableSurfaces& geometry,
const pointField& points,
Istream& is
)
:
blockEdge(dict, index, points, is),
geometry_(geometry)
{
wordList names(is);
surfaces_.setSize(names.size());
forAll(names, i)
{
surfaces_[i] = geometry_.findSurfaceID(names[i]);
if (surfaces_[i] == -1)
{
FatalIOErrorInFunction(is)
<< "Cannot find surface " << names[i] << " in geometry"
<< exit(FatalIOError);
}
}
Foam::valuePointPatchField<Type>::valuePointPatchField
(
const pointPatch& p,
const DimensionedField<Type, pointMesh>& iF,
const dictionary& dict,
const bool valueRequired
)
:
pointPatchField<Type>(p, iF, dict),
Field<Type>(p.size())
{
if (dict.found("value"))
{
Field<Type>::operator=
(
Field<Type>("value", dict, p.size())
);
}
else if (!valueRequired)
{
Field<Type>::operator=(Zero);
}
else
{
FatalIOErrorInFunction
(
dict
) << "Essential entry 'value' missing"
<< exit(FatalIOError);
}
}
Foam::tmp<Foam::multivariateSurfaceInterpolationScheme<Type>>
Foam::multivariateSurfaceInterpolationScheme<Type>::New
(
const fvMesh& mesh,
const multivariateSurfaceInterpolationScheme<Type>::fieldTable& vtfs,
const surfaceScalarField& faceFlux,
Istream& schemeData
)
{
if (fv::debug)
{
InfoInFunction
<< "Constructing surfaceInterpolationScheme<Type>" << endl;
}
const word schemeName(schemeData);
typename IstreamConstructorTable::iterator constructorIter =
IstreamConstructorTablePtr_->find(schemeName);
if (constructorIter == IstreamConstructorTablePtr_->end())
{
FatalIOErrorInFunction
(
schemeData
) << "Unknown discretisation scheme " << schemeName << nl << nl
<< "Valid schemes are :" << endl
<< IstreamConstructorTablePtr_->sortedToc()
<< exit(FatalIOError);
}
return constructorIter()(mesh, vtfs, faceFlux, schemeData);
}
Foam::processorCyclicFvPatchField<Type>::processorCyclicFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
processorFvPatchField<Type>(p, iF, dict),
procPatch_(refCast<const processorCyclicFvPatch>(p))
{
if (!isType<processorCyclicFvPatch>(p))
{
FatalIOErrorInFunction
(
dict
) << "\n patch type '" << p.type()
<< "' not constraint type '" << typeName << "'"
<< "\n for patch " << p.name()
<< " of field " << this->internalField().name()
<< " in file " << this->internalField().objectPath()
<< exit(FatalIOError);
}
if (Pstream::defaultCommsType == Pstream::commsTypes::scheduled)
{
WarningInFunction
<< "Scheduled communication with split cyclics not supported."
<< endl;
}
}
void Foam::functionEntries::ifeqEntry::skipUntil
(
DynamicList<filePos>& stack,
const dictionary& parentDict,
const word& endWord,
Istream& is
)
{
while (!is.eof())
{
token t;
readToken(t, is);
if (t.isWord())
{
if (t.wordToken() == "#if" || t.wordToken() == "#ifeq")
{
stack.append(filePos(is.name(), is.lineNumber()));
skipUntil(stack, parentDict, "#endif", is);
stack.remove();
}
else if (t.wordToken() == endWord)
{
return;
}
}
}
FatalIOErrorInFunction(parentDict)
<< "Did not find matching " << endWord << exit(FatalIOError);
}
Foam::radiationCoupledBase::radiationCoupledBase
(
const fvPatch& patch,
const dictionary& dict
)
:
patch_(patch),
method_(emissivityMethodTypeNames_.read(dict.lookup("emissivityMode")))
{
switch (method_)
{
case SOLIDRADIATION:
{
if (!isA<mappedPatchBase>(patch_.patch()))
{
FatalIOErrorInFunction
(
dict
) << "\n patch type '" << patch_.type()
<< "' not type '" << mappedPatchBase::typeName << "'"
<< "\n for patch " << patch_.name()
<< exit(FatalIOError);
}
emissivity_ = scalarField(patch_.size(), 0.0);
}
break;
case LOOKUP:
{
if (!dict.found("emissivity"))
{
FatalIOErrorInFunction
(
dict
) << "\n emissivity key does not exist for patch "
<< patch_.name()
<< exit(FatalIOError);
}
else
{
emissivity_ = scalarField("emissivity", dict, patch_.size());
}
}
break;
}
}
Foam::timeVaryingMappedFixedValueFvPatchField<Type>::
timeVaryingMappedFixedValueFvPatchField
(
const fvPatch& p,
const DimensionedField<Type, volMesh>& iF,
const dictionary& dict
)
:
fixedValueFvPatchField<Type>(p, iF),
fieldTableName_(iF.name()),
setAverage_(readBool(dict.lookup("setAverage"))),
perturb_(dict.lookupOrDefault("perturb", 1e-5)),
mapMethod_
(
dict.lookupOrDefault<word>
(
"mapMethod",
"planarInterpolation"
)
),
mapperPtr_(NULL),
sampleTimes_(0),
startSampleTime_(-1),
startSampledValues_(0),
startAverage_(Zero),
endSampleTime_(-1),
endSampledValues_(0),
endAverage_(Zero),
offset_(Function1<Type>::New("offset", dict))
{
if
(
mapMethod_ != "planarInterpolation"
&& mapMethod_ != "nearest"
)
{
FatalIOErrorInFunction
(
dict
) << "mapMethod should be one of 'planarInterpolation'"
<< ", 'nearest'" << exit(FatalIOError);
}
dict.readIfPresent("fieldTableName", fieldTableName_);
if (dict.found("value"))
{
fvPatchField<Type>::operator==(Field<Type>("value", dict, p.size()));
}
else
{
// Note: we use evaluate() here to trigger updateCoeffs followed
// by re-setting of fvatchfield::updated_ flag. This is
// so if first use is in the next time step it retriggers
// a new update.
this->evaluate(Pstream::blocking);
}
}
void Foam::IOstream::fatalCheck(const char* operation) const
{
if (bad())
{
FatalIOErrorInFunction(*this)
<< "error in IOstream " << name() << " for operation " << operation
<< exit(FatalIOError);
}
}
forAll(blockShape_, pi)
{
if (blockShape_[pi] < 0)
{
FatalIOErrorInFunction(is)
<< "Negative point label " << blockShape_[pi]
<< " in block " << *this
<< exit(FatalIOError);
}
else if (blockShape_[pi] >= vertices_.size())
{
FatalIOErrorInFunction(is)
<< "Point label " << blockShape_[pi]
<< " out of range 0.." << vertices_.size() - 1
<< " in block " << *this
<< exit(FatalIOError);
}
}
Foam::Field<Type>::Field
(
const word& keyword,
const dictionary& dict,
const label s
)
{
if (s)
{
ITstream& is = dict.lookup(keyword);
// Read first token
token firstToken(is);
if (firstToken.isWord())
{
if (firstToken.wordToken() == "uniform")
{
this->setSize(s);
operator=(pTraits<Type>(is));
}
else if (firstToken.wordToken() == "nonuniform")
{
is >> static_cast<List<Type>&>(*this);
if (this->size() != s)
{
FatalIOErrorInFunction
(
dict
) << "size " << this->size()
<< " is not equal to the given value of " << s
<< exit(FatalIOError);
}
}
else
{
FatalIOErrorInFunction
(
dict
) << "expected keyword 'uniform' or 'nonuniform', found "
<< firstToken.wordToken()
<< exit(FatalIOError);
}
}
tmp<snGradScheme<Type>> snGradScheme<Type>::New
(
const fvMesh& mesh,
Istream& schemeData
)
{
if (fv::debug)
{
InfoInFunction << "Constructing snGradScheme<Type>" << endl;
}
if (schemeData.eof())
{
FatalIOErrorInFunction
(
schemeData
) << "Discretisation scheme not specified"
<< endl << endl
<< "Valid schemes are :" << endl
<< MeshConstructorTablePtr_->sortedToc()
<< exit(FatalIOError);
}
const word schemeName(schemeData);
typename MeshConstructorTable::iterator constructorIter =
MeshConstructorTablePtr_->find(schemeName);
if (constructorIter == MeshConstructorTablePtr_->end())
{
FatalIOErrorInFunction
(
schemeData
) << "Unknown discretisation scheme "
<< schemeName << nl << nl
<< "Valid schemes are :" << endl
<< MeshConstructorTablePtr_->sortedToc()
<< exit(FatalIOError);
}
return constructorIter()(mesh, schemeData);
}
Foam::autoPtr<Foam::blockVertex> Foam::blockVertex::New
(
const dictionary& dict,
const label index,
const searchableSurfaces& geometry,
Istream& is
)
{
if (debug)
{
InfoInFunction << "Constructing blockVertex" << endl;
}
token firstToken(is);
if (firstToken.isPunctuation() && firstToken.pToken() == token::BEGIN_LIST)
{
// Putback the opening bracket
is.putBack(firstToken);
return autoPtr<blockVertex>
(
new blockVertices::pointVertex(dict, index, geometry, is)
);
}
else if (firstToken.isWord())
{
const word faceType(firstToken.wordToken());
IstreamConstructorTable::iterator cstrIter =
IstreamConstructorTablePtr_->find(faceType);
if (cstrIter == IstreamConstructorTablePtr_->end())
{
FatalErrorInFunction
<< "Unknown blockVertex type "
<< faceType << nl << nl
<< "Valid blockVertex types are" << endl
<< IstreamConstructorTablePtr_->sortedToc()
<< abort(FatalError);
}
return autoPtr<blockVertex>(cstrIter()(dict, index, geometry, is));
}
else
{
FatalIOErrorInFunction(is)
<< "incorrect first token, expected <word> or '(', found "
<< firstToken.info()
<< exit(FatalIOError);
return autoPtr<blockVertex>(nullptr);
}
}