diff --git a/dumux/boxmodels/2p2c/2p2cmodel.hh b/dumux/boxmodels/2p2c/2p2cmodel.hh
index 091e6b5d4ef113152550f209b1a68085341bf61c..2c2c64dd47421e8530b4ba1b37e2dac0cbe5d1a2 100644
--- a/dumux/boxmodels/2p2c/2p2cmodel.hh
+++ b/dumux/boxmodels/2p2c/2p2cmodel.hh
@@ -109,17 +109,17 @@ class TwoPTwoCModel: public BoxModel<TypeTag>
pressureIdx = Indices::pressureIdx,
switchIdx = Indices::switchIdx,
- lPhaseIdx = Indices::lPhaseIdx,
- gPhaseIdx = Indices::gPhaseIdx,
- lCompIdx = Indices::lCompIdx,
- gCompIdx = Indices::gCompIdx,
+ wPhaseIdx = Indices::lPhaseIdx,
+ nPhaseIdx = Indices::gPhaseIdx,
+ wCompIdx = Indices::lCompIdx,
+ nCompIdx = Indices::gCompIdx,
- lPhaseOnly = Indices::lPhaseOnly,
- gPhaseOnly = Indices::gPhaseOnly,
+ wPhaseOnly = Indices::lPhaseOnly,
+ nPhaseOnly = Indices::gPhaseOnly,
bothPhases = Indices::bothPhases,
- plSg = TwoPTwoCFormulation::plSg,
- pgSl = TwoPTwoCFormulation::pgSl,
+ pwSn = TwoPTwoCFormulation::plSg,
+ pnSw = TwoPTwoCFormulation::pgSl,
formulation = GET_PROP_VALUE(TypeTag, Formulation)
};
@@ -154,27 +154,27 @@ public:
// check, if velocity output can be used (works only for cubes so far)
velocityOutput_ = GET_PARAM(TypeTag, bool, EnableVelocityOutput);
- ElementIterator elemIt = this->gridView_().template begin<0>();
- ElementIterator elemEndIt = this->gridView_().template end<0>();
- for (; elemIt != elemEndIt; ++elemIt)
+ ElementIterator eIt = this->gridView_().template begin<0>();
+ ElementIterator eEndIt = this->gridView_().template end<0>();
+ for (; eIt != eEndIt; ++eIt)
{
- if(elemIt->geometry().type().isCube() == false){
+ if(eIt->geometry().type().isCube() == false){
velocityOutput_ = false;
};
};
if (velocityOutput_ != GET_PARAM(TypeTag, bool, EnableVelocityOutput))
std::cout << "ATTENTION: Velocity output only works for cubes and is set to false for simplices\n";
- VertexIterator it = this->gridView_().template begin<dim> ();
- const VertexIterator &endit = this->gridView_().template end<dim> ();
- for (; it != endit; ++it)
+ VertexIterator vIt = this->gridView_().template begin<dim> ();
+ const VertexIterator &vEndIt = this->gridView_().template end<dim> ();
+ for (; vIt != vEndIt; ++vIt)
{
- int globalIdx = this->dofMapper().map(*it);
- const GlobalPosition &globalPos = it->geometry().corner(0);
+ int globalIdx = this->dofMapper().map(*vIt);
+ const GlobalPosition &globalPos = vIt->geometry().corner(0);
// initialize phase presence
staticVertexDat_[globalIdx].phasePresence
- = this->problem_().initialPhasePresence(*it, globalIdx,
+ = this->problem_().initialPhasePresence(*vIt, globalIdx,
globalPos);
staticVertexDat_[globalIdx].wasSwitched = false;
@@ -189,24 +189,24 @@ public:
* \brief Compute the total storage inside one phase of all
* conservation quantities.
*
- * \param dest Contains the storage of each component for one phase
+ * \param storage Contains the storage of each component for one phase
* \param phaseIdx The phase index
*/
- void globalPhaseStorage(PrimaryVariables &dest, int phaseIdx)
+ void globalPhaseStorage(PrimaryVariables &storage, int phaseIdx)
{
- dest = 0;
+ storage = 0;
- ElementIterator elemIt = this->gridView_().template begin<0>();
- const ElementIterator elemEndIt = this->gridView_().template end<0>();
- for (; elemIt != elemEndIt; ++elemIt) {
- this->localResidual().evalPhaseStorage(*elemIt, phaseIdx);
+ ElementIterator eIt = this->gridView_().template begin<0>();
+ const ElementIterator eEndIt = this->gridView_().template end<0>();
+ for (; eIt != eEndIt; ++eIt) {
+ this->localResidual().evalPhaseStorage(*eIt, phaseIdx);
- for (int i = 0; i < elemIt->template count<dim>(); ++i)
- dest += this->localResidual().storageTerm()[i];
+ for (int i = 0; i < eIt->template count<dim>(); ++i)
+ storage += this->localResidual().storageTerm()[i];
};
if (this->gridView_().comm().size() > 1)
- dest = this->gridView_().comm().sum(dest);
+ storage = this->gridView_().comm().sum(storage);
}
/*!
@@ -225,13 +225,13 @@ public:
* \brief Returns the relative weight of a primary variable for
* calculating relative errors.
*
- * \param globalVertexIdx The global vertex index
+ * \param globalIdx The global vertex index
* \param pvIdx The primary variable index
*/
- Scalar primaryVarWeight(int globalVertexIdx, int pvIdx) const
+ Scalar primaryVarWeight(int globalIdx, int pvIdx) const
{
if (Indices::pressureIdx == pvIdx)
- return std::min(1.0/this->prevSol()[globalVertexIdx][pvIdx], 1.0);
+ return std::min(1.0/this->prevSol()[globalIdx][pvIdx], 1.0);
return 1;
}
@@ -263,13 +263,13 @@ public:
/*!
* \brief Returns the phase presence of the current or the old solution of a vertex.
*
- * \param globalVertexIdx The global vertex index
+ * \param globalIdx The global vertex index
* \param oldSol Evaluate function with solution of current or previous time step
*/
- int phasePresence(int globalVertexIdx, bool oldSol) const
+ int phasePresence(int globalIdx, bool oldSol) const
{
- return oldSol ? staticVertexDat_[globalVertexIdx].oldPhasePresence
- : staticVertexDat_[globalVertexIdx].phasePresence;
+ return oldSol ? staticVertexDat_[globalIdx].oldPhasePresence
+ : staticVertexDat_[globalIdx].phasePresence;
}
/*!
@@ -290,33 +290,33 @@ public:
// create the required scalar fields
unsigned numVertices = this->problem_().gridView().size(dim);
- ScalarField *Sg = writer.allocateManagedBuffer(numVertices);
- ScalarField *Sl = writer.allocateManagedBuffer(numVertices);
- ScalarField *pg = writer.allocateManagedBuffer(numVertices);
- ScalarField *pl = writer.allocateManagedBuffer(numVertices);
- ScalarField *pc = writer.allocateManagedBuffer(numVertices);
- ScalarField *rhoL = writer.allocateManagedBuffer(numVertices);
- ScalarField *rhoG = writer.allocateManagedBuffer(numVertices);
- ScalarField *mobL = writer.allocateManagedBuffer(numVertices);
- ScalarField *mobG = writer.allocateManagedBuffer(numVertices);
+ ScalarField *sN = writer.allocateManagedBuffer(numVertices);
+ ScalarField *sW = writer.allocateManagedBuffer(numVertices);
+ ScalarField *pN = writer.allocateManagedBuffer(numVertices);
+ ScalarField *pW = writer.allocateManagedBuffer(numVertices);
+ ScalarField *pC = writer.allocateManagedBuffer(numVertices);
+ ScalarField *rhoW = writer.allocateManagedBuffer(numVertices);
+ ScalarField *rhoN = writer.allocateManagedBuffer(numVertices);
+ ScalarField *mobW = writer.allocateManagedBuffer(numVertices);
+ ScalarField *mobN = writer.allocateManagedBuffer(numVertices);
ScalarField *phasePresence = writer.allocateManagedBuffer(numVertices);
ScalarField *massFrac[numPhases][numComponents];
- for (int i = 0; i < numPhases; ++i)
- for (int j = 0; j < numComponents; ++j)
- massFrac[i][j] = writer.allocateManagedBuffer(numVertices);
+ for (int phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx)
+ for (int compIdx = 0; compIdx < numComponents; ++compIdx)
+ massFrac[phaseIdx][compIdx] = writer.allocateManagedBuffer(numVertices);
ScalarField *temperature = writer.allocateManagedBuffer(numVertices);
ScalarField *poro = writer.allocateManagedBuffer(numVertices);
ScalarField *cellNum =writer.allocateManagedBuffer (numVertices);
- VectorField *velocityG = writer.template allocateManagedBuffer<double, dim>(numVertices);
- VectorField *velocityL = writer.template allocateManagedBuffer<double, dim>(numVertices);
+ VectorField *velocityN = writer.template allocateManagedBuffer<double, dim>(numVertices);
+ VectorField *velocityW = writer.template allocateManagedBuffer<double, dim>(numVertices);
if(velocityOutput_) // check if velocity output is demanded
{
// initialize velocity fields
for (int i = 0; i < numVertices; ++i)
{
- (*velocityG)[i] = Scalar(0);
- (*velocityL)[i] = Scalar(0);
+ (*velocityN)[i] = Scalar(0);
+ (*velocityW)[i] = Scalar(0);
(*cellNum)[i] = Scalar(0.0);
}
}
@@ -325,36 +325,36 @@ public:
ScalarField *rank =
writer.allocateManagedBuffer (numElements);
- FVElementGeometry fvElemGeom;
+ FVElementGeometry fvGeometry;
VolumeVariables volVars;
- ElementIterator elemIt = this->gridView_().template begin<0>();
- ElementIterator elemEndIt = this->gridView_().template end<0>();
- for (; elemIt != elemEndIt; ++elemIt)
+ ElementIterator eIt = this->gridView_().template begin<0>();
+ ElementIterator eEndIt = this->gridView_().template end<0>();
+ for (; eIt != eEndIt; ++eIt)
{
- int idx = this->elementMapper().map(*elemIt);
+ int idx = this->elementMapper().map(*eIt);
(*rank)[idx] = this->gridView_().comm().rank();
- fvElemGeom.update(this->gridView_(), *elemIt);
+ fvGeometry.update(this->gridView_(), *eIt);
- int numVerts = elemIt->template count<dim> ();
- for (int i = 0; i < numVerts; ++i)
+ int numVerts = eIt->template count<dim> ();
+ for (int scvIdx = 0; scvIdx < numVerts; ++scvIdx)
{
- int globalIdx = this->vertexMapper().map(*elemIt, i, dim);
+ int globalIdx = this->vertexMapper().map(*eIt, scvIdx, dim);
volVars.update(sol[globalIdx],
this->problem_(),
- *elemIt,
- fvElemGeom,
- i,
+ *eIt,
+ fvGeometry,
+ scvIdx,
false);
- (*Sg)[globalIdx] = volVars.saturation(gPhaseIdx);
- (*Sl)[globalIdx] = volVars.saturation(lPhaseIdx);
- (*pg)[globalIdx] = volVars.pressure(gPhaseIdx);
- (*pl)[globalIdx] = volVars.pressure(lPhaseIdx);
- (*pc)[globalIdx] = volVars.capillaryPressure();
- (*rhoL)[globalIdx] = volVars.fluidState().density(lPhaseIdx);
- (*rhoG)[globalIdx] = volVars.fluidState().density(gPhaseIdx);
- (*mobL)[globalIdx] = volVars.mobility(lPhaseIdx);
- (*mobG)[globalIdx] = volVars.mobility(gPhaseIdx);
+ (*sN)[globalIdx] = volVars.saturation(nPhaseIdx);
+ (*sW)[globalIdx] = volVars.saturation(wPhaseIdx);
+ (*pN)[globalIdx] = volVars.pressure(nPhaseIdx);
+ (*pW)[globalIdx] = volVars.pressure(wPhaseIdx);
+ (*pC)[globalIdx] = volVars.capillaryPressure();
+ (*rhoW)[globalIdx] = volVars.fluidState().density(wPhaseIdx);
+ (*rhoN)[globalIdx] = volVars.fluidState().density(nPhaseIdx);
+ (*mobW)[globalIdx] = volVars.mobility(wPhaseIdx);
+ (*mobN)[globalIdx] = volVars.mobility(nPhaseIdx);
for (int phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx)
for (int compIdx = 0; compIdx < numComponents; ++compIdx)
{
@@ -385,24 +385,24 @@ public:
}
typedef Dune::BlockVector<Dune::FieldVector<Scalar, dim> > SCVVelocities;
- SCVVelocities scvVelocityL(8), scvVelocityG(8);
+ SCVVelocities scvVelocityW(8), scvVelocityN(8);
- scvVelocityL = 0;
- scvVelocityG = 0;
+ scvVelocityW = 0;
+ scvVelocityN = 0;
ElementVolumeVariables elemVolVars;
elemVolVars.update(this->problem_(),
- *elemIt,
- fvElemGeom,
+ *eIt,
+ fvGeometry,
false /* oldSol? */);
- for (int faceIdx = 0; faceIdx< fvElemGeom.numEdges; faceIdx++)
+ for (int faceIdx = 0; faceIdx < fvGeometry.numEdges; faceIdx++)
{
- FluxVariables fluxDat(this->problem_(),
- *elemIt,
- fvElemGeom,
+ FluxVariables fluxVars(this->problem_(),
+ *eIt,
+ fvGeometry,
faceIdx,
elemVolVars);
@@ -412,16 +412,16 @@ public:
// data attached to upstream and the downstream vertices
// of the current phase
const VolumeVariables up =
- elemVolVars[fluxDat.upstreamIdx(phaseIdx)];
+ elemVolVars[fluxVars.upstreamIdx(phaseIdx)];
const VolumeVariables dn =
- elemVolVars[fluxDat.downstreamIdx(phaseIdx)];
+ elemVolVars[fluxVars.downstreamIdx(phaseIdx)];
// local position of integration point
- const Dune::FieldVector<Scalar, dim>& localPosIP = fvElemGeom.subContVolFace[faceIdx].ipLocal;
+ const Dune::FieldVector<Scalar, dim>& localPosIP = fvGeometry.subContVolFace[faceIdx].ipLocal;
// Transformation of the global normal vector to normal vector in the reference element
- const Dune::FieldMatrix<CoordScalar, dim, dim> jacobianT1 = elemIt->geometry().jacobianTransposed(localPosIP);
- const GlobalPosition globalNormal = fluxDat.face().normal;
+ const Dune::FieldMatrix<CoordScalar, dim, dim> jacobianT1 = eIt->geometry().jacobianTransposed(localPosIP);
+ const GlobalPosition globalNormal = fluxVars.face().normal;
GlobalPosition localNormal(0);
jacobianT1.mv(globalNormal, localNormal);
@@ -433,8 +433,8 @@ public:
// Get the Darcy velocities. The Darcy velocities are divided by the area of the subcontrolvolume
// face in the reference element.
massUpwindWeight_ = GET_PARAM(TypeTag, Scalar, MassUpwindWeight);
- PhasesVector q;
- q[phaseIdx] = fluxDat.KmvpNormal(phaseIdx)
+ PhasesVector flux;
+ flux[phaseIdx] = fluxVars.KmvpNormal(phaseIdx)
* (massUpwindWeight_
* up.mobility(phaseIdx)
+ (1- massUpwindWeight_)
@@ -442,42 +442,42 @@ public:
// transform the normal Darcy velocity into a vector
tmpVelocity[phaseIdx] = localNormal;
- tmpVelocity[phaseIdx] *= q[phaseIdx];
+ tmpVelocity[phaseIdx] *= flux[phaseIdx];
- if(phaseIdx == lPhaseIdx){
- scvVelocityL[fluxDat.face().i] += tmpVelocity[phaseIdx];
- scvVelocityL[fluxDat.face().j] += tmpVelocity[phaseIdx];
+ if(phaseIdx == wPhaseIdx){
+ scvVelocityW[fluxVars.face().i] += tmpVelocity[phaseIdx];
+ scvVelocityW[fluxVars.face().j] += tmpVelocity[phaseIdx];
}
- else if(phaseIdx == gPhaseIdx){
- scvVelocityG[fluxDat.face().i] += tmpVelocity[phaseIdx];
- scvVelocityG[fluxDat.face().j] += tmpVelocity[phaseIdx];
+ else if(phaseIdx == nPhaseIdx){
+ scvVelocityN[fluxVars.face().i] += tmpVelocity[phaseIdx];
+ scvVelocityN[fluxVars.face().j] += tmpVelocity[phaseIdx];
}
}
}
typedef Dune::GenericReferenceElements<Scalar, dim> ReferenceElements;
const Dune::FieldVector<Scalar, dim>& localPos =
- ReferenceElements::general(elemIt->geometry().type()).position(0, 0);
+ ReferenceElements::general(eIt->geometry().type()).position(0, 0);
// get the transposed Jacobian of the element mapping
- const Dune::FieldMatrix<CoordScalar, dim, dim> jacobianT2 = elemIt->geometry().jacobianTransposed(localPos);
+ const Dune::FieldMatrix<CoordScalar, dim, dim> jacobianT2 = eIt->geometry().jacobianTransposed(localPos);
// transform vertex velocities from local to global coordinates
- for (int i = 0; i < numVerts; ++i)
+ for (int scvIdx = 0; scvIdx < numVerts; ++scvIdx)
{
- int globalIdx = this->vertexMapper().map(*elemIt, i, dim);
+ int globalIdx = this->vertexMapper().map(*eIt, scvIdx, dim);
// calculate the subcontrolvolume velocity by the Piola transformation
Dune::FieldVector<CoordScalar, dim> scvVelocity(0);
- jacobianT2.mtv(scvVelocityL[i], scvVelocity);
- scvVelocity /= elemIt->geometry().integrationElement(localPos);
+ jacobianT2.mtv(scvVelocityW[scvIdx], scvVelocity);
+ scvVelocity /= eIt->geometry().integrationElement(localPos);
// add up the wetting phase subcontrolvolume velocities for each vertex
- (*velocityL)[globalIdx] += scvVelocity;
+ (*velocityW)[globalIdx] += scvVelocity;
- jacobianT2.mtv(scvVelocityG[i], scvVelocity);
- scvVelocity /= elemIt->geometry().integrationElement(localPos);
+ jacobianT2.mtv(scvVelocityN[scvIdx], scvVelocity);
+ scvVelocity /= eIt->geometry().integrationElement(localPos);
// add up the nonwetting phase subcontrolvolume velocities for each vertex
- (*velocityG)[globalIdx] += scvVelocity;
+ (*velocityN)[globalIdx] += scvVelocity;
}
}
}
@@ -485,28 +485,28 @@ public:
{
// divide the vertex velocities by the number of adjacent scvs i.e. cells
for(int globalIdx = 0; globalIdx<numVertices; ++globalIdx){
- (*velocityL)[globalIdx] /= (*cellNum)[globalIdx];
- (*velocityG)[globalIdx] /= (*cellNum)[globalIdx];
+ (*velocityW)[globalIdx] /= (*cellNum)[globalIdx];
+ (*velocityN)[globalIdx] /= (*cellNum)[globalIdx];
}
}
- writer.attachVertexData(*Sg, "Sg");
- writer.attachVertexData(*Sl, "Sl");
- writer.attachVertexData(*pg, "pg");
- writer.attachVertexData(*pl, "pl");
- writer.attachVertexData(*pc, "pc");
- writer.attachVertexData(*rhoL, "rhoL");
- writer.attachVertexData(*rhoG, "rhoG");
- writer.attachVertexData(*mobL, "mobL");
- writer.attachVertexData(*mobG, "mobG");
- for (int i = 0; i < numPhases; ++i)
+ writer.attachVertexData(*sN, "Sn");
+ writer.attachVertexData(*sW, "Sw");
+ writer.attachVertexData(*pN, "pN");
+ writer.attachVertexData(*pW, "pW");
+ writer.attachVertexData(*pC, "pC");
+ writer.attachVertexData(*rhoW, "rhoW");
+ writer.attachVertexData(*rhoN, "rhoN");
+ writer.attachVertexData(*mobW, "mobW");
+ writer.attachVertexData(*mobN, "mobN");
+ for (int phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx)
{
- for (int j = 0; j < numComponents; ++j)
+ for (int compIdx = 0; compIdx < numComponents; ++compIdx)
{
std::ostringstream oss;
- oss << "X_" << FluidSystem::phaseName(i) << "^" << FluidSystem::componentName(j);
- writer.attachVertexData(*massFrac[i][j], oss.str());
+ oss << "X_" << FluidSystem::phaseName(phaseIdx) << "^" << FluidSystem::componentName(compIdx);
+ writer.attachVertexData(*massFrac[phaseIdx][compIdx], oss.str());
}
}
writer.attachVertexData(*poro, "porosity");
@@ -515,8 +515,8 @@ public:
if(velocityOutput_) // check if velocity output is demanded
{
- writer.attachVertexData(*velocityL, "velocityL", dim);
- writer.attachVertexData(*velocityG, "velocityG", dim);
+ writer.attachVertexData(*velocityW, "velocityW", dim);
+ writer.attachVertexData(*velocityN, "velocityN", dim);
}
writer.attachCellData(*rank, "process rank");
}
@@ -525,18 +525,18 @@ public:
* \brief Write the current solution to a restart file.
*
* \param outStream The output stream of one vertex for the restart file
- * \param vert The vertex
+ * \param vertex The vertex
*/
- void serializeEntity(std::ostream &outStream, const Vertex &vert)
+ void serializeEntity(std::ostream &outStream, const Vertex &vertex)
{
// write primary variables
- ParentType::serializeEntity(outStream, vert);
+ ParentType::serializeEntity(outStream, vertex);
- int vertIdx = this->dofMapper().map(vert);
+ int globalIdx = this->dofMapper().map(vertex);
if (!outStream.good())
- DUNE_THROW(Dune::IOError, "Could not serialize vertex " << vertIdx);
+ DUNE_THROW(Dune::IOError, "Could not serialize vertex " << globalIdx);
- outStream << staticVertexDat_[vertIdx].phasePresence << " ";
+ outStream << staticVertexDat_[globalIdx].phasePresence << " ";
}
/*!
@@ -544,22 +544,22 @@ public:
* file.
*
* \param inStream The input stream of one vertex from the restart file
- * \param vert The vertex
+ * \param vertex The vertex
*/
- void deserializeEntity(std::istream &inStream, const Vertex &vert)
+ void deserializeEntity(std::istream &inStream, const Vertex &vertex)
{
// read primary variables
- ParentType::deserializeEntity(inStream, vert);
+ ParentType::deserializeEntity(inStream, vertex);
// read phase presence
- int vertIdx = this->dofMapper().map(vert);
+ int globalIdx = this->dofMapper().map(vertex);
if (!inStream.good())
DUNE_THROW(Dune::IOError,
- "Could not deserialize vertex " << vertIdx);
+ "Could not deserialize vertex " << globalIdx);
- inStream >> staticVertexDat_[vertIdx].phasePresence;
- staticVertexDat_[vertIdx].oldPhasePresence
- = staticVertexDat_[vertIdx].phasePresence;
+ inStream >> staticVertexDat_[globalIdx].phasePresence;
+ staticVertexDat_[globalIdx].oldPhasePresence
+ = staticVertexDat_[globalIdx].phasePresence;
}
@@ -577,16 +577,16 @@ public:
for (unsigned i = 0; i < staticVertexDat_.size(); ++i)
staticVertexDat_[i].visited = false;
- FVElementGeometry fvElemGeom;
+ FVElementGeometry fvGeometry;
static VolumeVariables volVars;
- ElementIterator it = this->gridView_().template begin<0> ();
- const ElementIterator &endit = this->gridView_().template end<0> ();
- for (; it != endit; ++it)
+ ElementIterator eIt = this->gridView_().template begin<0> ();
+ const ElementIterator &eEndIt = this->gridView_().template end<0> ();
+ for (; eIt != eEndIt; ++eIt)
{
- fvElemGeom.update(this->gridView_(), *it);
- for (int i = 0; i < fvElemGeom.numVertices; ++i)
+ fvGeometry.update(this->gridView_(), *eIt);
+ for (int scvIdx = 0; scvIdx < fvGeometry.numVertices; ++scvIdx)
{
- int globalIdx = this->vertexMapper().map(*it, i, dim);
+ int globalIdx = this->vertexMapper().map(*eIt, scvIdx, dim);
if (staticVertexDat_[globalIdx].visited)
continue;
@@ -594,15 +594,15 @@ public:
staticVertexDat_[globalIdx].visited = true;
volVars.update(curGlobalSol[globalIdx],
this->problem_(),
- *it,
- fvElemGeom,
- i,
+ *eIt,
+ fvGeometry,
+ scvIdx,
false);
- const GlobalPosition &global = it->geometry().corner(i);
+ const GlobalPosition &globalPos = eIt->geometry().corner(scvIdx);
if (primaryVarSwitch_(curGlobalSol,
volVars,
globalIdx,
- global))
+ globalPos))
{
this->jacobianAssembler().markVertexRed(globalIdx);
wasSwitched = true;
@@ -684,58 +684,58 @@ protected:
int newPhasePresence = phasePresence;
// check if a primary var switch is necessary
- if (phasePresence == gPhaseOnly)
+ if (phasePresence == nPhaseOnly)
{
- // calculate mole fraction in the hypothetic liquid phase
- Scalar xll = volVars.fluidState().moleFraction(lPhaseIdx, lCompIdx);
- Scalar xlg = volVars.fluidState().moleFraction(lPhaseIdx, gCompIdx);
+ // calculate mole fraction in the hypothetic wetting phase
+ Scalar xww = volVars.fluidState().moleFraction(wPhaseIdx, wCompIdx);
+ Scalar xwn = volVars.fluidState().moleFraction(wPhaseIdx, nCompIdx);
- Scalar xlMax = 1.0;
- if (xll + xlg > xlMax)
+ Scalar xwMax = 1.0;
+ if (xww + xwn > xwMax)
wouldSwitch = true;
if (staticVertexDat_[globalIdx].wasSwitched)
- xlMax *= 1.02;
+ xwMax *= 1.02;
// if the sum of the mole fractions would be larger than
- // 100%, liquid phase appears
- if (xll + xlg > xlMax)
+ // 100%, wetting phase appears
+ if (xww + xwn > xwMax)
{
- // liquid phase appears
- std::cout << "liquid phase appears at vertex " << globalIdx
- << ", coordinates: " << globalPos << ", xll + xlg: "
- << xll + xlg << std::endl;
+ // wetting phase appears
+ std::cout << "wetting phase appears at vertex " << globalIdx
+ << ", coordinates: " << globalPos << ", xww + xwn: "
+ << xww + xwn << std::endl;
newPhasePresence = bothPhases;
- if (formulation == pgSl)
+ if (formulation == pnSw)
globalSol[globalIdx][switchIdx] = 0.0;
- else if (formulation == plSg)
+ else if (formulation == pwSn)
globalSol[globalIdx][switchIdx] = 1.0;
};
}
- else if (phasePresence == lPhaseOnly)
+ else if (phasePresence == wPhaseOnly)
{
// calculate fractions of the partial pressures in the
- // hypothetic gas phase
- Scalar xgl = volVars.fluidState().moleFraction(gPhaseIdx, lCompIdx);
- Scalar xgg = volVars.fluidState().moleFraction(gPhaseIdx, gCompIdx);
+ // hypothetic nonwetting phase
+ Scalar xnw = volVars.fluidState().moleFraction(nPhaseIdx, wCompIdx);
+ Scalar xnn = volVars.fluidState().moleFraction(nPhaseIdx, nCompIdx);
Scalar xgMax = 1.0;
- if (xgl + xgg > xgMax)
+ if (xnw + xnn > xgMax)
wouldSwitch = true;
if (staticVertexDat_[globalIdx].wasSwitched)
xgMax *= 1.02;
// if the sum of the mole fractions would be larger than
- // 100%, gas phase appears
- if (xgl + xgg > xgMax)
+ // 100%, nonwetting phase appears
+ if (xnw + xnn > xgMax)
{
- // gas phase appears
- std::cout << "gas phase appears at vertex " << globalIdx
- << ", coordinates: " << globalPos << ", x_gl + x_gg: "
- << xgl + xgg << std::endl;
+ // nonwetting phase appears
+ std::cout << "nonwetting phase appears at vertex " << globalIdx
+ << ", coordinates: " << globalPos << ", xnw + xnn: "
+ << xnw + xnn << std::endl;
newPhasePresence = bothPhases;
- if (formulation == pgSl)
+ if (formulation == pnSw)
globalSol[globalIdx][switchIdx] = 0.999;
- else if (formulation == plSg)
+ else if (formulation == pwSn)
globalSol[globalIdx][switchIdx] = 0.001;
}
}
@@ -745,29 +745,29 @@ protected:
if (staticVertexDat_[globalIdx].wasSwitched)
Smin = -0.01;
- if (volVars.saturation(gPhaseIdx) <= Smin)
+ if (volVars.saturation(nPhaseIdx) <= Smin)
{
wouldSwitch = true;
- // gas phase disappears
- std::cout << "Gas phase disappears at vertex " << globalIdx
- << ", coordinates: " << globalPos << ", Sg: "
- << volVars.saturation(gPhaseIdx) << std::endl;
- newPhasePresence = lPhaseOnly;
+ // nonwetting phase disappears
+ std::cout << "Nonwetting phase disappears at vertex " << globalIdx
+ << ", coordinates: " << globalPos << ", Sn: "
+ << volVars.saturation(nPhaseIdx) << std::endl;
+ newPhasePresence = wPhaseOnly;
globalSol[globalIdx][switchIdx]
- = volVars.fluidState().massFraction(lPhaseIdx, gCompIdx);
+ = volVars.fluidState().massFraction(wPhaseIdx, nCompIdx);
}
- else if (volVars.saturation(lPhaseIdx) <= Smin)
+ else if (volVars.saturation(wPhaseIdx) <= Smin)
{
wouldSwitch = true;
- // liquid phase disappears
- std::cout << "Liquid phase disappears at vertex " << globalIdx
- << ", coordinates: " << globalPos << ", Sl: "
- << volVars.saturation(lPhaseIdx) << std::endl;
- newPhasePresence = gPhaseOnly;
+ // wetting phase disappears
+ std::cout << "Wetting phase disappears at vertex " << globalIdx
+ << ", coordinates: " << globalPos << ", Sw: "
+ << volVars.saturation(wPhaseIdx) << std::endl;
+ newPhasePresence = nPhaseOnly;
globalSol[globalIdx][switchIdx]
- = volVars.fluidState().massFraction(gPhaseIdx, lCompIdx);
+ = volVars.fluidState().massFraction(nPhaseIdx, wCompIdx);
}
}
diff --git a/dumux/boxmodels/2p2c/2p2cvolumevariables.hh b/dumux/boxmodels/2p2c/2p2cvolumevariables.hh
index b9bcef134ddabb8e09561b52650359cc4b42e449..339f5fd91104c8677e7be675eaaf2480677f906d 100644
--- a/dumux/boxmodels/2p2c/2p2cvolumevariables.hh
+++ b/dumux/boxmodels/2p2c/2p2cvolumevariables.hh
@@ -71,24 +71,24 @@ class TwoPTwoCVolumeVariables : public BoxVolumeVariables<TypeTag>
typedef typename GET_PROP_TYPE(TypeTag, Indices) Indices;
enum {
- lCompIdx = Indices::lCompIdx,
- gCompIdx = Indices::gCompIdx,
- lPhaseIdx = Indices::lPhaseIdx,
- gPhaseIdx = Indices::gPhaseIdx
+ wCompIdx = Indices::lCompIdx,
+ nCompIdx = Indices::gCompIdx,
+ wPhaseIdx = Indices::lPhaseIdx,
+ nPhaseIdx = Indices::gPhaseIdx
};
// present phases
enum {
- lPhaseOnly = Indices::lPhaseOnly,
- gPhaseOnly = Indices::gPhaseOnly,
+ wPhaseOnly = Indices::lPhaseOnly,
+ nPhaseOnly = Indices::gPhaseOnly,
bothPhases = Indices::bothPhases
};
// formulations
enum {
formulation = GET_PROP_VALUE(TypeTag, Formulation),
- plSg = TwoPTwoCFormulation::plSg,
- pgSl = TwoPTwoCFormulation::pgSl
+ pwSn = TwoPTwoCFormulation::plSg,
+ pnSw = TwoPTwoCFormulation::pgSl
};
// primary variable indices
@@ -116,31 +116,31 @@ public:
* \param priVars The primary variables
* \param problem The problem
* \param element The element
- * \param elemGeom The finite-volume geometry in the box scheme
+ * \param fvGeometry The finite-volume geometry in the box scheme
* \param scvIdx The local index of the SCV (sub-control volume)
* \param isOldSol Evaluate function with solution of current or previous time step
*/
void update(const PrimaryVariables &priVars,
const Problem &problem,
const Element &element,
- const FVElementGeometry &elemGeom,
- int scvIdx,
- bool isOldSol)
+ const FVElementGeometry &fvGeometry,
+ const int scvIdx,
+ const bool isOldSol)
{
ParentType::update(priVars,
problem,
element,
- elemGeom,
+ fvGeometry,
scvIdx,
isOldSol);
- completeFluidState(priVars, problem, element, elemGeom, scvIdx, fluidState_, isOldSol);
+ completeFluidState(priVars, problem, element, fvGeometry, scvIdx, fluidState_, isOldSol);
/////////////
// calculate the remaining quantities
/////////////
const MaterialLawParams &materialParams =
- problem.spatialParameters().materialLawParams(element, elemGeom, scvIdx);
+ problem.spatialParams().materialLawParams(element, fvGeometry, scvIdx);
// Second instance of a parameter cache.
// Could be avoided if diffusion coefficients also
@@ -150,11 +150,11 @@ public:
for (int phaseIdx = 0; phaseIdx < numPhases; ++phaseIdx) {
// relative permeabilities
Scalar kr;
- if (phaseIdx == lPhaseIdx)
- kr = MaterialLaw::krw(materialParams, saturation(lPhaseIdx));
- else // ATTENTION: krn requires the liquid saturation
+ if (phaseIdx == wPhaseIdx)
+ kr = MaterialLaw::krw(materialParams, saturation(wPhaseIdx));
+ else // ATTENTION: krn requires the wetting phase saturation
// as parameter!
- kr = MaterialLaw::krn(materialParams, saturation(lPhaseIdx));
+ kr = MaterialLaw::krn(materialParams, saturation(wPhaseIdx));
relativePermeability_[phaseIdx] = kr;
Valgrind::CheckDefined(relativePermeability_[phaseIdx]);
@@ -163,19 +163,19 @@ public:
FluidSystem::binaryDiffusionCoefficient(fluidState_,
paramCache,
phaseIdx,
- lCompIdx,
- gCompIdx);
+ wCompIdx,
+ nCompIdx);
Valgrind::CheckDefined(diffCoeff_[phaseIdx]);
}
// porosity
- porosity_ = problem.spatialParameters().porosity(element,
- elemGeom,
+ porosity_ = problem.spatialParams().porosity(element,
+ fvGeometry,
scvIdx);
Valgrind::CheckDefined(porosity_);
// energy related quantities not contained in the fluid state
- asImp_().updateEnergy_(priVars, problem, element, elemGeom, scvIdx, isOldSol);
+ asImp_().updateEnergy_(priVars, problem, element, fvGeometry, scvIdx, isOldSol);
}
/*!
@@ -185,13 +185,13 @@ public:
static void completeFluidState(const PrimaryVariables& primaryVariables,
const Problem& problem,
const Element& element,
- const FVElementGeometry& elementGeometry,
+ const FVElementGeometry& fvGeometry,
int scvIdx,
FluidState& fluidState,
bool isOldSol = false)
{
Scalar t = Implementation::temperature_(primaryVariables, problem, element,
- elementGeometry, scvIdx);
+ fvGeometry, scvIdx);
fluidState.setTemperature(t);
int globalVertIdx = problem.model().dofMapper().map(element, scvIdx, dim);
@@ -201,21 +201,21 @@ public:
// set the saturations
/////////////
Scalar Sg;
- if (phasePresence == gPhaseOnly)
+ if (phasePresence == nPhaseOnly)
Sg = 1.0;
- else if (phasePresence == lPhaseOnly) {
+ else if (phasePresence == wPhaseOnly) {
Sg = 0.0;
}
else if (phasePresence == bothPhases) {
- if (formulation == plSg)
+ if (formulation == pwSn)
Sg = primaryVariables[switchIdx];
- else if (formulation == pgSl)
+ else if (formulation == pnSw)
Sg = 1.0 - primaryVariables[switchIdx];
else DUNE_THROW(Dune::InvalidStateException, "Formulation: " << formulation << " is invalid.");
}
else DUNE_THROW(Dune::InvalidStateException, "phasePresence: " << phasePresence << " is invalid.");
- fluidState.setSaturation(lPhaseIdx, 1 - Sg);
- fluidState.setSaturation(gPhaseIdx, Sg);
+ fluidState.setSaturation(wPhaseIdx, 1 - Sg);
+ fluidState.setSaturation(nPhaseIdx, Sg);
/////////////
// set the pressures of the fluid phases
@@ -223,16 +223,16 @@ public:
// calculate capillary pressure
const MaterialLawParams &materialParams =
- problem.spatialParameters().materialLawParams(element, elementGeometry, scvIdx);
+ problem.spatialParams().materialLawParams(element, fvGeometry, scvIdx);
Scalar pC = MaterialLaw::pC(materialParams, 1 - Sg);
- if (formulation == plSg) {
- fluidState.setPressure(lPhaseIdx, primaryVariables[pressureIdx]);
- fluidState.setPressure(gPhaseIdx, primaryVariables[pressureIdx] + pC);
+ if (formulation == pwSn) {
+ fluidState.setPressure(wPhaseIdx, primaryVariables[pressureIdx]);
+ fluidState.setPressure(nPhaseIdx, primaryVariables[pressureIdx] + pC);
}
- else if (formulation == pgSl) {
- fluidState.setPressure(gPhaseIdx, primaryVariables[pressureIdx]);
- fluidState.setPressure(lPhaseIdx, primaryVariables[pressureIdx] - pC);
+ else if (formulation == pnSw) {
+ fluidState.setPressure(nPhaseIdx, primaryVariables[pressureIdx]);
+ fluidState.setPressure(wPhaseIdx, primaryVariables[pressureIdx] - pC);
}
else DUNE_THROW(Dune::InvalidStateException, "Formulation: " << formulation << " is invalid.");
@@ -244,7 +244,7 @@ public:
// now comes the tricky part: calculate phase compositions
if (phasePresence == bothPhases) {
// both phases are present, phase compositions are a
- // result of the the gas <-> liquid equilibrium. This is
+ // result of the the nonwetting <-> wetting equilibrium. This is
// the job of the "MiscibleMultiPhaseComposition"
// constraint solver
MiscibleMultiPhaseComposition::solve(fluidState,
@@ -253,59 +253,59 @@ public:
/*setInternalEnergy=*/false);
}
- else if (phasePresence == gPhaseOnly) {
- // only the gas phase is present, i.e. gas phase
+ else if (phasePresence == nPhaseOnly) {
+ // only the nonwetting phase is present, i.e. nonwetting phase
// composition is stored explicitly.
- // extract _mass_ fractions in the gas phase
- Scalar massFractionG[numComponents];
- massFractionG[lCompIdx] = primaryVariables[switchIdx];
- massFractionG[gCompIdx] = 1 - massFractionG[lCompIdx];
+ // extract _mass_ fractions in the nonwetting phase
+ Scalar massFractionN[numComponents];
+ massFractionN[wCompIdx] = primaryVariables[switchIdx];
+ massFractionN[nCompIdx] = 1 - massFractionN[wCompIdx];
- // calculate average molar mass of the gas phase
- Scalar M1 = FluidSystem::molarMass(lCompIdx);
- Scalar M2 = FluidSystem::molarMass(gCompIdx);
- Scalar X2 = massFractionG[gCompIdx];
+ // calculate average molar mass of the nonwetting phase
+ Scalar M1 = FluidSystem::molarMass(wCompIdx);
+ Scalar M2 = FluidSystem::molarMass(nCompIdx);
+ Scalar X2 = massFractionN[nCompIdx];
Scalar avgMolarMass = M1*M2/(M2 + X2*(M1 - M2));
// convert mass to mole fractions and set the fluid state
- fluidState.setMoleFraction(gPhaseIdx, lCompIdx, massFractionG[lCompIdx]*avgMolarMass/M1);
- fluidState.setMoleFraction(gPhaseIdx, gCompIdx, massFractionG[gCompIdx]*avgMolarMass/M2);
+ fluidState.setMoleFraction(nPhaseIdx, wCompIdx, massFractionN[wCompIdx]*avgMolarMass/M1);
+ fluidState.setMoleFraction(nPhaseIdx, nCompIdx, massFractionN[nCompIdx]*avgMolarMass/M2);
// calculate the composition of the remaining phases (as
// well as the densities of all phases). this is the job
// of the "ComputeFromReferencePhase" constraint solver
ComputeFromReferencePhase::solve(fluidState,
paramCache,
- gPhaseIdx,
+ nPhaseIdx,
/*setViscosity=*/true,
/*setInternalEnergy=*/false);
}
- else if (phasePresence == lPhaseOnly) {
- // only the liquid phase is present, i.e. liquid phase
+ else if (phasePresence == wPhaseOnly) {
+ // only the wetting phase is present, i.e. wetting phase
// composition is stored explicitly.
- // extract _mass_ fractions in the gas phase
- Scalar massFractionL[numComponents];
- massFractionL[gCompIdx] = primaryVariables[switchIdx];
- massFractionL[lCompIdx] = 1 - massFractionL[gCompIdx];
+ // extract _mass_ fractions in the nonwetting phase
+ Scalar massFractionW[numComponents];
+ massFractionW[nCompIdx] = primaryVariables[switchIdx];
+ massFractionW[wCompIdx] = 1 - massFractionW[nCompIdx];
- // calculate average molar mass of the gas phase
- Scalar M1 = FluidSystem::molarMass(lCompIdx);
- Scalar M2 = FluidSystem::molarMass(gCompIdx);
- Scalar X2 = massFractionL[gCompIdx];
+ // calculate average molar mass of the nonwetting phase
+ Scalar M1 = FluidSystem::molarMass(wCompIdx);
+ Scalar M2 = FluidSystem::molarMass(nCompIdx);
+ Scalar X2 = massFractionW[nCompIdx];
Scalar avgMolarMass = M1*M2/(M2 + X2*(M1 - M2));
// convert mass to mole fractions and set the fluid state
- fluidState.setMoleFraction(lPhaseIdx, lCompIdx, massFractionL[lCompIdx]*avgMolarMass/M1);
- fluidState.setMoleFraction(lPhaseIdx, gCompIdx, massFractionL[gCompIdx]*avgMolarMass/M2);
+ fluidState.setMoleFraction(wPhaseIdx, wCompIdx, massFractionW[wCompIdx]*avgMolarMass/M1);
+ fluidState.setMoleFraction(wPhaseIdx, nCompIdx, massFractionW[nCompIdx]*avgMolarMass/M2);
// calculate the composition of the remaining phases (as
// well as the densities of all phases). this is the job
// of the "ComputeFromReferencePhase" constraint solver
ComputeFromReferencePhase::solve(fluidState,
paramCache,
- lPhaseIdx,
+ wPhaseIdx,
/*setViscosity=*/true,
/*setInternalEnergy=*/false);
}
@@ -395,7 +395,7 @@ public:
* \brief Returns the effective capillary pressure within the control volume.
*/
Scalar capillaryPressure() const
- { return fluidState_.pressure(gPhaseIdx) - fluidState_.pressure(lPhaseIdx); }
+ { return fluidState_.pressure(nPhaseIdx) - fluidState_.pressure(wPhaseIdx); }
/*!
* \brief Returns the average porosity within the control volume.
@@ -414,10 +414,10 @@ protected:
static Scalar temperature_(const PrimaryVariables &priVars,
const Problem& problem,
const Element &element,
- const FVElementGeometry &elemGeom,
+ const FVElementGeometry &fvGeometry,
int scvIdx)
{
- return problem.boxTemperature(element, elemGeom, scvIdx);
+ return problem.boxTemperature(element, fvGeometry, scvIdx);
}
template<class ParameterCache>
@@ -434,7 +434,7 @@ protected:
void updateEnergy_(const PrimaryVariables &sol,
const Problem &problem,
const Element &element,
- const FVElementGeometry &elemGeom,
+ const FVElementGeometry &fvGeometry,
int vertIdx,
bool isOldSol)
{ }
diff --git a/dumux/boxmodels/common/boxelementboundarytypes.hh b/dumux/boxmodels/common/boxelementboundarytypes.hh
index b51cbae2f5a65b373abe76253e2528deda1dd521..9897d96fe799f9c113e84f8520e06303c3a90d8d 100644
--- a/dumux/boxmodels/common/boxelementboundarytypes.hh
+++ b/dumux/boxmodels/common/boxelementboundarytypes.hh
@@ -115,7 +115,7 @@ public:
* types should be collected
* \param fvGeometry The element's finite volume geometry
*/
- DUMUX_DEPRECATED_MSG("use update(problem, element) instead")
+ //DUMUX_DEPRECATED_MSG("use update(problem, element) instead")
void update(const Problem &problem,
const Element &element,
const FVElementGeometry &fvGeometry)
diff --git a/test/boxmodels/2p2c/injection-reference.vtu b/test/boxmodels/2p2c/injection-reference.vtu
index ff17c2df0b30fc58ecb53e0db9c3ae7a350ca37f..42f94bfa25d966ef2c0b42cf459e0ba101f1d4e0 100644
--- a/test/boxmodels/2p2c/injection-reference.vtu
+++ b/test/boxmodels/2p2c/injection-reference.vtu
@@ -2,8 +2,8 @@
<VTKFile type="UnstructuredGrid" version="0.1" byte_order="LittleEndian">
<UnstructuredGrid>
<Piece NumberOfCells="384" NumberOfPoints="425">
- <PointData Scalars="Sg">
- <DataArray type="Float32" Name="Sg" NumberOfComponents="1" format="ascii">
+ <PointData Scalars="Sn">
+ <DataArray type="Float32" Name="Sn" NumberOfComponents="1" format="ascii">
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
@@ -41,7 +41,7 @@
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0
</DataArray>
- <DataArray type="Float32" Name="Sl" NumberOfComponents="1" format="ascii">
+ <DataArray type="Float32" Name="Sw" NumberOfComponents="1" format="ascii">
1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1
@@ -79,7 +79,7 @@
1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1
</DataArray>
- <DataArray type="Float32" Name="pg" NumberOfComponents="1" format="ascii">
+ <DataArray type="Float32" Name="pN" NumberOfComponents="1" format="ascii">
2.6391e+07 2.63934e+07 2.63667e+07 2.63689e+07 2.63955e+07 2.63709e+07 2.63975e+07 2.6373e+07 2.63995e+07 2.63749e+07 2.64015e+07 2.63769e+07
2.64034e+07 2.63788e+07 2.64053e+07 2.63807e+07 2.64072e+07 2.63826e+07 2.64092e+07 2.63845e+07 2.64111e+07 2.63864e+07 2.6413e+07 2.63883e+07
2.64149e+07 2.63902e+07 2.64168e+07 2.63921e+07 2.64187e+07 2.63941e+07 2.64206e+07 2.6396e+07 2.64225e+07 2.63979e+07 2.64244e+07 2.63998e+07
@@ -117,7 +117,7 @@
2.60137e+07 2.60153e+07 2.6017e+07 2.60186e+07 2.60202e+07 2.60218e+07 2.60233e+07 2.60247e+07 2.60261e+07 2.60274e+07 2.60286e+07 2.60297e+07
2.60306e+07 2.60313e+07 2.60318e+07 2.60322e+07 2.60323e+07
</DataArray>
- <DataArray type="Float32" Name="pl" NumberOfComponents="1" format="ascii">
+ <DataArray type="Float32" Name="pW" NumberOfComponents="1" format="ascii">
2.6381e+07 2.63834e+07 2.63567e+07 2.63589e+07 2.63855e+07 2.63609e+07 2.63875e+07 2.6363e+07 2.63895e+07 2.63649e+07 2.63915e+07 2.63669e+07
2.63934e+07 2.63688e+07 2.63953e+07 2.63707e+07 2.63972e+07 2.63726e+07 2.63992e+07 2.63745e+07 2.64011e+07 2.63764e+07 2.6403e+07 2.63783e+07
2.64049e+07 2.63802e+07 2.64068e+07 2.63821e+07 2.64087e+07 2.63841e+07 2.64106e+07 2.6386e+07 2.64125e+07 2.63879e+07 2.64144e+07 2.63898e+07
@@ -155,7 +155,7 @@
2.60037e+07 2.60053e+07 2.6007e+07 2.60086e+07 2.60102e+07 2.60118e+07 2.60133e+07 2.60147e+07 2.60161e+07 2.60174e+07 2.60186e+07 2.60197e+07
2.60206e+07 2.60213e+07 2.60218e+07 2.60222e+07 2.60223e+07
</DataArray>
- <DataArray type="Float32" Name="pc" NumberOfComponents="1" format="ascii">
+ <DataArray type="Float32" Name="pC" NumberOfComponents="1" format="ascii">
10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000
10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000
10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000
@@ -193,7 +193,7 @@
10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000 10000
10000 10000 10000 10000 10000
</DataArray>
- <DataArray type="Float32" Name="rhoL" NumberOfComponents="1" format="ascii">
+ <DataArray type="Float32" Name="rhoW" NumberOfComponents="1" format="ascii">
1003.43 1003.43 1003.42 1003.42 1003.43 1003.42 1003.43 1003.42 1003.43 1003.42 1003.43 1003.42
1003.43 1003.42 1003.43 1003.42 1003.43 1003.42 1003.44 1003.42 1003.44 1003.43 1003.44 1003.43
1003.44 1003.43 1003.44 1003.43 1003.44 1003.43 1003.44 1003.43 1003.44 1003.43 1003.44 1003.43
@@ -231,7 +231,7 @@
1003.27 1003.27 1003.27 1003.27 1003.27 1003.27 1003.27 1003.28 1003.28 1003.28 1003.28 1003.28
1003.28 1003.28 1003.28 1003.28 1003.28
</DataArray>
- <DataArray type="Float32" Name="rhoG" NumberOfComponents="1" format="ascii">
+ <DataArray type="Float32" Name="rhoN" NumberOfComponents="1" format="ascii">
283.916 283.941 283.654 283.677 283.964 283.7 283.986 283.721 284.007 283.743 284.028 283.764
284.049 283.784 284.07 283.805 284.09 283.826 284.111 283.846 284.131 283.866 284.152 283.887
284.172 283.907 284.193 283.928 284.213 283.948 284.234 283.969 284.254 283.989 284.275 284.01
@@ -269,7 +269,7 @@
279.856 279.874 279.891 279.909 279.926 279.943 279.959 279.975 279.99 280.004 280.016 280.028
280.037 280.045 280.051 280.055 280.056
</DataArray>
- <DataArray type="Float32" Name="mobL" NumberOfComponents="1" format="ascii">
+ <DataArray type="Float32" Name="mobW" NumberOfComponents="1" format="ascii">
1523.32 1523.32 1523.33 1523.33 1523.32 1523.33 1523.32 1523.33 1523.32 1523.33 1523.32 1523.33
1523.32 1523.33 1523.32 1523.33 1523.32 1523.33 1523.32 1523.32 1523.31 1523.32 1523.31 1523.32
1523.31 1523.32 1523.31 1523.32 1523.31 1523.32 1523.31 1523.32 1523.31 1523.32 1523.31 1523.32
@@ -307,7 +307,7 @@
1523.46 1523.46 1523.46 1523.46 1523.46 1523.46 1523.46 1523.46 1523.46 1523.46 1523.46 1523.46
1523.45 1523.45 1523.45 1523.45 1523.45
</DataArray>
- <DataArray type="Float32" Name="mobG" NumberOfComponents="1" format="ascii">
+ <DataArray type="Float32" Name="mobN" NumberOfComponents="1" format="ascii">
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0