CoolProp 6.8.1dev
An open-source fluid property and humid air property database
HelmholtzEOSMixtureBackend.h
Go to the documentation of this file.
1
2#ifndef HELMHOLTZEOSMIXTUREBACKEND_H_
3#define HELMHOLTZEOSMIXTUREBACKEND_H_
4
5#include "AbstractState.h"
6#include "CoolPropFluid.h"
7#include "ReducingFunctions.h"
8#include "ExcessHEFunction.h"
9#include "Solvers.h"
10#include "PhaseEnvelope.h"
11#include "DataStructures.h"
12#include "Configuration.h"
13
14#include <vector>
15
16namespace CoolProp {
17
18class FlashRoutines;
19
20class ResidualHelmholtz;
21
22// This class contains the mole fractions for a given mixture.
23class MoleFractions{
24 private:
25 std::vector<CoolPropDbl> mole_fractions;
26 template <typename T>
27 bool verify_mole_fractions_set(T i) const {
28 if (i >= mole_fractions.size()){
29 throw CoolProp::ValueError("mole fractions are not set for all components");
30 }
31 return true;
32 }
33 public:
34 template <typename T>
35 void resize(T N){
36 return mole_fractions.resize(N);
37 }
38 std::size_t size() const {
39 return mole_fractions.size();
40 }
41 void clear() {
42 mole_fractions.clear();
43 }
44 // operator overloads
45 template<typename T>
46 MoleFractions& operator=(const std::vector<T>& values){
47 mole_fractions = values;
48 return *this;
49 }
50 template <typename T>
51 CoolPropDbl operator[](T i) const {
52 verify_mole_fractions_set(i);
53 return mole_fractions[i];
54 }
55 operator std::vector<CoolPropDbl>& () { return mole_fractions; }
56};
57
58class HelmholtzEOSMixtureBackend : public AbstractState
59{
60
61 protected:
62 void pre_update(CoolProp::input_pairs& input_pair, CoolPropDbl& value1, CoolPropDbl& value2);
63 void post_update(bool optional_checks = true);
64 std::vector<shared_ptr<HelmholtzEOSMixtureBackend>>
65 linked_states;
66 shared_ptr<HelmholtzEOSMixtureBackend> transient_pure_state;
67 shared_ptr<HelmholtzEOSMixtureBackend> TPD_state;
68 shared_ptr<HelmholtzEOSMixtureBackend> critical_state;
70 virtual void add_TPD_state() {
71 if (TPD_state.get() == NULL) {
72 bool sat_states = false;
73 TPD_state.reset(get_copy(sat_states));
74 linked_states.push_back(TPD_state);
75 }
76 };
78 virtual void add_critical_state() {
79 if (critical_state.get() == NULL) {
80 bool sat_states = true;
81 critical_state.reset(get_copy(sat_states));
82 linked_states.push_back(critical_state);
83 }
84 };
86 virtual void add_transient_pure_state() {
87 if (transient_pure_state.get() == NULL) {
88 bool sat_states = true;
89 transient_pure_state.reset(get_copy(sat_states));
90 linked_states.push_back(transient_pure_state);
91 }
92 };
93
94 std::vector<CoolPropFluid> components;
95 bool is_pure_or_pseudopure;
96 MoleFractions mole_fractions;
97 std::vector<CoolPropDbl> K,
98 lnK;
99
100 SimpleState _crit;
101 std::size_t N;
102
104 std::vector<CoolProp::CriticalState> _calc_all_critical_points(bool find_critical_points = true);
105
106 static void set_fluid_enthalpy_entropy_offset(CoolPropFluid& component, double delta_a1, double delta_a2, const std::string& ref);
107
108 std::optional<EquationOfState::SuperAncillary_t>& get_superanc_optional();
109
110 public:
111 HelmholtzEOSMixtureBackend();
112 HelmholtzEOSMixtureBackend(const std::vector<CoolPropFluid>& components, bool generate_SatL_and_SatV = true);
113 HelmholtzEOSMixtureBackend(const std::vector<std::string>& component_names, bool generate_SatL_and_SatV = true);
114 virtual HelmholtzEOSMixtureBackend* get_copy(bool generate_SatL_and_SatV = true);
115
116 // Copy over the reducing and departure terms to all linked states (recursively)
117 void sync_linked_states(const HelmholtzEOSMixtureBackend* const);
118
119 virtual ~HelmholtzEOSMixtureBackend(){};
120 std::string backend_name(void) {
121 return get_backend_string(HEOS_BACKEND_MIX);
122 }
123 shared_ptr<ReducingFunction> Reducing;
124 shared_ptr<ResidualHelmholtz> residual_helmholtz;
125 PhaseEnvelopeData PhaseEnvelope;
126 SimpleState hsat_max;
127 SsatSimpleState ssat_max;
128 SpinodalData spinodal_values;
129
130 bool clear() {
131 // Clear the locally cached values for the derivatives of the Helmholtz energy
132 // in each component
133 for (std::vector<CoolPropFluid>::iterator it = components.begin(); it != components.end(); ++it) {
134 (*it).EOS().alphar.clear();
135 (*it).EOS().alpha0.clear();
136 }
137 return AbstractState::clear();
138 };
139
140 friend class
141 FlashRoutines; // Allows the static methods in the FlashRoutines class to have access to all the protected members and methods of this class
142 friend class
143 TransportRoutines; // Allows the static methods in the TransportRoutines class to have access to all the protected members and methods of this class
144 friend class
145 MixtureDerivatives; // Allows the static methods in the MixtureDerivatives class to have access to all the protected members and methods of this class
146 friend class
147 PhaseEnvelopeRoutines; // Allows the static methods in the PhaseEnvelopeRoutines class to have access to all the protected members and methods of this class
148 friend class
149 MixtureParameters; // Allows the static methods in the MixtureParameters class to have access to all the protected members and methods of this class
150 friend class
151 CorrespondingStatesTerm; // // Allows the methods in the CorrespondingStatesTerm class to have access to all the protected members and methods of this class
152
153 // Helmholtz EOS backend uses mole fractions
154 bool using_mole_fractions() {
155 return true;
156 }
157 bool using_mass_fractions() {
158 return false;
159 }
160 bool using_volu_fractions() {
161 return false;
162 }
163 bool is_pure() {
164 return components.size() == 1 && !components[0].EOS().pseudo_pure;
165 }
166 bool has_melting_line() {
167 return is_pure_or_pseudopure && components[0].ancillaries.melting_line.enabled();
168 };
169 CoolPropDbl calc_melting_line(int param, int given, CoolPropDbl value);
171 std::string fluid_param_string(const std::string&);
172
174 virtual void set_reference_stateS(const std::string& reference_state);
175
177 virtual void set_reference_stateD(double T, double rhomolar, double hmolar0, double smolar0);
178
180 virtual void set_binary_interaction_double(const std::size_t i, const std::size_t j, const std::string& parameter, const double value);
182 virtual double get_binary_interaction_double(const std::size_t i, const std::size_t j, const std::string& parameter);
184 //virtual std::string get_binary_interaction_string(const std::size_t &i, const std::size_t &j, const std::string &parameter);
186 void set_binary_interaction_string(const std::size_t i, const std::size_t j, const std::string& parameter, const std::string& value);
188 void apply_simple_mixing_rule(std::size_t i, std::size_t j, const std::string& model);
189
190 // Set the cubic alpha function's constants:
191 virtual void set_cubic_alpha_C(const size_t i, const std::string& parameter, const double c1, const double c2, const double c3) {
192 throw ValueError("set_cubic_alpha_C only defined for cubic backends");
193 };
194
195 // Set fluid parameter (currently the volume translation parameter for cubic)
196 virtual void set_fluid_parameter_double(const size_t i, const std::string& parameter, const double value) {
197 throw ValueError("set_fluid_parameter_double only defined for cubic backends");
198 };
199 virtual double get_fluid_parameter_double(const size_t i, const std::string& parameter);
200
201 phases calc_phase(void) {
202 return _phase;
203 };
204
209 void calc_specify_phase(phases phase_index) {
210 imposed_phase_index = phase_index;
211 _phase = phase_index;
212 }
215 void calc_unspecify_phase() {
216 imposed_phase_index = iphase_not_imposed;
217 }
218 CoolPropDbl calc_saturation_ancillary(parameters param, int Q, parameters given, double value);
219 void calc_ssat_max(void);
220 void calc_hsat_max(void);
221 CoolPropDbl calc_GWP20();
222 CoolPropDbl calc_GWP500();
223 CoolPropDbl calc_GWP100();
224 CoolPropDbl calc_ODP();
225
226 CoolPropDbl calc_first_saturation_deriv(parameters Of1, parameters Wrt1);
227 CoolPropDbl calc_first_saturation_deriv(parameters Of1, parameters Wrt1, HelmholtzEOSMixtureBackend& SatL, HelmholtzEOSMixtureBackend& SatV);
228 CoolPropDbl calc_second_saturation_deriv(parameters Of1, parameters Wrt1, parameters Wrt2);
229 CoolPropDbl calc_first_two_phase_deriv(parameters Of, parameters Wrt, parameters Constant);
230 CoolPropDbl calc_second_two_phase_deriv(parameters Of, parameters Wrt1, parameters Constant1, parameters Wrt2, parameters Constant2);
231 CoolPropDbl calc_first_two_phase_deriv_splined(parameters Of, parameters Wrt, parameters Constant, CoolPropDbl x_end);
232
233 CriticalState calc_critical_point(double rho0, double T0);
235 std::vector<CoolProp::CriticalState> calc_all_critical_points() {
236 bool find_critical_points = true;
237 return _calc_all_critical_points(find_critical_points);
238 };
239
240 virtual void get_critical_point_starting_values(double& delta0, double& tau0) {
241 delta0 = get_config_double(SPINODAL_MINIMUM_DELTA); // The value of delta where we start searching for crossing with Lstar=0 contour
242 tau0 = 0.66; // The value of tau where we start searching at delta=delta0
243 }
245 virtual void get_critical_point_search_radii(double& R_delta, double& R_tau);
247 virtual bool get_critical_is_terminated(double& delta, double& tau) {
248 return delta > 5 || tau > 5;
249 }
250
252 virtual void calc_build_spinodal();
253
255 virtual SpinodalData calc_get_spinodal_data() {
256 return spinodal_values;
257 };
258
260 void calc_criticality_contour_values(double& L1star, double& M1star);
261
263 double calc_tangent_plane_distance(const double T, const double p, const std::vector<double>& w, const double rhomolar_guess);
264
266 void recalculate_singlephase_phase();
267
269 void calc_change_EOS(const std::size_t i, const std::string& EOS_name);
270
271 const CoolProp::SimpleState& calc_state(const std::string& state);
272
273 virtual const double get_fluid_constant(std::size_t i, parameters param) const {
274 const CoolPropFluid& fld = components[i];
275 switch (param) {
276 case iP_critical:
277 return fld.crit.p;
278 case iT_critical:
279 return fld.crit.T;
280 case iT_reducing:
281 return fld.EOS().reduce.T;
282 case irhomolar_reducing:
283 return fld.EOS().reduce.rhomolar;
284 case irhomolar_critical:
285 return fld.crit.rhomolar;
286 case iacentric_factor:
287 return fld.EOS().acentric;
288 case imolar_mass:
289 return fld.EOS().molar_mass;
290 case iT_triple:
291 return fld.EOS().sat_min_liquid.T;
292 case iP_triple:
293 return fld.EOS().sat_min_liquid.p;
294 case igas_constant:
295 return fld.EOS().R_u;
296 default:
297 throw ValueError(format("I don't know what to do with this fluid constant: %s", get_parameter_information(param, "short").c_str()));
298 }
299 }
300
301 const std::vector<CoolPropFluid>& get_components() const {
302 return components;
303 }
304 std::vector<CoolPropFluid>& get_components() {
305 return components;
306 }
307 std::vector<CoolPropDbl>& get_K() {
308 return K;
309 };
310 std::vector<CoolPropDbl>& get_lnK() {
311 return lnK;
312 };
313 HelmholtzEOSMixtureBackend& get_SatL() {
314 return *SatL;
315 };
316 HelmholtzEOSMixtureBackend& get_SatV() {
317 return *SatV;
318 };
319
320 std::vector<CoolPropDbl> calc_mole_fractions_liquid(void) {
321 return SatL->get_mole_fractions();
322 };
323 std::vector<CoolPropDbl> calc_mole_fractions_vapor(void) {
324 return SatV->get_mole_fractions();
325 };
326
327 const std::vector<CoolPropDbl> calc_mass_fractions(void);
328
329 const CoolProp::PhaseEnvelopeData& calc_phase_envelope_data() {
330 return PhaseEnvelope;
331 };
332
334 void calc_conformal_state(const std::string& reference_fluid, CoolPropDbl& T, CoolPropDbl& rhomolar);
335
336 void resize(std::size_t N);
337 shared_ptr<HelmholtzEOSMixtureBackend> SatL, SatV;
338
344 virtual void update(CoolProp::input_pairs input_pair, double value1, double value2);
345
349 void update_with_guesses(CoolProp::input_pairs input_pair, double Value1, double Value2, const GuessesStructure& guesses);
350
353 void update_internal(HelmholtzEOSMixtureBackend& HEOS);
354
360 void update_TP_guessrho(CoolPropDbl T, CoolPropDbl p, CoolPropDbl rho_guess);
361 void update_DmolarT_direct(CoolPropDbl rhomolar, CoolPropDbl T);
362 void update_TDmolarP_unchecked(CoolPropDbl T, CoolPropDbl rhomolarL, CoolPropDbl p);
363 void update_QT_pure_superanc(CoolPropDbl Q, CoolPropDbl T);
364 void update_HmolarQ_with_guessT(CoolPropDbl hmolar, CoolPropDbl Q, CoolPropDbl Tguess);
365
371 virtual void set_components(const std::vector<CoolPropFluid>& components, bool generate_SatL_and_SatV = true);
372
375 void set_mixture_parameters();
376
381 void set_mole_fractions(const std::vector<CoolPropDbl>& mf);
382
383 const std::vector<CoolPropDbl>& get_mole_fractions() {
384 return mole_fractions;
385 };
386 std::vector<CoolPropDbl>& get_mole_fractions_ref() {
387 return mole_fractions;
388 };
389 std::vector<double>& get_mole_fractions_doubleref(void) {
390 return mole_fractions;
391 }
392
397 void set_mass_fractions(const std::vector<CoolPropDbl>& mass_fractions);
398
399 void calc_ideal_curve(const std::string& type, std::vector<double>& T, std::vector<double>& p);
400
401 CoolPropDbl calc_molar_mass(void);
402 CoolPropDbl calc_gas_constant(void);
403 CoolPropDbl calc_acentric_factor(void);
404
405 CoolPropDbl calc_Bvirial(void);
406 CoolPropDbl calc_Cvirial(void);
407 CoolPropDbl calc_dBvirial_dT(void);
408 CoolPropDbl calc_dCvirial_dT(void);
409
410 CoolPropDbl calc_pressure(void);
411 CoolPropDbl calc_cvmolar(void);
412 CoolPropDbl calc_cpmolar(void);
413 CoolPropDbl calc_gibbsmolar(void);
414 CoolPropDbl calc_gibbsmolar_residual(void) {
415 return gas_constant() * _T * (alphar() + delta() * dalphar_dDelta());
416 }
417 CoolPropDbl calc_gibbsmolar_nocache(CoolPropDbl T, CoolPropDbl rhomolar);
418
419 CoolPropDbl calc_helmholtzmolar(void);
420 CoolPropDbl calc_cpmolar_idealgas(void);
421 CoolPropDbl calc_pressure_nocache(CoolPropDbl T, CoolPropDbl rhomolar);
422 CoolPropDbl calc_smolar(void);
423 CoolPropDbl calc_smolar_residual(void) {
424 return gas_constant() * (tau() * dalphar_dTau() - alphar());
425 }
426 CoolPropDbl calc_smolar_nocache(CoolPropDbl T, CoolPropDbl rhomolar);
427
428 CoolPropDbl calc_hmolar(void);
429 CoolPropDbl calc_hmolar_residual(void) {
430 return gas_constant() * _T * (tau() * dalphar_dTau() + delta() * dalphar_dDelta());
431 }
432 CoolPropDbl calc_hmolar_nocache(CoolPropDbl T, CoolPropDbl rhomolar);
433
434 CoolPropDbl calc_umolar_nocache(CoolPropDbl T, CoolPropDbl rhomolar);
435 CoolPropDbl calc_umolar(void);
436 CoolPropDbl calc_speed_sound(void);
437
438 void calc_excess_properties();
439
445 CoolPropDbl calc_phase_identification_parameter(void);
446 CoolPropDbl calc_fugacity(std::size_t i);
447 virtual CoolPropDbl calc_fugacity_coefficient(std::size_t i);
448 CoolPropDbl calc_chemical_potential(std::size_t i);
449
451 CoolPropDbl calc_flame_hazard(void) {
452 return components[0].environment.FH;
453 };
455 CoolPropDbl calc_health_hazard(void) {
456 return components[0].environment.HH;
457 };
459 CoolPropDbl calc_physical_hazard(void) {
460 return components[0].environment.PH;
461 };
462
464 CoolPropDbl calc_alphar(void);
466 CoolPropDbl calc_dalphar_dDelta(void);
468 CoolPropDbl calc_dalphar_dTau(void);
470 CoolPropDbl calc_d2alphar_dDelta2(void);
472 CoolPropDbl calc_d2alphar_dDelta_dTau(void);
474 CoolPropDbl calc_d2alphar_dTau2(void);
476 CoolPropDbl calc_d3alphar_dDelta3(void);
478 CoolPropDbl calc_d3alphar_dDelta2_dTau(void);
480 CoolPropDbl calc_d3alphar_dDelta_dTau2(void);
482 CoolPropDbl calc_d3alphar_dTau3(void);
484 CoolPropDbl calc_d4alphar_dDelta4(void);
486 CoolPropDbl calc_d4alphar_dDelta3_dTau(void);
488 CoolPropDbl calc_d4alphar_dDelta2_dTau2(void);
490 CoolPropDbl calc_d4alphar_dDelta_dTau3(void);
492 CoolPropDbl calc_d4alphar_dTau4(void);
493
494 CoolPropDbl calc_alpha0(void);
495 CoolPropDbl calc_dalpha0_dDelta(void);
496 CoolPropDbl calc_dalpha0_dTau(void);
497 CoolPropDbl calc_d2alpha0_dDelta2(void);
498 CoolPropDbl calc_d2alpha0_dDelta_dTau(void);
499 CoolPropDbl calc_d2alpha0_dTau2(void);
500 CoolPropDbl calc_d3alpha0_dDelta3(void);
501 CoolPropDbl calc_d3alpha0_dDelta2_dTau(void);
502 CoolPropDbl calc_d3alpha0_dDelta_dTau2(void);
503 CoolPropDbl calc_d3alpha0_dTau3(void);
504
505 CoolPropDbl calc_surface_tension(void);
506 CoolPropDbl calc_viscosity(void);
507 CoolPropDbl calc_viscosity_dilute(void);
508 CoolPropDbl calc_viscosity_background(void);
509 CoolPropDbl calc_viscosity_background(CoolPropDbl eta_dilute, CoolPropDbl& initial_density, CoolPropDbl& residual);
510 CoolPropDbl calc_conductivity(void);
511 CoolPropDbl calc_conductivity_background(void);
512
518 void calc_viscosity_contributions(CoolPropDbl& dilute, CoolPropDbl& initial_density, CoolPropDbl& residual, CoolPropDbl& critical);
524 void calc_conductivity_contributions(CoolPropDbl& dilute, CoolPropDbl& initial_density, CoolPropDbl& residual, CoolPropDbl& critical);
525
526 CoolPropDbl calc_saturated_liquid_keyed_output(parameters key);
527 CoolPropDbl calc_saturated_vapor_keyed_output(parameters key);
528
529 CoolPropDbl calc_Tmin(void);
530 CoolPropDbl calc_Tmax(void);
531 CoolPropDbl calc_pmax(void);
532 CoolPropDbl calc_Ttriple(void);
533 CoolPropDbl calc_p_triple(void);
534 CoolPropDbl calc_pmax_sat(void);
535 CoolPropDbl calc_Tmax_sat(void);
536 void calc_Tmin_sat(CoolPropDbl& Tmin_satL, CoolPropDbl& Tmin_satV);
537 void calc_pmin_sat(CoolPropDbl& pmin_satL, CoolPropDbl& pmin_satV);
538
539 virtual CoolPropDbl calc_T_critical(void);
540 virtual CoolPropDbl calc_p_critical(void);
541 virtual CoolPropDbl calc_rhomolar_critical(void);
542
543 CoolPropDbl calc_T_reducing(void) {
544 return get_reducing_state().T;
545 };
546 CoolPropDbl calc_rhomolar_reducing(void) {
547 return get_reducing_state().rhomolar;
548 };
549 CoolPropDbl calc_p_reducing(void) {
550 return get_reducing_state().p;
551 };
552
553 // Calculate the phase identification parameter of Venkatarathnam et al, Fluid Phase Equilibria
554 CoolPropDbl calc_PIP(void) {
555 return 2
556 - rhomolar()
557 * (second_partial_deriv(iP, iDmolar, iT, iT, iDmolar) / first_partial_deriv(iP, iT, iDmolar)
558 - second_partial_deriv(iP, iDmolar, iT, iDmolar, iT) / first_partial_deriv(iP, iDmolar, iT));
559 };
560
561 std::string calc_name(void);
562 std::vector<std::string> calc_fluid_names(void);
563
564 void calc_all_alphar_deriv_cache(const std::vector<CoolPropDbl>& mole_fractions, const CoolPropDbl& tau, const CoolPropDbl& delta);
565 virtual CoolPropDbl calc_alphar_deriv_nocache(const int nTau, const int nDelta, const std::vector<CoolPropDbl>& mole_fractions,
566 const CoolPropDbl& tau, const CoolPropDbl& delta);
567
592 CoolPropDbl calc_alpha0_deriv_nocache(const int nTau, const int nDelta, const std::vector<CoolPropDbl>& mole_fractions, const CoolPropDbl& tau,
593 const CoolPropDbl& delta, const CoolPropDbl& Tr, const CoolPropDbl& rhor);
594
595 virtual void calc_reducing_state(void);
596 virtual SimpleState calc_reducing_state_nocache(const std::vector<CoolPropDbl>& mole_fractions);
597
598 const CoolProp::SimpleState& get_reducing_state() {
599 calc_reducing_state();
600 return _reducing;
601 };
602
603 void update_states();
604
605 CoolPropDbl calc_compressibility_factor(void) {
606 return 1 + delta() * dalphar_dDelta();
607 };
608
609 void calc_phase_envelope(const std::string& type);
610
611 CoolPropDbl SRK_covolume();
612
613 // ***************************************************************
614 // ***************************************************************
615 // ************* PHASE DETERMINATION ROUTINES ******************
616 // ***************************************************************
617 // ***************************************************************
618 void T_phase_determination_pure_or_pseudopure(int other, CoolPropDbl value);
619 void p_phase_determination_pure_or_pseudopure(int other, CoolPropDbl value, bool& saturation_called);
620 void DmolarP_phase_determination();
621
622 // ***************************************************************
623 // ***************************************************************
624 // ******************* SOLVER ROUTINES *************************
625 // ***************************************************************
626 // ***************************************************************
627
628 virtual CoolPropDbl solver_rho_Tp(CoolPropDbl T, CoolPropDbl p, CoolPropDbl rho_guess = -1);
629 virtual CoolPropDbl solver_rho_Tp_SRK(CoolPropDbl T, CoolPropDbl p, phases phase);
630 enum StationaryPointReturnFlag
631 {
632 ZERO_STATIONARY_POINTS,
633 ONE_STATIONARY_POINT_FOUND,
634 TWO_STATIONARY_POINTS_FOUND
635 };
636 virtual StationaryPointReturnFlag solver_dpdrho0_Tp(CoolPropDbl T, CoolPropDbl p, CoolPropDbl rhomax, CoolPropDbl& light, CoolPropDbl& heavy);
637 virtual CoolPropDbl solver_rho_Tp_global(CoolPropDbl T, CoolPropDbl p, CoolPropDbl rhomax);
638};
639
640class CorrespondingStatesTerm
641{
642 public:
644 virtual HelmholtzDerivatives all(HelmholtzEOSMixtureBackend& HEOS, double tau, double delta, const std::vector<CoolPropDbl>& x,
645 bool cache_values = false) {
646 HelmholtzDerivatives summer;
647 std::size_t N = x.size();
648 for (std::size_t i = 0; i < N; ++i) {
649 HelmholtzDerivatives derivs = HEOS.components[i].EOS().alphar.all(tau, delta, cache_values);
650 summer = summer + derivs * x[i];
651 }
652 return summer;
653 }
654 CoolPropDbl dalphar_dxi(HelmholtzEOSMixtureBackend& HEOS, std::vector<CoolPropDbl>& x, std::size_t i, x_N_dependency_flag xN_flag) {
655 if (xN_flag == XN_INDEPENDENT) {
656 return HEOS.components[i].EOS().baser(HEOS.tau(), HEOS.delta());
657 } else if (xN_flag == XN_DEPENDENT) {
658 std::size_t N = x.size();
659 if (i == N - 1) return 0;
660 return HEOS.components[i].EOS().baser(HEOS.tau(), HEOS.delta()) - HEOS.components[N - 1].EOS().baser(HEOS.tau(), HEOS.delta());
661 } else {
662 throw ValueError(format("xN_flag is invalid"));
663 }
664 }
665 CoolPropDbl d2alphar_dxi_dTau(HelmholtzEOSMixtureBackend& HEOS, std::vector<CoolPropDbl>& x, std::size_t i, x_N_dependency_flag xN_flag) {
666 if (xN_flag == XN_INDEPENDENT) {
667 return HEOS.components[i].EOS().dalphar_dTau(HEOS._tau, HEOS._delta);
668 } else if (xN_flag == XN_DEPENDENT) {
669 std::size_t N = x.size();
670 if (i == N - 1) return 0;
671 return HEOS.components[i].EOS().dalphar_dTau(HEOS._tau, HEOS._delta) - HEOS.components[N - 1].EOS().dalphar_dTau(HEOS._tau, HEOS._delta);
672 } else {
673 throw ValueError(format("xN_flag is invalid"));
674 }
675 }
676 CoolPropDbl d2alphar_dxi_dDelta(HelmholtzEOSMixtureBackend& HEOS, std::vector<CoolPropDbl>& x, std::size_t i, x_N_dependency_flag xN_flag) {
677 if (xN_flag == XN_INDEPENDENT) {
678 return HEOS.components[i].EOS().dalphar_dDelta(HEOS.tau(), HEOS.delta());
679 } else if (xN_flag == XN_DEPENDENT) {
680 std::size_t N = x.size();
681 if (i == N - 1) return 0;
682 return HEOS.components[i].EOS().dalphar_dDelta(HEOS.tau(), HEOS.delta())
683 - HEOS.components[N - 1].EOS().dalphar_dDelta(HEOS._tau, HEOS._delta);
684 } else {
685 throw ValueError(format("xN_flag is invalid"));
686 }
687 }
688 CoolPropDbl d3alphar_dxi_dDelta2(HelmholtzEOSMixtureBackend& HEOS, std::vector<CoolPropDbl>& x, std::size_t i, x_N_dependency_flag xN_flag) {
689 if (xN_flag == XN_INDEPENDENT) {
690 return HEOS.components[i].EOS().d2alphar_dDelta2(HEOS.tau(), HEOS.delta());
691 } else if (xN_flag == XN_DEPENDENT) {
692 std::size_t N = x.size();
693 if (i == N - 1) return 0;
694 return HEOS.components[i].EOS().d2alphar_dDelta2(HEOS.tau(), HEOS.delta())
695 - HEOS.components[N - 1].EOS().d2alphar_dDelta2(HEOS.tau(), HEOS.delta());
696 } else {
697 throw ValueError(format("xN_flag is invalid"));
698 }
699 }
700 CoolPropDbl d3alphar_dxi_dTau2(HelmholtzEOSMixtureBackend& HEOS, std::vector<CoolPropDbl>& x, std::size_t i, x_N_dependency_flag xN_flag) {
701 if (xN_flag == XN_INDEPENDENT) {
702 return HEOS.components[i].EOS().d2alphar_dTau2(HEOS.tau(), HEOS.delta());
703 } else if (xN_flag == XN_DEPENDENT) {
704 std::size_t N = x.size();
705 if (i == N - 1) return 0;
706 return HEOS.components[i].EOS().d2alphar_dTau2(HEOS.tau(), HEOS.delta())
707 - HEOS.components[N - 1].EOS().d2alphar_dTau2(HEOS.tau(), HEOS.delta());
708 } else {
709 throw ValueError(format("xN_flag is invalid"));
710 }
711 }
712 CoolPropDbl d3alphar_dxi_dDelta_dTau(HelmholtzEOSMixtureBackend& HEOS, std::vector<CoolPropDbl>& x, std::size_t i, x_N_dependency_flag xN_flag) {
713 if (xN_flag == XN_INDEPENDENT) {
714 return HEOS.components[i].EOS().d2alphar_dDelta_dTau(HEOS.tau(), HEOS.delta());
715 } else if (xN_flag == XN_DEPENDENT) {
716 std::size_t N = x.size();
717 if (i == N - 1) return 0;
718 return HEOS.components[i].EOS().d2alphar_dDelta_dTau(HEOS.tau(), HEOS.delta())
719 - HEOS.components[N - 1].EOS().d2alphar_dDelta_dTau(HEOS.tau(), HEOS.delta());
720 } else {
721 throw ValueError(format("xN_flag is invalid"));
722 }
723 }
724
725 CoolPropDbl d2alphardxidxj(HelmholtzEOSMixtureBackend& HEOS, std::vector<CoolPropDbl>& x, std::size_t i, std::size_t j,
726 x_N_dependency_flag xN_flag) {
727 if (xN_flag == XN_INDEPENDENT) {
728 return 0;
729 } else if (xN_flag == XN_DEPENDENT) {
730 return 0;
731 } else {
732 throw ValueError(format("xN_flag is invalid"));
733 }
734 }
735
736 CoolPropDbl d4alphar_dxi_dDelta3(HelmholtzEOSMixtureBackend& HEOS, std::vector<CoolPropDbl>& x, std::size_t i, x_N_dependency_flag xN_flag) {
737 if (xN_flag == XN_INDEPENDENT) {
738 return HEOS.components[i].EOS().d3alphar_dDelta3(HEOS.tau(), HEOS.delta());
739 } else {
740 throw ValueError(format("xN_flag is invalid"));
741 }
742 }
743 CoolPropDbl d4alphar_dxi_dTau3(HelmholtzEOSMixtureBackend& HEOS, std::vector<CoolPropDbl>& x, std::size_t i, x_N_dependency_flag xN_flag) {
744 if (xN_flag == XN_INDEPENDENT) {
745 return HEOS.components[i].EOS().d3alphar_dTau3(HEOS.tau(), HEOS.delta());
746 } else {
747 throw ValueError(format("xN_flag is invalid"));
748 }
749 }
750 CoolPropDbl d4alphar_dxi_dDelta_dTau2(HelmholtzEOSMixtureBackend& HEOS, std::vector<CoolPropDbl>& x, std::size_t i, x_N_dependency_flag xN_flag) {
751 if (xN_flag == XN_INDEPENDENT) {
752 return HEOS.components[i].EOS().d3alphar_dDelta_dTau2(HEOS.tau(), HEOS.delta());
753 } else {
754 throw ValueError(format("xN_flag is invalid"));
755 }
756 }
757 CoolPropDbl d4alphar_dxi_dDelta2_dTau(HelmholtzEOSMixtureBackend& HEOS, std::vector<CoolPropDbl>& x, std::size_t i, x_N_dependency_flag xN_flag) {
758 if (xN_flag == XN_INDEPENDENT) {
759 return HEOS.components[i].EOS().d3alphar_dDelta2_dTau(HEOS.tau(), HEOS.delta());
760 } else {
761 throw ValueError(format("xN_flag is invalid"));
762 }
763 }
764
765 CoolPropDbl d3alphardxidxjdxk(HelmholtzEOSMixtureBackend& HEOS, std::vector<CoolPropDbl>& x, std::size_t i, std::size_t j, std::size_t k,
766 x_N_dependency_flag xN_flag) {
767 return 0;
768 }
769 CoolPropDbl d3alphar_dxi_dxj_dDelta(HelmholtzEOSMixtureBackend& HEOS, std::vector<CoolPropDbl>& x, std::size_t i, std::size_t j,
770 x_N_dependency_flag xN_flag) {
771 return 0;
772 }
773 CoolPropDbl d3alphar_dxi_dxj_dTau(HelmholtzEOSMixtureBackend& HEOS, std::vector<CoolPropDbl>& x, std::size_t i, std::size_t j,
774 x_N_dependency_flag xN_flag) {
775 return 0;
776 }
777 CoolPropDbl d4alphar_dxi_dxj_dDelta2(HelmholtzEOSMixtureBackend& HEOS, std::vector<CoolPropDbl>& x, std::size_t i, std::size_t j,
778 x_N_dependency_flag xN_flag) {
779 return 0;
780 }
781 CoolPropDbl d4alphar_dxi_dxj_dDelta_dTau(HelmholtzEOSMixtureBackend& HEOS, std::vector<CoolPropDbl>& x, std::size_t i, std::size_t j,
782 x_N_dependency_flag xN_flag) {
783 return 0;
784 }
785 CoolPropDbl d4alphar_dxi_dxj_dTau2(HelmholtzEOSMixtureBackend& HEOS, std::vector<CoolPropDbl>& x, std::size_t i, std::size_t j,
786 x_N_dependency_flag xN_flag) {
787 return 0;
788 }
789};
790
796class ResidualHelmholtz
797{
798 public:
799 ExcessTerm Excess;
800 CorrespondingStatesTerm CS;
801
802 ResidualHelmholtz(){};
803 ResidualHelmholtz(const ExcessTerm& E, const CorrespondingStatesTerm& C) : Excess(E), CS(C){};
804 virtual ~ResidualHelmholtz() = default;
805
806 ResidualHelmholtz copy() {
807 return ResidualHelmholtz(Excess.copy(), CS);
808 }
809 ResidualHelmholtz* copy_ptr() {
810 return new ResidualHelmholtz(Excess.copy(), CS);
811 }
812
813 virtual HelmholtzDerivatives all(HelmholtzEOSMixtureBackend& HEOS, const std::vector<CoolPropDbl>& mole_fractions, double tau, double delta,
814 bool cache_values = false) {
815 HelmholtzDerivatives a = CS.all(HEOS, tau, delta, mole_fractions, cache_values) + Excess.all(tau, delta, mole_fractions, cache_values);
816 a.delta_x_dalphar_ddelta = delta * a.dalphar_ddelta;
817 a.tau_x_dalphar_dtau = tau * a.dalphar_dtau;
818
819 a.delta2_x_d2alphar_ddelta2 = POW2(delta) * a.d2alphar_ddelta2;
820 a.deltatau_x_d2alphar_ddelta_dtau = delta * tau * a.d2alphar_ddelta_dtau;
821 a.tau2_x_d2alphar_dtau2 = POW2(tau) * a.d2alphar_dtau2;
822
823 return a;
824 }
825 virtual CoolPropDbl dalphar_dxi(HelmholtzEOSMixtureBackend& HEOS, std::size_t i, x_N_dependency_flag xN_flag) {
826 std::vector<CoolPropDbl>& mole_fractions = HEOS.get_mole_fractions_ref();
827 return CS.dalphar_dxi(HEOS, mole_fractions, i, xN_flag) + Excess.dalphar_dxi(mole_fractions, i, xN_flag);
828 }
829 virtual CoolPropDbl d2alphardxidxj(HelmholtzEOSMixtureBackend& HEOS, std::size_t i, std::size_t j, x_N_dependency_flag xN_flag) {
830 std::vector<CoolPropDbl>& mole_fractions = HEOS.get_mole_fractions_ref();
831 return CS.d2alphardxidxj(HEOS, mole_fractions, i, j, xN_flag) + Excess.d2alphardxidxj(mole_fractions, i, j, xN_flag);
832 }
833 virtual CoolPropDbl d2alphar_dxi_dTau(HelmholtzEOSMixtureBackend& HEOS, std::size_t i, x_N_dependency_flag xN_flag) {
834 std::vector<CoolPropDbl>& mole_fractions = HEOS.get_mole_fractions_ref();
835 return CS.d2alphar_dxi_dTau(HEOS, mole_fractions, i, xN_flag) + Excess.d2alphar_dxi_dTau(mole_fractions, i, xN_flag);
836 }
837 virtual CoolPropDbl d2alphar_dxi_dDelta(HelmholtzEOSMixtureBackend& HEOS, std::size_t i, x_N_dependency_flag xN_flag) {
838 std::vector<CoolPropDbl>& mole_fractions = HEOS.get_mole_fractions_ref();
839 return CS.d2alphar_dxi_dDelta(HEOS, mole_fractions, i, xN_flag) + Excess.d2alphar_dxi_dDelta(mole_fractions, i, xN_flag);
840 }
841 virtual CoolPropDbl d3alphar_dxi_dTau2(HelmholtzEOSMixtureBackend& HEOS, std::size_t i, x_N_dependency_flag xN_flag) {
842 std::vector<CoolPropDbl>& mole_fractions = HEOS.get_mole_fractions_ref();
843 return CS.d3alphar_dxi_dTau2(HEOS, mole_fractions, i, xN_flag) + Excess.d3alphar_dxi_dTau2(mole_fractions, i, xN_flag);
844 }
845 virtual CoolPropDbl d3alphar_dxi_dDelta_dTau(HelmholtzEOSMixtureBackend& HEOS, std::size_t i, x_N_dependency_flag xN_flag) {
846 std::vector<CoolPropDbl>& mole_fractions = HEOS.get_mole_fractions_ref();
847 return CS.d3alphar_dxi_dDelta_dTau(HEOS, mole_fractions, i, xN_flag) + Excess.d3alphar_dxi_dDelta_dTau(mole_fractions, i, xN_flag);
848 }
849 virtual CoolPropDbl d3alphar_dxi_dDelta2(HelmholtzEOSMixtureBackend& HEOS, std::size_t i, x_N_dependency_flag xN_flag) {
850 std::vector<CoolPropDbl>& mole_fractions = HEOS.get_mole_fractions_ref();
851 return CS.d3alphar_dxi_dDelta2(HEOS, mole_fractions, i, xN_flag) + Excess.d3alphar_dxi_dDelta2(mole_fractions, i, xN_flag);
852 }
853 virtual CoolPropDbl d3alphar_dxi_dxj_dTau(HelmholtzEOSMixtureBackend& HEOS, std::size_t i, std::size_t j, x_N_dependency_flag xN_flag) {
854 std::vector<CoolPropDbl>& mole_fractions = HEOS.get_mole_fractions_ref();
855 return CS.d3alphar_dxi_dxj_dTau(HEOS, mole_fractions, i, j, xN_flag) + Excess.d3alphar_dxi_dxj_dTau(mole_fractions, i, j, xN_flag);
856 }
857 virtual CoolPropDbl d3alphar_dxi_dxj_dDelta(HelmholtzEOSMixtureBackend& HEOS, std::size_t i, std::size_t j, x_N_dependency_flag xN_flag) {
858 std::vector<CoolPropDbl>& mole_fractions = HEOS.get_mole_fractions_ref();
859 return CS.d3alphar_dxi_dxj_dDelta(HEOS, mole_fractions, i, j, xN_flag) + Excess.d3alphar_dxi_dxj_dDelta(mole_fractions, i, j, xN_flag);
860 }
861 virtual CoolPropDbl d3alphardxidxjdxk(HelmholtzEOSMixtureBackend& HEOS, std::size_t i, std::size_t j, std::size_t k,
862 x_N_dependency_flag xN_flag) {
863 std::vector<CoolPropDbl>& mole_fractions = HEOS.get_mole_fractions_ref();
864 return CS.d3alphardxidxjdxk(HEOS, mole_fractions, i, j, k, xN_flag) + Excess.d3alphardxidxjdxk(mole_fractions, i, j, k, xN_flag);
865 }
866
867 virtual CoolPropDbl d4alphar_dxi_dTau3(HelmholtzEOSMixtureBackend& HEOS, std::size_t i, x_N_dependency_flag xN_flag) {
868 std::vector<CoolPropDbl>& mole_fractions = HEOS.get_mole_fractions_ref();
869 return CS.d4alphar_dxi_dTau3(HEOS, mole_fractions, i, xN_flag) + Excess.d4alphar_dxi_dTau3(mole_fractions, i, xN_flag);
870 }
871 virtual CoolPropDbl d4alphar_dxi_dDelta2_dTau(HelmholtzEOSMixtureBackend& HEOS, std::size_t i, x_N_dependency_flag xN_flag) {
872 std::vector<CoolPropDbl>& mole_fractions = HEOS.get_mole_fractions_ref();
873 return CS.d4alphar_dxi_dDelta2_dTau(HEOS, mole_fractions, i, xN_flag) + Excess.d4alphar_dxi_dDelta2_dTau(mole_fractions, i, xN_flag);
874 }
875 virtual CoolPropDbl d4alphar_dxi_dDelta_dTau2(HelmholtzEOSMixtureBackend& HEOS, std::size_t i, x_N_dependency_flag xN_flag) {
876 std::vector<CoolPropDbl>& mole_fractions = HEOS.get_mole_fractions_ref();
877 return CS.d4alphar_dxi_dDelta_dTau2(HEOS, mole_fractions, i, xN_flag) + Excess.d4alphar_dxi_dDelta_dTau2(mole_fractions, i, xN_flag);
878 }
879 virtual CoolPropDbl d4alphar_dxi_dDelta3(HelmholtzEOSMixtureBackend& HEOS, std::size_t i, x_N_dependency_flag xN_flag) {
880 std::vector<CoolPropDbl>& mole_fractions = HEOS.get_mole_fractions_ref();
881 return CS.d4alphar_dxi_dDelta3(HEOS, mole_fractions, i, xN_flag) + Excess.d4alphar_dxi_dDelta3(mole_fractions, i, xN_flag);
882 }
883 virtual CoolPropDbl d4alphar_dxi_dxj_dTau2(HelmholtzEOSMixtureBackend& HEOS, std::size_t i, std::size_t j, x_N_dependency_flag xN_flag) {
884 std::vector<CoolPropDbl>& mole_fractions = HEOS.get_mole_fractions_ref();
885 return CS.d4alphar_dxi_dxj_dTau2(HEOS, mole_fractions, i, j, xN_flag) + Excess.d4alphar_dxi_dxj_dTau2(mole_fractions, i, j, xN_flag);
886 }
887 virtual CoolPropDbl d4alphar_dxi_dxj_dDelta_dTau(HelmholtzEOSMixtureBackend& HEOS, std::size_t i, std::size_t j, x_N_dependency_flag xN_flag) {
888 std::vector<CoolPropDbl>& mole_fractions = HEOS.get_mole_fractions_ref();
889 return CS.d4alphar_dxi_dxj_dDelta_dTau(HEOS, mole_fractions, i, j, xN_flag)
890 + Excess.d4alphar_dxi_dxj_dDelta_dTau(mole_fractions, i, j, xN_flag);
891 }
892 virtual CoolPropDbl d4alphar_dxi_dxj_dDelta2(HelmholtzEOSMixtureBackend& HEOS, std::size_t i, std::size_t j, x_N_dependency_flag xN_flag) {
893 std::vector<CoolPropDbl>& mole_fractions = HEOS.get_mole_fractions_ref();
894 return CS.d4alphar_dxi_dxj_dDelta2(HEOS, mole_fractions, i, j, xN_flag) + Excess.d4alphar_dxi_dxj_dDelta2(mole_fractions, i, j, xN_flag);
895 }
896 virtual CoolPropDbl d4alphar_dxi_dxj_dxk_dDelta(HelmholtzEOSMixtureBackend& HEOS, std::size_t i, std::size_t j, std::size_t k,
897 x_N_dependency_flag xN_flag) {
898 return 0;
899 }
900 virtual CoolPropDbl d4alphar_dxi_dxj_dxk_dTau(HelmholtzEOSMixtureBackend& HEOS, std::size_t i, std::size_t j, std::size_t k,
901 x_N_dependency_flag xN_flag) {
902 return 0;
903 }
904};
905
906} /* namespace CoolProp */
907#endif /* HELMHOLTZEOSMIXTUREBACKEND_H_ */
Generated on Wed Jun 4 2025 04:12:26 for CoolProp by doxygen 1.9.4