/* print vector of statistics to outs */
void printStatisticsVector(pmols::HJStatistics &stat, std::ostream &outs) {
glm::vec3 appos_point;
std::tuple<float, float, float> box_size;
std::tie(appos_point, box_size) = stat.GetBoundingBox();
outs << "\"" << stat.PackedMolsNumber() << "\"" << ", " // number of packed mols (0)
<< "\"" << vec_to_string(appos_point) << "\"" << ", " // apposition point of bounding box (1)
<< "\"" << std::get<0>(box_size) << "x" << std::get<1>(box_size) << "x" << std::get<2>(box_size) << "\"" << ", "
// size of bounding box (2)
<< "\"" << stat.TotalAtomDistance() << "\"" << ", " // total distance between atoms (3)
<< "\"" << stat.AvgAtomDistance() << "\"" << ", " // average distance between atoms (4)
<< "\"" << stat.IntersectionsNumber() << "\"" << ", " // total number of intersections between atoms (5)
<< "\"" << stat.TotalIntersection() << "\"" << ", " // total value of intersections ... (6)
<< "\"" << stat.AvgIntersection() << "\"" << ", " // average value of intersections ... (7)
<< "\"" << stat.MaxIntersection() << "\"" << ", " // max value of intersections ... (8)
<< "\"" << stat.EmptyCellsNumber() << "\"" << ", " // number of empty cells ... (9)
<< "\"" << stat.TotalIterationsNumber() << "\"" << ", " // total number of iterations (10)
<< "\"" << stat.ESIterationsNumber() << "\"" << ", " // number of exploring search iterations (11)
<< "\"" << stat.PSIterationsNumber() << "\"" << ", " // number of pattern search iterations (12)
<< "\"" << stat.PSFalsePositiveIterationsNumber() << "\""; // number of false positive iterations of pattern search (13)
}
bool RangeLookupInBST::test() {
vector<int> preOrder = {19, 7, 3, 2, 5, 11, 17, 13, 43, 23, 37, 29, 31, 41, 47, 53};
unique_ptr<BSTNode<int>> tree = createBSTFromPreorder(preOrder);
Interval interval{16, 31};
vector<int> ans = {17,19, 23,29,31};
vector<int> res = rangeLookupInBST(tree, interval);
if (res != ans) {
cout << "Should be " << vec_to_string(ans) << endl;
cout << "Result " << vec_to_string(ans) << endl;
return false;
}
return true;
}
bool PlusOne::test() {
for (int i = 0; i != 131; ++i) {
vector<int> input = generateVectorFromNum(i);
vector<int> shouldBe = plusOneBruteForce(input);
vector<int> res = plusOne(input);
if (res != shouldBe) {
cout << "Increase " << vec_to_string(input)
<< " by one is " << vec_to_string(res)
<< endl;
return false;
}
}
return true;
}
bool CanReachEnd::test() {
int temp_arr1[] = { 3, 3, 1, 0, 2, 0, 1 };
vector<int> a ( temp_arr1, temp_arr1 + sizeof(temp_arr1) / sizeof(temp_arr1[0]) );
int temp_arr2[] = { 3, 2, 0, 0, 2, 0, 1 };
vector<int> b ( temp_arr2, temp_arr2 + sizeof(temp_arr2) / sizeof(temp_arr2[0]) );
cout << "In " << vec_to_string(a) << ", can ";
if (!canReachEnd(a))
cout << "not ";
cout << "reach the end. " << endl;
cout << "In " << vec_to_string(b) << ", can ";
if (!canReachEnd(b))
cout << "not ";
cout << "reach the end. " << endl;
return true;
}
bool StackByHeap::test() {
vector<int> input = {1, 2, 3, 4, 5};
Stack s;
for (int i : input) {
s.push(i);
}
vector<int> ans = {5, 4, 3, 2, 1};
vector<int> res;
while (!s.empty()) {
res.push_back(s.pop());
}
if (ans != res) {
cout << "Should be " << vec_to_string(ans) << endl;
cout << "Result " << vec_to_string(res) << endl;
return false;
}
return true;
}
bool NextPermutation::test() {
vector<int> perm1 = {1, 0, 2, 3};
vector<int> perm2 = {1, 0, 3, 2};
vector<int> perm3 = {0, 3, 2, 1};
vector<int> perm4 = {3, 2, 1, 0};
vector<int> perm5 = {6, 2, 1, 5, 4, 3, 0};
vector<int> perm6 = {2, 1, 0, 1};
vector<int> perm7 = {2, 1, 1, 3};
vector<int> perm8 = {2, 3, 1, 1};
vector<vector<int>> perms = {perm1, perm2, perm3, perm4, perm5, perm6, perm7, perm8};
for (vector<int> perm : perms) {
if (nextPermutationBruteForce(perm) != nextPermutation(perm)) {
cout << "Should be: " << vec_to_string(nextPermutationBruteForce(perm)) << endl;
cout << "Result: " << vec_to_string(nextPermutation(perm)) << endl;
return false;
}
}
return true;
}
bool GeneratePowerSet::test() {
vector<int> array = {1, 2, 3, 2};
vector<vector<int>> res = generatePowerSet(array);
if (res.size() != 12) {
cout << "Wrong number of results" << endl;
for (vector<int> vec : res) {
cout << vec_to_string(vec) << endl;
}
return false;
}
return true;
}
bool NQueens::test() {
vector<vector<int>> res = nQueens(4);
vector<int> ans1 = {1, 3, 0, 2};
vector<int> ans2 = {2, 0, 3, 1};
for (vector<int> vec : res) {
if (vec != ans1 && vec != ans2) {
cout << "Wrong ans " << endl;
cout << vec_to_string(vec) << endl;
return false;
}
}
return true;
}
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);
}
void _PropsSI_outputs(shared_ptr<AbstractState> &State,
const std::vector<output_parameter> &output_parameters,
CoolProp::input_pairs input_pair,
const std::vector<double> &in1,
const std::vector<double> &in2,
std::vector<std::vector<double> > &IO){
// Check the inputs
if (in1.size() != in2.size()){ throw ValueError(format("lengths of in1 [%d] and in2 [%d] are not the same", in1.size(), in2.size()));}
bool one_input_one_output = (in1.size() == 1 && in2.size() == 1 && output_parameters.size() == 1);
// If all trivial outputs, never do a state update
bool all_trivial_outputs = true;
for (std::size_t j = 0; j < output_parameters.size(); ++j){
if (output_parameters[j].type != output_parameter::OUTPUT_TYPE_TRIVIAL){
all_trivial_outputs = false;
}
}
parameters p1, p2;
// If all outputs are also inputs, never do a state update
bool all_outputs_in_inputs = true;
if (input_pair != INPUT_PAIR_INVALID){
// Split the input pair into parameters
split_input_pair(input_pair, p1, p2);
// See if each parameter is in the output vector and is a normal type input
for (std::size_t j = 0; j < output_parameters.size(); ++j){
if (output_parameters[j].type != output_parameter::OUTPUT_TYPE_NORMAL){
all_outputs_in_inputs = false; break;
}
if (!(output_parameters[j].Of1 == p1 || output_parameters[j].Of1 == p2)){
all_outputs_in_inputs = false; break;
}
}
}
else{
if (!all_trivial_outputs){
throw ValueError(format("Input pair variable is invalid and output(s) are non-trivial; cannot do state update"));
}
all_outputs_in_inputs = false;
}
if (get_debug_level() > 100)
{
std::cout << format("%s (%d): input pair = %d ",__FILE__,__LINE__, input_pair) << std::endl;
std::cout << format("%s (%d): in1 = %s ",__FILE__,__LINE__, vec_to_string(in1).c_str()) << std::endl;
std::cout << format("%s (%d): in2 = %s ",__FILE__,__LINE__, vec_to_string(in2).c_str()) << std::endl;
}
// Resize the output matrix
std::size_t N1 = std::max(static_cast<std::size_t>(1), in1.size());
std::size_t N2 = std::max(static_cast<std::size_t>(1), output_parameters.size());
IO.resize(N1, std::vector<double>(N2, _HUGE));
// Throw an error if at the end, there were no successes
bool success = false;
if (get_debug_level() > 100)
{
std::cout << format("%s (%d): Iterating over %d input value pairs.",__FILE__,__LINE__,IO.size()) << std::endl;
}
// Iterate over the state variable inputs
for (std::size_t i = 0; i < IO.size(); ++i){
try{
if (input_pair != INPUT_PAIR_INVALID && !all_trivial_outputs && !all_outputs_in_inputs){
// Update the state since it is a valid set of inputs
State->update(input_pair, in1[i], in2[i]);
}
}
catch(...){
if (one_input_one_output){IO.clear(); throw;} // Re-raise the exception since we want to bubble the error
// All the outputs are filled with _HUGE; go to next input
for (std::size_t j = 0; j < IO[i].size(); ++j){ IO[i][j] = _HUGE; }
continue;
}
for (std::size_t j = 0; j < IO[i].size(); ++j){
// If all the outputs are inputs, there is no need for a state input
if (all_outputs_in_inputs){
if (p1 == output_parameters[j].Of1){
IO[i][j] = in1[i]; success = true; continue;
}
else if (p2 == output_parameters[j].Of1){
IO[i][j] = in2[i]; success = true; continue;
}
else{
throw ValueError();
}
}
try{
const output_parameter &output = output_parameters[j];
switch (output.type){
case output_parameter::OUTPUT_TYPE_TRIVIAL:
case output_parameter::OUTPUT_TYPE_NORMAL:
IO[i][j] = State->keyed_output(output.Of1); break;
case output_parameter::OUTPUT_TYPE_FIRST_DERIVATIVE:
IO[i][j] = State->first_partial_deriv(output.Of1, output.Wrt1, output.Constant1); break;
case output_parameter::OUTPUT_TYPE_FIRST_SATURATION_DERIVATIVE:
IO[i][j] = State->first_saturation_deriv(output.Of1, output.Wrt1); break;
case output_parameter::OUTPUT_TYPE_SECOND_DERIVATIVE:
IO[i][j] = State->second_partial_deriv(output.Of1, output.Wrt1, output.Constant1, output.Wrt2, output.Constant2); break;
default:
throw ValueError(format("")); break;
}
// At least one has succeeded
success = true;
}
catch(...){
if (one_input_one_output){IO.clear(); throw;} // Re-raise the exception since we want to bubble the error
IO[i][j] = _HUGE;
}
}
}
if (success == false) { IO.clear(); throw ValueError(format("No outputs were able to be calculated"));}
}
void _PropsSI_initialize(const std::string &backend,
const std::vector<std::string> &fluid_names,
const std::vector<double> &z,
shared_ptr<AbstractState> &State){
if (fluid_names.empty()){throw ValueError("fluid_names cannot be empty");}
std::vector<double> fractions(1, 1.0); // Default to one component, unity fraction
const std::vector<double> *fractions_ptr = NULL; // Pointer to the array to be used;
if (fluid_names.size() > 1){
// Set the pointer - we are going to use the supplied fractions; they must be provided
fractions_ptr = &z;
// Reset the state
State.reset(AbstractState::factory(backend, fluid_names));
}
else if (fluid_names.size() == 1){
if (has_fractions_in_string(fluid_names[0]) || has_solution_concentration(fluid_names[0])){
// Extract fractions from the string
std::string fluid_string = extract_fractions(fluid_names[0], fractions);
// Set the pointer - we are going to use the extracted fractions
fractions_ptr = &fractions;
// Reset the state
State.reset(AbstractState::factory(backend, fluid_string));
}
else{
if (z.empty()){
// Set the pointer - we are going to use the default fractions
fractions_ptr = &fractions;
}
else{
// Set the pointer - we are going to use the provided fractions
fractions_ptr = &z;
}
// Reset the state
State.reset(AbstractState::factory(backend, fluid_names));
}
}
else { // The only path where fractions_ptr stays NULL
throw ValueError("fractions_ptr is NULL");
}
if (!State->available_in_high_level()){
throw ValueError("This AbstractState derived class cannot be used in the high-level interface; see www.coolprop.org/dev/coolprop/LowLevelAPI.html");
}
// Set the fraction for the state
if (State->using_mole_fractions()){
// If a predefined mixture or a pure fluid, the fractions will already be set
if (State->get_mole_fractions().empty()){
State->set_mole_fractions(*fractions_ptr);
}
} else if (State->using_mass_fractions()){
State->set_mass_fractions(*fractions_ptr);
} else if (State->using_volu_fractions()){
State->set_volu_fractions(*fractions_ptr);
} 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();
}
}
std::string extract_fractions(const std::string &fluid_string, std::vector<double> &fractions)
{
if (has_fractions_in_string(fluid_string))
{
fractions.clear();
std::vector<std::string> names;
// Break up into pairs - like "Ethane[0.5]&Methane[0.5]" -> ("Ethane[0.5]","Methane[0.5]")
std::vector<std::string> pairs = strsplit(fluid_string, '&');
for (std::size_t i = 0; i < pairs.size(); ++i)
{
const std::string &fluid = pairs[i];
// Must end with ']'
if (fluid[fluid.size()-1] != ']')
throw ValueError(format("Fluid entry [%s] must end with ']' character",pairs[i].c_str()));
// Split at '[', but first remove the ']' from the end by taking a substring
std::vector<std::string> name_fraction = strsplit(fluid.substr(0, fluid.size()-1), '[');
if (name_fraction.size() != 2){throw ValueError(format("Could not break [%s] into name/fraction", fluid.substr(0, fluid.size()-1).c_str()));}
// Convert fraction to a double
char *pEnd;
const std::string &name = name_fraction[0], &fraction = name_fraction[1];
double f = strtod(fraction.c_str(), &pEnd);
// If pEnd points to the last character in the string, it wasn't able to do the conversion
if (pEnd == &(fraction[fraction.size()-1])){throw ValueError(format("Could not convert [%s] into number", fraction.c_str()));}
// And add to vector
fractions.push_back(f);
// Add name
names.push_back(name);
}
if (get_debug_level()>10) std::cout << format("%s:%d: Detected fractions of %s for %s.",__FILE__,__LINE__,vec_to_string(fractions).c_str(), (strjoin(names, "&")).c_str());
// Join fluids back together
return strjoin(names, "&");
}
else if (has_solution_concentration(fluid_string))
{
fractions.clear();
double x;
std::vector<std::string> fluid_parts = strsplit(fluid_string,'-');
// Check it worked
if (fluid_parts.size() != 2){
throw ValueError(format("Format of incompressible solution string [%s] is invalid, should be like \"EG-20%\" or \"EG-0.2\" ", fluid_string.c_str()) );
}
// Convert the concentration into a string
char* pEnd;
x = strtod(fluid_parts[1].c_str(), &pEnd);
// Check if per cent or fraction syntax is used
if (!strcmp(pEnd,"%")){ x *= 0.01;}
fractions.push_back(x);
if (get_debug_level()>10) std::cout << format("%s:%d: Detected incompressible concentration of %s for %s.",__FILE__,__LINE__,vec_to_string(fractions).c_str(), fluid_parts[0].c_str());
return fluid_parts[0];
}
else
{
return fluid_string;
}
}
void exostore::load()
{
std::ifstream in(db_path_, std::ifstream::binary);
if (!in.is_open()) // File doesn't exist
{
return;
}
in.exceptions(std::ifstream::failbit | std::ifstream::badbit);
// Add the keys to this map first, then copy only if there are no errors.
boost::unordered_map<std::vector<unsigned char>, boost::any> temp_map;
try
{
// Read header.
std::vector<unsigned char> header = std::move(vec_from_file(in, 5));
if (vec_to_string(header) != "EXODB")
{
throw exostore::load_error("Incorrect file header");
}
// Read number of keys.
std::size_t num_keys;
in.read(reinterpret_cast<char*>(&num_keys), sizeof(num_keys));
for (std::size_t i = 0; i < num_keys; i++)
{
// Read the key size.
std::size_t key_size;
in.read(reinterpret_cast<char*>(&key_size), sizeof(key_size));
// Read the key.
auto key = std::move(vec_from_file(in, key_size));
// Read the value marker.
auto value_marker = std::move(vec_from_file(in, 4));
std::string marker_str = vec_to_string(value_marker);
if (marker_str == "BSTR") // Binary string
{
// Read bstring length.
std::size_t bstring_size;
in.read(reinterpret_cast<char*>(&bstring_size),
sizeof(bstring_size));
// Read bstring content.
auto bstring_content = std::move(vec_from_file(in,
bstring_size));
// Add to database.
temp_map[key] = exostore::bstring(bstring_content);
}
else if(marker_str == "ZSET") // Sorted set
{
// Read size of zset.
std::size_t zset_size;
in.read(reinterpret_cast<char*>(&zset_size), sizeof(zset_size));
// Read score-member pairs into zset.
exostore::zset zset;
for (std::size_t j = 0; j < zset_size; j++)
{
// Read score.
double score;
in.read(reinterpret_cast<char*>(&score), sizeof(score));
// Read member size.
std::size_t member_size;
in.read(reinterpret_cast<char*>(&member_size),
sizeof(member_size));
// Read member.
auto member = std::move(vec_from_file(in, member_size));
// Add to zset.
zset.add(member, score);
}
// Add to database.
temp_map[key] = zset;
}
}
}
catch (std::ifstream::failure e)
{
throw exostore::load_error("Bad file format");
}
map_ = std::move(temp_map);
}
/**
@param volu_fractions The vector of volume fractions of the components
*/
void IncompressibleBackend::set_volu_fractions(const std::vector<long double> &volu_fractions){
if (get_debug_level()>=10) std::cout << format("Incompressible backend: Called set_volu_fractions with %s ",vec_to_string(volu_fractions).c_str()) << std::endl;
if (volu_fractions.size()!=1) throw ValueError(format("The incompressible backend only supports one entry in the volume fraction vector and not %d.",volu_fractions.size()));
if (fluid->getxid()==IFRAC_PURE) {
this->set_fractions(std::vector<long double>(1,0));
if (get_debug_level()>=20) std::cout << format("Incompressible backend: Overwriting fractions for pure fluid with %s -> %s",vec_to_string(volu_fractions).c_str(),vec_to_string(this->_fractions).c_str()) << std::endl;
} else if (fluid->getxid()==IFRAC_VOLUME) {
this->set_fractions(volu_fractions);
} else {
std::vector<long double> tmp_fractions;
for (std::size_t i = 0; i < volu_fractions.size(); i++) {
tmp_fractions.push_back((long double) fluid->inputFromVolume(0.0, volu_fractions[i]));
}
this->set_fractions(tmp_fractions);
}
}
void IncompressibleBackend::update(CoolProp::input_pairs input_pair, double value1, double value2) {
//if (mass_fractions.empty()){
// throw ValueError("mass fractions have not been set");
//}
if (get_debug_level()>=10) {
//throw ValueError(format("%s (%d): You have to provide a dimension, 0 or 1, for the solver, %d is not valid. ",__FILE__,__LINE__,axis));
std::cout << format("Incompressible backend: Called update with %d and %f, %f ",input_pair, value1, value2) << std::endl;
}
clear();
if (get_debug_level()>=50) std::cout << format("Incompressible backend: _fractions are %s ",vec_to_string(_fractions).c_str()) << std::endl;
if (fluid->is_pure()){
this->_fluid_type = FLUID_TYPE_INCOMPRESSIBLE_LIQUID;
if (get_debug_level()>=50) std::cout << format("Incompressible backend: Fluid type is %d ",this->_fluid_type) << std::endl;
if ((_fractions.size()!=1) || (_fractions[0]!=0.0)){
throw ValueError(format("%s is a pure fluid. The composition has to be set to a vector with one entry equal to 0.0 or nothing. %s is not valid.",this->name().c_str(),vec_to_string(_fractions).c_str()));
}
} else {
this->_fluid_type = FLUID_TYPE_INCOMPRESSIBLE_SOLUTION;
if (get_debug_level()>=50) std::cout << format("Incompressible backend: Fluid type is %d ",this->_fluid_type) << std::endl;
if (_fractions.size()!=1 || ((_fractions[0]<0.0) || (_fractions[0]>1.0)) ){
throw ValueError(format("%s is a solution or brine. Mass fractions must be set to a vector with one entry between 0 and 1. %s is not valid.",this->name().c_str(),vec_to_string(_fractions).c_str()));
}
}
this->_phase = iphase_liquid;
if (get_debug_level()>=50) std::cout << format("Incompressible backend: Phase type is %d ",this->_phase) << std::endl;
switch (input_pair)
{
case PT_INPUTS: {
_p = value1;
_T = value2;
break;
}
case DmassP_INPUTS: {
_p = value2;
_T = this->DmassP_flash(value1,value2);
break;
}
case PUmass_INPUTS: {
_p = value1;
_T = this->PUmass_flash(value1, value2);
break;
}
case PSmass_INPUTS: {
_p = value1;
_T = this->PSmass_flash(value1, value2);
break;
}
case HmassP_INPUTS: {
_p = value2;
_T = this->HmassP_flash(value1, value2);
break;
}
case QT_INPUTS: {
if (value1!=0) {throw ValueError("Incompressible fluids can only handle saturated liquid, Q=0.");}
_T = value2;
_p = fluid->psat(value2, _fractions[0]);
break;
}
default: {
throw ValueError(
format("This pair of inputs [%s] is not yet supported",
get_input_pair_short_desc(input_pair).c_str()));
}
}
if (_p < 0){ throw ValueError("p is less than zero");}
if (!ValidNumber(_p)){ throw ValueError("p is not a valid number");}
if (_T < 0){ throw ValueError("T is less than zero");}
if (!ValidNumber(_T)){ throw ValueError("T is not a valid number");}
if (get_debug_level()>=50) std::cout << format("Incompressible backend: Update finished T=%f, p=%f, x=%s ",this->_T,this->_p,vec_to_string(_fractions).c_str()) << std::endl;
fluid->checkTPX(_T,_p,_fractions[0]);
}
// 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());
}
}
/**
@param fractions The vector of fractions of the components converted to the correct input
*/
void IncompressibleBackend::set_fractions(const std::vector<long double> &fractions){
if (get_debug_level()>=10) std::cout << format("Incompressible backend: Called set_fractions with %s ",vec_to_string(fractions).c_str()) << std::endl;
if (fractions.size()!=1) throw ValueError(format("The incompressible backend only supports one entry in the fraction vector and not %d.",fractions.size()));
if ( ( this->_fractions.size()!=1 ) ||
( this->_fractions[0]!=fractions[0] ) ) { // Change it!
if (get_debug_level()>=20) std::cout << format("Incompressible backend: Updating the fractions triggered a change in reference state %s -> %s",vec_to_string(this->_fractions).c_str(),vec_to_string(fractions).c_str()) << std::endl;
this->_fractions = fractions;
fluid->set_reference_state(fluid->getTref(), fluid->getpref(), this->_fractions[0], fluid->gethref(), fluid->getsref());
}
}