Foam::autoPtr<ChemistryModel> Foam::basicChemistryModel::New
(
const fvMesh& mesh
)
{
IOdictionary chemistryDict
(
IOobject
(
"chemistryProperties",
mesh.time().constant(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
)
);
word chemistryTypeName;
if (chemistryDict.isDict("chemistryType"))
{
const dictionary& chemistryTypeDict
(
chemistryDict.subDict("chemistryType")
);
Info<< "Selecting chemistry type " << chemistryTypeDict << endl;
const int nCmpt = 8;
const char* cmptNames[nCmpt] =
{
"chemistrySolver",
"chemistryModel",
"chemistryThermo",
"transport",
"thermo",
"equationOfState",
"specie",
"energy"
};
IOdictionary thermoDict
(
IOobject
(
"thermophysicalProperties",
mesh.time().constant(),
mesh,
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE,
false
)
);
word thermoTypeName;
if (thermoDict.isDict("thermoType"))
{
const dictionary& thermoTypeDict(thermoDict.subDict("thermoType"));
thermoTypeName =
word(thermoTypeDict.lookup("transport")) + '<'
+ word(thermoTypeDict.lookup("thermo")) + '<'
+ word(thermoTypeDict.lookup("equationOfState")) + '<'
+ word(thermoTypeDict.lookup("specie")) + ">>,"
+ word(thermoTypeDict.lookup("energy")) + ">";
}
else
{
FatalIOErrorIn
(
(ChemistryModel::typeName + "::New(const mesh&)").c_str(),
thermoDict
) << "thermoType is in the old format and must be upgraded"
<< exit(FatalIOError);
}
Switch isTDAC(chemistryTypeDict.lookupOrDefault("TDAC",false));
// Construct the name of the chemistry type from the components
if (isTDAC)
{
chemistryTypeName =
word(chemistryTypeDict.lookup("chemistrySolver")) + '<'
+ "TDACChemistryModel<"
+ word(chemistryTypeDict.lookup("chemistryThermo")) + ','
+ thermoTypeName + ">>";
}
else
{
chemistryTypeName =
word(chemistryTypeDict.lookup("chemistrySolver")) + '<'
+ "chemistryModel<"
+ word(chemistryTypeDict.lookup("chemistryThermo")) + ','
+ thermoTypeName + ">>";
}
typename ChemistryModel::fvMeshConstructorTable::iterator cstrIter =
ChemistryModel::fvMeshConstructorTablePtr_->find(chemistryTypeName);
if (cstrIter == ChemistryModel::fvMeshConstructorTablePtr_->end())
{
FatalErrorIn(ChemistryModel::typeName + "::New(const mesh&)")
<< "Unknown " << ChemistryModel::typeName << " type " << nl
<< "chemistryType" << chemistryTypeDict << nl << nl
<< "Valid " << ChemistryModel ::typeName << " types are:"
<< nl << nl;
// Get the list of all the suitable chemistry packages available
wordList validChemistryTypeNames
(
ChemistryModel::fvMeshConstructorTablePtr_->sortedToc()
);
// Build a table of the thermo packages constituent parts
// Note: row-0 contains the names of constituent parts
List<wordList> validChemistryTypeNameCmpts
(
validChemistryTypeNames.size() + 1
);
validChemistryTypeNameCmpts[0].setSize(nCmpt);
forAll(validChemistryTypeNameCmpts[0], j)
{
validChemistryTypeNameCmpts[0][j] = cmptNames[j];
}
// Split the thermo package names into their constituent parts
forAll(validChemistryTypeNames, i)
{
validChemistryTypeNameCmpts[i+1] = basicThermo::splitThermoName
(
validChemistryTypeNames[i],
nCmpt
);
}
// Print the table of available packages
// in terms of their constituent parts
printTable(validChemistryTypeNameCmpts, FatalError);
FatalError<< exit(FatalError);
}
Foam::autoPtr<Foam::chemistryTabulationMethod<CompType, ThermoType>>
Foam::chemistryTabulationMethod<CompType, ThermoType>::New
(
const IOdictionary& dict,
TDACChemistryModel<CompType, ThermoType>& chemistry
)
{
IOdictionary thermoDict
(
IOobject
(
"thermophysicalProperties",
dict.db().time().constant(),
dict.db(),
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE,
false
)
);
word thermoTypeName;
if (thermoDict.isDict("thermoType"))
{
const dictionary& thermoTypeDict(thermoDict.subDict("thermoType"));
thermoTypeName =
word(thermoTypeDict.lookup("transport")) + '<'
+ word(thermoTypeDict.lookup("thermo")) + '<'
+ word(thermoTypeDict.lookup("equationOfState")) + '<'
+ word(thermoTypeDict.lookup("specie")) + ">>,"
+ word(thermoTypeDict.lookup("energy")) + ">";
}
else
{
FatalIOErrorInFunction(thermoDict)
<< "thermoType is in the old format and must be upgraded"
<< exit(FatalIOError);
}
dictionary tabdict(dict.subDict("tabulation"));
word chemistryTabulationMethodName =
word(tabdict.lookup("method")) + '<'
+ word(dict.subDict("chemistryType").lookup("chemistryThermo")) + ','
+ thermoTypeName + '>';
typename dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(chemistryTabulationMethodName);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorInFunction
<< "Unknown chemistryTabulationMethodType type "
<< chemistryTabulationMethodName
<< endl << endl
<< "Valid chemistryTabulationMethodType types are :" << endl
<< dictionaryConstructorTablePtr_->toc()
<< exit(FatalError);
}
return autoPtr<chemistryTabulationMethod<CompType, ThermoType>>
(
cstrIter()(dict, chemistry)
);
}
void getCellTable(const fvMesh & mesh)
{
cellTableMap_.clear();
cellTableId_.setSize(mesh.nCells(), 1);
IOdictionary cellTableDict
(
IOobject
(
"cellTable",
"constant",
mesh,
IOobject::READ_IF_PRESENT,
IOobject::NO_WRITE,
false
)
);
volScalarField volField
(
IOobject
(
"cellTableId",
mesh.time().timeName(),
mesh,
IOobject::READ_IF_PRESENT,
IOobject::NO_WRITE,
false
),
mesh,
dimensionedScalar("cellTableId", dimless, 1.0)
);
// get cellTableId information from the volScalarField if possible
if (volField.headerOk())
{
const scalarField & field = volField.internalField();
forAll(field, cellI)
{
cellTableId_[cellI] = static_cast<int>(field[cellI]);
}
if (cellTableDict.headerOk())
{
// convert dictionary to map
wordList toc = cellTableDict.toc();
forAll(toc, i)
{
word keyword = toc[i];
if (!cellTableDict.isDict(keyword)) continue;
const dictionary & dict = cellTableDict.subDict(keyword);
if (dict.found("Id") && dict.found("MaterialType"))
{
label Id;
dict["Id"] >> Id;
dict["MaterialType"] >> keyword;
if (keyword == "fluid")
{
cellTableMap_.insert(Id, 1);
}
else if (keyword == "solid")
{
cellTableMap_.insert(Id, 2);
}
}
}
int main(int argc, char *argv[])
{
# include "addTimeOptions.H"
# include "setRootCase.H"
# include "createTime.H"
# include "createMesh.H"
IOdictionary stlDefs
(
IOobject
(
"stlDefinitions",
runTime.constant(),
"triSurface",
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
)
);
wordList toc = stlDefs.toc();
forAll (toc, item)
{
if (stlDefs.isDict(toc[item]))
{
Info << "\nCreates the STL surface for " << toc[item] << endl;
pointField pp ( stlDefs.subDict(toc[item]).lookup("points") );
faceList faces( stlDefs.subDict(toc[item]).lookup("faces") );
triFaceList tfl(0);
label count(0);
if (
stlDefs.subDict(toc[item])
.lookupOrDefault<Switch>("extrude", false )
)
{
if (faces.size() <= 1)
{
extrudeFacesAndPoints
(
stlDefs.subDict(toc[item]),
faces,
pp
);
}
else
{
Info << "\nWARNING: Using extrude, but"
<< " multiple faces are defined\n" << endl;
}
}
forAll (faces, facei)
{
faceTriangulation triangulation(pp, faces[facei], true );
tfl.setSize( count + triangulation.size() );
forAll (triangulation, triI)
{
tfl[count++] = triangulation[triI];
}
}
triSurface ts( tfl, pp );
Info << "Writes the STL surface for " << toc[item] << endl;
ts.write( "constant/triSurface/"+toc[item]+".stl" );
}
int main(int argc, char *argv[])
{
# include "setRootCase.H"
# include "createTime.H"
Info << "\nReading g" << endl;
uniformDimensionedVectorField g
(
IOobject
(
"g",
runTime.constant(),
runTime,
IOobject::MUST_READ,
IOobject::NO_WRITE
)
);
Info << "\nReading waveProperties\n" << endl;
IOdictionary waveProperties
(
IOobject
(
"waveProperties.input",
runTime.constant(),
runTime,
IOobject::MUST_READ,
IOobject::NO_WRITE
)
);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
IOobject wOut
(
"waveProperties",
runTime.constant(),
runTime,
IOobject::NO_READ,
IOobject::NO_WRITE
);
// Write waveProperties with the above computed changes
OFstream os
(
wOut.objectPath(),
#if EXTBRANCH==1
ios_base::out|ios_base::trunc,
#elif OFPLUSBRANCH==1
// Nothing to be put here
#else
#if OFVERSION<170
ios_base::out|ios_base::trunc,
#endif
#endif
IOstream::ASCII,
IOstream::currentVersion,
IOstream::UNCOMPRESSED
);
// Write the OF banner
wOut.writeBanner( os );
// Write the file information. Class name is not correct when
// using wOut.writeHeader( os ); hence manual entries
os << "FoamFile" << nl;
os << token::BEGIN_BLOCK << incrIndent << nl;
os << indent << "version" << tab << IOstream::currentVersion
<< token::END_STATEMENT << nl;
os << indent << "format" << tab << "ascii;" << nl;
os << indent << "class" << tab << "dictionary;" << nl;
os << indent << "object" << tab << "waveProperties;" << nl;
os << decrIndent << indent << token::END_BLOCK << nl;
// Write the divider
wOut.writeDivider( os );
os << nl;
/* Loop over all subdicts in waveProperties. For each of them compute the
wave parameters relevant for that particular wave theory. */
wordList toc = waveProperties.toc();
forAll (toc, item)
{
// If a sub-dictionary, then compute parameters and write the subdict
if (waveProperties.isDict(toc[item]))
{
dictionary& sd = waveProperties.subDict(toc[item]);
autoPtr<setWaveProperties> props
(
setWaveProperties::New(runTime, sd, true)
);
props->set( os );
}
else
{
label Nspaces = 20;
// Read the entry and write to the dummy output file
ITstream read = waveProperties.lookup(toc[item]);
os << toc[item] << token::SPACE;
for (int i=toc[item].size(); i<Nspaces-1; i++)
{
os << token::SPACE;
}
forAll (read, ri)
{
if (ri < read.size() - 1)
{
os << read[ri] << token::SPACE;
}
else
{
os << read[ri];
}
}
os << token::END_STATEMENT << nl << endl;
// Additional level of check, such that the code does not crash at
// runTime:
if (toc[item] == "seaLevel")
{
// Read the magnitude of the sea level
scalar sL = readScalar(waveProperties.lookup("seaLevel"));
// If the Switch seaLevelAsReference is not found _and_ the
// magnitude of the sea level differs from 0 (zero), stop the
// evaluation of the wave parameters
if
(
!waveProperties.found("seaLevelAsReference") &&
SMALL < Foam::mag(sL)
)
{
// This merely looks up the string, it will not be found
// and the user is forced to correct waveProperties.input,
// before any execution is possible.
waveProperties.lookup("seaLevelAsReference");
}
}
}
}
// Write end divider
wOut.writeEndDivider(os);
// End
Info<< "\nEnd\n" << endl;
return 0;
}