| Cantera 3.0.0

Loading...
Searching...
No Matches
MolalityVPSSTP.h
Go to the documentation of this file.
1/**
2 * @file MolalityVPSSTP.h
3 * Header for intermediate ThermoPhase object for phases which
4 * employ molality based activity coefficient formulations
5 * (see @ref thermoprops
6 * and class @link Cantera::MolalityVPSSTP MolalityVPSSTP@endlink).
7 *
8 * Header file for a derived class of ThermoPhase that handles
9 * variable pressure standard state methods for calculating
10 * thermodynamic properties that are further based upon activities
11 * based on the molality scale. These include most of the methods for
12 * calculating liquid electrolyte thermodynamics.
13 */
14
15// This file is part of Cantera. See License.txt in the top-level directory or
16// at https://cantera.org/license.txt for license and copyright information.
17
18#ifndef CT_MOLALITYVPSSTP_H
19#define CT_MOLALITYVPSSTP_H
20
21#include "VPStandardStateTP.h"
22
23 namespace Cantera
24{
25
26//! Scale to be used for the output of single-ion activity coefficients is that
27//! used by Pitzer.
28/*!
29 * This is the internal scale used within the code. One property is that the
30 * activity coefficients for the cation and anion of a single salt will be
31 * equal. This scale is the one presumed by the formulation of the single-ion
32 * activity coefficients described in this report.
33 *
34 * Activity coefficients for species k may be altered between scales s1 to s2
35 * using the following formula
36 *
37 * @f[
38 * \ln(\gamma_k^{s2}) = \ln(\gamma_k^{s1})
39 * + \frac{z_k}{z_j} \left( \ln(\gamma_j^{s2}) - \ln(\gamma_j^{s1}) \right)
40 * @f]
41 *
42 * where j is any one species.
43 */
44 const int PHSCALE_PITZER = 0;
45
46//! Scale to be used for evaluation of single-ion activity coefficients is that
47//! used by the NBS standard for evaluation of the pH variable.
48/*!
49 * This is not the internal scale used within the code.
50 *
51 * Activity coefficients for species k may be altered between scales s1 to s2
52 * using the following formula
53 *
54 * @f[
55 * \ln(\gamma_k^{s2}) = \ln(\gamma_k^{s1})
56 * + \frac{z_k}{z_j} \left( \ln(\gamma_j^{s2}) - \ln(\gamma_j^{s1}) \right)
57 * @f]
58 *
59 * where j is any one species. For the NBS scale, j is equal to the Cl- species
60 * and
61 *
62 * @f[
63 * \ln(\gamma_{Cl-}^{s2}) = \frac{-A_{\phi} \sqrt{I}}{1.0 + 1.5 \sqrt{I}}
64 * @f]
65 *
66 * This is the NBS pH scale, which is used in all conventional pH measurements.
67 * and is based on the Bates-Guggenheim equations.
68 */
69 const int PHSCALE_NBS = 1;
70
71/**
72 * MolalityVPSSTP is a derived class of ThermoPhase that handles variable
73 * pressure standard state methods for calculating thermodynamic properties that
74 * are further based on molality-scaled activities. This category incorporates
75 * most of the methods for calculating liquid electrolyte thermodynamics that
76 * have been developed since the 1970's.
77 *
78 * This class adds additional functions onto the ThermoPhase interface that
79 * handle molality based standard states. The ThermoPhase class includes a
80 * member function, ThermoPhase::activityConvention() that indicates which
81 * convention the activities are based on. The default is to assume activities
82 * are based on the molar convention. However, classes which derive from the
83 * MolalityVPSSTP class return `cAC_CONVENTION_MOLALITY` from this member
84 * function.
85 *
86 * The molality of a solute, @f$ m_i @f$, is defined as
87 *
88 * @f[
89 * m_i = \frac{n_i}{\tilde{M}_o n_o}
90 * @f]
91 * where
92 * @f[
93 * \tilde{M}_o = \frac{M_o}{1000}
94 * @f]
95 *
96 * where @f$ M_o @f$ is the molecular weight of the solvent. The molality has
97 * units of gmol/kg. For the solute, the molality may be considered
98 * as the amount of gmol's of solute per kg of solvent, a natural experimental
99 * quantity.
100 *
101 * The formulas for calculating mole fractions if given the molalities of the
102 * solutes is stated below. First calculate @f$ L^{sum} @f$, an intermediate
103 * quantity.
104 *
105 * @f[
106 * L^{sum} = \frac{1}{\tilde{M}_o X_o} = \frac{1}{\tilde{M}_o} + \sum_{i\ne o} m_i
107 * @f]
108 * Then,
109 * @f[
110 * X_o = \frac{1}{\tilde{M}_o L^{sum}}
111 * @f]
112 * @f[
113 * X_i = \frac{m_i}{L^{sum}}
114 * @f]
115 * where @f$ X_o @f$ is the mole fraction of solvent, and @f$ X_o @f$ is the
116 * mole fraction of solute *i*. Thus, the molality scale and the mole fraction
117 * scale offer a one-to-one mapping between each other, except in the limit of a
118 * zero solvent mole fraction.
119 *
120 * The standard states for thermodynamic objects that derive from MolalityVPSSTP
121 * are on the unit molality basis. Chemical potentials of the solutes, @f$ \mu_k
122 * @f$, and the solvent, @f$ \mu_o @f$, which are based on the molality form,
123 * have the following general format:
124 *
125 * @f[
126 * \mu_k = \mu^{\triangle}_k(T,P) + R T \ln(\gamma_k^{\triangle} \frac{m_k}{m^\triangle})
127 * @f]
128 * @f[
129 * \mu_o = \mu^o_o(T,P) + RT \ln(a_o)
130 * @f]
131 *
132 * where @f$ \gamma_k^{\triangle} @f$ is the molality based activity coefficient
133 * for species @f$ k @f$.
134 *
135 * The chemical potential of the solvent is thus expressed in a different format
136 * than the chemical potential of the solutes. Additionally, the activity of the
137 * solvent, @f$ a_o @f$, is further reexpressed in terms of an osmotic
138 * coefficient, @f$ \phi @f$.
139 * @f[
140 * \phi = \frac{- \ln(a_o)}{\tilde{M}_o \sum_{i \ne o} m_i}
141 * @f]
142 *
143 * MolalityVPSSTP::osmoticCoefficient() returns the value of @f$ \phi @f$. Note
144 * there are a few of definitions of the osmotic coefficient floating around. We
145 * use the one defined in (Activity Coefficients in Electrolyte Solutions, K. S.
146 * Pitzer CRC Press, Boca Raton, 1991, p. 85, Eqn. 28). This definition is most
147 * clearly related to theoretical calculation.
148 *
149 * The molar-based activity coefficients @f$ \gamma_k @f$ may be calculated from
150 * the molality-based activity coefficients, @f$ \gamma_k^\triangle @f$ by the
151 * following formula.
152 * @f[
153 * \gamma_k = \frac{\gamma_k^\triangle}{X_o}
154 * @f]
155 * For purposes of establishing a convention, the molar activity coefficient of
156 * the solvent is set equal to the molality-based activity coefficient of the
157 * solvent:
158 * @f[
159 * \gamma_o = \gamma_o^\triangle
160 * @f]
161 *
162 * The molality-based and molarity-based standard states may be related to one
163 * another by the following formula.
164 *
165 * @f[
166 * \mu_k^\triangle(T,P) = \mu_k^o(T,P) + R T \ln(\tilde{M}_o m^\triangle)
167 * @f]
168 *
169 * An important convention is followed in all routines that derive from
170 * MolalityVPSSTP. Standard state thermodynamic functions and reference state
171 * thermodynamic functions return the molality-based quantities. Also all
172 * functions which return activities return the molality-based activities. The
173 * reason for this convention has been discussed in supporting memos. However,
174 * it's important because the term in the equation above is non-trivial. For
175 * example it's equal to 2.38 kcal/gmol for water at 298 K.
176 *
177 * In order to prevent a singularity, this class includes the concept of a
178 * minimum value for the solvent mole fraction. All calculations involving the
179 * formulation of activity coefficients and other non-ideal solution behavior
180 * adhere to this concept of a minimal value for the solvent mole fraction. This
181 * makes sense because these solution behavior were all designed and measured
182 * far away from the zero solvent singularity condition and are not applicable
183 * in that limit.
184 *
185 * This objects add a layer that supports molality. It inherits from
186 * VPStandardStateTP.
187 *
188 * All objects that derive from this are assumed to have molality based standard
189 * states.
190 *
191 * Molality based activity coefficients are scaled according to the current pH
192 * scale. See the Eq3/6 manual for details.
193 *
194 * Activity coefficients for species k may be altered between scales s1 to s2
195 * using the following formula
196 *
197 * @f[
198 * \ln(\gamma_k^{s2}) = \ln(\gamma_k^{s1})
199 * + \frac{z_k}{z_j} \left( \ln(\gamma_j^{s2}) - \ln(\gamma_j^{s1}) \right)
200 * @f]
201 *
202 * where j is any one species. For the NBS scale, j is equal to the Cl- species
203 * and
204 *
205 * @f[
206 * \ln(\gamma_{Cl-}^{s2}) = \frac{-A_{\phi} \sqrt{I}}{1.0 + 1.5 \sqrt{I}}
207 * @f]
208 *
209 * The Pitzer scale doesn't actually change anything. The pitzer scale is
210 * defined as the raw unscaled activity coefficients produced by the underlying
211 * objects.
212 *
213 * ### SetState Strategy
214 *
215 * The MolalityVPSSTP object does not have a setState strategy concerning the
216 * molalities. It does not keep track of whether the molalities have changed.
217 * It's strictly an interfacial layer that writes the current mole fractions to
218 * the State object. When molalities are needed it recalculates the molalities
219 * from the State object's mole fraction vector.
220 *
221 * @todo Make two solvent minimum fractions. One would be for calculation of the
222 * non-ideal factors. The other one would be for purposes of stoichiometry
223 * evaluation. the stoichiometry evaluation one would be a 1E-13 limit.
224 * Anything less would create problems with roundoff error.
225 */
226 class MolalityVPSSTP : public VPStandardStateTP
227{
228 public:
229 //! Default Constructor
230 /*!
231 * This doesn't do much more than initialize constants with default values
232 * for water at 25C. Water molecular weight comes from the default
233 * elements definitions. It actually differs slightly from the IAPWS95 value of
234 * 18.015268. However, density conservation and therefore element
235 * conservation is the more important principle to follow.
236 */
237 MolalityVPSSTP();
238
239 //! @name Utilities
240 //! @{
241
242 //! String indicating the mechanical phase of the matter in this Phase.
243 /*!
244 * All derived phases from `MolalityVPSSTP` always represent liquids.
245 */
246 string phaseOfMatter() const override {
247 return "liquid";
248 }
249
250 //! Set the pH scale, which determines the scale for single-ion activity
251 //! coefficients.
252 /*!
253 * Single ion activity coefficients are not unique in terms of the
254 * representing actual measurable quantities.
255 *
256 * @param pHscaleType Integer representing the pHscale
257 */
258 void setpHScale(const int pHscaleType);
259
260 //! Reports the pH scale, which determines the scale for single-ion activity
261 //! coefficients.
262 /*!
263 * Single ion activity coefficients are not unique in terms of the
264 * representing actual measurable quantities.
265 *
266 * @returns the pHscale type
267 */
268 int pHScale() const;
269
270 //! @}
271 //! @name Utilities for Solvent ID and Molality
272 //! @{
273
274 /**
275 * Sets the minimum mole fraction in the molality formulation. Note the
276 * molality formulation is singular in the limit that the solvent mole
277 * fraction goes to zero. Numerically, how this limit is treated and
278 * resolved is an ongoing issue within Cantera. The minimum mole fraction
279 * must be in the range 0 to 0.9.
280 *
281 * @param xmolSolventMIN Input double containing the minimum mole fraction
282 */
283 void setMoleFSolventMin(double xmolSolventMIN);
284
285 //! Returns the minimum mole fraction in the molality formulation.
286 double moleFSolventMin() const;
287
288 //! Calculates the molality of all species and stores the result internally.
289 /*!
290 * We calculate the vector of molalities of the species in the phase and
291 * store the result internally:
292 * @f[
293 * m_i = \frac{X_i}{1000 * M_o * X_{o,p}}
294 * @f]
295 * where
296 * - @f$ M_o @f$ is the molecular weight of the solvent
297 * - @f$ X_o @f$ is the mole fraction of the solvent
298 * - @f$ X_i @f$ is the mole fraction of the solute.
299 * - @f$ X_{o,p} = \max (X_{o}^{min}, X_o) @f$
300 * - @f$ X_{o}^{min} @f$ = minimum mole fraction of solvent allowed
301 * in the denominator.
302 */
303 void calcMolalities() const;
304
305 //! This function will return the molalities of the species.
306 /*!
307 * We calculate the vector of molalities of the species in the phase
308 * @f[
309 * m_i = \frac{X_i}{1000 * M_o * X_{o,p}}
310 * @f]
311 * where
312 * - @f$ M_o @f$ is the molecular weight of the solvent
313 * - @f$ X_o @f$ is the mole fraction of the solvent
314 * - @f$ X_i @f$ is the mole fraction of the solute.
315 * - @f$ X_{o,p} = \max (X_{o}^{min}, X_o) @f$
316 * - @f$ X_{o}^{min} @f$ = minimum mole fraction of solvent allowed
317 * in the denominator.
318 *
319 * @param molal Output vector of molalities. Length: m_kk.
320 */
321 void getMolalities(double* const molal) const;
322
323 //! Set the molalities of the solutes in a phase
324 /*!
325 * Note, the entry for the solvent is not used. We are supplied with the
326 * molalities of all of the solute species. We then calculate the mole
327 * fractions of all species and update the ThermoPhase object.
328 * @f[
329 * m_i = \frac{X_i}{M_o/1000 * X_{o,p}}
330 * @f]
331 * where
332 * - @f$ M_o @f$ is the molecular weight of the solvent
333 * - @f$ X_o @f$ is the mole fraction of the solvent
334 * - @f$ X_i @f$ is the mole fraction of the solute.
335 * - @f$ X_{o,p} = \max(X_o^{min}, X_o) @f$
336 * - @f$ X_o^{min} @f$ = minimum mole fraction of solvent allowed
337 * in the denominator.
338 *
339 * The formulas for calculating mole fractions are
340 * @f[
341 * L^{sum} = \frac{1}{\tilde{M}_o X_o} = \frac{1}{\tilde{M}_o} + \sum_{i\ne o} m_i
342 * @f]
343 * Then,
344 * @f[
345 * X_o = \frac{1}{\tilde{M}_o L^{sum}}
346 * @f]
347 * @f[
348 * X_i = \frac{m_i}{L^{sum}}
349 * @f]
350 * It is currently an error if the solvent mole fraction is attempted to be
351 * set to a value lower than @f$ X_o^{min} @f$.
352 *
353 * @param molal Input vector of molalities. Length: m_kk.
354 */
355 void setMolalities(const double* const molal);
356
357 //! Set the molalities of a phase
358 /*!
359 * Set the molalities of the solutes in a phase. Note, the entry for the
360 * solvent is not used.
361 *
362 * @param xMap Composition Map containing the molalities.
363 */
364 void setMolalitiesByName(const Composition& xMap);
365
366 //! Set the molalities of a phase
367 /*!
368 * Set the molalities of the solutes in a phase. Note, the entry for the
369 * solvent is not used.
370 *
371 * @param name String containing the information for a composition map.
372 */
373 void setMolalitiesByName(const string& name);
374
375 //! @}
376 //! @name Activities, Standard States, and Activity Concentrations
377 //!
378 //! The activity @f$ a_k @f$ of a species in solution is related to the
379 //! chemical potential by @f[ \mu_k = \mu_k^0(T) + \hat R T \ln a_k. @f] The
380 //! quantity @f$ \mu_k^0(T,P) @f$ is the chemical potential at unit activity,
381 //! which depends only on temperature and pressure.
382 //! @{
383
384 /**
385 * We set the convention to molality here.
386 */
387 int activityConvention() const override;
388
389 void getActivityConcentrations(double* c) const override;
390 double standardConcentration(size_t k=0) const override;
391
392 //! Get the array of non-dimensional activities (molality based for this
393 //! class and classes that derive from it) at the current solution
394 //! temperature, pressure, and solution concentration.
395 /*!
396 * All standard state properties for molality-based phases are evaluated
397 * consistent with the molality scale. Therefore, this function must return
398 * molality-based activities.
399 *
400 * @f[
401 * a_i^\triangle = \gamma_k^{\triangle} \frac{m_k}{m^\triangle}
402 * @f]
403 *
404 * This function must be implemented in derived classes.
405 *
406 * @param ac Output vector of molality-based activities. Length: m_kk.
407 */
408 void getActivities(double* ac) const override;
409
410 //! Get the array of non-dimensional activity coefficients at
411 //! the current solution temperature, pressure, and solution concentration.
412 /*!
413 * These are mole-fraction based activity coefficients. In this
414 * object, their calculation is based on translating the values
415 * of the molality-based activity coefficients.
416 * See Denbigh p. 278 @cite denbigh1981 for a thorough discussion.
417 *
418 * The molar-based activity coefficients @f$ \gamma_k @f$ may be calculated
419 * from the molality-based activity coefficients, @f$ \gamma_k^\triangle @f$
420 * by the following formula.
421 * @f[
422 * \gamma_k = \frac{\gamma_k^\triangle}{X_o}
423 * @f]
424 *
425 * For purposes of establishing a convention, the molar activity coefficient of the
426 * solvent is set equal to the molality-based activity coefficient of the
427 * solvent:
428 *
429 * @f[
430 * \gamma_o = \gamma_o^\triangle
431 * @f]
432 *
433 * Derived classes don't need to overload this function. This function is
434 * handled at this level.
435 *
436 * @param ac Output vector containing the mole-fraction based activity
437 * coefficients. length: m_kk.
438 */
439 void getActivityCoefficients(double* ac) const override;
440
441 //! Get the array of non-dimensional molality based activity coefficients at
442 //! the current solution temperature, pressure, and solution concentration.
443 /*!
444 * See Denbigh p. 278 @cite denbigh1981 for a thorough discussion. This method must
445 * be overridden in classes which derive from MolalityVPSSTP. This function
446 * takes over from the molar-based activity coefficient calculation,
447 * getActivityCoefficients(), in derived classes.
448 *
449 * These molality based activity coefficients are scaled according to the
450 * current pH scale. See the Eq3/6 manual for details.
451 *
452 * Activity coefficients for species k may be altered between scales s1 to
453 * s2 using the following formula
454 *
455 * @f[
456 * \ln(\gamma_k^{s2}) = \ln(\gamma_k^{s1})
457 * + \frac{z_k}{z_j} \left( \ln(\gamma_j^{s2}) - \ln(\gamma_j^{s1}) \right)
458 * @f]
459 *
460 * where j is any one species. For the NBS scale, j is equal to the Cl-
461 * species and
462 *
463 * @f[
464 * \ln(\gamma_{Cl-}^{s2}) = \frac{-A_{\phi} \sqrt{I}}{1.0 + 1.5 \sqrt{I}}
465 * @f]
466 *
467 * @param acMolality Output vector containing the molality based activity
468 * coefficients. length: m_kk.
469 */
470 virtual void getMolalityActivityCoefficients(double* acMolality) const;
471
472 //! Calculate the osmotic coefficient
473 /*!
474 * @f[
475 * \phi = \frac{- \ln(a_o)}{\tilde{M}_o \sum_{i \ne o} m_i}
476 * @f]
477 *
478 * Note there are a few of definitions of the osmotic coefficient floating
479 * around. We use the one defined in (Activity Coefficients in Electrolyte
480 * Solutions, K. S. Pitzer CRC Press, Boca Raton, 1991, p. 85, Eqn. 28).
481 * This definition is most clearly related to theoretical calculation.
482 *
483 * units = dimensionless
484 */
485 virtual double osmoticCoefficient() const;
486
487 //! @}
488
489 //! @name Initialization
490 //!
491 //! The following methods are used in the process of constructing the phase
492 //! and setting its parameters from a specification in an input file. They
493 //! are not normally used in application programs. To see how they are used,
494 //! see importPhase().
495 //! @{
496
497 bool addSpecies(shared_ptr<Species> spec) override;
498 void initThermo() override;
499
500 //! @}
501
502 //! Set the temperature (K), pressure (Pa), and molalities
503 //!(gmol kg-1) of the solutes
504 /*!
505 * @param t Temperature (K)
506 * @param p Pressure (Pa)
507 * @param molalities Input vector of molalities of the solutes.
508 * Length: m_kk.
509 */
510 void setState_TPM(double t, double p, const double* const molalities);
511
512 //! Set the temperature (K), pressure (Pa), and molalities.
513 /*!
514 * @param t Temperature (K)
515 * @param p Pressure (Pa)
516 * @param m Composition containing the molalities
517 */
518 void setState_TPM(double t, double p, const Composition& m);
519
520 //! Set the temperature (K), pressure (Pa), and molalities.
521 /*!
522 * @param t Temperature (K)
523 * @param p Pressure (Pa)
524 * @param m String which gets translated into a composition
525 * map for the molalities of the solutes.
526 */
527 void setState_TPM(double t, double p, const string& m);
528
529 //! @copydoc ThermoPhase::setState
530 /*!
531 * Additionally uses the keys `molalities` or `M` to set the molalities.
532 */
533 void setState(const AnyMap& state) override;
534
535 void getdlnActCoeffdlnN(const size_t ld, double* const dlnActCoeffdlnN) override {
536 getdlnActCoeffdlnN_numderiv(ld, dlnActCoeffdlnN);
537 }
538
539 string report(bool show_thermo=true, double threshold=1e-14) const override;
540
541 protected:
542 void getCsvReportData(vector<string>& names,
543 vector<vector<double>>& data) const override;
544
545 //! Get the array of unscaled non-dimensional molality based activity
546 //! coefficients at the current solution temperature, pressure, and solution
547 //! concentration.
548 /*!
549 * See Denbigh p. 278 @cite denbigh1981 for a thorough discussion. This method must
550 * be overridden in classes which derive from MolalityVPSSTP. This function
551 * takes over from the molar-based activity coefficient calculation,
552 * getActivityCoefficients(), in derived classes.
553 *
554 * @param acMolality Output vector containing the molality based activity
555 * coefficients. length: m_kk.
556 */
557 virtual void getUnscaledMolalityActivityCoefficients(double* acMolality) const;
558
559 //! Apply the current phScale to a set of activity Coefficients or
560 //! activities
561 /*!
562 * See the Eq3/6 Manual for a thorough discussion.
563 *
564 * @param acMolality input/Output vector containing the molality based
565 * activity coefficients. length: m_kk.
566 */
567 virtual void applyphScale(double* acMolality) const;
568
569 private:
570 //! Returns the index of the Cl- species.
571 /*!
572 * The Cl- species is special in the sense that its single ion molality-
573 * based activity coefficient is used in the specification of the pH scale
574 * for single ions. Therefore, we need to know what species index is Cl-. If
575 * the species isn't in the species list then this routine returns -1, and
576 * we can't use the NBS pH scale.
577 *
578 * Right now we use a restrictive interpretation. The species must be named
579 * "Cl-". It must consist of exactly one Cl and one E atom.
580 */
581 size_t findCLMIndex() const;
582
583 protected:
584 //! Scaling to be used for output of single-ion species activity
585 //! coefficients.
586 /*!
587 * Index of the species to be used in the single-ion scaling law. This is
588 * the identity of the Cl- species for the PHSCALE_NBS scaling. Either
589 * PHSCALE_PITZER or PHSCALE_NBS
590 */
591 int m_pHScalingType = PHSCALE_PITZER;
592
593 //! Index of the phScale species
594 /*!
595 * Index of the species to be used in the single-ion scaling law. This is
596 * the identity of the Cl- species for the PHSCALE_NBS scaling
597 */
598 size_t m_indexCLM = npos;
599
600 //! Molecular weight of the Solvent
601 double m_weightSolvent = 18.01528;
602
603 /**
604 * In any molality implementation, it makes sense to have a minimum solvent
605 * mole fraction requirement, since the implementation becomes singular in
606 * the xmolSolvent=0 limit. The default is to set it to 0.01. We then modify
607 * the molality definition to ensure that molal_solvent = 0 when
608 * xmol_solvent = 0.
609 */
610 double m_xmolSolventMIN = 0.01;
611
612 //! This is the multiplication factor that goes inside log expressions
613 //! involving the molalities of species. It's equal to Wt_0 / 1000, where
614 //! Wt_0 = weight of solvent (kg/kmol)
615 double m_Mnaught = 18.01528E-3;
616
617 //! Current value of the molalities of the species in the phase. Note this
618 //! vector is a mutable quantity. units are (kg/kmol)
619 mutable vector<double> m_molalities;
620};
621
622}
623
624#endif
VPStandardStateTP.h
Header file for a derived class of ThermoPhase that handles variable pressure standard state methods ...
Cantera::AnyMap
A map of string keys to values whose type can vary at runtime.
Definition AnyMap.h:427
Cantera::MolalityVPSSTP
MolalityVPSSTP is a derived class of ThermoPhase that handles variable pressure standard state method...
Definition MolalityVPSSTP.h:227
Cantera::MolalityVPSSTP::activityConvention
int activityConvention() const override
We set the convention to molality here.
Definition MolalityVPSSTP.cpp:181
Cantera::MolalityVPSSTP::setState
void setState(const AnyMap &state) override
Set the state using an AnyMap containing any combination of properties supported by the thermodynamic...
Definition MolalityVPSSTP.cpp:252
Cantera::MolalityVPSSTP::getCsvReportData
void getCsvReportData(vector< string > &names, vector< vector< double > > &data) const override
Fills names and data with the column names and species thermo properties to be included in the output...
Definition MolalityVPSSTP.cpp:465
Cantera::MolalityVPSSTP::setMolalitiesByName
void setMolalitiesByName(const Composition &xMap)
Set the molalities of a phase.
Definition MolalityVPSSTP.cpp:105
Cantera::MolalityVPSSTP::m_Mnaught
double m_Mnaught
This is the multiplication factor that goes inside log expressions involving the molalities of specie...
Definition MolalityVPSSTP.h:615
Cantera::MolalityVPSSTP::m_indexCLM
size_t m_indexCLM
Index of the phScale species.
Definition MolalityVPSSTP.h:598
Cantera::MolalityVPSSTP::findCLMIndex
size_t findCLMIndex() const
Returns the index of the Cl- species.
Definition MolalityVPSSTP.cpp:287
Cantera::MolalityVPSSTP::initThermo
void initThermo() override
Initialize the ThermoPhase object after all species have been set up.
Definition MolalityVPSSTP.cpp:269
Cantera::MolalityVPSSTP::getActivityConcentrations
void getActivityConcentrations(double *c) const override
This method returns an array of generalized concentrations.
Definition MolalityVPSSTP.cpp:186
Cantera::MolalityVPSSTP::pHScale
int pHScale() const
Reports the pH scale, which determines the scale for single-ion activity coefficients.
Definition MolalityVPSSTP.cpp:40
Cantera::MolalityVPSSTP::getMolalityActivityCoefficients
virtual void getMolalityActivityCoefficients(double *acMolality) const
Get the array of non-dimensional molality based activity coefficients at the current solution tempera...
Definition MolalityVPSSTP.cpp:210
Cantera::MolalityVPSSTP::setpHScale
void setpHScale(const int pHscaleType)
Set the pH scale, which determines the scale for single-ion activity coefficients.
Definition MolalityVPSSTP.cpp:31
Cantera::MolalityVPSSTP::m_xmolSolventMIN
double m_xmolSolventMIN
In any molality implementation, it makes sense to have a minimum solvent mole fraction requirement,...
Definition MolalityVPSSTP.h:610
Cantera::MolalityVPSSTP::m_molalities
vector< double > m_molalities
Current value of the molalities of the species in the phase.
Definition MolalityVPSSTP.h:619
Cantera::MolalityVPSSTP::applyphScale
virtual void applyphScale(double *acMolality) const
Apply the current phScale to a set of activity Coefficients or activities.
Definition MolalityVPSSTP.cpp:282
Cantera::MolalityVPSSTP::m_pHScalingType
int m_pHScalingType
Scaling to be used for output of single-ion species activity coefficients.
Definition MolalityVPSSTP.h:591
Cantera::MolalityVPSSTP::setMolalities
void setMolalities(const double *const molal)
Set the molalities of the solutes in a phase.
Definition MolalityVPSSTP.cpp:78
Cantera::MolalityVPSSTP::getMolalities
void getMolalities(double *const molal) const
This function will return the molalities of the species.
Definition MolalityVPSSTP.cpp:70
Cantera::MolalityVPSSTP::setMoleFSolventMin
void setMoleFSolventMin(double xmolSolventMIN)
Sets the minimum mole fraction in the molality formulation.
Definition MolalityVPSSTP.cpp:45
Cantera::MolalityVPSSTP::osmoticCoefficient
virtual double osmoticCoefficient() const
Calculate the osmotic coefficient.
Definition MolalityVPSSTP.cpp:216
Cantera::MolalityVPSSTP::MolalityVPSSTP
MolalityVPSSTP()
Default Constructor.
Definition MolalityVPSSTP.cpp:21
Cantera::MolalityVPSSTP::moleFSolventMin
double moleFSolventMin() const
Returns the minimum mole fraction in the molality formulation.
Definition MolalityVPSSTP.cpp:55
Cantera::MolalityVPSSTP::setState_TPM
void setState_TPM(double t, double p, const double *const molalities)
Set the temperature (K), pressure (Pa), and molalities (gmol kg-1) of the solutes.
Definition MolalityVPSSTP.cpp:234
Cantera::MolalityVPSSTP::getActivities
void getActivities(double *ac) const override
Get the array of non-dimensional activities (molality based for this class and classes that derive fr...
Definition MolalityVPSSTP.cpp:196
Cantera::MolalityVPSSTP::getUnscaledMolalityActivityCoefficients
virtual void getUnscaledMolalityActivityCoefficients(double *acMolality) const
Get the array of unscaled non-dimensional molality based activity coefficients at the current solutio...
Definition MolalityVPSSTP.cpp:277
Cantera::MolalityVPSSTP::calcMolalities
void calcMolalities() const
Calculates the molality of all species and stores the result internally.
Definition MolalityVPSSTP.cpp:60
Cantera::MolalityVPSSTP::standardConcentration
double standardConcentration(size_t k=0) const override
Return the standard concentration for the kth species.
Definition MolalityVPSSTP.cpp:191
Cantera::MolalityVPSSTP::m_weightSolvent
double m_weightSolvent
Molecular weight of the Solvent.
Definition MolalityVPSSTP.h:601
Cantera::MolalityVPSSTP::addSpecies
bool addSpecies(shared_ptr< Species > spec) override
Add a Species to this Phase.
Definition MolalityVPSSTP.cpp:343
Cantera::MolalityVPSSTP::getActivityCoefficients
void getActivityCoefficients(double *ac) const override
Get the array of non-dimensional activity coefficients at the current solution temperature,...
Definition MolalityVPSSTP.cpp:201
Cantera::MolalityVPSSTP::phaseOfMatter
string phaseOfMatter() const override
String indicating the mechanical phase of the matter in this Phase.
Definition MolalityVPSSTP.h:246
Cantera::MolalityVPSSTP::getdlnActCoeffdlnN
void getdlnActCoeffdlnN(const size_t ld, double *const dlnActCoeffdlnN) override
Get the array of derivatives of the log activity coefficients with respect to the log of the species ...
Definition MolalityVPSSTP.h:535
Cantera::MolalityVPSSTP::report
string report(bool show_thermo=true, double threshold=1e-14) const override
returns a summary of the state of the phase as a string
Definition MolalityVPSSTP.cpp:357
Cantera::Phase::name
string name() const
Return the name of the phase.
Definition Phase.cpp:20
Cantera::VPStandardStateTP
This is a filter class for ThermoPhase that implements some preparatory steps for efficiently handlin...
Definition VPStandardStateTP.h:44
Cantera
Namespace for the Cantera kernel.
Definition AnyMap.cpp:564
Cantera::npos
const size_t npos
index returned by functions to indicate "no position"
Definition ct_defs.h:195
Cantera::PHSCALE_PITZER
const int PHSCALE_PITZER
Scale to be used for the output of single-ion activity coefficients is that used by Pitzer.
Definition MolalityVPSSTP.h:44
Cantera::PHSCALE_NBS
const int PHSCALE_NBS
Scale to be used for evaluation of single-ion activity coefficients is that used by the NBS standard ...
Definition MolalityVPSSTP.h:69
Cantera::Composition
map< string, double > Composition
Map from string names to doubles.
Definition ct_defs.h:184