pyEQL 1.4.0rc9__cp310-cp310-macosx_10_9_x86_64.whl

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

@@ -0,0 +1,128 @@
+#if !defined(SSASSEMBLAGESS_H_INCLUDED)
+#define SSASSEMBLAGESS_H_INCLUDED
+
+#include <cassert>				// assert
+#include <vector>
+#include <string>				// std::string
+#include <list>					// std::list
+#include <vector>				// std::vector
+#include "phrqtype.h"
+#include "NameDouble.h"
+#include "SScomp.h"
+
+
+class cxxSS: public PHRQ_base
+{
+
+  public:
+	cxxSS(PHRQ_io *io=NULL);
+	virtual ~cxxSS();
+
+	enum SS_PARAMETER_TYPE
+	{
+		SS_PARM_NONE = -1,
+		SS_PARM_A0_A1 = 0,
+		SS_PARM_GAMMAS = 1,
+		SS_PARM_DIST_COEF = 2,
+		SS_PARM_MISCIBILITY = 3,
+		SS_PARM_SPINODAL = 4,
+		SS_PARM_CRITICAL = 5,
+		SS_PARM_ALYOTROPIC = 6,
+		SS_PARM_DIM_GUGG = 7,
+		SS_PARM_WALDBAUM = 8,
+		SS_PARM_MARGULES = 9
+	};
+
+	void dump_xml(std::ostream & os, unsigned int indent = 0) const;
+
+	void dump_raw(std::ostream & s_oss, unsigned int indent) const;
+
+	void read_raw(CParser & parser, bool check = true);
+
+	const std::string &Get_name() const
+	{
+		return this->name;
+	}
+	void Set_name (const std::string & s) {this->name = s;}
+	void Set_name (const char * s)
+	{
+		if (s != NULL)
+			this->name = std::string(s);
+		else
+			this->name.clear();
+	}
+
+	void totalize(Phreeqc * phreeqc_ptr);
+	const cxxNameDouble & Get_totals() const
+	{
+		return (this->totals);
+	};
+
+	cxxSScomp * Find(const char * comp_name);
+
+	void add(const cxxSS & comp, LDBLE extensive);
+	void multiply(LDBLE extensive);
+
+	LDBLE Get_total_moles(void) const {return total_moles;}
+	void Set_total_moles(LDBLE t) {total_moles = t;}
+
+	LDBLE Get_dn(void) const {return (this->dn);}
+	void Set_dn(LDBLE t) {this->dn = t;}
+
+	LDBLE Get_a0() const {return (this->a0);}
+	void Set_a0(LDBLE t) {a0 = t;}
+	LDBLE Get_a1() const {return (this->a1);}
+	void Set_a1(LDBLE t) {a1 = t;}
+	LDBLE Get_ag0() const {return (this->ag0);}
+	void Set_ag0(LDBLE t) {ag0 = t;}
+	LDBLE Get_ag1() const {return (this->ag1);}
+	void Set_ag1(LDBLE t) {ag1 = t;}
+	bool Get_ss_in() const {return (this->ss_in);}
+	void Set_ss_in(bool t) {ss_in = t;}
+	bool Get_miscibility() const {return (this->miscibility);}
+	void Set_miscibility(bool t) {miscibility = t;}
+	bool Get_spinodal() const {return (this->spinodal);}
+	void Set_spinodal(bool t) {spinodal = t;}
+	LDBLE Get_xb1() const {return (this->xb1);}
+	void Set_xb1(LDBLE t) {xb1 = t;}
+	LDBLE Get_xb2() const {return (this->xb2);}
+	void Set_xb2(LDBLE t) {xb2 = t;}
+	std::vector<cxxSScomp> & Get_ss_comps(void) {return ss_comps;}
+	const std::vector<cxxSScomp> & Get_ss_comps(void)const {return ss_comps;}
+	void Set_ss_comps(const std::vector<cxxSScomp> & comps) {ss_comps = comps;}
+
+	LDBLE Get_tk(void)const {return this->tk;}
+	void Set_tk(LDBLE t) {this->tk = t;}
+	SS_PARAMETER_TYPE Get_input_case(void)const {return this->input_case;}
+	void Set_input_case(SS_PARAMETER_TYPE t) {this->input_case = t;}
+	std::vector<LDBLE> & Get_p(void)             {return this->p;}
+	const std::vector<LDBLE> & Get_p(void)const  {return this->p;}
+	void Set_p(const std::vector<LDBLE> & t) {this->p = t;}
+	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:
+	std::string name;
+	// candidates for SOLID_SOLUTION_MODIFY
+	LDBLE ag0, ag1;
+	std::vector<cxxSScomp> ss_comps;
+
+	// SOLID_SOLUTION keyword data
+	LDBLE a0, a1;
+	bool miscibility;
+	bool spinodal;
+	LDBLE tk, xb1, xb2;
+	SS_PARAMETER_TYPE input_case;
+	std::vector<LDBLE> p;
+
+	// workspace variable
+	LDBLE total_moles;
+	LDBLE dn;
+	bool ss_in;
+	cxxNameDouble totals;
+	const static std::vector < std::string > vopts;
+public:
+
+};
+
+#endif // !defined(SSASSEMBLAGESS_H_INCLUDED)

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

@@ -0,0 +1,317 @@
+// SSassemblage.cxx: implementation of the cxxSSassemblage class.
+//
+//////////////////////////////////////////////////////////////////////
+#ifdef _DEBUG
+#pragma warning(disable : 4786)	// disable truncation warning (Only used by debugger)
+#endif
+#include <float.h>
+#include <cassert>				// assert
+#include <algorithm>			// std::sort
+
+#include "Utils.h"				// define first
+#include "Phreeqc.h"
+#include "SSassemblage.h"
+#include "SS.h"
+#include "cxxMix.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
+
+//////////////////////////////////////////////////////////////////////
+// Construction/Destruction
+//////////////////////////////////////////////////////////////////////
+
+cxxSSassemblage::cxxSSassemblage(PHRQ_io * io)
+	//
+	// default constructor for cxxSSassemblage 
+	//
+:	cxxNumKeyword(io)
+{
+	new_def = false;
+}
+
+cxxSSassemblage::cxxSSassemblage(const std::map < int,
+								 cxxSSassemblage > &entities, cxxMix & mix,
+								 int l_n_user, PHRQ_io * io):
+cxxNumKeyword(io)
+{
+	this->n_user = this->n_user_end = l_n_user;
+//
+//   Mix
+//
+	const std::map < int, LDBLE >&mixcomps = mix.Get_mixComps();
+	std::map < int, LDBLE >::const_iterator it;
+	for (it = mixcomps.begin(); it != mixcomps.end(); it++)
+	{
+		if (entities.find(it->first) != entities.end())
+		{
+			const cxxSSassemblage *entity_ptr =
+				&(entities.find(it->first)->second);
+			this->add(*entity_ptr, it->second);
+		}
+	}
+	this->new_def = false;
+}
+
+cxxSSassemblage::~cxxSSassemblage()
+{
+}
+
+void
+cxxSSassemblage::dump_raw(std::ostream & s_oss, unsigned int indent, int *n_out) const
+{
+	unsigned int i;
+	s_oss.precision(DBL_DIG - 1);
+	std::string indent0(""), indent1(""), indent2("");
+	for (i = 0; i < indent; ++i)
+		indent0.append(Utilities::INDENT);
+	for (i = 0; i < indent + 1; ++i)
+		indent1.append(Utilities::INDENT);
+	for (i = 0; i < indent + 2; ++i)
+		indent2.append(Utilities::INDENT);
+
+	// SSassemblage element and attributes
+	s_oss << indent0;
+	int n_user_local = (n_out != NULL) ? *n_out : this->n_user;
+	s_oss << "SOLID_SOLUTIONS_RAW          " << n_user_local << " " << this->description << "\n";
+
+	s_oss << indent1 << "# SOLID_SOLUTION_MODIFY candidate identifiers #\n";
+	// SSs
+	for (std::map < std::string, cxxSS >::const_iterator it =
+		 SSs.begin(); it != SSs.end(); ++it)
+	{
+		s_oss << indent1;
+		s_oss << "-solid_solution            " << it->first << "\n";
+		(*it).second.dump_raw(s_oss, indent + 2);
+	}
+
+	s_oss << indent1 << "# SOLID_SOLUTION candidate identifiers with new_def=true #\n";
+	s_oss << indent1;
+	s_oss << "-new_def                   " << (this->new_def ? 1 : 0) << "\n";
+
+	s_oss << indent1 << "# solid solution workspace variables #\n";
+	s_oss << indent1;
+	s_oss << "-SSassemblage_totals       " << "\n";
+	this->totals.dump_raw(s_oss, indent + 2);
+}
+void
+cxxSSassemblage::read_raw(CParser & parser, bool check)
+{
+
+	std::istream::pos_type ptr;
+	std::istream::pos_type next_char;
+	std::string token;
+	int opt_save;
+	bool useLastLine(false);
+	cxxSS *ss_ptr = NULL;
+
+	// Read SSassemblage number and description
+	this->read_number_description(parser);
+	this->Set_new_def(false);
+
+	opt_save = CParser::OPT_ERROR;
+
+	for (;;)
+	{
+		int opt;
+		if (useLastLine == false)
+		{
+			opt = parser.get_option(vopts, next_char);
+		}
+		else
+		{
+			opt = parser.getOptionFromLastLine(vopts, next_char, true);
+		}
+		if (opt == CParser::OPT_DEFAULT)
+		{
+			opt = opt_save;
+		}
+		useLastLine = false;
+		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 SOLID_SOLUTIONS_RAW or SOLID_SOLUTIONS_MODIFY keyword.",
+						  PHRQ_io::OT_CONTINUE);
+			parser.error_msg(parser.line().c_str(), PHRQ_io::OT_CONTINUE);
+			break;
+
+		case 0:				// solid_solution
+			{
+				std::string str;
+				if (!(parser.get_iss() >> str))
+				{
+						parser.incr_input_error();
+					parser.error_msg("Expected string value for solid solution name.",
+									 PHRQ_io::OT_CONTINUE);
+				}
+				cxxSS temp_ss(this->Get_io());
+				temp_ss.Set_name(str);
+				ss_ptr = this->Find(str);
+				if (ss_ptr)
+				{ 
+					temp_ss = *ss_ptr;
+				}
+				temp_ss.read_raw(parser, false);
+				this->SSs[str] = temp_ss;
+			}
+			useLastLine = true;
+			break;
+		case 1:				// totals
+			if (this->totals.read_raw(parser, next_char) !=
+				CParser::PARSER_OK)
+			{
+				parser.incr_input_error();
+				parser.
+					error_msg
+					("Expected element name and molality for SSassemblage totals.",
+					 PHRQ_io::OT_CONTINUE);
+			}
+			opt_save = 1;
+			break;
+		case 2:				// new_def
+			{
+				int i;
+				if (!(parser.get_iss() >> i))
+				{
+					parser.incr_input_error();
+					parser.error_msg("Expected 0/1 for new_def.", PHRQ_io::OT_CONTINUE);
+				}
+				else
+				{
+					this->new_def = (i == 0) ? false : true;
+				}
+			}
+			break;
+		}
+		if (opt == CParser::OPT_EOF || opt == CParser::OPT_KEYWORD)
+			break;
+	}
+}
+
+void
+cxxSSassemblage::totalize(Phreeqc * phreeqc_ptr)
+{
+	this->totals.clear();
+	// component structures
+	for (std::map < std::string, cxxSS >::iterator it =
+		 SSs.begin(); it != SSs.end(); ++it)
+	{
+		(*it).second.totalize(phreeqc_ptr);
+		this->totals.add_extensive((*it).second.Get_totals(), 1.0);
+	}
+	return;
+}
+void
+cxxSSassemblage::add(const cxxSSassemblage & addee, LDBLE extensive)
+		//
+		// Add to existing ssassemblage to "this" ssassemblage
+		//
+{
+	if (extensive == 0.0)
+		return;
+
+	for (std::map < std::string, cxxSS >::const_iterator itadd =
+		 addee.SSs.begin(); itadd != addee.SSs.end();
+		 ++itadd)
+	{
+		std::map < std::string, cxxSS >::iterator it =
+			this->SSs.find((*itadd).first);
+		if (it != this->SSs.end())
+		{
+			(*it).second.add((*itadd).second, extensive);
+		}
+		else
+		{
+			cxxSS entity = (*itadd).second;
+			entity.multiply(extensive);
+			std::string str(entity.Get_name());
+			this->SSs[str] = entity;
+		}
+	}
+}
+
+std::vector<cxxSS *> cxxSSassemblage::
+Vectorize(void)
+{
+	std::vector<cxxSS *> ss_v;
+	std::map<std::string, cxxSS>::iterator it;
+	for (it = this->SSs.begin(); it != this->SSs.end(); it++)
+	{
+		ss_v.push_back(&(it->second));
+	}
+	return ss_v;
+}
+cxxSS * cxxSSassemblage::
+Find(const std::string &s)
+{
+	std::map<std::string, cxxSS>::iterator it;
+	it = this->SSs.find(s);
+	if (it != this->SSs.end())
+		return &(it->second);
+	return NULL;
+}
+void
+cxxSSassemblage::Serialize(Dictionary & dictionary, std::vector < int >&ints, 
+	std::vector < double >&doubles)
+{
+	/* int n_user; */
+	ints.push_back(this->n_user);
+	{
+		ints.push_back((int) this->SSs.size());
+		std::map < std::string, cxxSS >::iterator it;
+		for (it = this->SSs.begin(); it != this->SSs.end();	it++)
+		{
+			(*it).second.Serialize(dictionary, ints, doubles);
+		}
+	}
+	ints.push_back(this->new_def ? 1 : 0);
+	this->totals.Serialize(dictionary, ints, doubles);
+}
+
+void
+cxxSSassemblage::Deserialize(Dictionary & dictionary, std::vector < int >&ints, 
+	std::vector < double >&doubles, int &ii, int &dd)
+{
+
+	this->n_user = ints[ii++];
+	this->n_user_end = this->n_user;
+	this->description = " ";
+	{
+		int count = ints[ii++];
+		this->SSs.clear();
+		for (int n = 0; n < count; n++)
+		{
+			cxxSS ssc(this->io);
+			ssc.Deserialize(dictionary, ints, doubles, ii, dd);
+			std::string str(ssc.Get_name());
+			this->SSs[str] = ssc;
+		}
+	}
+	this->new_def = (ints[ii++] != 0);
+	this->totals.Deserialize(dictionary, ints, doubles, ii, dd);
+
+}
+
+
+
+
+const std::vector< std::string >::value_type temp_vopts[] = {
+	std::vector< std::string >::value_type("solid_solution"),	    // 0
+	std::vector< std::string >::value_type("ssassemblage_totals"),	// 1
+	std::vector< std::string >::value_type("new_def") 	            // 2
+};									   
+const std::vector< std::string > cxxSSassemblage::vopts(temp_vopts, temp_vopts + sizeof temp_vopts / sizeof temp_vopts[0]);	

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

@@ -0,0 +1,59 @@
+#if !defined(SSASSEMBLAGE_H_INCLUDED)
+#define SSASSEMBLAGE_H_INCLUDED
+
+
+#include <cassert>				// assert
+#include <map>					// std::map
+#include <string>				// std::string
+#include <list>					// std::list
+#include <vector>				// std::vector
+
+#include "NumKeyword.h"
+#include "NameDouble.h"
+#include "SS.h"
+
+class cxxSS;
+
+//#include "cxxMix.h"
+class cxxMix;
+
+class cxxSSassemblage:public cxxNumKeyword
+{
+
+public:
+	cxxSSassemblage(PHRQ_io * io = NULL);
+	cxxSSassemblage(const std::map < int, cxxSSassemblage > &entity_map,
+		cxxMix & mx, int n_user, PHRQ_io * io = NULL);
+	~cxxSSassemblage();
+
+	//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::map < std::string, cxxSS > & Get_SSs(void) {return SSs;}
+	const std::map < std::string, cxxSS > & Get_SSs(void)const {return SSs;}
+	void Set_SSs(std::map < std::string, cxxSS > & ss) {SSs = ss;}
+	bool Get_new_def(void) const {return new_def;}
+	void Set_new_def(bool tf) {new_def = tf;}
+	std::vector<cxxSS *> Vectorize(void);
+	void add(const cxxSSassemblage & addee, LDBLE extensive);
+	cxxSS *Find(const std::string &s);
+	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:
+	// SOLID_SOLUTION_MODIFY candidate
+	std::map < std::string, cxxSS > SSs;
+	// SOLID_SOLUTION keyword data
+	bool new_def;
+	// internal variables
+	cxxNameDouble totals;
+	const static std::vector < std::string > vopts;
+};
+
+#endif // !defined(SSASSEMBLAGE_H_INCLUDED)