pyEQL 1.4.0rc9__cp311-cp311-win_amd64.whl

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

@@ -0,0 +1,141 @@
+#if !defined(STORAGEBIN_H_INCLUDED)
+#define STORAGEBIN_H_INCLUDED
+#include <cassert>				// assert
+#include <map>					// std::map
+#include <string>				// std::string
+#include <list>					// std::list
+#include <vector>				// std::vector
+
+#include "System.h"
+#include "PHRQ_io.h"
+#include "PHRQ_base.h"
+class cxxSolution;
+class cxxExchange;
+class cxxGasPhase;
+class cxxKinetics;
+class cxxPPassemblage;
+class cxxSSassemblage;
+class cxxSurface;
+class cxxReaction;
+class cxxTemperature;
+class cxxUse;
+
+class cxxStorageBin: public PHRQ_base
+{
+
+  public:
+	cxxStorageBin(PHRQ_io *io=NULL);
+	cxxStorageBin(cxxUse &use_ref, PHRQ_io *io=NULL);
+	virtual ~cxxStorageBin();
+
+	void Copy(int destination, int source);
+	void Remove(int n);
+	void Clear(void);
+
+	cxxSolution *Get_Solution(int n_user);
+	void Set_Solution(int n_user, cxxSolution * entity);
+	void Set_Solution(int n_user, cxxSolution & entity);
+	void Remove_Solution(int n_user);
+
+	cxxExchange *Get_Exchange(int n_user);
+	void Set_Exchange(int n_user, cxxExchange * entity);
+	void Set_Exchange(int n_user, cxxExchange & entity);
+	void Remove_Exchange(int n_user);
+
+	cxxPPassemblage *Get_PPassemblage(int n_user);
+	void Set_PPassemblage(int n_user, cxxPPassemblage * entity);
+	void Set_PPassemblage(int n_user, cxxPPassemblage & entity);
+	void Remove_PPassemblage(int n_user);
+
+	cxxGasPhase *Get_GasPhase(int n_user);
+	void Set_GasPhase(int n_user, cxxGasPhase * entity);
+	void Set_GasPhase(int n_user, cxxGasPhase & entity);
+	void Remove_GasPhase(int n_user);
+
+	cxxSSassemblage *Get_SSassemblage(int n_user);
+	void Set_SSassemblage(int n_user, cxxSSassemblage * entity);
+	void Set_SSassemblage(int n_user, cxxSSassemblage & entity);
+	void Remove_SSassemblage(int n_user);
+
+	cxxKinetics *Get_Kinetics(int n_user);
+	void Set_Kinetics(int n_user, cxxKinetics * entity);
+	void Set_Kinetics(int n_user, cxxKinetics & entity);
+	void Remove_Kinetics(int n_user);
+
+	cxxSurface *Get_Surface(int n_user);
+	void Set_Surface(int n_user, cxxSurface * entity);
+	void Set_Surface(int n_user, cxxSurface & entity);
+	void Remove_Surface(int n_user);
+
+	cxxMix *Get_Mix(int n_user);
+	void Set_Mix(int n_user, cxxMix * entity);
+	void Set_Mix(int n_user, cxxMix & entity);
+	void Remove_Mix(int n_user);
+
+	cxxReaction *Get_Reaction(int n_user);
+	void Set_Reaction(int n_user, cxxReaction * entity);
+	void Set_Reaction(int n_user, cxxReaction & entity);
+	void Remove_Reaction(int n_user);
+
+	cxxTemperature *Get_Temperature(int n_user);
+	void Set_Temperature(int n_user, cxxTemperature * entity);
+	void Set_Temperature(int n_user, cxxTemperature & entity);
+	void Remove_Temperature(int n_user);
+
+	cxxPressure *Get_Pressure(int n_user);
+	void Set_Pressure(int n_user, cxxPressure * entity);
+	void Set_Pressure(int n_user, cxxPressure & entity);
+	void Remove_Pressure(int n_user);
+
+	cxxSystem &Get_System(void);
+	void Set_System(cxxUse *use_ptr);
+	void Set_System(int i);
+
+	void dump_raw(std::ostream & s_oss, unsigned int indent) const;
+
+	void dump_raw(std::ostream & s_oss, int i, unsigned int indent, int *n_out=NULL);
+	void dump_raw_range(std::ostream & s_oss, int start, int end, unsigned int indent) const;
+
+	void read_raw(CParser & parser);
+	int read_raw_keyword(CParser & parser);
+
+	void Add(cxxStorageBin &src, int n);
+	void Add_uz(cxxStorageBin &uzbin);
+
+	//cxxSolution *mix_cxxSolutions(cxxMix &mixmap);
+	cxxExchange *mix_cxxExchange(cxxMix & mixmap);
+
+	std::map < int, cxxSolution > &Get_Solutions();
+	std::map < int, cxxExchange > &Get_Exchangers();
+	std::map < int, cxxGasPhase > &Get_GasPhases();
+	std::map < int, cxxKinetics > &Get_Kinetics();
+	std::map < int, cxxPPassemblage > &Get_PPassemblages();
+	std::map < int, cxxSSassemblage > &Get_SSassemblages();
+	std::map < int, cxxSurface > &Get_Surfaces();
+	std::map < int, cxxMix > &Get_Mixes();
+	std::map < int, cxxReaction > &Get_Reactions();
+	std::map < int, cxxTemperature > &Get_Temperatures();
+	std::map < int, cxxPressure > &Get_Pressures();
+
+	cxxSystem & Get_system(void) {return system;};
+
+  protected:
+	// Tidied classes
+	std::map < int, cxxSolution > Solutions;
+	std::map < int, cxxExchange > Exchangers;
+	std::map < int, cxxGasPhase > GasPhases;
+	std::map < int, cxxKinetics > Kinetics;
+	std::map < int, cxxPPassemblage > PPassemblages;
+	std::map < int, cxxSSassemblage > SSassemblages;
+	std::map < int, cxxSurface > Surfaces;
+
+	// Reaction classes
+	std::map < int, cxxMix > Mixes;
+	std::map < int, cxxReaction > Reactions;
+	std::map < int, cxxTemperature > Temperatures;
+	std::map < int, cxxPressure > Pressures;
+	cxxSystem system;
+
+};
+
+#endif // !defined(STORAGEBIN_H_INCLUDED)

pyEQL/phreeqc/ext/iphreeqc-3.8.6-17100/src/phreeqcpp/StorageBinList.cpp

@@ -0,0 +1,358 @@
+#include <algorithm>			// std::replace
+#include "StorageBinList.h"
+#include "Parser.h"
+
+#if defined(PHREEQCI_GUI)
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+#endif
+
+StorageBinListItem::StorageBinListItem(void)
+{
+	this->defined = false;
+}
+
+StorageBinListItem::~StorageBinListItem(void)
+{
+}
+StorageBinListItem::StorageBinListItem(CParser & parser)
+{
+	this->Clear();
+	// Read list of numbers or number ranges 
+	for (;;)
+	{
+		//read lines
+		PHRQ_io::LINE_TYPE l = parser.check_line("read StorageBinListLtem", false, true, true, true);
+		std::istream::pos_type next_char = 0;
+		if (l == PHRQ_io::LT_EOF) break;
+		for (;;)
+		{ 
+			std::string token;
+			CParser::TOKEN_TYPE j = parser.copy_token(token, next_char);
+			if (j == CParser::TT_DIGIT)
+			{
+				this->Augment(token);
+			}
+			else if (j == CParser::TT_EMPTY)
+			{
+				break;
+			}
+		}
+	}
+}
+void StorageBinListItem::Augment(std::string token)
+{
+	this->defined = true;
+	if (token.size() == 0) return;
+
+	// split string accounting for possible negative numbers
+	size_t pos;
+	if ((pos = token.find("--")) != std::string::npos)
+	{
+		token.replace(pos,2," &");
+	}
+	std::replace(token.begin() + 1, token.end(), '-', ' ');
+	std::replace(token.begin() + 1, token.end(), '&', '-');
+
+	// parse string into 1 or 2 numbers
+	std::istringstream iss(token);
+	std::set < int > temp_set;
+	int i;
+	if (iss >> i)
+	{
+		// add first 
+		temp_set.insert(i);
+		if (iss >> i)
+		{
+			// add second if defined
+			temp_set.insert(i);
+		}
+	}
+
+	// add single number or range to StorageBinListItem
+	if (temp_set.size() == 1)
+	{
+		this->numbers.insert(*(temp_set.begin()));
+	}
+	else if (temp_set.size() == 2)
+	{
+		int i1, i2;
+		std::set <int>::iterator it;
+		it = temp_set.begin();
+		i1 = *it;
+		it++;
+		i2 = *it;
+		for (i = i1; i <= i2; i++)
+		{
+			this->numbers.insert(i);
+		}
+	}
+}
+void StorageBinListItem::Augment(int i)
+{
+	// Skip if all are defined
+	if (this->defined == true && this->numbers.size() ==  0) return;
+	this->defined = true;
+	this->numbers.insert(i);
+}
+//
+//Class definitions for StorageBinList
+//
+StorageBinList::StorageBinList(PHRQ_io *io)
+:
+PHRQ_base(io)
+{
+}
+StorageBinList::StorageBinList(CParser & parser, PHRQ_io *io)
+:
+PHRQ_base(io)
+{
+	this->Read(parser);
+}
+StorageBinList::~StorageBinList(void)
+{
+}
+
+std::set<StorageBinListItem *> StorageBinList::GetAllItems(void)
+{
+	// don't include this->cell
+	std::set<StorageBinListItem *> items;
+	items.insert(&this->solution);
+	items.insert(&this->pp_assemblage);
+	items.insert(&this->exchange);
+	items.insert(&this->surface);
+	items.insert(&this->ss_assemblage);
+	items.insert(&this->gas_phase);
+	items.insert(&this->kinetics);
+	items.insert(&this->mix);
+	items.insert(&this->reaction);
+	items.insert(&this->temperature);
+	items.insert(&this->pressure);
+	return items;
+}
+
+void StorageBinList::SetAll(bool tf)
+{
+	std::set<StorageBinListItem *> all = this->GetAllItems();
+	std::set<StorageBinListItem *>::iterator it = all.begin();
+	for (; it != all.end(); ++it)
+	{
+		(*it)->Clear();
+		(*it)->Set_defined(tf);
+	}
+}
+
+bool StorageBinList::Read(CParser & parser)
+{
+	bool return_value(true);
+
+	std::istream::pos_type next_char;
+	std::string token;
+	int opt_save;
+
+	opt_save = CParser::OPT_DEFAULT;
+	// reset cells
+	this->cell.Clear();
+	this->cell.Set_defined(false);
+	for (;;)
+	{
+		int opt;
+		opt = parser.get_option(vopts, next_char);
+		if (opt == CParser::OPT_DEFAULT)
+		{
+			opt = opt_save;
+		}
+		else
+		{
+			opt_save = opt;
+		}
+
+		// Select StorageBinListItem
+		StorageBinListItem *item = NULL;
+		switch (opt)
+		{
+		case 0:
+			item = &(this->Get_solution());
+			break;
+		case 1:
+		case 2:
+			item = &(this->Get_pp_assemblage());
+			break;
+		case 3:
+			item = &(this->Get_exchange());
+			break;
+		case 4:
+			item = &(this->Get_surface());
+			break;
+		case 5:
+		case 6:
+		case 7:
+			item = &(this->Get_ss_assemblage());
+			break;
+		case 8:
+			item = &(this->Get_gas_phase());
+			break;
+		case 9:
+			item = &(this->Get_kinetics());
+			break;
+		case 10:
+			item = &(this->Get_mix());
+			break;
+		case 11:
+			item = &(this->Get_reaction());
+			break;
+		case 12:
+		case 16:
+			item = &(this->Get_temperature());
+			break;
+		case 14:
+		case 15:
+			item = &(this->Get_cell());
+			break;
+		case 17:
+		case 18:
+			item = &(this->Get_pressure());
+			break;
+		default:
+			break;
+		}
+
+		// Read dump entity list of numbers or number ranges for line, store in item
+		if ((opt >= 0 && opt <= 12) || (opt >= 14))
+		{
+			for (;;)
+			{ 
+				CParser::TOKEN_TYPE j = parser.copy_token(token, next_char);
+				if (item)
+				{
+					if (j == CParser::TT_DIGIT)
+					{
+						item->Augment(token);
+					}
+					else if (j == CParser::TT_EMPTY)
+					{
+						item->Augment(token);
+						break;
+					}
+					else
+					{
+						parser.error_msg("Expected single number or range of numbers.",
+							PHRQ_io::OT_CONTINUE);
+						break;
+					}
+				}
+				else
+				{
+						parser.error_msg("Dump entity type not defined.",
+							PHRQ_io::OT_CONTINUE);
+						break;
+				}
+			}
+		}
+
+		// Process other identifiers
+		switch (opt)
+		{
+		case CParser::OPT_EOF:
+			break;
+		case CParser::OPT_KEYWORD:
+			break;
+
+		case 0:
+		case 1:
+		case 2:
+		case 3:
+		case 4:
+		case 5:
+		case 6:
+		case 7:
+		case 8:
+		case 9:
+		case 10:
+		case 11:
+		case 12:
+		case 16:
+		case 17:
+		case 18:
+			break;
+		case 13:			//all
+			this->SetAll(true);
+			break;
+		case 14:
+		case 15:
+			//if (cell_list.Get_numbers().empty())
+			//{
+			//	this->SetAll(true);
+			//}
+			//else
+			//{
+				//this->TransferAll(cell_list);
+			//}
+			break;
+		default:
+		case CParser::OPT_DEFAULT:
+		case CParser::OPT_ERROR:
+			opt = CParser::OPT_EOF;
+			parser.error_msg("Unknown input reading DELETE definition.",
+							 PHRQ_io::OT_CONTINUE);
+			parser.error_msg(parser.line().c_str(), PHRQ_io::OT_CONTINUE);
+			return_value = false;
+			break;
+		}
+		if (opt == CParser::OPT_EOF || opt == CParser::OPT_KEYWORD)
+			break;
+	}
+
+	// Now check to see if cell_list defined 
+	if (this->Get_cell().Get_defined())
+	{
+		if (this->Get_cell().Get_numbers().empty())
+		{
+			this->SetAll(true);
+		}
+		else
+		{
+			this->TransferAll(this->Get_cell());
+		}
+	}
+	return(return_value);
+}
+
+void StorageBinList::TransferAll(StorageBinListItem &source)
+{
+	std::set<StorageBinListItem *> items = this->GetAllItems();
+	std::set < int >::iterator it;
+	for (it = source.Get_numbers().begin(); it != source.Get_numbers().end(); it++)
+	{
+		std::set<StorageBinListItem *>::iterator item = items.begin();
+		for (; item != items.end(); ++item)
+		{
+			(*item)->Augment(*it);
+		}
+	}
+}
+const std::vector< std::string >::value_type temp_vopts[] = {
+	std::vector< std::string >::value_type("solution"),			       // 0 
+	std::vector< std::string >::value_type("pp_assemblage"),		   // 1 
+	std::vector< std::string >::value_type("equilibrium_phases"),	   // 2 
+	std::vector< std::string >::value_type("exchange"),			       // 3 
+	std::vector< std::string >::value_type("surface"),			       // 4 
+	std::vector< std::string >::value_type("ss_assemblage"),		   // 5 
+	std::vector< std::string >::value_type("solid_solution"),		   // 6 
+	std::vector< std::string >::value_type("solid_solutions"),		   // 7 
+	std::vector< std::string >::value_type("gas_phase"),			   // 8 
+	std::vector< std::string >::value_type("kinetics"),			       // 9 
+	std::vector< std::string >::value_type("mix"),				       // 10
+	std::vector< std::string >::value_type("reaction"),			       // 11
+	std::vector< std::string >::value_type("temperature"),			   // 12
+	std::vector< std::string >::value_type("all"),   			       // 13
+	std::vector< std::string >::value_type("cell"),			           // 14
+	std::vector< std::string >::value_type("cells"), 			       // 15
+	std::vector< std::string >::value_type("reaction_temperature"),	   // 16
+	std::vector< std::string >::value_type("pressure"),			       // 17
+	std::vector< std::string >::value_type("reaction_pressure") 	   // 18 
+};									   
+const std::vector< std::string > StorageBinList::vopts(temp_vopts, temp_vopts + sizeof temp_vopts / sizeof temp_vopts[0]);	

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

@@ -0,0 +1,81 @@
+#if !defined(STORAGEBINLIST_H_INCLUDED)
+#define STORAGEBINLIST_H_INCLUDED
+#include <set>                  // std::set
+#include <string>               // std::string
+#include <list>                 // std::list
+#include <vector>               // std::vector
+#include "PHRQ_base.h"
+class CParser;
+
+class StorageBinListItem
+{
+public:
+	StorageBinListItem(void);
+	StorageBinListItem(CParser & parser);
+	~StorageBinListItem(void);
+	void Set_defined(bool tf) { this->defined = tf; };
+	bool Get_defined(void)const { return(this->defined); };
+	void Augment(std::string token);
+	void Augment(int i);
+	std::set < int > &Get_numbers(void) { return(this->numbers); };
+	const std::set < int > &Get_numbers(void)const { return(this->numbers); };
+	void Clear(void) { this->numbers.clear(); };
+protected:
+	std::set < int > numbers;
+	bool defined;
+};
+class StorageBinList: public PHRQ_base
+{
+public:
+	StorageBinList(PHRQ_io *io=NULL);
+	StorageBinList(CParser & parser, PHRQ_io *io=NULL);
+	virtual ~StorageBinList(void);
+	bool Read(CParser & parser);
+	void SetAll(bool tf);
+	void TransferAll(StorageBinListItem &source);
+	std::set<StorageBinListItem *> GetAllItems(void);
+
+	StorageBinListItem & Get_solution(void)      { return(this->solution); };
+	StorageBinListItem & Get_pp_assemblage(void) { return(this->pp_assemblage); };
+	StorageBinListItem & Get_exchange(void)      { return(this->exchange); };
+	StorageBinListItem & Get_surface(void)       { return(this->surface); };
+	StorageBinListItem & Get_ss_assemblage(void) { return(this->ss_assemblage); };
+	StorageBinListItem & Get_gas_phase(void)     { return(this->gas_phase); };
+	StorageBinListItem & Get_kinetics(void)      { return(this->kinetics); };
+	StorageBinListItem & Get_mix(void)           { return(this->mix); };
+	StorageBinListItem & Get_reaction(void)      { return(this->reaction); };
+	StorageBinListItem & Get_temperature(void)   { return(this->temperature); };
+	StorageBinListItem & Get_pressure(void)      { return(this->pressure); };
+	StorageBinListItem & Get_cell(void)          { return(this->cell); };
+
+	const StorageBinListItem & Get_solution(void)const      { return(this->solution); };
+	const StorageBinListItem & Get_pp_assemblage(void)const { return(this->pp_assemblage); };
+	const StorageBinListItem & Get_exchange(void)const      { return(this->exchange); };
+	const StorageBinListItem & Get_surface(void)const       { return(this->surface); };
+	const StorageBinListItem & Get_ss_assemblage(void)const { return(this->ss_assemblage); };
+	const StorageBinListItem & Get_gas_phase(void)const     { return(this->gas_phase); };
+	const StorageBinListItem & Get_kinetics(void)const      { return(this->kinetics); };
+	const StorageBinListItem & Get_mix(void)const           { return(this->mix); };
+	const StorageBinListItem & Get_reaction(void)const      { return(this->reaction); };
+	const StorageBinListItem & Get_temperature(void)const   { return(this->temperature); };
+	const StorageBinListItem & Get_pressure(void)const      { return(this->pressure); };
+	const StorageBinListItem & Get_cell(void)const          { return(this->cell); };
+protected:
+	// update GetAllItems() if StorageBinListItem is added/removed
+	StorageBinListItem solution;
+	StorageBinListItem pp_assemblage;
+	StorageBinListItem exchange;
+	StorageBinListItem surface;
+	StorageBinListItem ss_assemblage;
+	StorageBinListItem gas_phase;
+	StorageBinListItem kinetics;
+	StorageBinListItem mix;
+	StorageBinListItem reaction;
+	StorageBinListItem temperature;
+	StorageBinListItem pressure;
+	const static std::vector < std::string > vopts;
+	StorageBinListItem cell; // not included in GetAllItems
+};
+
+
+#endif // !defined(STORAGEBINLIST_H_INCLUDED)