pyEQL 1.4.0rc9__cp311-cp311-win_amd64.whl

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

@@ -0,0 +1,103 @@
+#if !defined(GASPHASE_H_INCLUDED)
+#define GASPHASE_H_INCLUDED
+
+#include <cassert>				// assert
+#include <map>					// std::map
+#include <string>				// std::string
+#include <list>					// std::list
+#include <vector>				// std::vector
+#include "phrqtype.h"
+#include "NumKeyword.h"
+#include "NameDouble.h"
+#include "GasComp.h"
+class cxxMix;
+
+class cxxGasPhase:public cxxNumKeyword
+{
+
+  public:
+	cxxGasPhase(PHRQ_io * io=NULL);
+	cxxGasPhase(std::map < int, cxxGasPhase > &entity_map,
+		cxxMix & mx, int n_user, PHRQ_io * io=NULL);
+	 ~cxxGasPhase();
+
+	enum GP_TYPE
+	{
+		GP_PRESSURE = 0,
+		GP_VOLUME = 1,
+		GP_UNKNOWN = 2
+	};
+
+	//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;
+
+	void read_raw(CParser & parser, bool check = true);
+
+	void totalize(Phreeqc * phreeqc_ptr);
+
+	const cxxNameDouble & Get_totals() const
+	{
+		return this->totals;
+	};
+	std::vector<cxxGasComp> & Get_gas_comps(void) {return gas_comps;};
+	const std::vector<cxxGasComp> & Get_gas_comps(void)const {return gas_comps;};
+	void Set_gas_comps(const std::vector<cxxGasComp> v) {gas_comps = v;};
+
+	GP_TYPE Get_type(void) const {return type;};
+	void Set_type(GP_TYPE t) {type = t;};
+	LDBLE Get_total_p(void) const {return total_p;};
+	void Set_total_p(LDBLE t) {total_p = t;};
+	LDBLE Get_volume(void) const {return volume;};
+	void Set_volume(LDBLE v) {volume = v;};
+	LDBLE Get_v_m(void) const {return v_m;};
+	void Set_v_m(LDBLE v) {v_m = v;};
+	bool Get_pr_in(void) const {return pr_in;};
+	void Set_pr_in(bool tf) {pr_in = tf;};
+	cxxNameDouble & Get_totals(void) {return totals;};
+
+	bool Get_new_def(void) const {return this->new_def;};
+	void Set_new_def(bool tf) {this->new_def = tf;};
+	bool Get_solution_equilibria(void) const {return this->solution_equilibria;};
+	void Set_solution_equilibria(bool tf) {this->solution_equilibria = tf;};
+	int Get_n_solution(void) const {return this->n_solution;};
+	void Set_n_solution(int i) {this->n_solution = i;};
+	LDBLE Get_total_moles(void)const {return total_moles;};
+	void Set_total_moles(LDBLE t) {total_moles = t;};
+	LDBLE Get_temperature(void)const {return temperature;};
+	void Set_temperature(LDBLE t) {temperature = t;};
+	LDBLE Calc_total_moles(void)const;
+	cxxGasComp *Find_comp(const char * comp_name);
+	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);
+	void Delete_component(const std::string comp_name);
+	void Set_component_moles(const std::string comp_name, const double moles);
+	double Get_component_moles(const std::string comp_name);
+	double Get_component_p(const std::string comp_name);
+	double Get_component_phi(const std::string comp_name);
+	double Get_component_f(const std::string comp_name);
+protected:
+	void add(const cxxGasPhase & addee, LDBLE extensive);
+
+protected:
+	// candidate variables for GAS_PHASE_MODIFY
+	GP_TYPE type;
+	LDBLE total_p;
+	LDBLE volume;
+	std::vector<cxxGasComp> gas_comps;
+
+	// GAS_PHASE_MODIFY with new_def=true variables
+	bool new_def;
+	bool solution_equilibria;
+	int n_solution;
+	LDBLE temperature;
+
+	// internal variables
+	LDBLE total_moles;
+	LDBLE v_m;
+	bool pr_in;
+	cxxNameDouble totals;
+	const static std::vector < std::string > vopts;
+};
+
+#endif // !defined(GASPHASE_H_INCLUDED)

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

@@ -0,0 +1,40 @@
+// ISolution.cxx: implementation of the cxxSolutionxx class.
+//
+//////////////////////////////////////////////////////////////////////
+#ifdef _DEBUG
+#pragma warning(disable : 4786)	// disable truncation warning (Only used by debugger)
+#endif
+#include <cassert>				// assert
+#include <algorithm>			// std::sort
+#include <sstream>
+
+#include "Utils.h" // define first
+#include "Phreeqc.h"
+#include "ISolution.h"
+#include "phqalloc.h"
+
+#if defined(PHREEQCI_GUI)
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+#endif
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+cxxISolution::cxxISolution(PHRQ_io *io)
+:
+units("mMol/kgw")
+{
+	default_pe = "pe";
+	CReaction temp_pe_reactions;
+	pe_reactions[default_pe] = temp_pe_reactions;
+	this->calc_density = false;
+
+}
+cxxISolution::~cxxISolution()
+{
+}

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

@@ -0,0 +1,53 @@
+#if !defined(ISOLUTION_H_INCLUDED)
+#define ISOLUTION_H_INCLUDED
+
+#include <cassert>				// assert
+#include <map>					// std::map
+#include <string>				// std::string
+#include <list>					// std::list
+#include <vector>				// std::vector
+#include <set>					// std::set
+#include <iostream>
+#include <sstream>
+#include <fstream>
+
+#include "ISolutionComp.h"
+#include "PHRQ_base.h"
+#include "NameDouble.h"
+#include "global_structures.h"
+class cxxISolution: public PHRQ_base
+{
+
+  public:
+	cxxISolution(PHRQ_io *io=NULL);
+	cxxISolution(const cxxISolution *is);
+	virtual ~cxxISolution();
+	std::string Get_units() const                     {return units;}
+	void Set_units(std::string l_units)               {units = l_units;}
+	void Set_units(const char * l_units)
+	{
+		if (l_units != NULL)
+			this->units = std::string(l_units);
+		else
+			this->units.clear();
+	}
+	const char * Get_default_pe() const                {return default_pe;}
+	void Set_default_pe(const char * pe)               {default_pe = pe;}
+	bool Get_calc_density(void)                        {return this->calc_density;}
+	void Set_calc_density(bool calc)                   {this->calc_density = calc;}
+	std::map < std::string, cxxISolutionComp > &Get_comps(void) {return this->comps;}
+	const std::map < std::string, cxxISolutionComp > &Get_comps(void)const {return this->comps;}
+	void Set_comps(std::map < std::string, cxxISolutionComp > &c) {this->comps = c;}
+	std::map<std::string, CReaction>& Get_pe_reactions(void) { return this->pe_reactions; }
+	void Set_pe_reactions(std::map < std::string, CReaction >& pe) { this->pe_reactions = pe; }
+
+  protected:
+	friend class cxxISolutionComp;	// for this->pe access
+	std::string units;
+	bool calc_density;
+	std::map < std::string, cxxISolutionComp > comps;
+	std::map <std::string, CReaction> pe_reactions;
+	const char * default_pe;
+};
+
+#endif // !defined(ISOLUTION_H_INCLUDED)

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

@@ -0,0 +1,202 @@
+#ifdef _DEBUG
+#pragma warning(disable : 4786)	// disable truncation warning (Only used by debugger)
+#endif
+#include <cassert>
+
+#include "Utils.h"
+#include "ISolutionComp.h"
+#include "Parser.h"
+#include "Solution.h"
+#include "phqalloc.h"
+
+#if defined(PHREEQCI_GUI)
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+#endif
+
+cxxISolutionComp::cxxISolutionComp(PHRQ_io *io):
+PHRQ_base(io),
+moles(0.0), 
+input_conc(0.0), 
+phase_si(0.0),
+gfw(0.0)
+{
+}
+cxxISolutionComp::~cxxISolutionComp(void)
+{
+}
+
+/* ---------------------------------------------------------------------- */
+CParser::STATUS_TYPE cxxISolutionComp::
+read(const char *line_in, cxxSolution *solution_ptr)
+/* ---------------------------------------------------------------------- */
+{
+/*
+ *   Remove space between "kg" and "solution" or "water" in units
+ */
+	std::string line = line_in;
+	Utilities::replace("Kg", "kg", line);
+	Utilities::replace("KG", "kg", line);
+	while (Utilities::replace("kg ", "kg", line) == TRUE);
+/*
+ *   Read master species list for mass balance equation
+ */
+	std::string master_list;
+	std::string token;
+	std::string::iterator b = line.begin(); 
+	std::string::iterator e = line.end(); 
+	{
+		int j;
+		while (((j = CParser::copy_token(token, b, e)) == CParser::TT_UPPER) ||
+			(token[0] == '[') ||
+			(Utilities::strcmp_nocase(token.c_str(), "ph") == 0) ||
+			(Utilities::strcmp_nocase(token.c_str(), "pe") == 0))
+		{
+			Utilities::replace("(+", "(", token);
+			if (master_list.size() > 0)
+				master_list.append(" ");
+			master_list.append(token);
+		}
+	}
+	if (master_list.size() == 0)
+	{
+		error_msg
+			("No element or master species given for concentration input.",
+			  PHRQ_io::OT_CONTINUE);
+		return (CParser::PARSER_ERROR);
+	}
+	this->Set_description(master_list.c_str());
+/*
+ *   Determine if reading alkalinity, allow equivalents for units
+ */
+	bool alk;
+	Utilities::str_tolower(master_list);
+	if (strstr(master_list.c_str(), "alk") == master_list.c_str())
+	{
+		alk = true;
+	}
+	else
+	{
+		alk = false;
+	}
+/*
+ *   Read concentration
+ */
+	{
+		LDBLE dummy;
+		int j = sscanf(token.c_str(), SCANFORMAT, &dummy);
+		if (j == 0)
+		{
+			std::ostringstream errstr;
+			errstr << "Concentration data error for " << master_list << " in solution input.";
+			error_msg(errstr.str().c_str(),  PHRQ_io::OT_CONTINUE);
+			return (CParser::PARSER_ERROR);
+		}
+		else
+		{
+			this->Set_input_conc(dummy);
+		}
+		if ((j = CParser::copy_token(token, b, e)) == CParser::TT_EMPTY)
+			return (CParser::PARSER_OK);
+	}
+/*
+ *   Read optional data
+ */
+	std::string token1 = token;
+
+/*
+ *   Check for units info
+ */
+	CParser parser(this->io);
+	if (solution_ptr->Get_initial_data() == NULL)
+	{
+		error_msg("Initial_data instance not defined in cxxISolutionComp::read", 1);
+	}
+	if (parser.check_units(token1, alk, false, solution_ptr->Get_initial_data()->Get_units().c_str(), false) == CParser::PARSER_OK)
+	{
+		if (parser.check_units(token1, alk, false, solution_ptr->Get_initial_data()->Get_units().c_str(), true) == CParser::PARSER_OK)
+		{
+			this->units = token1;
+			if ((CParser::copy_token(token, b, e)) == CParser::TT_EMPTY)
+				return (CParser::PARSER_OK);
+		}
+		else
+		{
+			return (CParser::PARSER_ERROR);
+		}
+	}
+/*
+ *   Check for "as" followed by formula to be used for gfw
+ */
+	token1 = token;
+	Utilities::str_tolower(token1);
+	if (strcmp(token1.c_str(), "as") == 0)
+	{
+		CParser::copy_token(token, b, e);
+		this->as = token;
+		if ((CParser::copy_token(token, b, e)) == CParser::TT_EMPTY)
+			return (CParser::PARSER_OK);
+/*
+ *   Check for "gfw" followed by gram formula weight
+ */
+	}
+	else if (strcmp(token1.c_str(), "gfw") == 0 || strcmp(token1.c_str(), "gfm") == 0)
+	{
+		if (CParser::copy_token(token, b, e) != DIGIT)
+		{
+			error_msg("Expecting gram formula weight.",  PHRQ_io::OT_CONTINUE);
+			return (CParser::PARSER_ERROR);
+		}
+		else
+		{
+			(void)sscanf(token.c_str(), SCANFORMAT, &this->gfw);
+			if ((CParser::copy_token(token, b, e)) == CParser::TT_EMPTY)
+				return (CParser::PARSER_OK);
+		}
+	}
+/*
+ *   Check for redox couple for pe
+ */
+	if (Utilities::strcmp_nocase(token.c_str(), "pe") == 0)
+	{
+		this->pe_reaction = token;
+		if ((CParser::copy_token(token, b, e)) == CParser::TT_EMPTY)
+			return (CParser::PARSER_OK);
+	}
+	else if (strstr(token.c_str(), "/") != NULL)
+	{
+		if (parser.parse_couple(token) == CParser::PARSER_OK)
+		{
+			this->pe_reaction = token;
+			if ((CParser::copy_token(token, b, e)) == CParser::TT_EMPTY)
+				return (CParser::PARSER_OK);
+		}
+		else
+		{
+			return (CParser::PARSER_ERROR);
+		}
+	}
+/*
+ *   Must have phase
+ */
+	this->equation_name = token;
+	if (CParser::copy_token(token, b, e) == CParser::TT_EMPTY)
+		return (CParser::PARSER_OK);
+/*
+ *   Check for saturation index
+ */
+	{
+		int j = sscanf(token.c_str(), SCANFORMAT,
+			&(this->phase_si));
+		if (j != 1)
+		{
+			error_msg("Expected saturation index.",  PHRQ_io::OT_CONTINUE);
+			return (CParser::PARSER_ERROR);
+		}
+	}
+	return (CParser::PARSER_OK);
+
+}

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

@@ -0,0 +1,138 @@
+#if !defined(ISOLUTIONCOMP_H_INCLUDED)
+#define ISOLUTIONCOMP_H_INCLUDED
+
+#include <string.h>             // ::strcmp
+#include <string>
+#include <map>                  // std::map
+#include <vector>
+#include <set>
+#include "phrqtype.h"           // LDBLE
+#include "Parser.h"             // CParser
+#include "PHRQ_base.h"          // PHRQ_base
+
+// forward declarations
+class cxxSolution;
+class cxxISolution;             // reqd for read and dump_xml
+class PHRQ_io;
+
+class cxxISolutionComp: public PHRQ_base
+{
+  public:
+	cxxISolutionComp(PHRQ_io *io=NULL);
+	virtual ~cxxISolutionComp(void);
+
+  public:
+
+	CParser::STATUS_TYPE read(const char *line, cxxSolution *solution_ptr);
+
+	void dump_xml(std::ostream & os, unsigned int indent = 0) const;
+
+	const std::string &Get_description() const
+	{
+		return this->description;
+	}
+	void Set_description(const char *l_description)
+	{
+		if (l_description != NULL)
+			this->description = std::string(l_description);
+		else
+			this->description.clear();
+	}
+
+	LDBLE Get_moles() const
+	{
+		return this->moles;
+	}
+	void Set_moles(LDBLE l_moles)
+	{
+		this->moles = l_moles;
+	}
+
+	LDBLE Get_input_conc() const
+	{
+		return this->input_conc;
+	}
+	void Set_input_conc(LDBLE l_input_conc)
+	{
+		this->input_conc = l_input_conc;
+	}
+
+	std::string Get_units()const
+	{
+		return this->units;
+	}
+	void Set_units(const char *l_units)
+	{
+		if (l_units != NULL)
+			this->units = std::string(l_units);
+		else
+			this->units.clear();
+	}
+
+	const std::string &Get_equation_name() const
+	{
+		return this->equation_name;
+	}
+	void Set_equation_name(const char *l_equation_name)
+	{
+		if (l_equation_name != NULL)
+			this->equation_name = std::string(l_equation_name);
+		else
+			this->equation_name.clear();
+
+	}
+
+	LDBLE Get_phase_si() const
+	{
+		return this->phase_si;
+	}
+	void Set_phase_si(int l_phase_si)
+	{
+		this->phase_si = l_phase_si;
+	}
+	std::string Get_pe_reaction() const
+	{
+		return this->pe_reaction;
+	}
+	void Set_pe_reaction(const std::string & pe_r)
+	{
+		this->pe_reaction = pe_r;
+	}
+	const std::string &Get_as() const
+	{
+		return this->as;
+	}
+	void Set_as(const char *l_as)
+	{
+		if (l_as != NULL)
+			this->as = std::string(l_as);
+		else
+			this->as.clear();
+	}
+	LDBLE Get_gfw() const
+	{
+		return this->gfw;
+	};
+	void Set_gfw(LDBLE l_gfw)
+	{
+		this->gfw = l_gfw;
+	}
+
+	bool operator<(const cxxISolutionComp & conc) const
+	{
+		return ::strcmp(this->description.c_str(), conc.description.c_str()) < 0;
+	}
+
+  protected:
+	  std::string description;
+	  LDBLE moles;
+	  LDBLE input_conc;
+	  std::string units;
+	  std::string equation_name;
+	  LDBLE phase_si;
+	  std::string pe_reaction;
+	  std::string as;
+	  LDBLE gfw;
+};
+
+#endif // ISOLUTIONCOMP_H_INCLUDED