pyEQL 1.4.0rc9__cp311-cp311-macosx_11_0_arm64.whl

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

@@ -0,0 +1,42 @@
+#if !defined(TEMPERATURE_H_INCLUDED)
+#define TEMPERATURE_H_INCLUDED
+
+#include <cassert>				// assert
+#include <map>					// std::map
+#include <string>				// std::string
+#include <list>					// std::list
+#include <vector>				// std::vector
+
+#include "NumKeyword.h"
+
+class cxxTemperature:public cxxNumKeyword
+{
+
+  public:
+	cxxTemperature(PHRQ_io *io=NULL);
+	~cxxTemperature();
+
+	//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 = false);
+	int read(CParser & parser);
+	LDBLE Temperature_for_step(int step_number);
+	std::vector<LDBLE> & Get_temps(void) {return temps;}
+	const std::vector<LDBLE> & Get_temps(void)const {return temps;}
+	int Get_countTemps(void) const;
+	void Set_countTemps(int i) {countTemps = i;}
+	bool Get_equalIncrements(void) const {return equalIncrements;}
+	void Set_equalIncrements(bool tf) {equalIncrements = tf;}
+	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::vector < LDBLE >temps;
+	int countTemps;
+	bool equalIncrements;
+	const static std::vector < std::string > vopts;
+};
+
+#endif // !defined(TEMPERATURE_H_INCLUDED)

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

@@ -0,0 +1,78 @@
+#include <stdio.h>
+#include "Use.h"
+
+#if defined(PHREEQCI_GUI)
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+#endif
+
+cxxUse::cxxUse()
+{
+	this->init();
+
+}
+
+
+cxxUse::~cxxUse(void)
+{
+}
+void cxxUse::
+init(void)
+{
+	solution_in = false;
+	n_solution_user = -999;
+	solution_ptr = NULL;
+
+	pp_assemblage_in = false;
+	n_pp_assemblage_user = -999;
+	pp_assemblage_ptr = NULL;
+
+	mix_in = false;
+	n_mix_user = -999;
+	mix_ptr = NULL;
+	n_mix_user_orig = -999;
+
+	reaction_in = false;
+	n_reaction_user = -999;
+	reaction_ptr = NULL;
+
+	exchange_in = false;
+	n_exchange_user = -999;
+	exchange_ptr = NULL;
+
+	kinetics_in = false;
+	n_kinetics_user = -999;
+	kinetics_ptr = NULL;
+
+	surface_in = false;
+	n_surface_user = -999;
+	surface_ptr = NULL;
+
+	pressure_in = false;
+	n_pressure_user = -999;
+	pressure_ptr = NULL;
+
+	temperature_in = false;
+	n_temperature_user = -999;
+	temperature_ptr = NULL;
+
+	inverse_in = false;
+	n_inverse_user = -999;
+	inverse_ptr = NULL;
+
+	gas_phase_in = false;
+	n_gas_phase_user = -999;
+	gas_phase_ptr = NULL;
+
+	ss_assemblage_in = false;
+	n_ss_assemblage_user = -999;
+	ss_assemblage_ptr = NULL;
+
+	trans_in = false;
+	advect_in = false;
+}
+
+

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

@@ -0,0 +1,159 @@
+#if !defined(USE_H_INCLUDED)
+#define USE_H_INCLUDED
+class cxxPPassemblage;
+class cxxMix;
+class cxxReaction;
+class cxxExchange;
+class cxxGasPhase;
+class cxxPressure;
+class cxxTemperature;
+class cxxSSassemblage;
+class cxxKinetics;
+class cxxSurface;
+class cxxSolution;
+
+class cxxUse
+{
+public:
+	cxxUse();
+	virtual ~cxxUse(void);
+	void init(void);
+
+	bool Get_solution_in(void) const      {return this->solution_in;}
+	bool Get_pp_assemblage_in(void) const {return this->pp_assemblage_in;}
+	bool Get_mix_in(void) const           {return this->mix_in;}
+	bool Get_reaction_in(void) const      {return this->reaction_in;}
+	bool Get_exchange_in(void) const      {return this->exchange_in;}
+	bool Get_kinetics_in(void) const      {return this->kinetics_in;}
+	bool Get_surface_in(void) const       {return this->surface_in;}
+	bool Get_pressure_in(void) const      {return this->pressure_in;}
+	bool Get_temperature_in(void) const   {return this->temperature_in;}
+	bool Get_gas_phase_in(void) const     {return this->gas_phase_in;}
+	bool Get_inverse_in(void) const       {return this->inverse_in;}
+	bool Get_ss_assemblage_in(void) const {return this->ss_assemblage_in;}
+	bool Get_advect_in(void) const        {return this->advect_in;}
+	bool Get_trans_in(void) const         {return this->trans_in;}
+
+	void Set_solution_in(bool tf)         {solution_in = tf;}
+	void Set_pp_assemblage_in(bool tf)    {pp_assemblage_in = tf;}
+	void Set_mix_in(bool tf)              {mix_in = tf;}
+	void Set_reaction_in(bool tf)         {reaction_in = tf;}
+	void Set_exchange_in(bool tf)         {exchange_in = tf;}
+	void Set_kinetics_in(bool tf)         {kinetics_in = tf;}
+	void Set_surface_in(bool tf)          {surface_in = tf;}
+	void Set_pressure_in(bool tf)         {pressure_in = tf;}
+	void Set_temperature_in(bool tf)      {temperature_in = tf;}
+	void Set_gas_phase_in(bool tf)        {gas_phase_in = tf;}
+	void Set_inverse_in(bool tf)          {inverse_in = tf;}
+	void Set_ss_assemblage_in(bool tf)    {ss_assemblage_in = tf;}
+	void Set_advect_in(bool tf)           {advect_in = tf;}
+	void Set_trans_in(bool tf)            {trans_in = tf;}
+
+	int Get_n_solution_user(void) const       {return n_solution_user;}
+	int Get_n_pp_assemblage_user(void) const  {return n_pp_assemblage_user;}
+	int Get_n_mix_user(void) const            {return n_mix_user;}
+	int Get_n_mix_user_orig(void) const       {return n_mix_user_orig;}
+	int Get_n_reaction_user(void) const       {return n_reaction_user;}
+	int Get_n_exchange_user(void) const       {return n_exchange_user;}
+	int Get_n_kinetics_user(void) const       {return n_kinetics_user;}
+	int Get_n_surface_user(void) const        {return n_surface_user;}
+	int Get_n_pressure_user(void) const       {return n_pressure_user;}
+	int Get_n_temperature_user(void) const    {return n_temperature_user;}
+	int Get_n_gas_phase_user(void) const      {return n_gas_phase_user;}
+	int Get_n_inverse_user(void) const        {return n_inverse_user;}
+	int Get_n_ss_assemblage_user(void) const  {return n_ss_assemblage_user;}
+
+	void Set_n_solution_user(int i)       {n_solution_user = i;}
+	void Set_n_pp_assemblage_user(int i)  {n_pp_assemblage_user = i;}
+	void Set_n_mix_user(int i)            {n_mix_user = i;}
+	void Set_n_mix_user_orig(int i)       {n_mix_user_orig = i;}
+	void Set_n_reaction_user(int i)       {n_reaction_user = i;}
+	void Set_n_exchange_user(int i)       {n_exchange_user = i;}
+	void Set_n_kinetics_user(int i)       {n_kinetics_user = i;}
+	void Set_n_surface_user(int i)        {n_surface_user = i;}
+	void Set_n_pressure_user(int i)       {n_pressure_user = i;}
+	void Set_n_temperature_user(int i)    {n_temperature_user = i;}
+	void Set_n_gas_phase_user(int i)      {n_gas_phase_user = i;}
+	void Set_n_inverse_user(int i)        {n_inverse_user = i;}
+	void Set_n_ss_assemblage_user(int i)  {n_ss_assemblage_user = i;}
+
+	cxxSolution * Get_solution_ptr(void) const               {return this->solution_ptr;}
+	cxxPPassemblage * Get_pp_assemblage_ptr(void) const      {return this->pp_assemblage_ptr;}
+	cxxMix * Get_mix_ptr(void) const                         {return this->mix_ptr;}
+	cxxReaction * Get_reaction_ptr(void) const               {return this->reaction_ptr;}
+	cxxExchange * Get_exchange_ptr(void) const               {return this->exchange_ptr;}
+	cxxKinetics * Get_kinetics_ptr(void) const               {return this->kinetics_ptr;}
+	cxxSurface * Get_surface_ptr(void) const                 {return this->surface_ptr;}
+	cxxPressure * Get_pressure_ptr(void) const               {return this->pressure_ptr;}
+	cxxTemperature * Get_temperature_ptr(void) const         {return this->temperature_ptr;}
+	cxxGasPhase * Get_gas_phase_ptr(void) const              {return this->gas_phase_ptr;}
+	class inverse * Get_inverse_ptr(void) const             {return this->inverse_ptr;}
+	cxxSSassemblage * Get_ss_assemblage_ptr(void)            {return this->ss_assemblage_ptr;}
+
+	void Set_solution_ptr(cxxSolution * p)                   {this->solution_ptr = p;}
+	void Set_pp_assemblage_ptr(cxxPPassemblage * p)          {this->pp_assemblage_ptr = p;}
+	void Set_mix_ptr(cxxMix * p)                             {this->mix_ptr = p;}
+	void Set_reaction_ptr(cxxReaction * p)                   {this->reaction_ptr = p;}
+	void Set_exchange_ptr(cxxExchange * p)                   {this->exchange_ptr = p;}
+	void Set_kinetics_ptr(cxxKinetics * p)                   {this->kinetics_ptr = p;}
+	void Set_surface_ptr(cxxSurface * p)                     {this->surface_ptr = p;}
+	void Set_pressure_ptr(cxxPressure * p)                   {this->pressure_ptr = p;}
+	void Set_temperature_ptr(cxxTemperature * p)             {this->temperature_ptr = p;}
+	void Set_gas_phase_ptr(cxxGasPhase * p)                  {this->gas_phase_ptr = p;}
+	void Set_inverse_ptr(class inverse * p)                 {this->inverse_ptr = p;}
+	void Set_ss_assemblage_ptr(cxxSSassemblage * p)     {this->ss_assemblage_ptr = p;}
+
+protected:
+	bool solution_in;
+	int n_solution_user;
+	cxxSolution *solution_ptr;
+
+	bool pp_assemblage_in;
+	int n_pp_assemblage_user;
+	cxxPPassemblage *pp_assemblage_ptr;
+
+	bool mix_in;
+	int n_mix_user;
+	cxxMix * mix_ptr;
+	int n_mix_user_orig;
+
+	bool reaction_in;
+	int n_reaction_user;
+	cxxReaction * reaction_ptr;
+
+	bool exchange_in;
+	int n_exchange_user;
+	cxxExchange * exchange_ptr;
+
+	bool kinetics_in;
+	int n_kinetics_user;
+	cxxKinetics *kinetics_ptr;
+
+	bool surface_in;
+	int n_surface_user;
+	cxxSurface *surface_ptr;
+
+	bool pressure_in;
+	int n_pressure_user;
+	cxxPressure *pressure_ptr;
+
+	bool temperature_in;
+	int n_temperature_user;
+	cxxTemperature *temperature_ptr;
+
+	bool inverse_in;
+	int n_inverse_user;
+	class inverse *inverse_ptr;
+
+	bool gas_phase_in;
+	int n_gas_phase_user;
+	cxxGasPhase * gas_phase_ptr;
+
+	bool ss_assemblage_in;
+	int n_ss_assemblage_user;
+	cxxSSassemblage *ss_assemblage_ptr;
+
+	bool trans_in;
+	bool advect_in;
+};
+#endif // !defined(USE_H_INCLUDED)

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

@@ -0,0 +1,32 @@
+#include "UserPunch.h"
+#include "Phreeqc.h"
+
+#if defined(PHREEQCI_GUI)
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+#endif
+
+UserPunch::UserPunch(int n, PHRQ_io *io)
+:	cxxNumKeyword(io)
+{
+	this->PhreeqcPtr    = NULL;
+	this->rate          = NULL;
+}
+
+
+UserPunch::~UserPunch(void)
+{
+	if (this->rate != NULL)
+	{
+		if (this->PhreeqcPtr != NULL)
+		{
+			this->PhreeqcPtr->rate_free(this->rate);
+			delete this->rate;
+		}
+	}
+	this->PhreeqcPtr = NULL;
+	this->rate = NULL;
+}

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

@@ -0,0 +1,39 @@
+#if !defined(USERPUNCH_H_INCLUDED)
+#define USERPUNCH_H_INCLUDED
+#include <vector>
+#include <string>				// std::string
+#include "NumKeyword.h"
+class Phreeqc;
+class UserPunch:public cxxNumKeyword
+{
+public:
+	UserPunch(int n=1, PHRQ_io *io=NULL);
+	~UserPunch(void);
+
+	// headings
+	//
+	std::vector <std::string> &Get_headings() {return this->headings;}
+	const std::vector <std::string> &Get_headings()const {return this->headings;}
+
+	void Set_headings(std::vector <std::string> & h) {this->headings = h;}
+
+	// phreeqc pointer
+	//
+	Phreeqc * Get_PhreeqcPtr() {return this->PhreeqcPtr;}
+	const Phreeqc * Get_PhreeqcPtr()const {return this->PhreeqcPtr;}
+
+	void Set_PhreeqcPtr(Phreeqc * p) {this->PhreeqcPtr = p;}
+
+	// rate
+	//
+	class rate * Get_rate() {return this->rate;}
+	const class rate * Get_rate()const {return this->rate;}
+
+	void Set_rate(class rate * r) {this->rate = r;}
+
+protected:
+	std::vector <std::string> headings;
+	class rate *             rate;
+	Phreeqc *                 PhreeqcPtr;
+};
+#endif // !defined(USERPUNCH_H_INCLUDED)

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

@@ -0,0 +1,140 @@
+#include "Utils.h"
+#include "Phreeqc.h"
+#include "phqalloc.h"
+#include "cxxKinetics.h"
+#include "Solution.h"
+
+
+#if defined(PHREEQCI_GUI)
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+#endif
+
+/* ---------------------------------------------------------------------- */
+int Phreeqc::
+advection(void)
+/* ---------------------------------------------------------------------- */
+{
+	int i;
+	LDBLE kin_time;
+/*
+ *   Calculate advection
+ */
+	state = ADVECTION;
+/*	mass_water_switch = TRUE; */
+/*
+ *   Check existence of all solutions
+ */
+	for (i = 0; i <= count_ad_cells; i++)
+	{
+		if (Utilities::Rxn_find(Rxn_solution_map, i) == NULL)
+		//if (solution_bsearch(i, &n, TRUE) == NULL)
+		{
+			input_error++;
+			error_string = sformatf(
+					"Solution %d is needed for advection, but is not defined.",
+					i);
+			error_msg(error_string, CONTINUE);
+		}
+	}
+/*
+ *   Check kinetics logic
+ */
+	kin_time = advection_kin_time;
+	if (kin_time <= 0.0)
+	{
+		for (i = 1; i <= count_ad_cells; i++)
+		{
+			if (Utilities::Rxn_find(Rxn_kinetics_map, i) != NULL)
+			{
+				input_error++;
+				error_string = sformatf(
+						"KINETIC reaction(s) defined, but time_step is not defined in ADVECTION keyword.");
+				error_msg(error_string, CONTINUE);
+				break;
+			}
+		}
+	}
+/*
+ *   Quit on error
+ */
+	if (get_input_errors() > 0)
+	{
+		error_msg("Program terminating due to input errors.", STOP);
+	}
+/*
+ *   Equilibrate solutions with phases, exchangers, surfaces
+ */
+	last_model.force_prep = true;
+	rate_sim_time_start = 0;
+	for (advection_step = 1; advection_step <= count_ad_shifts;
+		 advection_step++)
+	{
+		log_msg(sformatf(
+				   "\nBeginning of advection time step %d, cumulative pore volumes %f.\n",
+				   advection_step,
+				   (double) (((LDBLE) advection_step) /
+							 ((LDBLE) count_ad_cells))));
+		if (pr.use == TRUE && pr.all == TRUE)
+		{
+			output_msg(sformatf(
+					   "Beginning of advection time step %d, cumulative pore volumes %f.\n",
+					   advection_step,
+					   (double) (((LDBLE) advection_step) /
+								 ((LDBLE) count_ad_cells))));
+		}
+/*
+ *  Advect
+ */
+		for (i = count_ad_cells; i > 0; i--)
+		{
+			//solution_duplicate(i - 1, i);
+			Utilities::Rxn_copy(Rxn_solution_map, i -1, i);
+		}
+/*
+ *  Equilibrate and (or) mix
+ */
+		for (int i = 1; i <= count_ad_cells; i++)
+		{
+			set_initial_moles(i);
+			cell_no = i;
+			set_advection(i, TRUE, TRUE, i);
+			run_reactions(i, kin_time, TRUE, 1.0);
+			if (advection_kin_time_defined == TRUE)
+			{
+				rate_sim_time = rate_sim_time_start + kin_time;
+			}
+			log_msg(sformatf( "\nCell %d.\n\n", i));
+			if (pr.use == TRUE && pr.all == TRUE &&
+				advection_step % print_ad_modulus == 0 &&
+				advection_print[(size_t)i - 1] == TRUE)
+			{
+				output_msg(sformatf( "\nCell %d.\n\n", i));
+			}
+			if (advection_step % punch_ad_modulus == 0 &&
+				advection_punch[(size_t)i - 1] == TRUE)
+			{
+				punch_all();
+			}
+			if (advection_step % print_ad_modulus == 0 &&
+				advection_print[(size_t)i - 1] == TRUE)
+			{
+				print_all();
+			}
+			if (i > 1)
+				Utilities::Rxn_copy(Rxn_solution_map, -2, i - 1);
+				//solution_duplicate(-2, i - 1);
+			saver();
+		}
+		Utilities::Rxn_copy(Rxn_solution_map, -2, count_ad_cells);
+		//solution_duplicate(-2, count_ad_cells);
+		rate_sim_time_start += kin_time;
+	}
+	initial_total_time += rate_sim_time_start;
+	/* free_model_allocs(); */
+	mass_water_switch = FALSE;
+	return (OK);
+}