pyEQL 1.4.0rc9__cp310-cp310-macosx_11_0_arm64.whl

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

@@ -0,0 +1,297 @@
+// SScomp.cxx: implementation of the cxxSScomp 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 "SScomp.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
+//////////////////////////////////////////////////////////////////////
+
+cxxSScomp::cxxSScomp(PHRQ_io *io)
+:
+PHRQ_base(io)
+	//
+	// default constructor for cxxSScomp 
+	//
+{
+	name = "";
+	initial_moles = 0;
+	moles = 0;
+	init_moles = 0;
+	delta = 0;
+	fraction_x = 0;
+	log10_lambda = 0;
+	log10_fraction_x = 0;
+	dn = 0;
+	dnc = 0; 
+	dnb = 0;
+}
+cxxSScomp::~cxxSScomp()
+{
+}
+
+void
+cxxSScomp::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 << indent1 << "# SOLID_SOLUTION_MODIFY candidate identifiers #\n";
+	s_oss << indent1 << "-moles               " << this->moles << "\n";
+
+	s_oss << indent1 << "# Solid solution workspace variables #\n";
+	s_oss << indent1 << "-initial_moles       " << this->initial_moles << "\n";
+	s_oss << indent1 << "-init_moles          " << this->init_moles << "\n";
+	s_oss << indent1 << "-delta               " << this->delta << "\n";
+	s_oss << indent1 << "-fraction_x          " << this->fraction_x << "\n";
+	s_oss << indent1 << "-log10_lambda        " << this->log10_lambda << "\n";
+	s_oss << indent1 << "-log10_fraction_x    " << this->log10_fraction_x << "\n";
+	s_oss << indent1 << "-dn                  " << this->dn << "\n";
+	s_oss << indent1 << "-dnc                 " << this->dnc << "\n";
+	s_oss << indent1 << "-dnb                 " << this->dnb << "\n";
+}
+
+void
+cxxSScomp::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 initial_moles_defined(false);
+	bool moles_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 Exchange for more processing
+			break;
+
+		case 0:				// name
+			parser.error_msg("-Name ignored. Define with -component.");
+			break;
+
+		case 1:				// initial_moles
+			if (!(parser.get_iss() >> this->initial_moles))
+			{
+				this->initial_moles = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for initial_moles.",
+								 PHRQ_io::OT_CONTINUE);
+			}
+			initial_moles_defined = true;
+			break;
+
+		case 2:				// 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 3:				// init_moles
+			if (!(parser.get_iss() >> this->init_moles))
+			{
+				this->init_moles = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for init_moles.",
+								 PHRQ_io::OT_CONTINUE);
+			}
+			break;
+
+		case 4:				// delta
+			if (!(parser.get_iss() >> this->delta))
+			{
+				this->delta = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for delta.",
+								 PHRQ_io::OT_CONTINUE);
+			}
+			break;
+
+		case 5:				// fraction_x
+			if (!(parser.get_iss() >> this->fraction_x))
+			{
+				this->fraction_x = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for fraction_x.",
+								 PHRQ_io::OT_CONTINUE);
+			}
+			break;
+
+
+		case 6:				// log10_lambda
+			if (!(parser.get_iss() >> this->log10_lambda))
+			{
+				this->log10_lambda = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected boolean value for log10_lambda.",
+								 PHRQ_io::OT_CONTINUE);
+			}
+			break;
+
+		case 7:				// log10_fraction_x
+			if (!(parser.get_iss() >> this->log10_fraction_x))
+			{
+				this->log10_fraction_x = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected boolean value for log10_fraction_x.",
+								 PHRQ_io::OT_CONTINUE);
+			}
+			break;
+
+		case 8:				// dn
+			if (!(parser.get_iss() >> this->dn))
+			{
+				this->dn = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected boolean value for dn.",
+								 PHRQ_io::OT_CONTINUE);
+			}
+			break;
+		case 9:				// dnc
+			if (!(parser.get_iss() >> this->dnc))
+			{
+				this->dnc = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for dnc.",
+								 PHRQ_io::OT_CONTINUE);
+			}
+			break;
+		case 10:				// dnb
+			if (!(parser.get_iss() >> this->dnb))
+			{
+				this->dnb = 0;
+				parser.incr_input_error();
+				parser.error_msg("Expected numeric value for dnb.",
+								 PHRQ_io::OT_CONTINUE);
+			}
+			break;
+		}
+		if (opt == CParser::OPT_EOF || opt == CParser::OPT_KEYWORD)
+			break;
+	}
+	// members that must be defined
+	if (check)
+	{
+		if (moles_defined == false)
+		{
+			parser.incr_input_error();
+			parser.error_msg("Moles not defined for PPassemblageComp input.",
+				PHRQ_io::OT_CONTINUE);
+		}
+		if (initial_moles_defined == false)
+		{
+			parser.incr_input_error();
+			parser.error_msg("Initial_moles not defined for PPassemblageComp input.",
+				PHRQ_io::OT_CONTINUE);
+		}
+	}
+}
+
+void
+cxxSScomp::multiply(LDBLE extensive)
+{
+	this->moles *= extensive;
+	this->delta *= extensive;
+	this->initial_moles *= extensive;
+}
+void
+cxxSScomp::Serialize(Dictionary & dictionary, std::vector < int >&ints, 
+	std::vector < double >&doubles)
+{
+
+	ints.push_back(dictionary.Find(this->name));
+	doubles.push_back(this->moles);
+	doubles.push_back(this->initial_moles);
+	doubles.push_back(this->init_moles);
+	doubles.push_back(this->delta);
+	doubles.push_back(this->fraction_x);
+	doubles.push_back(this->log10_lambda);
+	doubles.push_back(this->log10_fraction_x);
+	doubles.push_back(this->dn);
+	doubles.push_back(this->dnc);
+	doubles.push_back(this->dnb);
+
+}
+
+void
+cxxSScomp::Deserialize(Dictionary & dictionary, std::vector < int >&ints, 
+	std::vector < double >&doubles, int &ii, int &dd)
+{
+
+	this->name = dictionary.GetWords()[ints[ii++]];
+	this->moles = doubles[dd++];
+	this->initial_moles = doubles[dd++];
+	this->init_moles = doubles[dd++];
+	this->delta = doubles[dd++];
+	this->fraction_x = doubles[dd++];
+	this->log10_lambda = doubles[dd++];
+	this->log10_fraction_x = doubles[dd++];
+	this->dn = doubles[dd++];
+	this->dnc = doubles[dd++];
+	this->dnb = 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("initial_moles"),	// 1
+	std::vector< std::string >::value_type("moles"),	        // 2
+	std::vector< std::string >::value_type("init_moles"),	    // 3
+	std::vector< std::string >::value_type("delta"),	        // 4
+	std::vector< std::string >::value_type("fraction_x"),	    // 5     
+	std::vector< std::string >::value_type("log10_lambda"),	    // 6
+	std::vector< std::string >::value_type("log10_fraction_x"),	// 7
+	std::vector< std::string >::value_type("dn"),	            // 8
+	std::vector< std::string >::value_type("dnc"),	            // 9
+	std::vector< std::string >::value_type("dnb") 	            // 10
+};									   
+const std::vector< std::string > cxxSScomp::vopts(temp_vopts, temp_vopts + sizeof temp_vopts / sizeof temp_vopts[0]);	

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

@@ -0,0 +1,66 @@
+#if !defined(SSCOMP_H_INCLUDED)
+#define SSCOMP_H_INCLUDED
+
+#include <cassert>				// assert
+#include <map>					// std::map
+#include <string>				// std::string
+#include <list>					// std::list
+#include <vector>				// std::vector
+
+#include "NameDouble.h"
+
+class cxxSScomp: public PHRQ_base
+{
+
+  public:
+	cxxSScomp(PHRQ_io *io=NULL);
+	virtual ~cxxSScomp();
+
+	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(std::string s) {this->name = s;}
+
+	LDBLE Get_initial_moles() const {return this->initial_moles;}
+	void Set_initial_moles(LDBLE t) {this->initial_moles = t;}
+	LDBLE Get_moles() const {return this->moles;}
+	void Set_moles(LDBLE t) {this->moles = t;}
+	LDBLE Get_init_moles() const {return this->init_moles;}
+	void Set_init_moles(LDBLE t) {this->init_moles = t;}
+	LDBLE Get_delta() const {return this->delta;}
+	void Set_delta(LDBLE t) {this->delta = t;}
+	LDBLE Get_fraction_x() const {return this->fraction_x;}
+	void Set_fraction_x(LDBLE t) {this->fraction_x = t;}
+	LDBLE Get_log10_lambda() const {return this->log10_lambda;}
+	void Set_log10_lambda(LDBLE t) {this->log10_lambda = t;}
+	LDBLE Get_log10_fraction_x() const {return this->log10_fraction_x;}
+	void Set_log10_fraction_x(LDBLE t) {this->log10_fraction_x = t;}
+	LDBLE Get_dn() const {return this->dn;}
+	void Set_dn(LDBLE t) {this->dn = t;}
+	LDBLE Get_dnc() const {return this->dnc;}
+	void Set_dnc(LDBLE t) {this->dnc = t;}
+	LDBLE Get_dnb() const {return this->dnb;}
+	void Set_dnb(LDBLE t) {this->dnb = t;}
+
+	void multiply(LDBLE extensive);
+	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;
+	// SOLID_SOLUTION_MODIFY candidate identifier
+	LDBLE moles;
+
+	// Solid solution workspace variables
+	LDBLE initial_moles;
+	LDBLE init_moles;
+	LDBLE delta;
+	LDBLE fraction_x;
+	LDBLE log10_lambda;
+	LDBLE log10_fraction_x;
+	LDBLE dn, dnc, dnb;
+	const static std::vector < std::string > vopts;
+};
+
+#endif // !defined(SSCOMP_H_INCLUDED)

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

@@ -0,0 +1,115 @@
+#include "SelectedOutput.h"
+
+#if defined(PHREEQCI_GUI)
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+#endif
+
+SelectedOutput::SelectedOutput(int n, PHRQ_io *io)
+:	cxxNumKeyword(io)
+{
+	// file_name
+	this->Set_file_name(n);
+
+	// punch_ostream
+	this->punch_ostream = NULL;
+
+	// state vars
+	this->active             = true;
+	this->new_def            = false;
+	this->user_punch_new_def = false;
+	this->have_punch_name    = false;
+
+	// as-is vars
+	//
+	this->user_punch       = true;
+	this->high_precision   = false;
+	this->inverse          = true;
+
+	this->sim              = true;
+	this->state            = true;
+	this->soln             = true;
+	this->dist             = true;
+	this->time             = true;
+
+	this->step             = true;
+	this->ph               = true;
+	this->pe               = true;
+	this->rxn              = false;
+	this->temp             = false;
+
+	this->alk              = false;
+	this->mu               = false;
+	this->water            = false;
+	this->charge_balance   = false;
+	this->percent_error    = false;
+	this->new_line         = true;
+
+	// as-is set flags
+	//
+	this->set_user_punch     = false;
+	this->set_high_precision = false;
+	this->set_inverse        = false;
+
+	this->set_sim            = false;
+	this->set_state          = false;
+	this->set_soln           = false;
+	this->set_dist           = false;
+	this->set_time           = false;
+
+	this->set_step           = false;
+	this->set_ph             = false;
+	this->set_pe             = false;
+	this->set_rxn            = false;
+	this->set_temp           = false;
+
+	this->set_alk            = false;
+	this->set_mu             = false;
+	this->set_water          = false;
+	this->set_charge_balance = false;
+	this->set_percent_error  = false;
+	this->set_new_line       = false;
+}
+
+SelectedOutput::~SelectedOutput(void)
+{
+	if (this->punch_ostream != NULL)
+	{
+		delete this->punch_ostream;
+	}
+	this->punch_ostream = NULL;
+}
+
+void
+SelectedOutput::Reset(bool value)
+{
+	// as-is vars
+	Set_sim(value);
+	Set_state(value);
+	Set_soln(value);
+	Set_dist(value);
+	Set_time(value);
+
+	Set_step(value);
+	Set_ph(value);
+	Set_pe(value);
+	Set_rxn(value);
+	Set_temp(value);
+
+	Set_alk(value);
+	Set_mu(value);
+	Set_water(value);
+	Set_charge_balance(value);
+	Set_percent_error(value);
+}
+
+void
+SelectedOutput::Set_file_name(int n)
+{
+	std::ostringstream os;
+	os << "selected_output_" << n << ".sel";
+	file_name = os.str();
+}

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

@@ -0,0 +1,209 @@
+#if !defined(SELECTEDOUTPUT_H_INCLUDED)
+#define SELECTEDOUTPUT_H_INCLUDED
+#include <string>				// std::string
+#include <vector>
+#include <map>
+#include "NumKeyword.h"
+
+class SelectedOutput:public cxxNumKeyword
+{
+public:
+	SelectedOutput(int n=1, PHRQ_io *io=NULL);
+	~SelectedOutput(void);
+
+	void Reset(bool tf);
+
+	// vector getters
+	inline std::vector< std::pair< std::string, void * > > & Get_totals(void)           {return this->totals;}
+	inline std::vector< std::pair< std::string, void * > > & Get_molalities(void)       {return this->molalities;}
+	inline std::vector< std::pair< std::string, void * > > & Get_activities(void)       {return this->activities;}
+	inline std::vector< std::pair< std::string, void * > > & Get_pure_phases(void)      {return this->pure_phases;}
+	inline std::vector< std::pair< std::string, void * > > & Get_si(void)               {return this->si;}
+	inline std::vector< std::pair< std::string, void * > > & Get_gases(void)            {return this->gases;}
+	inline std::vector< std::pair< std::string, void * > > & Get_s_s(void)              {return this->s_s;}
+	inline std::vector< std::pair< std::string, void * > > & Get_kinetics(void)         {return this->kinetics;}
+	inline std::vector< std::pair< std::string, void * > > & Get_isotopes(void)         {return this->isotopes;}
+	inline std::vector< std::pair< std::string, void * > > & Get_calculate_values(void) {return this->calculate_values;}
+
+	// const vector getters
+	inline const std::vector< std::pair< std::string, void * > > & Get_totals(void)const           {return this->totals;}
+	inline const std::vector< std::pair< std::string, void * > > & Get_molalities(void)const       {return this->molalities;}
+	inline const std::vector< std::pair< std::string, void * > > & Get_activities(void)const       {return this->activities;}
+	inline const std::vector< std::pair< std::string, void * > > & Get_pure_phases(void)const      {return this->pure_phases;}
+	inline const std::vector< std::pair< std::string, void * > > & Get_si(void)const               {return this->si;}
+	inline const std::vector< std::pair< std::string, void * > > & Get_gases(void)const            {return this->gases;}
+	inline const std::vector< std::pair< std::string, void * > > & Get_s_s(void)const              {return this->s_s;}
+	inline const std::vector< std::pair< std::string, void * > > & Get_kinetics(void)const         {return this->kinetics;}
+	inline const std::vector< std::pair< std::string, void * > > & Get_isotopes(void)const         {return this->isotopes;}
+	inline const std::vector< std::pair< std::string, void * > > & Get_calculate_values(void)const {return this->calculate_values;}
+
+	// file_name getters/setters
+	void Set_file_name(int i);
+	inline void Set_file_name(std::string s)                          {this->file_name = s;}
+	inline std::string & Get_file_name(void)                          {return this->file_name;}
+	inline const std::string & Get_file_name(void)const               {return this->file_name;}
+
+	// punch_ostream getters/setters
+	inline std::ostream* Get_punch_ostream(void)                      {return this->punch_ostream;}
+	inline const std::ostream* Get_punch_ostream(void)const           {return this->punch_ostream;}
+	inline void Set_punch_ostream(std::ostream * os)                  {this->punch_ostream = os;}
+
+	// state var getters
+	inline bool Get_active(void)const                                 {return this->active;}
+	inline bool Get_new_def(void)const                                {return this->new_def;}
+	inline bool Get_user_punch_new_def(void)const                     {return this->user_punch_new_def;}
+	inline bool Get_have_punch_name(void)const                        {return this->have_punch_name;}
+
+	// state var setters
+	inline void Set_active(bool tf)                                   {this->active = tf;}
+	inline void Set_new_def(bool tf)                                  {this->new_def = tf;}
+	inline void Set_user_punch_new_def(bool tf)                       {this->user_punch_new_def = tf;}
+	inline void Set_have_punch_name(bool tf)                          {this->have_punch_name = tf;}
+
+	// as_is getters
+	inline bool Get_user_punch(void)const                             {return this->user_punch;}
+	inline bool Get_high_precision(void)const                         {return this->high_precision;}
+	inline bool Get_inverse(void)const                                {return this->inverse;}
+
+	inline bool Get_sim(void)const                                    {return this->sim;}
+	inline bool Get_state(void)const                                  {return this->state;}
+	inline bool Get_soln(void)const                                   {return this->soln;}
+	inline bool Get_dist(void)const                                   {return this->dist;}
+	inline bool Get_time(void)const                                   {return this->time;}
+
+	inline bool Get_step(void)const                                   {return this->step;}
+	inline bool Get_ph(void)const                                     {return this->ph;}
+	inline bool Get_pe(void)const                                     {return this->pe;}
+	inline bool Get_rxn(void)const                                    {return this->rxn;}
+	inline bool Get_temp(void)const                                   {return this->temp;}
+
+	inline bool Get_alk(void)const                                    {return this->alk;}
+	inline bool Get_mu(void)const                                     {return this->mu;}
+	inline bool Get_water(void)const                                  {return this->water;}
+	inline bool Get_charge_balance(void)const                         {return this->charge_balance;}
+	inline bool Get_percent_error(void)const                          {return this->percent_error;}
+	inline bool Get_new_line(void)const                               {return this->new_line; }
+
+	// as-is setters
+	inline void Set_user_punch(bool tf)                               {this->user_punch = tf;              this->set_user_punch = true;}
+	inline void Set_high_precision(bool tf)                           {this->high_precision = tf;          this->set_high_precision = true;}
+	inline void Set_inverse(bool tf)                                  {this->inverse = tf;                 this->set_inverse = true;}
+
+	inline void Set_sim(bool tf)                                      {this->sim = tf;                     this->set_sim = true;}
+	inline void Set_state(bool tf)                                    {this->state = tf;                   this->set_state = true;}
+	inline void Set_soln(bool tf)                                     {this->soln = tf;                    this->set_soln = true;}
+	inline void Set_dist(bool tf)                                     {this->dist = tf;                    this->set_dist = true;}
+	inline void Set_time(bool tf)                                     {this->time = tf;                    this->set_time = true;}
+
+	inline void Set_step(bool tf)                                     {this->step = tf;                    this->set_step = true;}
+	inline void Set_ph(bool tf)                                       {this->ph = tf;                      this->set_ph = true;}
+	inline void Set_pe(bool tf)                                       {this->pe = tf;                      this->set_pe = true;}
+	inline void Set_rxn(bool tf)                                      {this->rxn = tf;                     this->set_rxn = true;}
+	inline void Set_temp(bool tf)                                     {this->temp = tf;                    this->set_temp = true;}
+
+	inline void Set_alk(bool tf)                                      {this->alk = tf;                     this->set_alk = true;}
+	inline void Set_mu(bool tf)                                       {this->mu = tf;                      this->set_mu = true;}
+	inline void Set_water(bool tf)                                    {this->water = tf;                   this->set_water = true;}
+	inline void Set_charge_balance(bool tf)                           {this->charge_balance = tf;          this->set_charge_balance = true;}
+	inline void Set_percent_error(bool tf)                            {this->percent_error = tf;           this->set_percent_error = true;}
+	inline void Set_new_line(bool tf)                                 {this->new_line = tf;                this->set_new_line = true;}
+
+	// set flag getters
+	inline bool was_set_user_punch()const                             {return this->set_user_punch;}
+	inline bool was_set_high_precision()const                         {return this->set_high_precision;}
+	inline bool was_set_inverse()const                                {return this->set_inverse;}
+
+	inline bool was_set_sim()const                                    {return this->set_sim;}
+	inline bool was_set_state()const                                  {return this->set_state;}
+	inline bool was_set_soln()const                                   {return this->set_soln;}
+	inline bool was_set_dist()const                                   {return this->set_dist;}
+	inline bool was_set_time()const                                   {return this->set_time;}
+
+	inline bool was_set_step()const                                   {return this->set_step;}
+	inline bool was_set_ph()const                                     {return this->set_ph;}
+	inline bool was_set_pe()const                                     {return this->set_pe;}
+	inline bool was_set_rxn()const                                    {return this->set_rxn;}
+	inline bool was_set_temp()const                                   {return this->set_temp;}
+
+	inline bool was_set_alk()const                                    {return this->set_alk;}
+	inline bool was_set_mu()const                                     {return this->set_mu;}
+	inline bool was_set_water()const                                  {return this->set_water;}
+	inline bool was_set_charge_balance()const                         {return this->set_charge_balance;}
+	inline bool was_set_percent_error()const                          {return this->set_percent_error;}
+	inline bool was_set_new_line()const                               {return this->set_new_line;}
+
+protected:
+
+	// vectors
+	std::vector< std::pair< std::string, void * > > totals;
+	std::vector< std::pair< std::string, void * > > molalities;
+	std::vector< std::pair< std::string, void * > > activities;
+	std::vector< std::pair< std::string, void * > > pure_phases;
+	std::vector< std::pair< std::string, void * > > si;
+	std::vector< std::pair< std::string, void * > > gases;
+	std::vector< std::pair< std::string, void * > > s_s;
+	std::vector< std::pair< std::string, void * > > kinetics;
+	std::vector< std::pair< std::string, void * > > isotopes;
+	std::vector< std::pair< std::string, void * > > calculate_values;
+
+	// file_name
+	std::string file_name;
+
+	// punch_ostream
+	std::ostream * punch_ostream;
+
+	// state vars
+	bool active;
+	bool new_def;
+	bool user_punch_new_def;
+	bool have_punch_name;
+
+	// as-is vars
+	bool user_punch;
+	bool high_precision;
+	bool inverse;
+
+	bool sim;
+	bool state;
+	bool soln;
+	bool dist;
+	bool time;
+
+	bool step;
+	bool ph;
+	bool pe;
+	bool rxn;
+	bool temp;
+
+	bool alk;
+	bool mu;
+	bool water;
+	bool charge_balance;
+	bool percent_error;
+	bool new_line;
+
+	// as-is set flags
+	bool set_user_punch;
+	bool set_high_precision;
+	bool set_inverse;
+
+	bool set_sim;
+	bool set_state;
+	bool set_soln;
+	bool set_dist;
+	bool set_time;
+
+	bool set_step;
+	bool set_ph;
+	bool set_pe;
+	bool set_rxn;
+	bool set_temp;
+
+	bool set_alk;
+	bool set_mu;
+	bool set_water;
+	bool set_charge_balance;
+	bool set_percent_error;
+	bool set_new_line;
+};
+#endif // !defined(SELECTEDOUTPUT_H_INCLUDED)