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