pyEQL 1.4.0rc9__cp311-cp311-macosx_11_0_arm64.whl

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

@@ -0,0 +1,617 @@
+// SurfaceCharge.cxx: implementation of the cxxSurfaceCharge class.
+//
+//////////////////////////////////////////////////////////////////////
+#ifdef _DEBUG
+#pragma warning(disable : 4786)	// disable truncation warning (Only used by debugger)
+#endif
+#include <cassert>				// assert
+#include <algorithm>			// std::sort
+
+#include "Utils.h"				// define first
+#include "Phreeqc.h"
+#include "SurfaceCharge.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
+//////////////////////////////////////////////////////////////////////
+
+cxxSurfaceCharge::cxxSurfaceCharge(PHRQ_io *io)
+:
+PHRQ_base(io)
+//
+// default constructor for cxxSurfaceCharge 
+//
+{
+	specific_area = 0.0;
+	grams = 0.0;
+	charge_balance = 0.0;
+	mass_water = 0.0;
+	DDL_viscosity = 0.0;
+	f_free = 0.0;
+	la_psi = 0.0;
+	capacitance[0] = 1.0;
+	capacitance[1] = 5.0;
+	sigma0 = sigma1 = sigma2 = sigmaddl = 0;
+	diffuse_layer_totals.type = cxxNameDouble::ND_ELT_MOLES;
+}
+cxxSurfaceCharge::~cxxSurfaceCharge()
+{
+}
+
+void
+cxxSurfaceCharge::dump_xml(std::ostream & s_oss, unsigned int indent) 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);
+
+	// Surf_Charge element and attributes
+	s_oss << indent0 << "name=\"" << this->name << "\"" << "\n";
+	s_oss << indent0 << "specific_area=\"" << this->
+		specific_area << "\"" << "\n";
+	s_oss << indent0 << "grams=\"" << this->grams << "\"" << "\n";
+	s_oss << indent0 << "charge_balance=\"" << this->
+		charge_balance << "\"" << "\n";
+	s_oss << indent0 << "mass_water=\"" << this->
+		mass_water << "\"" << "\n";
+	s_oss << indent0 << "f_free=\"" << this->f_free << "\"" << "\n";
+	s_oss << indent0 << "la_psi=\"" << this->la_psi << "\"" << "\n";
+	s_oss << indent0 << "capacitance=\"" << this->
+		capacitance[0] << " " << this->capacitance[0] << "\"" << "\n";
+
+	// totals
+	s_oss << indent0;
+	s_oss << "<diffuse_layer_totals " << "\n";
+	this->diffuse_layer_totals.dump_xml(s_oss, indent + 1);
+
+}
+
+void
+cxxSurfaceCharge::dump_raw(std::ostream & s_oss, unsigned int indent) 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);
+
+	// Surf_Charge element and attributes
+	s_oss << indent0 << "# SURFACE_MODIFY candidate identifiers #\n";
+	s_oss << indent0 << "-specific_area           " << this->specific_area << "\n";
+	s_oss << indent0 << "-grams                   " << this->grams << "\n";
+	s_oss << indent0 << "-charge_balance          " << this->charge_balance << "\n";
+	s_oss << indent0 << "-mass_water              " << this->mass_water << "\n";
+	s_oss << indent0 << "-f_free                  " << this->f_free << "\n";
+	s_oss << indent0 << "-ddl_viscosity           " << this->DDL_viscosity << "\n";
+	s_oss << indent0 << "-la_psi                  " << this->la_psi << "\n";
+	s_oss << indent0 << "-capacitance0            " << this->capacitance[0] << "\n";
+	s_oss << indent0 << "-capacitance1            " << this->capacitance[1] << "\n";
+	// totals
+	s_oss << indent0;
+	s_oss << "-diffuse_layer_totals" << "\n";
+	this->diffuse_layer_totals.dump_raw(s_oss, indent + 1);
+
+	// DL species
+	//s_oss << indent0;
+	//s_oss << "-diffuse_layer_species" << "\n";
+	if (dl_species_map.size() > 0)
+	{
+		s_oss << indent0;
+		s_oss << "-diffuse_layer_species" << "\n";
+		std::map<int, double>::const_iterator it = this->dl_species_map.begin();
+		for ( ; it != dl_species_map.end(); it++)
+		{
+			s_oss << indent1;
+			s_oss << it->first << " " << it->second << "\n";
+		}
+	}
+	s_oss << indent0 << "# Surface workspace variables #\n";
+	s_oss << indent0 << "-sigma0                  " << this->sigma0 << "\n";
+	s_oss << indent0 << "-sigma1                  " << this->sigma1 << "\n";
+	s_oss << indent0 << "-sigma2                  " << this->sigma2 << "\n";
+	s_oss << indent0 << "-sigmaddl                " << this->sigmaddl << "\n";
+	std::map<LDBLE, cxxSurfDL>::const_iterator git;
+	for (git = this->g_map.begin(); git != g_map.end(); git++)
+	{
+		s_oss << indent0 << "-g_map                   " << git->first << "\t";
+		s_oss << git->second.Get_g() << "\t";
+		s_oss << git->second.Get_dg() << "\t";
+		s_oss << git->second.Get_psi_to_z() << "\n";
+	}
+}
+
+void
+cxxSurfaceCharge::read_raw(CParser & parser, bool check)
+{
+	std::string str;
+
+
+	std::istream::pos_type ptr;
+	std::istream::pos_type next_char;
+	std::string token;
+	int opt_save;
+
+	opt_save = CParser::OPT_ERROR;
+	bool specific_area_defined(false);
+	bool grams_defined(false);
+	bool charge_balance_defined(false);
+	bool mass_water_defined(false);
+	bool la_psi_defined(false);
+	bool capacitance0_defined(false);
+	bool capacitance1_defined(false);
+	bool g_map_first(true);
+	bool DDL_viscosity_defined(false);
+
+	for (;;)
+	{
+		int opt = parser.get_option(vopts, next_char);
+		if (opt == CParser::OPT_DEFAULT)
+		{
+			opt = opt_save;
+		}
+
+		switch (opt)
+		{
+		case CParser::OPT_EOF:
+			break;
+		case CParser::OPT_KEYWORD:
+			break;
+		case CParser::OPT_DEFAULT:
+		case CParser::OPT_ERROR:
+			opt = CParser::OPT_KEYWORD;
+			// Allow return to Surface for more processing
+			break;
+
+		case 0:				// name
+			warning_msg("-name ignored. Defined with -charge_component.");
+			break;
+
+		case 1:				// specific_area
+			if (!(parser.get_iss() >> this->specific_area))
+			{
+				this->specific_area = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for specific_area.",
+					PHRQ_io::OT_CONTINUE);
+			}
+			specific_area_defined = true;
+			break;
+
+		case 2:				// grams
+			if (!(parser.get_iss() >> this->grams))
+			{
+				this->grams = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for grams.",
+					PHRQ_io::OT_CONTINUE);
+			}
+			grams_defined = true;
+			break;
+
+
+		case 3:				// charge_balance
+			if (!(parser.get_iss() >> this->charge_balance))
+			{
+				this->charge_balance = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for charge_balance.",
+					PHRQ_io::OT_CONTINUE);
+			}
+			charge_balance_defined = true;
+			break;
+
+		case 4:				// mass_water
+			if (!(parser.get_iss() >> this->mass_water))
+			{
+				this->mass_water = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for mass_water.",
+					PHRQ_io::OT_CONTINUE);
+			}
+			mass_water_defined = true;
+			break;
+
+		case 5:				// la_psi
+			if (!(parser.get_iss() >> this->la_psi))
+			{
+				this->la_psi = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for la_psi.",
+					PHRQ_io::OT_CONTINUE);
+			}
+			la_psi_defined = true;
+			break;
+
+
+		case 6:				// diffuse_layer_totals
+			if (this->diffuse_layer_totals.read_raw(parser, next_char) !=
+				CParser::PARSER_OK)
+			{
+				parser.incr_input_error();
+				parser.
+					error_msg
+					("Expected element name and molality for SurfaceCharge diffuse_layer_totals.",
+					PHRQ_io::OT_CONTINUE);
+			}
+			opt_save = 6;
+			break;
+
+		case 7:				// la_psi1
+			parser.warning_msg("-la_psi1 identifier not used");
+			break;
+
+		case 8:				// la_psi2
+			parser.warning_msg("-la_psi2 identifier not used");
+			break;
+
+		case 9:				// capacitance0
+			if (!(parser.get_iss() >> this->capacitance[0]))
+			{
+				this->capacitance[0] = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for capacitance0.",
+					PHRQ_io::OT_CONTINUE);
+			}
+			capacitance0_defined = true;
+			break;
+
+		case 10:				// capacitance1
+			if (!(parser.get_iss() >> this->capacitance[1]))
+			{
+				this->capacitance[1] = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for capacitance1.",
+					PHRQ_io::OT_CONTINUE);
+			}
+			capacitance1_defined = true;
+			break;
+		case 11:				// sigma0
+			if (!(parser.get_iss() >> this->sigma0))
+			{
+				this->sigma0 = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for sigma0.",
+					PHRQ_io::OT_CONTINUE);
+			}
+			break;
+		case 12:				// sigma1
+			if (!(parser.get_iss() >> this->sigma1))
+			{
+				this->sigma1 = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for sigma1.",
+					PHRQ_io::OT_CONTINUE);
+			}
+			break;
+		case 13:				// sigma2
+			if (!(parser.get_iss() >> this->sigma2))
+			{
+				this->sigma2 = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for sigma2.",
+					PHRQ_io::OT_CONTINUE);
+			}
+			break;
+		case 14:				// sigmaddl
+			if (!(parser.get_iss() >> this->sigmaddl))
+			{
+				this->sigmaddl = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for sigmaddl.",
+					PHRQ_io::OT_CONTINUE);
+			}
+			break;
+		case 15:				// g_map
+			{
+				if (g_map_first)
+				{
+					this->g_map.clear();
+					g_map_first = false;
+				}
+				LDBLE z, dummy;
+				if (!(parser.get_iss() >> z))
+					break;
+				cxxSurfDL temp_surf_dl;
+				this->g_map[z] = temp_surf_dl;
+				std::map<LDBLE, cxxSurfDL>::iterator git = g_map.find(z);
+				if (!(parser.get_iss() >> dummy))
+					break;
+				else
+					git->second.Set_g(dummy);
+				if (!(parser.get_iss() >> dummy))
+					break;
+				else
+					git->second.Set_dg(dummy);
+				if (!(parser.get_iss() >> dummy))
+					break;
+				else
+					git->second.Set_psi_to_z(dummy);
+			}
+			break;
+		case 16:				// dl_species_map
+			int s_num;
+			if (parser.peek_token() != CParser::TT_EMPTY)
+			{
+				if (!(parser.get_iss() >> s_num))
+				{
+					parser.incr_input_error();
+					parser.error_msg("Expected integer for species number.",
+						PHRQ_io::OT_CONTINUE);
+				}
+				else
+				{
+					double d; 
+					if (!(parser.get_iss() >> d))
+					{
+						parser.incr_input_error();
+						parser.error_msg("Expected double for species concentration.",
+							PHRQ_io::OT_CONTINUE);
+					}
+					this->dl_species_map[s_num] = d;
+				}
+			}
+			opt_save = 16;
+			break;
+		case 17:				// f_free of water
+			if (!(parser.get_iss() >> this->f_free))
+			{
+				this->f_free = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for f_free of mass_water.",
+					PHRQ_io::OT_CONTINUE);
+			}
+			break;
+		case 18:				// DDL_viscosity
+			if (!(parser.get_iss() >> this->DDL_viscosity))
+			{
+				this->DDL_viscosity = 1.0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for DDL_viscosity.",
+					PHRQ_io::OT_CONTINUE);
+			}
+			DDL_viscosity_defined = true;
+			break;
+
+		}
+		if (opt == CParser::OPT_EOF || opt == CParser::OPT_KEYWORD)
+			break;
+	}
+	if (check)
+	{
+		// members that must be defined
+		if (specific_area_defined == false)
+		{
+			parser.incr_input_error();
+			parser.error_msg("Specific_area not defined for SurfaceCharge input.",
+				PHRQ_io::OT_CONTINUE);
+		}
+		if (grams_defined == false)
+		{
+			parser.incr_input_error();
+			parser.error_msg("Grams not defined for SurfaceCharge input.",
+				PHRQ_io::OT_CONTINUE);
+		}
+		if (charge_balance_defined == false)
+		{
+			parser.incr_input_error();
+			parser.
+				error_msg("Charge_balance not defined for SurfaceCharge input.",
+				PHRQ_io::OT_CONTINUE);
+		}
+		if (mass_water_defined == false)
+		{
+			parser.incr_input_error();
+			parser.error_msg("Mass_water not defined for SurfaceCharge input.",
+				PHRQ_io::OT_CONTINUE);
+		}
+		if (la_psi_defined == false)
+		{
+			parser.incr_input_error();
+			parser.error_msg("La_psi not defined for SurfaceCharge input.",
+				PHRQ_io::OT_CONTINUE);
+		}
+		if (capacitance0_defined == false)
+		{
+			parser.incr_input_error();
+			parser.error_msg("Capacitance0 not defined for SurfaceCharge input.",
+				PHRQ_io::OT_CONTINUE);
+		}
+		if (capacitance1_defined == false)
+		{
+			parser.incr_input_error();
+			parser.error_msg("Capacitance1 not defined for SurfaceCharge input.",
+				PHRQ_io::OT_CONTINUE);
+		}
+	}
+}
+
+void
+cxxSurfaceCharge::add(const cxxSurfaceCharge & addee, LDBLE extensive)
+{
+	if (extensive == 0.0)
+		return;
+
+	if (this->name.size() == 0 && addee.name.size() == 0)
+	{
+		return;
+	}
+	assert(this->name == addee.name);
+
+	LDBLE ext1, ext2, f1, f2;
+	ext1 = this->specific_area * this->grams;
+	ext2 = addee.specific_area * addee.grams * extensive;
+	if (ext1 + ext2 != 0)
+	{
+		f1 = ext1 / (ext1 + ext2);
+		f2 = ext2 / (ext1 + ext2);
+	}
+	else
+	{
+		f1 = 0.5;
+		f2 = 0.5;
+	}
+	this->specific_area = f1 * this->specific_area + f2 * addee.specific_area;
+	this->grams += addee.grams * extensive;
+	this->charge_balance += addee.charge_balance * extensive;
+	this->mass_water += addee.mass_water * extensive;
+	this->la_psi = this->la_psi * f1 + addee.la_psi * f2;
+	this->capacitance[0] =
+		this->capacitance[0] * f1 + addee.capacitance[0] * f2;
+	this->capacitance[1] =
+		this->capacitance[1] * f1 + addee.capacitance[1] * f2;
+	this->f_free = this->f_free * f1 + addee.f_free * f2;
+	this->DDL_viscosity = this->DDL_viscosity * f1 + addee.DDL_viscosity * f2;
+	this->diffuse_layer_totals.add_extensive(addee.diffuse_layer_totals, extensive);
+}
+
+void
+cxxSurfaceCharge::multiply(LDBLE extensive)
+{
+	this->grams *= extensive;
+	this->charge_balance *= extensive;
+	this->mass_water *= extensive;
+	this->diffuse_layer_totals.multiply(extensive);
+}
+void
+cxxSurfaceCharge::Serialize(Dictionary & dictionary, std::vector < int >&ints, 
+	std::vector < double >&doubles)
+{
+
+	ints.push_back(dictionary.Find(this->name));
+	doubles.push_back(this->specific_area);
+	doubles.push_back(this->grams);
+	doubles.push_back(this->charge_balance);
+	doubles.push_back(this->mass_water);
+	doubles.push_back(this->la_psi);
+	doubles.push_back(this->capacitance[0]);
+	doubles.push_back(this->capacitance[1]);
+	this->diffuse_layer_totals.Serialize(dictionary, ints, doubles);
+	doubles.push_back(this->sigma0);
+	doubles.push_back(this->sigma1);
+	doubles.push_back(this->sigma2);
+	doubles.push_back(this->sigmaddl);
+	doubles.push_back(this->f_free);
+	doubles.push_back(this->DDL_viscosity);
+	ints.push_back((int) this->g_map.size());
+	{
+		std::map<LDBLE, cxxSurfDL>::iterator it;
+		for (it = this->g_map.begin(); it != this->g_map.end(); it++) 
+		{
+			doubles.push_back(it->first);
+			it->second.Serialize(dictionary, ints, doubles);
+		}
+	}
+	ints.push_back((int) this->dl_species_map.size());
+	{
+		std::map<int, double>::iterator it;
+		for (it = this->dl_species_map.begin(); it != this->dl_species_map.end(); it++) 
+		{
+			ints.push_back(it->first);
+			doubles.push_back(it->second);
+		}
+	}
+}
+
+void
+cxxSurfaceCharge::Deserialize(Dictionary & dictionary, std::vector < int >&ints, 
+	std::vector < double >&doubles, int &ii, int &dd)
+{
+	this->name = dictionary.GetWords()[ints[ii++]];
+	this->specific_area = doubles[dd++];
+	this->grams = doubles[dd++];
+	this->charge_balance = doubles[dd++];
+	this->mass_water = doubles[dd++];
+	this->la_psi = doubles[dd++];
+	this->capacitance[0] = doubles[dd++];
+	this->capacitance[1] = doubles[dd++];
+	this->diffuse_layer_totals.Deserialize(dictionary, ints, doubles, ii, dd);
+	this->sigma0 = doubles[dd++];
+	this->sigma1 = doubles[dd++];
+	this->sigma2 = doubles[dd++];
+	this->sigmaddl = doubles[dd++];
+	this->f_free = doubles[dd++];
+	this->DDL_viscosity = doubles[dd++];
+	{
+		this->g_map.clear();
+		int count = ints[ii++];
+		for (int i = 0; i < count; i++)
+		{
+			double d = doubles[dd++];
+			cxxSurfDL sdl;
+			sdl.Deserialize(dictionary, ints, doubles, ii, dd);
+			this->g_map[d] = sdl;
+		}
+	}
+	{
+		this->dl_species_map.clear();
+		int count = ints[ii++];
+		for (int i = 0; i < count; i++)
+		{
+			int j = ints[ii++];
+			double d = doubles[dd++];
+			dl_species_map[j] = d;
+		}
+	}
+
+
+}
+void
+cxxSurfDL::Serialize(Dictionary & dictionary, std::vector < int >&ints, 
+	std::vector < double >&doubles)
+{
+	doubles.push_back(this->g);
+	doubles.push_back(this->dg);
+	doubles.push_back(this->psi_to_z);
+}
+
+void
+cxxSurfDL::Deserialize(Dictionary & dictionary, std::vector < int >&ints, 
+	std::vector < double >&doubles, int &ii, int &dd)
+{
+	this->g = doubles[dd++];
+	this->dg = doubles[dd++];
+	this->psi_to_z = doubles[dd++];
+}
+const std::vector< std::string >::value_type temp_vopts[] = {
+	std::vector< std::string >::value_type("name"),	                // 0 
+	std::vector< std::string >::value_type("specific_area"),	    // 1 
+	std::vector< std::string >::value_type("grams"),	            // 2 
+	std::vector< std::string >::value_type("charge_balance"),	    // 3 
+	std::vector< std::string >::value_type("mass_water"),	        // 4 
+	std::vector< std::string >::value_type("la_psi"),	            // 5 
+	std::vector< std::string >::value_type("diffuse_layer_totals"),	// 6 
+	std::vector< std::string >::value_type("la_psi1"),	            // 7 
+	std::vector< std::string >::value_type("la_psi2"),	            // 8 
+	std::vector< std::string >::value_type("capacitance0"),	        // 9 
+	std::vector< std::string >::value_type("capacitance1"),	        // 10 
+	std::vector< std::string >::value_type("sigma0"),	            // 11 
+	std::vector< std::string >::value_type("sigma1"),	            // 12 
+	std::vector< std::string >::value_type("sigma2"),	            // 13 
+	std::vector< std::string >::value_type("sigmaddl"),	            // 14
+	std::vector< std::string >::value_type("g_map"),	            // 15
+	std::vector< std::string >::value_type("diffuse_layer_species"),// 16
+	std::vector< std::string >::value_type("f_free"),               // 17
+	std::vector< std::string >::value_type("ddl_viscosity")         // 18
+
+};									   
+const std::vector< std::string > cxxSurfaceCharge::vopts(temp_vopts, temp_vopts + sizeof temp_vopts / sizeof temp_vopts[0]);