pyEQL 1.4.0rc9__cp312-cp312-macosx_10_13_x86_64.whl

pyEQL/phreeqc/ext/iphreeqc-3.8.6-17100/src/phreeqcpp/Solution.h

@@ -0,0 +1,154 @@
+#if !defined(SOLUTION_H_INCLUDED)
+#define SOLUTION_H_INCLUDED
+
+#include <cassert>				// assert
+#include <map>					// std::map
+#include <string>				// std::string
+#include <vector>				// std::vector
+#include <iostream>
+#include "NumKeyword.h"
+#include "SolutionIsotope.h"
+#include "NameDouble.h"
+#include "PHRQ_base.h"
+#include "PHRQ_io.h"
+#include "ISolution.h"
+class cxxMix;
+
+class cxxSolution:public cxxNumKeyword
+{
+
+  public:
+	cxxSolution(PHRQ_io *io=NULL);
+	cxxSolution(const cxxSolution &old_sol);
+	const cxxSolution & operator = (const cxxSolution &rhs);
+	cxxSolution(std::map < int, cxxSolution > &solution_map,
+				  cxxMix & mx, int n_user, PHRQ_io *io=NULL);
+	virtual ~cxxSolution();
+
+	bool Get_new_def() const  {return this->new_def;}
+	void Set_new_def(bool p)  {this->new_def = p;}
+	LDBLE Get_patm() const    {return this->patm;}
+	void Set_patm(LDBLE p)    {this->patm = p;}
+	LDBLE Get_potV() const    {return this->potV;}
+	void Set_potV(LDBLE p)    {this->potV = p;}
+	LDBLE Get_tc() const      {return this->tc;}
+	void Set_tc(LDBLE l_tc)   {this->tc = l_tc;}
+	LDBLE Get_ph() const      {return this->ph;}
+	void Set_ph(LDBLE pH)     {this->ph = pH;}
+	LDBLE Get_pe() const      {return this->pe;}
+	void Set_pe(LDBLE l_pe)   {this->pe = l_pe;}
+	LDBLE Get_mu() const      {return this->mu;}
+	void Set_mu(LDBLE l_mu)   {this->mu = l_mu;}
+	LDBLE Get_ah2o() const                              {return this->ah2o;}
+	void Set_ah2o(LDBLE l_ah2o)                         {this->ah2o = l_ah2o;}
+	LDBLE Get_total_h() const                           {return this->total_h;}
+	void Set_total_h(LDBLE l_total_h)                   {this->total_h = l_total_h;}
+	LDBLE Get_total_o() const                           {return this->total_o;}
+	void Set_total_o(LDBLE l_total_o)                   {this->total_o = l_total_o;}
+	LDBLE Get_cb() const                                {return this->cb;}
+	void Set_cb(LDBLE l_cb)                             {this->cb = l_cb;}
+	LDBLE Get_density() const                           {return this->density;}
+	void Set_density(LDBLE l_density)                   {this->density = l_density;}
+	LDBLE Get_viscosity() const                         { return this->viscosity; }
+	void Set_viscosity(LDBLE l_viscos)                  { this->viscosity = l_viscos; }
+	LDBLE Get_viscos_0() const                          { return this->viscos_0; }
+	void Set_viscos_0(LDBLE l_viscos_0)                 { this->viscos_0 = l_viscos_0; }
+	LDBLE Get_mass_water() const                        {return this->mass_water;}
+	void Set_mass_water(LDBLE l_mass_water)             {this->mass_water = l_mass_water;}
+	LDBLE Get_total_alkalinity() const                  {return this->total_alkalinity;}
+	void Set_total_alkalinity(LDBLE l_total_alkalinity) {this->total_alkalinity = l_total_alkalinity;}
+	LDBLE Get_soln_vol() const                          {return this->soln_vol;}
+	void Set_soln_vol(LDBLE t)                          {this->soln_vol = t;}
+	cxxNameDouble & Get_totals(void)                    {return this->totals;}
+	const cxxNameDouble & Get_totals(void)const         {return this->totals;}
+	void Set_totals(cxxNameDouble & nd)
+	{
+		this->totals = nd;
+		this->totals.type = cxxNameDouble::ND_ELT_MOLES;
+	}
+	cxxNameDouble & Get_master_activity(void)           {return this->master_activity;}
+	cxxNameDouble & Get_species_gamma(void)             {return this->species_gamma;}
+	std::map<int, double> & Get_species_map(void)       {return this->species_map;}
+	std::map<int, double> & Get_log_gamma_map(void)     {return this->log_gamma_map;}
+	std::map<int, double>& Get_log_molalities_map(void) { return this->log_molalities_map; }
+	std::map < std::string, cxxSolutionIsotope > & Get_isotopes(void)             {return this->isotopes;}	
+	const std::map < std::string, cxxSolutionIsotope > & Get_isotopes(void)const  {return this->isotopes;}	
+	void Set_isotopes(const std::map < std::string, cxxSolutionIsotope > &iso ) {this->isotopes = iso;}	
+	cxxISolution *Get_initial_data()                    {return this->initial_data;}
+	const cxxISolution *Get_initial_data()const         {return this->initial_data;}
+	void Set_initial_data(const cxxISolution * id)
+	{
+		if (this->initial_data != NULL)
+			delete this->initial_data;
+		this->initial_data = new cxxISolution(*id);
+	}
+	void Create_initial_data()
+	{
+		if (this->initial_data != NULL)
+			delete initial_data;
+		initial_data = new cxxISolution;
+	}
+	void Destroy_initial_data()
+	{
+		if (this->initial_data != NULL)
+			delete initial_data;
+		initial_data = NULL;
+	}
+
+	void clear_totals()					{this->totals.clear();}
+	void clear_master_activity()    	{this->master_activity.clear();}
+
+	void zero();
+	void add(const cxxSolution & addee, LDBLE extensive);
+	void Add_isotopes(const std::map < std::string, cxxSolutionIsotope > &old, LDBLE intensive, LDBLE extensive);
+	void multiply(LDBLE extensive);
+	void Multiply_isotopes(LDBLE extensive);
+	// not checked
+	void dump_xml(std::ostream & os, unsigned int indent = 0) const;
+	void dump_raw(std::ostream & s_oss, unsigned int indent, int *n_out=NULL) const;
+
+	LDBLE Get_master_activity(char *string) const;
+	void Set_master_activity(char *string, LDBLE value);	
+	LDBLE Get_total(const char *string) const;
+	LDBLE Get_total_element(const char *string) const;
+	void Set_total(char *string, LDBLE value);
+	void read_raw(CParser & parser, bool check = true);
+	//void modify_activities(const cxxSolution & original);
+	//void Simplify_totals();
+	void Update(const cxxNameDouble &nd);
+	void Update(LDBLE h_tot, LDBLE o_tot, LDBLE charge, const cxxNameDouble &nd);
+	void Update_activities(const cxxNameDouble &original_tot);
+	void Serialize(Dictionary & dictionary, std::vector < int >&ints, std::vector < double >&doubles);
+	void Deserialize(Dictionary & dictionary, std::vector < int >&ints, std::vector < double >&doubles, int &ii, int &dd);
+
+  protected:
+	bool new_def;
+	LDBLE patm;
+	LDBLE potV;
+	LDBLE tc;
+	LDBLE ph;
+	LDBLE pe;
+	LDBLE mu;
+	LDBLE ah2o;
+	LDBLE total_h;
+	LDBLE total_o;
+	LDBLE cb;
+	LDBLE mass_water;
+	LDBLE density;
+	LDBLE viscosity;
+	LDBLE viscos_0;
+	LDBLE soln_vol;
+	LDBLE total_alkalinity;
+	cxxNameDouble totals;
+	cxxNameDouble master_activity;
+	cxxNameDouble species_gamma;
+	//cxxSolutionIsotopeList isotopes;
+	std::map < std::string, cxxSolutionIsotope > isotopes;
+	cxxISolution *initial_data;
+	const static std::vector < std::string > vopts;
+	std::map<int, double> species_map;
+	std::map<int, double> log_gamma_map;
+	std::map<int, double> log_molalities_map;
+};
+
+#endif // !defined(SOLUTION_H_INCLUDED)

pyEQL/phreeqc/ext/iphreeqc-3.8.6-17100/src/phreeqcpp/SolutionIsotope.cxx

@@ -0,0 +1,333 @@
+#ifdef _DEBUG
+#pragma warning(disable : 4786)	// disable truncation warning (Only used by debugger)
+#endif
+#include <cassert>
+#include <sstream>				// std::ostrstream
+
+#include "Utils.h"
+#include "Phreeqc.h"
+#include "SolutionIsotope.h"
+#include "phqalloc.h"
+#include "Dictionary.h"
+
+#if defined(PHREEQCI_GUI)
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+#endif
+
+cxxSolutionIsotope::cxxSolutionIsotope(PHRQ_io *io)
+:
+PHRQ_base(io),
+isotope_number(0.0)
+{
+	isotope_number = 0;
+	elt_name.clear();
+	isotope_name.clear();
+	total = 0;
+	ratio = -9999.9;
+	ratio_uncertainty = 1;
+	ratio_uncertainty_defined = false;
+	x_ratio_uncertainty = 0;
+	coef = 0;
+}
+cxxSolutionIsotope::~cxxSolutionIsotope(void)
+{
+}
+
+void
+cxxSolutionIsotope::dump_xml(std::ostream & s_oss, unsigned int indent) const
+{
+	unsigned int i;
+
+	std::string indent0(""), indent1("");
+	for (i = 0; i < indent; ++i)
+		indent0.append(Utilities::INDENT);
+	for (i = 0; i < indent + 1; ++i)
+		indent1.append(Utilities::INDENT);
+
+	s_oss << indent0;
+	s_oss << "<soln_isotope=\"" << "\n";
+
+	s_oss << indent1;
+	s_oss << "iso_isotope_number=\"" << this->
+		isotope_number << "\"" << "\n";
+
+	s_oss << indent1;
+	s_oss << "iso_elt_name=\"" << this->elt_name << "\"" << "\n";
+
+	s_oss << indent1;
+	s_oss << "iso_isotope_name=\"" << this->isotope_name << "\"" << "\n";
+
+	s_oss << indent1;
+	s_oss << "iso_total=\"" << this->total << "\"" << "\n";
+
+	s_oss << indent1;
+	s_oss << "iso_ratio=\"" << this->ratio << "\"" << "\n";
+
+	if (!std::isnan(this->ratio_uncertainty))
+	{
+		s_oss << indent1;
+		s_oss << "iso_ratio_uncertainty=\"" << this->
+			ratio_uncertainty << "\"" << "\n";
+	}
+	s_oss << indent0;
+	s_oss << "\">" << "\n";
+}
+
+void
+cxxSolutionIsotope::dump_raw(std::ostream & s_oss, unsigned int indent) const
+{
+	unsigned int i;
+
+	std::string indent0("");
+	for (i = 0; i < indent; ++i)
+		indent0.append(Utilities::INDENT);
+	std::string indent1 = indent0;
+	indent1.append(Utilities::INDENT);
+
+	s_oss << indent0;
+	s_oss << indent0 << "-isotope_number                    " << this->isotope_number << "\n";
+	s_oss << indent0 << "-elt_name                          " << this->elt_name << "\n";
+	s_oss << indent0 << "-total                             " << this->total << "\n";
+	s_oss << indent0 << "-ratio                             " << this->ratio << "\n";
+	s_oss << indent0 << "-ratio_uncertainty_defined         " << this->ratio_uncertainty_defined << "\n";
+	if (this->ratio_uncertainty_defined)
+	{
+		s_oss << indent0 << "-ratio_uncertainty                 " << this->ratio_uncertainty << "\n";
+	}
+	s_oss << indent0 << "-x_ratio_uncertainty               " << this->x_ratio_uncertainty << "\n";
+	s_oss << indent0 << "-coef                              " << this->coef << "\n";
+}
+void cxxSolutionIsotope::read_raw(CParser & parser, bool check )
+{
+
+	std::istream::pos_type ptr;
+	std::istream::pos_type next_char;
+	std::string token;
+	int opt_save;
+
+	opt_save = CParser::OPT_ERROR;
+	bool isotope_number_defined(false);
+	bool elt_name_defined(false);
+	bool total_defined(false);
+	bool ratio_defined(false);
+
+	for (;;)
+	{
+		int opt = parser.get_option(vopts, next_char);
+		if (opt == CParser::OPT_DEFAULT)
+		{
+			opt = opt_save;
+		}
+		
+		opt_save = CParser::OPT_DEFAULT;
+		switch (opt)
+		{
+		case CParser::OPT_EOF:
+			break;
+		case CParser::OPT_KEYWORD:
+			break;
+		case CParser::OPT_DEFAULT:
+		case CParser::OPT_ERROR:
+			opt = CParser::OPT_EOF;
+			parser.error_msg("Unknown input in isotopes of SOLUTION_RAW keyword.",
+							 PHRQ_io::OT_CONTINUE);
+			parser.error_msg(parser.line().c_str(), PHRQ_io::OT_CONTINUE);
+			continue;
+
+		case 0:				// isotope_number                  
+			if (!(parser.get_iss() >> this->isotope_number))
+			{
+				this->isotope_number = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for isotope_number.",
+								 PHRQ_io::OT_CONTINUE);
+			}
+			isotope_number_defined = true;
+			break;
+
+		case 1:				// elt_name                
+			if (!(parser.get_iss() >> this->elt_name))
+			{
+				this->elt_name.clear();
+				parser.incr_input_error();
+				parser.error_msg("Expected character value for elt_name.",
+								 PHRQ_io::OT_CONTINUE);
+			}
+			elt_name_defined = true;
+			break;
+
+		case 2:				// total
+			if (!(parser.get_iss() >> this->total))
+			{
+				this->total = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for total.",
+								 PHRQ_io::OT_CONTINUE);
+			}
+			total_defined = true;
+			break;
+
+		case 3:				// ratio
+			if (!(parser.get_iss() >> this->ratio))
+			{
+				this->ratio = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for ratio.",
+								 PHRQ_io::OT_CONTINUE);
+			}
+			total_defined = true;
+			break;
+
+		case 4:				// ratio_uncertainty_defined
+			if (!(parser.get_iss() >> this->ratio_uncertainty_defined))
+			{
+				this->ratio_uncertainty_defined = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected boolean value for ratio_uncertainty_defined.",
+								 PHRQ_io::OT_CONTINUE);
+			}
+			break;
+
+		case 5:				// ratio_uncertainty
+			if (!(parser.get_iss() >> this->ratio_uncertainty))
+			{
+				this->ratio_uncertainty = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for ratio_uncertainty.",
+								 PHRQ_io::OT_CONTINUE);
+			}
+			ratio_uncertainty_defined = true;
+			break;
+
+		case 6:				// x_ratio_uncertainty
+			if (!(parser.get_iss() >> this->x_ratio_uncertainty))
+			{
+				this->x_ratio_uncertainty = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for x_ratio_uncertainty.",
+								 PHRQ_io::OT_CONTINUE);
+			}
+			break;
+		case 7:				// coef
+			if (!(parser.get_iss() >> this->coef))
+			{
+				this->coef = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for coef.",
+								 PHRQ_io::OT_CONTINUE);
+			}
+			break;
+		}
+
+		if (opt == CParser::OPT_EOF || opt == CParser::OPT_KEYWORD)
+			break;
+	}
+	if (check)
+	{
+		// all members must be defined
+		if (isotope_number_defined == false)
+		{
+			parser.incr_input_error();
+			parser.error_msg("isotope_number not defined for isotopes SOLUTION_RAW input.",
+				PHRQ_io::OT_CONTINUE);
+		}
+		if (elt_name_defined == false)
+		{
+			parser.incr_input_error();
+			parser.error_msg("elt_name not defined for isotopes SOLUTION_RAW input.",
+				PHRQ_io::OT_CONTINUE);
+		}
+		if (total_defined == false)
+		{
+			parser.incr_input_error();
+			parser.error_msg("total not defined for isotopes SOLUTION_RAW input.",
+				PHRQ_io::OT_CONTINUE);
+		}
+		if (ratio_defined == false)
+		{
+			parser.incr_input_error();
+			parser.error_msg("ratio not defined for isotopes SOLUTION_RAW input.",
+				PHRQ_io::OT_CONTINUE);
+		}
+		if (ratio_uncertainty_defined == false)
+		{
+			parser.incr_input_error();
+			parser.
+				error_msg("ratio_uncertainty not defined for isotopes SOLUTION_RAW input.",
+				PHRQ_io::OT_CONTINUE);
+		}
+	}
+	return;
+}
+bool
+cxxSolutionIsotope::operator<(const cxxSolutionIsotope & isotope) const
+{
+	int i = Utilities::strcmp_nocase(this->elt_name.c_str(), isotope.elt_name.c_str());
+	if (i != 0)
+		return (i < 0);
+	return (this->isotope_number < isotope.isotope_number);
+}
+
+void
+cxxSolutionIsotope::add(const cxxSolutionIsotope & isotope_ptr,
+						LDBLE intensive, LDBLE extensive)
+{
+	if ((this->isotope_number == isotope_ptr.isotope_number) &&
+		(this->elt_name == isotope_ptr.elt_name) &&
+		(this->isotope_name == isotope_ptr.isotope_name))
+	{
+		this->total += isotope_ptr.total * extensive;
+		this->ratio += isotope_ptr.ratio * intensive;
+		this->ratio_uncertainty += isotope_ptr.ratio_uncertainty * intensive;
+		this->ratio_uncertainty_defined = (this->ratio_uncertainty_defined
+										   || isotope_ptr.
+										   ratio_uncertainty_defined);
+	}
+}
+void
+cxxSolutionIsotope::multiply(LDBLE extensive)
+{
+	this->total *= extensive;
+}
+void 
+cxxSolutionIsotope::Serialize(Dictionary & dictionary, std::vector < int >&ints, std::vector < double >&doubles)
+{
+	doubles.push_back(this->isotope_number);
+	ints.push_back(dictionary.Find(this->elt_name));
+	ints.push_back(dictionary.Find(this->isotope_name));
+	doubles.push_back(this->total);
+	doubles.push_back(this->ratio);
+	doubles.push_back(this->ratio_uncertainty);
+	ints.push_back(this->ratio_uncertainty_defined ? 1 : 0);
+	doubles.push_back(this->x_ratio_uncertainty);
+	doubles.push_back(this->coef);
+}
+void 
+cxxSolutionIsotope::Deserialize(Dictionary & dictionary, std::vector < int >&ints, std::vector < double >&doubles, int &ii, int &dd)
+{
+	this->isotope_number = doubles[dd++];
+	this->elt_name = dictionary.GetWords()[ints[ii++]];
+	this->isotope_name = dictionary.GetWords()[ints[ii++]];
+	this->total = doubles[dd++];
+	this->ratio = doubles[dd++];
+	this->ratio_uncertainty = doubles[dd++];
+	this->ratio_uncertainty_defined = (ints[ii++] != 0);
+	this->x_ratio_uncertainty = doubles[dd++];
+	this->coef = doubles[dd++];
+}
+
+const std::vector< std::string >::value_type temp_vopts[] = {
+	std::vector< std::string >::value_type("isotope_number"),	            // 0 
+	std::vector< std::string >::value_type("elt_name"),	                    // 1 
+	std::vector< std::string >::value_type("total"),	                    // 2 
+	std::vector< std::string >::value_type("ratio"),	                    // 3 
+	std::vector< std::string >::value_type("ratio_uncertainty_defined"),	// 4 
+	std::vector< std::string >::value_type("ratio_uncertainty"),	        // 5 
+	std::vector< std::string >::value_type("x_ratio_uncertainty"),	        // 6 
+	std::vector< std::string >::value_type("coef") 	                        // 7 
+};									   
+const std::vector< std::string > cxxSolutionIsotope::vopts(temp_vopts, temp_vopts + sizeof temp_vopts / sizeof temp_vopts[0]);

pyEQL/phreeqc/ext/iphreeqc-3.8.6-17100/src/phreeqcpp/SolutionIsotope.h

@@ -0,0 +1,85 @@
+#if !defined(SOLUTIONISOTOPE_H_INCLUDED)
+#define SOLUTIONISOTOPE_H_INCLUDED
+
+#include <ostream>				// std::ostream
+#include <string>				// std::string
+#include <list>					// std::list
+#include "Parser.h"
+class Dictionary;
+
+class cxxSolutionIsotope: public PHRQ_base
+{
+  public:
+	cxxSolutionIsotope(PHRQ_io *io=NULL);
+	cxxSolutionIsotope(class isotope *isotope_ptr, PHRQ_io *io=NULL);
+	virtual ~cxxSolutionIsotope(void);
+
+	void dump_xml(std::ostream & os, unsigned int indent) const;
+	void dump_raw(std::ostream & os, unsigned int indent) const;
+
+	//CParser::STATUS_TYPE read_raw(CParser & parser, std::istream::pos_type next_char);
+	void read_raw(CParser & parser, bool check);
+
+	LDBLE Get_isotope_number() const
+	{
+		return this->isotope_number;
+	}
+	void Set_isotope_number(LDBLE d)
+	{
+		this->isotope_number = d;
+	}
+	const std::string &Get_elt_name() const	{return this->elt_name;}
+	void Set_elt_name(const char *cstring)
+	{
+		if (cstring != NULL)
+			this->elt_name = std::string(cstring);
+		else
+			this->elt_name.clear();
+	}
+
+	const std::string &Get_isotope_name() const	{return this->isotope_name;}
+	void Set_isotope_name(const char *cstring)
+	{
+		if (cstring != NULL)
+			this->isotope_name = std::string(cstring);
+		else
+			this->isotope_name.clear();
+	}
+
+	LDBLE Get_total() const	{return this->total;}
+	void Set_total(LDBLE d)	{this->total = d;}
+
+	LDBLE Get_ratio() const	            {return this->ratio;}
+	void Set_ratio(LDBLE t)             {this->ratio = t;}
+
+	LDBLE Get_ratio_uncertainty() const	{return this->ratio_uncertainty;}
+	void Set_ratio_uncertainty(LDBLE t) {this->ratio_uncertainty = t;}
+
+	LDBLE Get_x_ratio_uncertainty() const	{return this->x_ratio_uncertainty;}
+	void Set_x_ratio_uncertainty(LDBLE t)   {this->x_ratio_uncertainty = t;}
+
+	bool Get_ratio_uncertainty_defined() const  {return this->ratio_uncertainty_defined;}
+	void Set_ratio_uncertainty_defined(bool tf) {this->ratio_uncertainty_defined = tf;}
+	LDBLE Get_coef() const	{return this->coef;}
+	void Set_coef(LDBLE t)   {this->coef = t;}
+
+	bool operator<(const cxxSolutionIsotope & conc) const;
+	void add(const cxxSolutionIsotope & isotope_ptr, LDBLE intensive,
+			 LDBLE extensive);
+	void multiply(LDBLE extensive);
+	void Serialize(Dictionary & dictionary, std::vector < int >&ints, std::vector < double >&doubles);
+	void Deserialize(Dictionary & dictionary, std::vector < int >&ints, std::vector < double >&doubles, int &ii, int &dd);
+
+  protected:
+	LDBLE isotope_number;
+	std::string elt_name;
+	std::string isotope_name;
+	LDBLE total;
+	LDBLE ratio;
+	LDBLE ratio_uncertainty;
+	bool ratio_uncertainty_defined;
+ 	LDBLE x_ratio_uncertainty;
+ 	LDBLE coef;					/* coefficient of element in phase */
+	const static std::vector < std::string > vopts;
+};
+#endif // SOLUTIONISOTOPE_H_INCLUDED