pyEQL 1.4.0rc9__cp312-cp312-macosx_10_13_x86_64.whl

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

@@ -0,0 +1,137 @@
+#if !defined(SURFACECHARGE_H_INCLUDED)
+#define SURFACECHARGE_H_INCLUDED
+
+#include <cassert>				// assert
+#include <map>					// std::map
+#include <string>				// std::string
+#include <list>					// std::list
+#include <vector>				// std::vector
+
+#include "NameDouble.h"
+#include "PHRQ_base.h"
+class cxxSpeciesDL
+{
+public:
+	cxxSpeciesDL()
+	{
+		g_moles = dg_g_moles = dx_moles = dh2o_moles = drelated_moles = 0;
+	}
+	LDBLE Get_g_moles(void) const {return g_moles;}
+	void Set_g_moles(LDBLE t) {g_moles = t;}
+	LDBLE Get_dg_g_moles(void) const {return dg_g_moles;}
+	void Set_dg_g_moles(LDBLE t) {dg_g_moles = t;}
+	LDBLE Get_dx_moles(void) const {return dx_moles;}
+	void Set_dx_moles(LDBLE t) {dx_moles = t;}
+	LDBLE Get_dh2o_moles(void) const {return dh2o_moles;}
+	void Set_dh2o_moles(LDBLE t) {dh2o_moles = t;}
+	LDBLE Get_drelated_moles(void) const {return drelated_moles;}
+	void Set_drelated_moles(LDBLE t) {drelated_moles = t;}
+
+	LDBLE *Get_g_moles_address(void) {return &g_moles;}
+	LDBLE *Get_dg_g_moles_address(void) {return &dg_g_moles;}
+	LDBLE *Get_dx_moles_address(void) {return &dx_moles;}
+	LDBLE *Get_dh2o_moles_address(void) {return &dh2o_moles;}
+	LDBLE *Get_drelated_moles_address(void) {return &drelated_moles;}
+	
+protected:
+	LDBLE g_moles;
+	LDBLE dg_g_moles;			/* g_moles*dgterm */
+	LDBLE dx_moles;
+	LDBLE dh2o_moles;			/* moles*g*Ws/Waq */
+	LDBLE drelated_moles;		/* for related phase */
+};
+class cxxSurfDL
+{
+public:
+	cxxSurfDL()
+	{
+		g = dg = psi_to_z = 0;
+	}
+	LDBLE Get_g(void) const {return g;}
+	void Set_g(LDBLE t) {g = t;}
+	LDBLE Get_dg(void) const {return dg;}
+	void Set_dg(LDBLE t) {dg = t;}
+	LDBLE Get_psi_to_z(void) const {return psi_to_z;}
+	void Set_psi_to_z(LDBLE t) {psi_to_z = 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:
+	LDBLE g;
+	LDBLE dg;
+	LDBLE psi_to_z;
+};
+class cxxSurfaceCharge: public PHRQ_base
+{
+
+public:
+
+	cxxSurfaceCharge(PHRQ_io *io=NULL);
+	cxxSurfaceCharge(struct surface_charge *, PHRQ_io *io=NULL);
+	virtual ~cxxSurfaceCharge();
+
+	class master *Get_psi_master();
+	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);
+	void add(const cxxSurfaceCharge & comp, LDBLE extensive);
+	void multiply(LDBLE extensive);
+
+	const std::string &Get_name() const	{return this->name;}
+	void Set_name(const char * f) {this->name = f ? f : "";}
+	LDBLE Get_specific_area() const {return this->specific_area;}
+	void Set_specific_area(LDBLE d) {this->specific_area = d;}
+	LDBLE Get_grams() const {return this->grams;}
+	void Set_grams(LDBLE d) {this->grams = d;}
+	LDBLE Get_charge_balance() const {return this->charge_balance;}
+	void Set_charge_balance(LDBLE d) {this->charge_balance = d;}
+	LDBLE Get_mass_water() const {return this->mass_water;}
+	void Set_mass_water(LDBLE d) {this->mass_water = d;}
+	LDBLE Get_DDL_viscosity(void) const { return DDL_viscosity; }
+	void Set_DDL_viscosity(LDBLE t) { DDL_viscosity = t; }
+	LDBLE Get_f_free() const {return this->f_free;}
+	void Set_f_free(LDBLE d) {this->f_free = d;}
+	LDBLE Get_la_psi() const {return this->la_psi;}
+	void Set_la_psi(LDBLE d) {this->la_psi = d;}
+	LDBLE Get_capacitance0() const {return this->capacitance[0];}
+	void Set_capacitance0(LDBLE d) {this->capacitance[0] = d;}
+	LDBLE Get_capacitance1() const {return this->capacitance[1];}
+	void Set_capacitance1(LDBLE d) {this->capacitance[1] = d;}
+	LDBLE Get_sigma0() const {return this->sigma0;}
+	void Set_sigma0(LDBLE d) {this->sigma0 = d;}
+	LDBLE Get_sigma1() const {return this->sigma1;}
+	void Set_sigma1(LDBLE d) {this->sigma1 = d;}
+	LDBLE Get_sigma2() const {return this->sigma2;}
+	void Set_sigma2(LDBLE d) {this->sigma2 = d;}
+	LDBLE Get_sigmaddl() const {return this->sigmaddl;}
+	void Set_sigmaddl(LDBLE d) {this->sigmaddl = d;}
+	cxxNameDouble & Get_diffuse_layer_totals(void) { return this->diffuse_layer_totals; }
+	const cxxNameDouble & Get_diffuse_layer_totals(void)const { return this->diffuse_layer_totals; }
+	void Set_diffuse_layer_totals(cxxNameDouble & nd) {this->diffuse_layer_totals = nd;}
+	std::map<LDBLE, cxxSurfDL> &Get_g_map(void) {return g_map;}
+	void Set_g_map(std::map<LDBLE, cxxSurfDL> & t) {g_map = t;}
+	std::map<LDBLE, LDBLE> &Get_z_gMCD_map(void) { return z_gMCD_map; } // z, exp(-zF Psi / RT) * fraction of dl water
+	std::map<int, double> & Get_dl_species_map(void)       {return this->dl_species_map;}
+	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;
+	LDBLE specific_area;
+	LDBLE grams;
+	LDBLE charge_balance;
+	LDBLE mass_water;
+	LDBLE DDL_viscosity;
+	LDBLE f_free;
+	LDBLE la_psi;
+	LDBLE capacitance[2];
+	cxxNameDouble diffuse_layer_totals;
+	// workspace variables
+	LDBLE sigma0, sigma1, sigma2, sigmaddl;
+	std::map<LDBLE, cxxSurfDL> g_map;
+	std::map<LDBLE, LDBLE> z_gMCD_map;
+	const static std::vector < std::string > vopts;
+	std::map<int, double> dl_species_map;
+};
+
+#endif // !defined(SURFACECHARGE_H_INCLUDED)

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

@@ -0,0 +1,509 @@
+// SurfaceComp.cxx: implementation of the cxxSurfaceComp 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 "SurfaceComp.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
+//////////////////////////////////////////////////////////////////////
+
+cxxSurfaceComp::cxxSurfaceComp(PHRQ_io *io)
+:
+PHRQ_base(io)
+//
+// default constructor for cxxSurfaceComp 
+//
+{
+	formula_z = 0.0;
+	moles = 0.0;
+	totals.type = cxxNameDouble::ND_ELT_MOLES;
+	la = 0.0;
+	charge_balance = 0;
+	phase_proportion = 0.0;
+	Dw = 0.0;
+}
+cxxSurfaceComp::~cxxSurfaceComp()
+{
+}
+
+void
+cxxSurfaceComp::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_Comp element and attributes
+
+	//s_oss << indent0 << "formula=\"" << this->formula << "\"" << "\n";
+	s_oss << indent0 << "formula_z=\"" << this->formula_z << "\"" << "\n";
+	s_oss << indent0 << "moles=\"" << this->moles << "\"" << "\n";
+	s_oss << indent0 << "la=\"" << this->la << "\"" << "\n";
+	s_oss << indent0 << "charge_balance=\"" << this->charge_balance << "\"" << "\n";
+	s_oss << indent0 << "phase_proportion=\"" << this->phase_proportion << "\"" << "\n";
+	s_oss << indent0 << "Dw=\"" << this->Dw << "\"" << "\n";
+	s_oss << indent0 << "charge_name=\"" << this->charge_name << "\"" << "\n";
+	if (this->phase_name.size() != 0)
+	{
+		s_oss << indent0 << "phase_name=\"" << this->phase_name << "\"" << "\n";
+	}
+	if (this->rate_name.size() != 0)
+	{
+		s_oss << indent0 << "rate_name=\"" << this->rate_name << "\"" << "\n";
+	}
+
+	// totals
+	s_oss << indent0;
+	s_oss << "<totals " << "\n";
+	this->totals.dump_xml(s_oss, indent + 1);
+}
+
+void
+cxxSurfaceComp::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);
+
+	s_oss << indent0 << "# SURFACE_MODIFY candidate identifiers #\n";
+	s_oss << indent0 << "-formula_z               " << this->formula_z << "\n";
+	s_oss << indent0 << "-moles                   " << this->moles << "\n";
+	s_oss << indent0 << "-la                      " << this->la << "\n";
+	s_oss << indent0 << "-charge_balance          " << this->charge_balance << "\n";
+	if (this->phase_name.size() != 0)
+	{
+		s_oss << indent0 << "-phase_name              " << this->phase_name << "\n";
+	}
+	if (this->rate_name.size() != 0)
+	{
+		s_oss << indent0 << "-rate_name               " << this->rate_name << "\n";
+	}
+	s_oss << indent0 << "-phase_proportion        " << this->phase_proportion << "\n";
+	s_oss << indent0 << "-Dw                      " << this->Dw << "\n";
+	s_oss << indent0 << "-charge_name             " << this->charge_name << "\n";
+	s_oss << indent0 << "-master_element          " << this->master_element << "\n";
+	// totals
+	s_oss << indent0;
+	s_oss << "-totals" << "\n";
+	this->totals.dump_raw(s_oss, indent + 1);
+}
+
+void
+cxxSurfaceComp::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 master_element_defined(false);
+	bool charge_name_defined(false);
+	bool moles_defined(false);
+	bool la_defined(false);
+	bool charge_balance_defined(false);
+	bool formula_z_defined(false);
+	bool Dw_defined(false);
+	bool totals_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:				// formula
+			output_msg("-formula is obsolete in surface comp raw");
+			break;
+
+		case 1:				// moles
+			if (!(parser.get_iss() >> this->moles))
+			{
+				this->moles = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for moles.",
+					PHRQ_io::OT_CONTINUE);
+			}
+			moles_defined = true;
+			break;
+
+		case 2:				// la
+			if (!(parser.get_iss() >> this->la))
+			{
+				this->la = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for la.",
+					PHRQ_io::OT_CONTINUE);
+			}
+			la_defined = true;
+			break;
+		case 3:				// charge_number not used
+			parser.warning_msg("-charge_number identifier is obsolete.");
+			break;
+
+		case 4:				// 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 5:				// phase_name
+			if (!(parser.get_iss() >> str))
+			{
+				this->phase_name.clear();
+				parser.incr_input_error();
+				parser.error_msg("Expected string value for phase_name.",
+					PHRQ_io::OT_CONTINUE);
+			}
+			else
+			{
+				this->phase_name = str;
+			}
+			break;
+
+		case 6:				// rate_name
+			if (!(parser.get_iss() >> str))
+			{
+				this->rate_name.clear();
+				parser.incr_input_error();
+				parser.error_msg("Expected string value for rate_name.",
+					PHRQ_io::OT_CONTINUE);
+			}
+			else
+			{
+				this->rate_name = str;
+			}
+			break;
+
+		case 7:				// phase_proportion
+			if (!(parser.get_iss() >> this->phase_proportion))
+			{
+				this->phase_proportion = 0;
+				parser.incr_input_error();
+				parser.
+					error_msg("Expected numeric value for phase_proportion.",
+					PHRQ_io::OT_CONTINUE);
+			}
+			break;
+
+		case 8:				// 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 SurfaceComp totals.",
+					PHRQ_io::OT_CONTINUE);
+			}
+			totals_defined = true;
+			opt_save = 8;
+			break;
+
+		case 9:				// formula_z
+			if (!(parser.get_iss() >> this->formula_z))
+			{
+				this->formula_z = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for formula_z.",
+					PHRQ_io::OT_CONTINUE);
+			}
+			formula_z_defined = true;
+			break;
+
+		case 10:				// formula_totals
+			parser.warning_msg("-formula_totals is an obsolete identifier.");
+			break;
+
+		case 11:				// Dw
+			if (!(parser.get_iss() >> this->Dw))
+			{
+				this->Dw = 0.0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for Dw.",
+					PHRQ_io::OT_CONTINUE);
+			}
+			Dw_defined = true;
+			break;
+		case 12:				// charge_name
+			if (!(parser.get_iss() >> str))
+			{
+				this->charge_name.clear();
+				parser.incr_input_error();
+				parser.error_msg("Expected string value for charge_name.",
+					PHRQ_io::OT_CONTINUE);
+			}
+			else
+			{
+				this->charge_name = str;
+			}
+			charge_name_defined = true;
+			break;
+		case 13:				// master_element
+			if (!(parser.get_iss() >> str))
+			{
+				this->master_element.clear();
+				parser.incr_input_error();
+				parser.error_msg("Expected string value for master_element.",
+					PHRQ_io::OT_CONTINUE);
+			}
+			else
+			{
+				this->master_element = str;
+			}
+			master_element_defined = true;
+			break;
+		}
+		if (opt == CParser::OPT_EOF || opt == CParser::OPT_KEYWORD)
+			break;
+	}
+	if (check)
+	{
+		// members that must be defined
+		if (charge_name_defined == false)
+		{
+			parser.incr_input_error();
+			parser.error_msg("Charge_name not defined for SurfaceComp input.",
+				PHRQ_io::OT_CONTINUE);
+		}
+		if (formula_z_defined == false)
+		{
+			parser.incr_input_error();
+			parser.error_msg("Formula_z not defined for ExchComp input.",
+				PHRQ_io::OT_CONTINUE);
+		}
+		if (moles_defined == false)
+		{
+			parser.incr_input_error();
+			parser.error_msg("Moles not defined for SurfaceComp input.",
+				PHRQ_io::OT_CONTINUE);
+		}
+		if (la_defined == false)
+		{
+			parser.incr_input_error();
+			parser.error_msg("La not defined for SurfaceComp input.",
+				PHRQ_io::OT_CONTINUE);
+		}
+
+		if (charge_balance_defined == false)
+		{
+			parser.incr_input_error();
+			parser.error_msg("Charge_balance not defined for SurfaceComp input.",
+				PHRQ_io::OT_CONTINUE);
+		}
+		if (Dw_defined == false)
+		{
+			parser.incr_input_error();
+			parser.error_msg("Dw not defined for SurfaceComp input.",
+				PHRQ_io::OT_CONTINUE);
+		}
+		if (master_element_defined == false)
+		{
+			parser.incr_input_error();
+			parser.error_msg("Master_element name not defined for SurfaceComp input.",
+				PHRQ_io::OT_CONTINUE);
+		}
+		if (totals_defined == false)
+		{
+			parser.incr_input_error();
+			parser.error_msg("Totals not defined for SurfaceComp input.",
+				PHRQ_io::OT_CONTINUE);
+		}
+	}
+}
+
+void
+cxxSurfaceComp::add(const cxxSurfaceComp & addee, LDBLE extensive)
+{
+	if (extensive == 0.0)
+		return;
+	if (addee.formula.size() == 0)
+		return;
+
+	if (this->formula.size() == 0 && addee.formula.size() == 0)
+	{
+		return;
+	}
+	assert(this->formula == addee.formula);
+	assert(this->formula_z == addee.formula_z);
+	if (this->formula.size() == 0 && addee.formula.size() != 0)
+	{
+		this->formula = addee.formula;
+	}
+
+	// this and addee must have same formula
+	// otherwise generate a new exchcomp with multiply
+	LDBLE ext1, ext2, f1, f2;
+	ext1 = this->moles;
+	ext2 = addee.moles * extensive;
+	if (ext1 + ext2 != 0)
+	{
+		f1 = ext1 / (ext1 + ext2);
+		f2 = ext2 / (ext1 + ext2);
+	}
+	else
+	{
+		f1 = 0.5;
+		f2 = 0.5;
+	}
+	this->moles += addee.moles * extensive;
+	this->totals.add_extensive(addee.totals, extensive);
+	this->la = f1 * this->la + f2 * addee.la;
+	this->charge_balance += addee.charge_balance * extensive;
+	//if (this->phase_name != addee.phase_name)
+	if (Phreeqc::strcmp_nocase(this->phase_name.c_str(),addee.phase_name.c_str()) != 0)
+	{
+		std::ostringstream oss;
+		oss <<
+			"Cannot mix two Surface components with same formula and different related phases, "
+			<< this->formula;
+		error_msg(oss.str().c_str(), CONTINUE);
+		return;
+	}
+	else if (this->phase_name.size() != 0)
+	{
+		this->phase_proportion =
+			this->phase_proportion * f1 + addee.phase_proportion * f2;
+	}
+
+	//if (this->rate_name != addee.rate_name)
+	if (Phreeqc::strcmp_nocase(this->rate_name.c_str(), addee.rate_name.c_str()) != 0)
+	{
+		std::ostringstream oss;
+		oss <<
+			"Cannot mix two surface components with same formula and different related kinetics, "
+			<< this->formula;
+		error_msg(oss.str().c_str(), CONTINUE);
+		return;
+	}
+	else if (this->rate_name.size() != 0)
+	{
+		//LDBLE phase_proportion;
+		this->phase_proportion =
+			this->phase_proportion * f1 + addee.phase_proportion * f2;
+	}
+	if ((this->rate_name.size() != 0 && addee.phase_name.size() != 0) ||
+		(this->phase_name.size() != 0 && addee.rate_name.size() != 0))
+	{
+		std::ostringstream oss;
+		oss <<
+			"Cannot mix surface components related to phase with surface components related to kinetics, "
+			<< this->formula;
+		error_msg(oss.str().c_str(), CONTINUE);
+		return;
+	}
+
+}
+void
+cxxSurfaceComp::multiply(LDBLE extensive)
+{
+	this->moles *= extensive;
+
+	this->totals.multiply(extensive);
+
+	this->charge_balance *= extensive;
+}
+void
+cxxSurfaceComp::Serialize(Dictionary & dictionary, std::vector < int >&ints, std::vector < double >&doubles)
+{
+	ints.push_back(dictionary.Find(this->formula));
+	doubles.push_back(this->formula_z);
+	doubles.push_back(this->moles);
+	this->totals.Serialize(dictionary, ints, doubles);
+	doubles.push_back(this->la);
+	ints.push_back(dictionary.Find(this->charge_name));
+	doubles.push_back(this->charge_balance);
+	ints.push_back(dictionary.Find(this->phase_name));
+	doubles.push_back(this->phase_proportion);
+	ints.push_back(dictionary.Find(this->rate_name));
+	doubles.push_back(this->Dw);
+	ints.push_back(dictionary.Find(this->master_element));
+}
+
+void
+cxxSurfaceComp::Deserialize(Dictionary & dictionary, std::vector < int >&ints, std::vector < double >&doubles, int &ii, int &dd)
+{
+	this->formula = dictionary.GetWords()[ints[ii++]];
+	this->formula_z = doubles[dd++];
+	this->moles = doubles[dd++];
+	this->totals.Deserialize(dictionary, ints, doubles, ii, dd);
+	this->la = doubles[dd++];
+	this->charge_name = dictionary.GetWords()[ints[ii++]];
+	this->charge_balance = doubles[dd++];
+	this->phase_name = dictionary.GetWords()[ints[ii++]];
+	this->phase_proportion = doubles[dd++];
+	this->rate_name = dictionary.GetWords()[ints[ii++]];
+	this->Dw = doubles[dd++];
+	this->master_element = dictionary.GetWords()[ints[ii++]];
+}
+
+const std::vector< std::string >::value_type temp_vopts[] = {
+	std::vector< std::string >::value_type("formula"),	        // 0 
+	std::vector< std::string >::value_type("moles"),	        // 1
+	std::vector< std::string >::value_type("la"),	            // 2 
+	std::vector< std::string >::value_type("charge_number"),	// 3 
+	std::vector< std::string >::value_type("charge_balance"),	// 4
+	std::vector< std::string >::value_type("phase_name"),	    // 5 
+	std::vector< std::string >::value_type("rate_name"),	    // 6 
+	std::vector< std::string >::value_type("phase_proportion"),	// 7 
+	std::vector< std::string >::value_type("totals"),	        // 8
+	std::vector< std::string >::value_type("formula_z"),	    // 9
+	std::vector< std::string >::value_type("formula_totals"),	// 10
+	std::vector< std::string >::value_type("dw"),	            // 11
+	std::vector< std::string >::value_type("charge_name"),	    // 12
+	std::vector< std::string >::value_type("master_element") 	// 13
+};									   
+const std::vector< std::string > cxxSurfaceComp::vopts(temp_vopts, temp_vopts + sizeof temp_vopts / sizeof temp_vopts[0]);