void _PropsSImulti(const std::vector<std::string> &Outputs, const std::string &Name1, const std::vector<double> &Prop1, const std::string &Name2, const std::vector<double> &Prop2, const std::string &backend, const std::vector<std::string> &fluids, const std::vector<double> &fractions, std::vector<std::vector<double> > &IO) { shared_ptr<AbstractState> State; CoolProp::parameters key1, key2; CoolProp::input_pairs input_pair; std::vector<output_parameter> output_parameters; std::vector<double> v1, v2; try{ // Initialize the State class _PropsSI_initialize(backend, fluids, fractions, State); } catch(std::exception &e){ // Initialization failed. Stop. throw ValueError(format("Initialize failed for backend: \"%s\", fluid: \"%s\" fractions \"%s\"; error: %s",backend.c_str(), strjoin(fluids,"&").c_str(), vec_to_string(fractions, "%0.10f").c_str(), e.what()) ); } try{ // Get update pair is_valid_parameter(Name1, key1); is_valid_parameter(Name2, key2); input_pair = generate_update_pair(key1, Prop1, key2, Prop2, v1, v2); } catch (std::exception &e){ // Input parameter parsing failed. Stop throw ValueError(format("Input pair parsing failed for Name1: \"%s\", Name2: \"%s\"; err: %s", Name1.c_str(), Name2.c_str(), e.what())); } try{ output_parameters = output_parameter::get_output_parameters(Outputs); } catch (std::exception &e){ // Output parameter parsing failed. Stop. throw ValueError(format("Output parameter parsing failed; error: %s", e.what())); } // Calculate the output(s). In the case of a failure, all values will be filled with _HUGE _PropsSI_outputs(State, output_parameters, input_pair, v1, v2, IO); }
// Internal function to do the actual calculations, make this a wrapped function so // that error bubbling can be done properly double _PropsSI(const std::string &Output, const std::string &Name1, double Prop1, const std::string &Name2, double Prop2, const std::string &backend, const std::string &Ref, const std::vector<double> &z) { parameters iOutput = iundefined_parameter; parameters iOf = iundefined_parameter, iWrt = iundefined_parameter, iConstant = iundefined_parameter, iOf1 = iundefined_parameter, iWrt1 = iundefined_parameter, iConstant1 = iundefined_parameter, iWrt2 = iundefined_parameter, iConstant2 = iundefined_parameter; double x1, x2; if (get_debug_level()>5){ std::cout << format("%s:%d: _PropsSI(%s,%s,%g,%s,%g,%s,%s)\n",__FILE__,__LINE__,Output.c_str(),Name1.c_str(),Prop1,Name2.c_str(),Prop2,backend.c_str(),Ref.c_str(), vec_to_string(z).c_str()).c_str(); } // The state we are going to use shared_ptr<AbstractState> State; // If the fractions of the components have been encoded in the string, extract them // If they have not, this function does nothing std::vector<double> fractions; if (z.empty()) { // Make a one-element vector fractions = std::vector<double>(1, 1); } else{ // Make a copy fractions = z; } std::string fluid_string = extract_fractions(Ref, fractions); // We are going to let the factory function load the state State.reset(AbstractState::factory(backend, fluid_string)); // First check if it is a trivial input (critical/max parameters for instance) if (is_valid_parameter(Output, iOutput) && is_trivial_parameter(iOutput)) { double val = State->trivial_keyed_output(iOutput); return val; } long iName1 = get_parameter_index(Name1); long iName2 = get_parameter_index(Name2); if (State->using_mole_fractions()){ State->set_mole_fractions(fractions); } else if (State->using_mass_fractions()){ State->set_mass_fractions(fractions); } else if (State->using_volu_fractions()){ State->set_volu_fractions(fractions); } else { if (get_debug_level()>50) std::cout << format("%s:%d: _PropsSI, could not set composition to %s, defaulting to mole fraction.\n",__FILE__,__LINE__, vec_to_string(z).c_str()).c_str(); } // Obtain the input pair CoolProp::input_pairs pair = generate_update_pair(iName1, Prop1, iName2, Prop2, x1, x2); // Update the state State->update(pair, x1, x2); if (iOutput != iundefined_parameter){ // Get the desired output double val = State->keyed_output(iOutput); // Return the value return val; } else if (is_valid_first_derivative(Output, iOf, iWrt, iConstant)){ // Return the desired output double val = State->first_partial_deriv(iOf, iWrt, iConstant); // Return the value return val; } else if (is_valid_second_derivative(Output, iOf1, iWrt1, iConstant1, iWrt2, iConstant2)){ // Return the desired output double val = State->second_partial_deriv(iOf1, iWrt1, iConstant1, iWrt2, iConstant2); // Return the value return val; } else{ throw ValueError(format("Output [%s] is not a parameter or a string representation of a derivative",Output.c_str()).c_str()); } }