Foam::reactingParcelInjectionData::reactingParcelInjectionData(Istream& is)
:
thermoParcelInjectionData(is)
{
is.check("reading Y's");
is >> Y_;
is.check("reactingParcelInjectionData(Istream& is)");
}
Foam::thermoParcelInjectionData::thermoParcelInjectionData(Istream& is)
:
kinematicParcelInjectionData(is)
{
is.check("reading T");
is >> T_;
is.check("reading cp");
is >> cp_;
is.check("thermoParcelInjectionData(Istream& is)");
}
Foam::WetParcel<ParcelType>::WetParcel
(
const polyMesh& mesh,
Istream& is,
bool readFields
)
:
ParcelType(mesh, is, readFields),
Vliq_(0.0)
{
if (readFields)
{
if (is.format() == IOstream::ASCII)
{
Vliq_ = readScalar(is);
}
else
{
is.read
(
reinterpret_cast<char*>(&Vliq_),
sizeof(Vliq_)
);
}
}
// Check state of Istream
is.check
(
"WetParcel<ParcelType>::WetParcel"
"(const polyMesh&, Istream&, bool)"
);
}
Foam::phaseProperties::phaseProperties(Istream& is)
:
phase_(UNKNOWN),
stateLabel_("(unknown)"),
names_(0),
Y_(0),
globalIds_(0),
globalCarrierIds_(0)
{
is.check("Foam::phaseProperties::phaseProperties(Istream& is)");
dictionaryEntry phaseInfo(dictionary::null, is);
phase_ = phaseTypeNames_[phaseInfo.keyword()];
stateLabel_ = phaseToStateLabel(phase_);
if (phaseInfo.size() > 0)
{
label nComponents = phaseInfo.size();
names_.setSize(nComponents, "unknownSpecie");
Y_.setSize(nComponents, 0.0);
globalIds_.setSize(nComponents, -1);
globalCarrierIds_.setSize(nComponents, -1);
label cmptI = 0;
forAllConstIter(IDLList<entry>, phaseInfo, iter)
{
names_[cmptI] = iter().keyword();
Y_[cmptI] = readScalar(phaseInfo.lookup(names_[cmptI]));
cmptI++;
}
Foam::incompressible::incompressible(Istream& is)
:
specie(is),
rho_(readScalar(is))
{
is.check("incompressible::incompressible(Istream& is)");
}
Foam::ignitionSite::ignitionSite
(
Istream& is,
const engineTime& edb,
const fvMesh& mesh
)
:
db_(edb),
mesh_(mesh),
ignitionSiteDict_(is),
location_(ignitionSiteDict_.lookup("location")),
diameter_(readScalar(ignitionSiteDict_.lookup("diameter"))),
time_
(
db_.userTimeToTime
(
edb.degToTime(readScalar(ignitionSiteDict_.lookup("start")))
)
),
duration_
(
db_.userTimeToTime
(
edb.degToTime(readScalar(ignitionSiteDict_.lookup("duration")))
)
),
strength_(readScalar(ignitionSiteDict_.lookup("strength"))),
timeIndex_(db_.timeIndex())
{
// Check state of Istream
is.check("ignitionSite::ignitionSite(Istream&)");
findIgnitionCells(mesh_);
}
Foam::reactingMultiphaseParcelInjectionData::
reactingMultiphaseParcelInjectionData(Istream& is)
:
reactingParcelInjectionData(is)
{
is.check("reading YGas's");
is >> YGas_;
is.check("reading YLiquid's");
is >> YLiquid_;
is.check("reading YSolid's");
is >> YSolid_;
is.check("reactingMultiphaseParcelInjectionData(Istream& is)");
}
Foam::eConstThermo<equationOfState>::eConstThermo(Istream& is)
:
equationOfState(is),
Cv_(readScalar(is)),
Hf_(readScalar(is))
{
is.check("eConstThermo::eConstThermo(Istream& is)");
}
Foam::specie::specie(Istream& is)
:
name_(is),
nMoles_(readScalar(is)),
molWeight_(readScalar(is))
{
is.check("specie::specie(Istream& is)");
}
injector::injector(const Time& t, Istream& is)
:
injectorDict_(is),
properties_(injectorType::New(t, injectorDict_))
{
// Check state of Istream
is.check("Istream& operator>>(Istream&, injector&)");
}
Foam::ClassName<TemplateArgument>::ClassName(Istream& is)
:
base1(is),
base2(is),
member1(is),
member2(is)
{
// Check state of Istream
is.check("Foam::ClassName<TemplateArgument>::ClassName(Foam::Istream&)");
}
Foam::className::className(Istream& is)
:
base1(is),
base2(is),
member1(is),
member2(is)
{
// Check state of Istream
is.check("Foam::className::className(Foam::Istream&)");
}
Foam::CLASSNAME::CLASSNAME(Istream& is)
:
base1(is),
base2(is),
member1(is),
member2(is)
{
// Check state of Istream
is.check("Foam::CLASSNAME::CLASSNAME(Foam::Istream&)");
}
Foam::hRefpropLiqThermo<equationOfState>::hRefpropLiqThermo(Istream& is)
:
equationOfState(is),
Cp_(readScalar(is)),
Hf_(readScalar(is))
{
is.check("hRefpropLiqThermo::hRefpropLiqThermo(Istream& is)");
Cp_ *= this->W();
Hf_ *= this->W();
}
Foam::eConstThermo<EquationOfState>::eConstThermo(Istream& is)
:
EquationOfState(is),
Cv_(readScalar(is)),
Hf_(readScalar(is))
{
is.check("eConstThermo<EquationOfState>::eConstThermo(Istream&)");
Cv_ *= this->W();
Hf_ *= this->W();
}
Foam::hConstThermo<EquationOfState>::hConstThermo(Istream& is)
:
EquationOfState(is),
Cp_(readScalar(is)),
Hf_(readScalar(is))
{
is.check("hConstThermo::hConstThermo(Istream& is)");
Cp_ *= this->W();
Hf_ *= this->W();
}
Foam::CollisionRecordList<PairType, WallType>::CollisionRecordList(Istream& is)
:
pairRecords_(is),
wallRecords_(is)
{
// Check state of Istream
is.check
(
"Foam::CollisionRecordList<PairType, WallType>::"
"CollisionRecordList(Foam::Istream&)"
);
}
Foam::PairCollisionRecord<Type>::PairCollisionRecord(Istream& is)
:
origProcOfOther_(readLabel(is)),
origIdOfOther_(readLabel(is)),
data_(is)
{
// Check state of Istream
is.check
(
"Foam::PairCollisionRecord<Type>::PairCollisionRecord(Foam::Istream&)"
);
}
Foam::ReactingMultiphaseParcel<ParcelType>::ReactingMultiphaseParcel
(
const Cloud<ParcelType>& cloud,
Istream& is,
bool readFields
)
:
ReactingParcel<ParcelType>(cloud, is, readFields),
YGas_(0),
YLiquid_(0),
YSolid_(0),
canCombust_(false)
{
if (readFields)
{
const ReactingMultiphaseCloud<ParcelType>& cR =
dynamic_cast<const ReactingMultiphaseCloud<ParcelType>&>(cloud);
const label idGas = cR.composition().idGas();
const label nGas = cR.composition().componentNames(idGas).size();
const label idLiquid = cR.composition().idLiquid();
const label nLiquid = cR.composition().componentNames(idLiquid).size();
const label idSolid = cR.composition().idGas();
const label nSolid = cR.composition().componentNames(idSolid).size();
YGas_.setSize(nGas);
YLiquid_.setSize(nLiquid);
YSolid_.setSize(nSolid);
is >> YGas_ >> YLiquid_ >> YSolid_;
// scale the mass fractions
const scalarField& YMix = this->Y_;
YGas_ /= YMix[GAS] + ROOTVSMALL;
YLiquid_ /= YMix[LIQ] + ROOTVSMALL;
YSolid_ /= YMix[SLD] + ROOTVSMALL;
}
// Check state of Istream
is.check
(
"ReactingMultiphaseParcel<ParcelType>::ReactingMultiphaseParcel"
"("
"const Cloud<ParcelType>&, "
"Istream&, "
"bool"
")"
);
}
Foam::VectorSpace<Form, Cmpt, nCmpt>::VectorSpace
(
Istream& is
)
{
// Read beginning of VectorSpace<Cmpt>
is.readBegin("VectorSpace<Form, Cmpt, nCmpt>");
for (int i=0; i<nCmpt; i++)
{
is >> v_[i];
}
// Read end of VectorSpace<Cmpt>
is.readEnd("VectorSpace<Form, Cmpt, nCmpt>");
// Check state of Istream
is.check("VectorSpace<Form, Cmpt, nCmpt>::VectorSpace(Istream&)");
}
Foam::TemplateCollidingParcel<ParcelType>::TemplateCollidingParcel
(
const polyMesh& mesh,
Istream& is,
bool readFields
)
:
ParcelType(mesh, is, readFields)
{
if (readFields)
{
}
// Check state of Istream
is.check
(
"TemplateCollidingParcel<ParcelType>::TemplateCollisionParcel"
"(const polyMesh&, Istream&, bool)"
);
}
Foam::ThermoParcel<ParcelType>::ThermoParcel
(
const Cloud<ParcelType>& cloud,
Istream& is,
bool readFields
)
:
KinematicParcel<ParcelType>(cloud, is, readFields),
T_(0.0),
cp_(0.0),
Tc_(0.0),
cpc_(0.0)
{
if (readFields)
{
if (is.format() == IOstream::ASCII)
{
T_ = readScalar(is);
cp_ = readScalar(is);
}
else
{
is.read
(
reinterpret_cast<char*>(&T_),
+ sizeof(T_)
+ sizeof(cp_)
);
}
}
// Check state of Istream
is.check
(
"ThermoParcel::ThermoParcel(const Cloud<ParcelType>&, Istream&, bool)"
);
}
Foam::kinematicParcelInjectionData::kinematicParcelInjectionData(Istream& is)
{
is.check("reading (Px Py Pz)");
is >> x_;
is.check("reading (Ux Uy Uz)");
is >> U_;
is.check("reading d");
is >> d_;
is.check("reading rho");
is >> rho_;
is.check("reading mDot");
is >> mDot_;
is.check("kinematicParcelInjectionData(Istream& is)");
}
Foam::tabulated<Specie>::tabulated(Istream& is)
:
Specie(is)
{
is.check("tabulated<Specie>::tabulated(Istream& is)");
}
specieThermo<thermo>::specieThermo(Istream& is)
:
thermo(is)
{
is.check("specieThermo::specieThermo(Istream& is)");
}
Foam::specieThermo<Thermo>::specieThermo(Istream& is)
:
Thermo(is)
{
is.check("specieThermo<Thermo>::specieThermo(Istream&)");
}
Foam::speciesTransport::speciesTransport(Istream& is)
:
janafThermo(is)
{
is.check("speciesTransport::speciesTransport(Istream& is)");
}
Foam::WetParcel<ParcelType>::WetParcel
(
const polyMesh& mesh,
Istream& is,
bool readFields
)
:
ParcelType(mesh, is, readFields),
Vliq_(0.0),
partVliq_(),
liquidPositionVectors_(),
liquidPositions_(),
contactList_(),
previousContactList_()
{
if (readFields)
{
if (is.format() == IOstream::ASCII)
{
Vliq_ = readScalar(is);
partVliq_ = readList<scalar>(is);
liquidPositions_ = readList<vector>(is);
liquidPositionVectors_ = readList<vector>(is);
contactList_ = readList<label>(is);
previousContactList_ = readList<label>(is);
}
else
{
/*
is.read
(
reinterpret_cast<char*>(&Vliq_),
sizeof(Vliq_)
);
is.read
(
reinterpret_cast<char*>(&partVliq_),
sizeof(partVliq_)
);
is.read
(
reinterpret_cast<char*>(&liquidPositions_),
sizeof(liquidPositions_)
);
is.read
(
reinterpret_cast<char*>(&liquidPositionVectors_),
sizeof(liquidPositionVectors_)
);
*/
is.read
(
reinterpret_cast<char*>(&Vliq_),
sizeof(Vliq_)
+sizeof(partVliq_)
+sizeof(liquidPositionVectors_)
+sizeof(liquidPositions_)
+sizeof(contactList_)
+sizeof(previousContactList_)
);
}
}
// Check state of Istream
is.check
(
"WetParcel<ParcelType>::WetParcel"
"(const polyMesh&, Istream&, bool)"
);
}
perfectGas::perfectGas(Istream& is)
:
specie(is)
{
is.check("perfectGas::perfectGas(Istream& is)");
}
