diff --git a/Dictionary.h b/Dictionary.h index 98c0914e..8d3f96af 100644 --- a/Dictionary.h +++ b/Dictionary.h @@ -1,44 +1,45 @@ #if !defined(DICTIONARY_H_INCLUDED) #define DICTIONARY_H_INCLUDED -#include // assert -#include // std::map -#include // std::string -#include // std::list -#include // std::vector +#include // assert +#include // std::map +#include // std::string +#include // std::list +#include // std::vector #include "Solution.h" #include "NameDouble.h" class cxxDictionary { -public: - cxxDictionary(); + public: + cxxDictionary(); - ~cxxDictionary(); + ~cxxDictionary(); - void add_phreeqc(); + void add_phreeqc(); - int size() { + int size() + { return (int) stringkey.size(); } int putString(std::string str); - int putString(char * str); + int putString(char *str); int string2int(std::string str); - int string2int(char * str); + int string2int(char *str); - std::string *int2string(int i); + std::string * int2string(int i); char *int2char(int i); -protected: - std::map stringkey; - std::map intkey; + protected: + std::map < std::string, int >stringkey; + std::map < int, std::string > intkey; -public: + public: }; diff --git a/ExchComp.h b/ExchComp.h index 640872d2..353b496a 100644 --- a/ExchComp.h +++ b/ExchComp.h @@ -4,88 +4,149 @@ #include "NameDouble.h" #define EXTERNAL extern #include "global.h" -#include // assert -#include // std::map -#include // std::string -#include // std::list -#include // std::vector +#include // assert +#include // std::map +#include // std::string +#include // std::list +#include // std::vector #include "char_star.h" class cxxExchComp { -public: - cxxExchComp(); - cxxExchComp(struct exch_comp *); - ~cxxExchComp(); + public: + cxxExchComp(); + cxxExchComp(struct exch_comp *); + ~cxxExchComp(); - struct master *get_master(); + struct master *get_master(); - static struct exch_comp *cxxExchComp2exch_comp(std::list& el); + static struct exch_comp *cxxExchComp2exch_comp(std::list < cxxExchComp > + &el); - void dump_xml(std::ostream& os, unsigned int indent = 0)const; + void dump_xml(std::ostream & os, unsigned int indent = 0) const; - void dump_raw(std::ostream& s_oss, unsigned int indent)const; + void dump_raw(std::ostream & s_oss, unsigned int indent) const; - void read_raw(CParser& parser); + void read_raw(CParser & parser); - char * get_formula()const { return this->formula;} - void set_formula(char * cstring) { this->formula = cstring;} - double get_moles()const { return this->moles;} - void set_moles(double d) { this->moles = d;} - double get_la()const { return this->la;} - void set_la(double d) { this->la = d;} - double get_charge_balance()const { return this->charge_balance;} - void set_charge_balance(double d) { this->charge_balance = d;} - char * get_phase_name()const { return this->phase_name;} - void set_phase_name(char * cstring) { this->phase_name = cstring;} - double get_phase_proportion()const { return this->phase_proportion;} - void set_phase_proportion(double d) { this->phase_proportion = d;} - char * get_rate_name()const { return this->rate_name;} - void set_rate_name(char * cstring) { this->rate_name = cstring;} - double get_formula_z()const { return this->formula_z;} - void set_formula_z(double d) { this->formula_z = d;} - void set_totals(struct elt_list *e_l, int count) - {this->totals = cxxNameDouble(e_l, count);} - void set_totals(struct elt_list *e_l) - {this->totals = cxxNameDouble(e_l);} - void set_totals(cxxNameDouble nd) - {this->totals = nd;} - void set_formula_totals(struct elt_list *e_l, int count) - {this->formula_totals = cxxNameDouble(e_l, count);} - void set_formula_totals(struct elt_list *e_l) - {this->formula_totals = cxxNameDouble(e_l);} - void set_formula_totals(cxxNameDouble nd) - {this->formula_totals = nd;} - - const cxxNameDouble &get_totals()const + char *get_formula() const { - return (this->totals); + return this->formula; + } + void set_formula(char *cstring) + { + this->formula = cstring; + } + double get_moles() const + { + return this->moles; + } + void set_moles(double d) + { + this->moles = d; + } + double get_la() const + { + return this->la; + } + void set_la(double d) + { + this->la = d; + } + double get_charge_balance() const + { + return this->charge_balance; + } + void set_charge_balance(double d) + { + this->charge_balance = d; + } + char *get_phase_name() const + { + return this->phase_name; + } + void set_phase_name(char *cstring) + { + this->phase_name = cstring; + } + double get_phase_proportion() const + { + return this->phase_proportion; + } + void set_phase_proportion(double d) + { + this->phase_proportion = d; + } + char *get_rate_name() const + { + return this->rate_name; + } + void set_rate_name(char *cstring) + { + this->rate_name = cstring; + } + double get_formula_z() const + { + return this->formula_z; + } + void set_formula_z(double d) + { + this->formula_z = d; + } + void set_totals(struct elt_list *e_l, int count) + { + this->totals = cxxNameDouble(e_l, count); + } + void set_totals(struct elt_list *e_l) + { + this->totals = cxxNameDouble(e_l); + } + void set_totals(cxxNameDouble nd) + { + this->totals = nd; + } + void set_formula_totals(struct elt_list *e_l, int count) + { + this->formula_totals = cxxNameDouble(e_l, count); + } + void set_formula_totals(struct elt_list *e_l) + { + this->formula_totals = cxxNameDouble(e_l); + } + void set_formula_totals(cxxNameDouble nd) + { + this->formula_totals = nd; + } + + const cxxNameDouble & get_totals() const + { + return (this->totals); }; - void add(const cxxExchComp &comp, double extensive); + void add(const cxxExchComp & comp, double extensive); void multiply(double extensive); #ifdef USE_MPI - void mpi_pack(std::vector& ints, std::vector& doubles); + void mpi_pack(std::vector < int >&ints, std::vector < double >&doubles); void mpi_unpack(int *ints, int *ii, double *doubles, int *dd); #endif -protected: - char * formula; - double moles; - cxxNameDouble formula_totals; - cxxNameDouble totals; - double la; - double charge_balance; - char *phase_name; - double phase_proportion; - char *rate_name; - double formula_z; // charge on formula + protected: + char *formula; + double moles; + cxxNameDouble formula_totals; + cxxNameDouble totals; + double la; + double charge_balance; + char *phase_name; + double phase_proportion; + char *rate_name; + double formula_z; // charge on formula -public: + public: }; diff --git a/Exchange.h b/Exchange.h index bd93feca..9a234578 100644 --- a/Exchange.h +++ b/Exchange.h @@ -3,67 +3,71 @@ #define EXTERNAL extern #include "global.h" -#include // assert -#include // std::map -#include // std::string -#include // std::list +#include // assert +#include // std::map +#include // std::string +#include // std::list #include "ExchComp.h" #include "cxxMix.h" -class cxxExchange : public cxxNumKeyword +class cxxExchange:public cxxNumKeyword { -public: - cxxExchange(); + public: + cxxExchange(); cxxExchange(int n_user); - cxxExchange(struct exchange *); - cxxExchange(const std::map &exchange_map, cxxMix &mx, int n_user); - ~cxxExchange(); + cxxExchange(struct exchange *); + cxxExchange(const std::map < int, cxxExchange > &exchange_map, + cxxMix & mx, int n_user); + ~cxxExchange(); - struct exchange *cxxExchange2exchange(); + struct exchange *cxxExchange2exchange(); - struct exch_comp *cxxExchComp2exch_comp(); + struct exch_comp *cxxExchComp2exch_comp(); - void dump_raw(std::ostream& s_oss, unsigned int indent)const; + void dump_raw(std::ostream & s_oss, unsigned int indent) const; - void read_raw(CParser& parser); + void read_raw(CParser & parser); - bool get_related_phases(void); + bool get_related_phases(void); - bool get_related_rate(void); + bool get_related_rate(void); - bool get_pitzer_exchange_gammas() { + bool get_pitzer_exchange_gammas() + { return this->pitzer_exchange_gammas; } - void set_pitzer_exchange_gammas(bool b) { + void set_pitzer_exchange_gammas(bool b) + { this->pitzer_exchange_gammas = b; } - std::list &get_exchComps(void) { - return(this->exchComps); + std::list < cxxExchComp > &get_exchComps(void) + { + return (this->exchComps); } void totalize(); - const cxxNameDouble& get_totals()const + const cxxNameDouble & get_totals() const { - return totals; + return totals; }; #ifdef USE_MPI - void mpi_pack(std::vector& ints, std::vector& doubles); + void mpi_pack(std::vector < int >&ints, std::vector < double >&doubles); void mpi_unpack(int *ints, int *ii, double *doubles, int *dd); #endif -private: - void add(const cxxExchange &addee, double extensive); + private: + void add(const cxxExchange & addee, double extensive); // not written - void dump_xml(std::ostream& os, unsigned int indent = 0)const; + void dump_xml(std::ostream & os, unsigned int indent = 0) const; -protected: - std::list exchComps; - bool pitzer_exchange_gammas; + protected: + std::list < cxxExchComp > exchComps; + bool pitzer_exchange_gammas; cxxNameDouble totals; -public: + public: }; diff --git a/GasPhase.h b/GasPhase.h index 24188b85..4b6a86ce 100644 --- a/GasPhase.h +++ b/GasPhase.h @@ -5,63 +5,65 @@ #include "NameDouble.h" #define EXTERNAL extern #include "global.h" -#include // assert -#include // std::map -#include // std::string -#include // std::list -#include // std::vector +#include // assert +#include // std::map +#include // std::string +#include // std::list +#include // std::vector #include "char_star.h" #include "cxxMix.h" -class cxxGasPhase : public cxxNumKeyword +class cxxGasPhase:public cxxNumKeyword { -public: - cxxGasPhase(); - cxxGasPhase(struct gas_phase *); - cxxGasPhase(const std::map &entity_map, cxxMix &mx, int n_user); - ~cxxGasPhase(); + public: + cxxGasPhase(); + cxxGasPhase(struct gas_phase *); + cxxGasPhase(const std::map < int, cxxGasPhase > &entity_map, + cxxMix & mx, int n_user); + ~cxxGasPhase(); - enum GP_TYPE { - GP_PRESSURE = 0, - GP_VOLUME = 1 - }; + enum GP_TYPE + { + GP_PRESSURE = 0, + GP_VOLUME = 1 + }; - struct gas_phase *cxxGasPhase2gas_phase(); + struct gas_phase *cxxGasPhase2gas_phase(); - struct gas_comp *cxxGasPhaseComp2gas_comp(); + struct gas_comp *cxxGasPhaseComp2gas_comp(); - //void dump_xml(std::ostream& os, unsigned int indent = 0)const; + //void dump_xml(std::ostream& os, unsigned int indent = 0)const; - void dump_raw(std::ostream& s_oss, unsigned int indent)const; + void dump_raw(std::ostream & s_oss, unsigned int indent) const; - void read_raw(CParser& parser); + void read_raw(CParser & parser); #ifdef USE_MPI - void mpi_pack(std::vector& ints, std::vector& doubles); + void mpi_pack(std::vector < int >&ints, std::vector < double >&doubles); void mpi_unpack(int *ints, int *ii, double *doubles, int *dd); #endif void totalize(); - const cxxNameDouble& get_totals()const + const cxxNameDouble & get_totals() const { - return this->totals; + return this->totals; }; -private: - void add(const cxxGasPhase &addee, double extensive); + private: + void add(const cxxGasPhase & addee, double extensive); -protected: - cxxNameDouble gasPhaseComps; + protected: + cxxNameDouble gasPhaseComps; GP_TYPE type; - double total_p; - double volume; + double total_p; + double volume; cxxNameDouble totals; -public: - //static std::map& map; + public: + //static std::map& map; }; diff --git a/ISolution.h b/ISolution.h index 6d578d72..51fcb8ed 100644 --- a/ISolution.h +++ b/ISolution.h @@ -6,65 +6,78 @@ #include "NumKeyword.h" #include "Solution.h" //#include "Isotope.h" -#include // assert -#include // std::map -#include // std::string -#include // std::list -#include // std::vector -#include // std::set +#include // assert +#include // std::map +#include // std::string +#include // std::list +#include // std::vector +#include // std::set #include #include #include -class cxxISolution : public cxxSolution +class cxxISolution:public cxxSolution { -public: - cxxISolution(); - cxxISolution(struct solution *); - //cxxISolution(const cxxISolution&); - ~cxxISolution(); + public: + cxxISolution(); + cxxISolution(struct solution *); + //cxxISolution(const cxxISolution&); + ~cxxISolution(); - //static cxxISolution& read(CParser& parser); + //static cxxISolution& read(CParser& parser); - //void add(cxxISolutionComp conc) { this->concs.push_back(conc); } + //void add(cxxISolutionComp conc) { this->concs.push_back(conc); } - struct solution *cxxISolution2solution(); + struct solution *cxxISolution2solution(); - double get_density()const {return this->density;} - void set_density(double density) {this->density = density;} + double get_density() const + { + return this->density; + } + void set_density(double density) + { + this->density = density; + } - std::string get_units()const {return units;} - void set_units(std::string units) {units = units;} + std::string get_units() const + { + return units; + } + void set_units(std::string units) + { + units = units; + } - //char * get_redox()const {return this->pe[this->default_pe].get_name();} + //char * get_redox()const {return this->pe[this->default_pe].get_name();} - //void dump_xml(std::ostream& os, unsigned int indent = 0)const; + //void dump_xml(std::ostream& os, unsigned int indent = 0)const; void ConvertUnits(); #ifdef ORCHESTRA - void ORCH_write(std::ostream &chemistry_dat, std::ostream &input_dat, std::ostream &output_dat); - void ORCH_write_chemistry(std::ostream &chemistry_dat); - void ORCH_write_input(std::ostream &input_dat); - void ORCH_write_output_vars(std::ostream &input_dat); -private: - void ORCH_write_chemistry_water(std::ostream &chemistry_dat); - void ORCH_write_chemistry_primary(std::ostream &chemistry_dat); - void ORCH_write_chemistry_total_O_H(std::ostream &chemistry_dat); - void ORCH_write_chemistry_alkalinity(std::ostream &chemistry_dat); - void ORCH_write_chemistry_minerals(std::ostream &chemistry_dat); + void ORCH_write(std::ostream & chemistry_dat, std::ostream & input_dat, + std::ostream & output_dat); + void ORCH_write_chemistry(std::ostream & chemistry_dat); + void ORCH_write_input(std::ostream & input_dat); + void ORCH_write_output_vars(std::ostream & input_dat); + private: + void ORCH_write_chemistry_water(std::ostream & chemistry_dat); + void ORCH_write_chemistry_primary(std::ostream & chemistry_dat); + void ORCH_write_chemistry_total_O_H(std::ostream & chemistry_dat); + void ORCH_write_chemistry_alkalinity(std::ostream & chemistry_dat); + void ORCH_write_chemistry_minerals(std::ostream & chemistry_dat); #endif -protected: - friend class cxxISolutionComp; // for this->pe access - double density; - std::string units; - std::map comps; - struct pe_data *pes; - int default_pe; + protected: + friend class cxxISolutionComp; // for this->pe access + double density; + std::string units; + std::map < char *, cxxISolutionComp, CHARSTAR_LESS > comps; + struct pe_data *pes; + int default_pe; -public: - //static std::map& map; + public: + //static std::map& map; }; diff --git a/ISolutionComp.h b/ISolutionComp.h index 7b48063b..b2c3221b 100644 --- a/ISolutionComp.h +++ b/ISolutionComp.h @@ -9,70 +9,129 @@ #include "phrqproto.h" #include -#include // std::map +#include // std::map #include #include #include "char_star.h" // forward declarations -class cxxISolution; // reqd for read and dump_xml +class cxxISolution; // reqd for read and dump_xml class cxxISolutionComp { -public: - cxxISolutionComp(void); - cxxISolutionComp(struct conc *conc_ptr); - ~cxxISolutionComp(void); + public: + cxxISolutionComp(void); + cxxISolutionComp(struct conc *conc_ptr); + ~cxxISolutionComp(void); -public: + public: - //STATUS_TYPE read(CParser& parser, CSolution& sol); + //STATUS_TYPE read(CParser& parser, CSolution& sol); - void dump_xml(std::ostream& os, unsigned int indent = 0)const; + void dump_xml(std::ostream & os, unsigned int indent = 0) const; - char * get_description()const {return this->description;} - void set_description(char * description) {this->description = description;} + char *get_description() const + { + return this->description; + } + void set_description(char *description) + { + this->description = description; + } - double get_moles()const {return this->moles;} - void set_moles(double moles) {this->moles = moles;} + double get_moles() const + { + return this->moles; + } + void set_moles(double moles) + { + this->moles = moles; + } - double get_input_conc()const {return this->input_conc;} - void set_input_conc(double input_conc) {this->input_conc = input_conc;} + double get_input_conc() const + { + return this->input_conc; + } + void set_input_conc(double input_conc) + { + this->input_conc = input_conc; + } - std::string get_units()const {return this->units;} - void set_units(char * units) {this->units = units;} + std::string get_units()const + { + return this->units; + } + void set_units(char *units) + { + this->units = units; + } - char * get_equation_name()const {return this->equation_name;} - void set_equation_name(char * equation_name) {this->equation_name = equation_name;} + char *get_equation_name() const + { + return this->equation_name; + } + void set_equation_name(char *equation_name) + { + this->equation_name = equation_name; + } - double get_phase_si()const {return this->phase_si;} - void set_phase_si(int phase_si) {this->phase_si = phase_si;} + double get_phase_si() const + { + return this->phase_si; + } + void set_phase_si(int phase_si) + { + this->phase_si = phase_si; + } - int get_n_pe()const {return this->n_pe;} - void set_n_pe(int n_pe) {this->n_pe = n_pe;} + int get_n_pe() const + { + return this->n_pe; + } + void set_n_pe(int n_pe) + { + this->n_pe = n_pe; + } - char *get_as()const {return this->as;} - void set_as(char *as) {this->as = as;} + char *get_as() const + { + return this->as; + } + void set_as(char *as) + { + this->as = as; + } - //double get_gfw()const {return this->gfw;} - double get_gfw()const {return this->gfw;}; - void set_gfw(double gfw) {this->gfw = gfw;} + //double get_gfw()const {return this->gfw;} + double get_gfw() const + { + return this->gfw; + }; + void set_gfw(double gfw) + { + this->gfw = gfw; + } void set_gfw(); - bool operator<(const cxxISolutionComp& conc)const { return ::strcmp(this->description, conc.description) < 0; } + bool operator<(const cxxISolutionComp & conc) const + { + return::strcmp(this->description, conc.description) < 0; + } - static struct conc * cxxISolutionComp2conc(const std::map &t ); + static struct conc *cxxISolutionComp2conc(const std::map < char *, + cxxISolutionComp, + CHARSTAR_LESS > &t); -private: - char * description; - double moles; - double input_conc; - char * units; - char * equation_name; - double phase_si; - int n_pe; - char * as; - double gfw; + private: + char *description; + double moles; + double input_conc; + char *units; + char *equation_name; + double phase_si; + int n_pe; + char *as; + double gfw; }; #endif // ISOLUTIONCOMP_H_INCLUDED diff --git a/KineticsComp.h b/KineticsComp.h index 7097f34a..c51a62b1 100644 --- a/KineticsComp.h +++ b/KineticsComp.h @@ -4,49 +4,54 @@ #include "NameDouble.h" #define EXTERNAL extern #include "global.h" -#include // assert -#include // std::map -#include // std::string -#include // std::list -#include // std::vector +#include // assert +#include // std::map +#include // std::string +#include // std::list +#include // std::vector #include "char_star.h" -class cxxKineticsComp +class cxxKineticsComp { -public: - cxxKineticsComp(); - cxxKineticsComp(struct kinetics_comp *); - ~cxxKineticsComp(); + public: + cxxKineticsComp(); + cxxKineticsComp(struct kinetics_comp *); + ~cxxKineticsComp(); - static struct kinetics_comp *cxxKineticsComp2kinetics_comp(std::list& el); + static struct kinetics_comp *cxxKineticsComp2kinetics_comp(std::list < + cxxKineticsComp + > &el); - void dump_xml(std::ostream& os, unsigned int indent = 0)const; + void dump_xml(std::ostream & os, unsigned int indent = 0) const; - void dump_raw(std::ostream& s_oss, unsigned int indent)const; + void dump_raw(std::ostream & s_oss, unsigned int indent) const; - void read_raw(CParser& parser); - - char *get_rate_name()const {return this->rate_name;} + void read_raw(CParser & parser); + + char *get_rate_name() const + { + return this->rate_name; + } #ifdef USE_MPI void mpi_unpack(int *ints, int *ii, double *doubles, int *dd); - void mpi_pack(std::vector& ints, std::vector& doubles); + void mpi_pack(std::vector < int >&ints, std::vector < double >&doubles); #endif - void add(const cxxKineticsComp &comp, double extensive); + void add(const cxxKineticsComp & comp, double extensive); void multiply(double extensive); -protected: - char * rate_name; - cxxNameDouble namecoef; //stoichiometry of reaction - double tol; - double m; - double m0; - double moles; - std::vector d_params; + protected: + char *rate_name; + cxxNameDouble namecoef; //stoichiometry of reaction + double tol; + double m; + double m0; + double moles; + std::vector < double >d_params; -public: + public: }; diff --git a/NameDouble.h b/NameDouble.h index 43130853..0ce531aa 100644 --- a/NameDouble.h +++ b/NameDouble.h @@ -2,73 +2,95 @@ #define NAMEDOUBLE_H_INCLUDED //#define EXTERNAL extern -#include // assert -#include // std::map -#include // std::string -#include // std::list -#include // std::vector +#include // assert +#include // std::map +#include // std::string +#include // std::list +#include // std::vector //#include "global.h" #include "char_star.h" #include "Parser.h" -class cxxNameDouble : public std::map +class cxxNameDouble:public +std::map < char *, double, + CHARSTAR_LESS > { -public: - enum ND_TYPE { - ND_ELT_MOLES = 1, - ND_SPECIES_LA = 2, - ND_SPECIES_GAMMA = 3, - ND_NAME_COEF = 4 - }; + public: + enum ND_TYPE + { + ND_ELT_MOLES = 1, + ND_SPECIES_LA = 2, + ND_SPECIES_GAMMA = 3, + ND_NAME_COEF = 4 + }; - cxxNameDouble(); - cxxNameDouble(struct elt_list *); - cxxNameDouble(struct elt_list *, int count); - cxxNameDouble(struct conc *); - cxxNameDouble(struct master_activity *ma, int count, ND_TYPE); - cxxNameDouble(struct name_coef *nc, int count); - cxxNameDouble(const cxxNameDouble &old, double factor); - ~cxxNameDouble(); + cxxNameDouble(); + cxxNameDouble(struct elt_list *); + cxxNameDouble(struct elt_list *, int count); + cxxNameDouble(struct conc *); + cxxNameDouble(struct master_activity *ma, int count, ND_TYPE); + cxxNameDouble(struct name_coef *nc, int count); + cxxNameDouble(const cxxNameDouble & old, double factor); + ~ + cxxNameDouble(); - struct elt_list *elt_list(); + struct elt_list * + elt_list(); - struct master_activity *master_activity()const; + struct master_activity * + master_activity() const; - struct conc *conc()const; + struct conc * + conc() const; - struct name_coef *name_coef()const; + struct name_coef * + name_coef() const; - void dump_xml(std::ostream& s_oss, unsigned int indent)const; + void + dump_xml(std::ostream & s_oss, unsigned int indent) const; - void dump_raw(std::ostream& s_oss, unsigned int indent)const; + void + dump_raw(std::ostream & s_oss, unsigned int indent) const; - CParser::STATUS_TYPE read_raw(CParser& parser, std::istream::pos_type& pos); + CParser::STATUS_TYPE + read_raw(CParser & parser, std::istream::pos_type & pos); - void add_extensive(const cxxNameDouble &old, double factor); - void add_intensive(const cxxNameDouble &addee, double fthis, double f2); - void add_log_activities(const cxxNameDouble &addee, double fthis, double f2); - void add(const char * key, double total); - void multiply(double factor); + void + add_extensive(const cxxNameDouble & old, double factor); + void + add_intensive(const cxxNameDouble & addee, double fthis, double f2); + void + add_log_activities(const cxxNameDouble & addee, double fthis, double f2); + void + add(const char *key, double total); + void + multiply(double factor); - void insert(char *str, double d) { + void + insert(char *str, double d) + { (*this)[str] = d; } - void mpi_pack(std::vector& ints, std::vector& doubles); - void mpi_pack(int *ints, int *ii, double *doubles, int *dd); + void + mpi_pack(std::vector < int >&ints, std::vector < double >&doubles); + void + mpi_pack(int *ints, int *ii, double *doubles, int *dd); - void mpi_unpack(int *ints, int *ii, double *doubles, int *dd); + void + mpi_unpack(int *ints, int *ii, double *doubles, int *dd); - enum ND_TYPE type; - -protected: + enum ND_TYPE + type; - //std::map totals; + protected: + + //std::map totals; -public: - //static std::map& map; + public: + //static std::map& map; }; diff --git a/NumKeyword.h b/NumKeyword.h index 55298566..9c31fb69 100644 --- a/NumKeyword.h +++ b/NumKeyword.h @@ -2,8 +2,8 @@ #define NUMKEYWORD_H_INCLUDED #include "Parser.h" -#include // std::ostream -#include // std::string +#include // std::ostream +#include // std::string //#define EXTERNAL extern //#include "global.h" //#include "phrqproto.h" @@ -11,33 +11,58 @@ extern char *string_duplicate(const char *); class cxxNumKeyword { -public: - cxxNumKeyword(); - virtual ~cxxNumKeyword(); + public: + cxxNumKeyword(); + virtual ~ cxxNumKeyword(); - char * get_description()const { return string_duplicate(this->description.c_str()); } - void set_description(std::string str) { this->description = str; } - void set_description(char * str) { if (str != NULL) this->description = str; } + char *get_description() const + { + return string_duplicate(this->description.c_str()); + } + void set_description(std::string str) + { + this->description = str; + } + void set_description(char *str) + { + if (str != NULL) + this->description = str; + } - int get_n_user()const { return this->n_user; } - void set_n_user(int user) { this->n_user = user; } + int get_n_user() const + { + return this->n_user; + } + void set_n_user(int user) + { + this->n_user = user; + } - int get_n_user_end()const { return this->n_user_end; } - void set_n_user_end(int user_end) { this->n_user_end = user_end; } + int get_n_user_end() const + { + return this->n_user_end; + } + void set_n_user_end(int user_end) + { + this->n_user_end = user_end; + } - bool operator<(const cxxNumKeyword& key)const { return (this->n_user < key.n_user); } + bool operator<(const cxxNumKeyword & key) const + { + return (this->n_user < key.n_user); + } - virtual void dump_xml(std::ostream& os, unsigned int indent = 0)const; + virtual void dump_xml(std::ostream & os, unsigned int indent = 0) const; - void read_number_description(CParser& parser); + void read_number_description(CParser & parser); -protected: - int n_user; - int n_user_end; - std::string description; + protected: + int n_user; + int n_user_end; + std::string description; -private: - void read_number_description(std::istream& is); + private: + void read_number_description(std::istream & is); }; #endif // !defined(NUMKEYWORD_H_INCLUDED) diff --git a/PPassemblage.h b/PPassemblage.h index ff2e3f44..b47d5654 100644 --- a/PPassemblage.h +++ b/PPassemblage.h @@ -4,63 +4,67 @@ #include "NumKeyword.h" #define EXTERNAL extern #include "global.h" -#include // assert -#include // std::map -#include // std::string -#include // std::list -#include // std::vector +#include // assert +#include // std::map +#include // std::string +#include // std::list +#include // std::vector #include "char_star.h" #include "PPassemblageComp.h" #include "cxxMix.h" -class cxxPPassemblage : public cxxNumKeyword +class cxxPPassemblage:public cxxNumKeyword { -public: - cxxPPassemblage(); - cxxPPassemblage(struct pp_assemblage *); - cxxPPassemblage(const std::map &entity_map, cxxMix &mx, int n_user); - ~cxxPPassemblage(); + public: + cxxPPassemblage(); + cxxPPassemblage(struct pp_assemblage *); + cxxPPassemblage(const std::map < int, cxxPPassemblage > &entity_map, + cxxMix & mx, int n_user); + ~cxxPPassemblage(); - struct pp_assemblage *cxxPPassemblage2pp_assemblage(); + struct pp_assemblage *cxxPPassemblage2pp_assemblage(); - struct pure_phase *cxxPPassemblageComp2pure_phase(); + struct pure_phase *cxxPPassemblageComp2pure_phase(); - void dump_raw(std::ostream& s_oss, unsigned int indent)const; + void dump_raw(std::ostream & s_oss, unsigned int indent) const; - void read_raw(CParser& parser); + void read_raw(CParser & parser); - const cxxNameDouble& get_totals()const + const cxxNameDouble & get_totals() const { - return this->totals; + return this->totals; }; #ifdef USE_MPI - void mpi_pack(std::vector& ints, std::vector& doubles); + void mpi_pack(std::vector < int >&ints, std::vector < double >&doubles); void mpi_unpack(int *ints, int *ii, double *doubles, int *dd); #endif void totalize(); #ifdef ORCHESTRA - void ORCH_write_chemistry(std::ostream &chemistry_dat); - void ORCH_write_output_vars(std::ostream &outstream); - void ORCH_read(std::vector > output_vector, std::vector < std::pair < std::string, double > >::iterator &it); - void ORCH_store_global(std::map < std::string, double > output_map); + void ORCH_write_chemistry(std::ostream & chemistry_dat); + void ORCH_write_output_vars(std::ostream & outstream); + void ORCH_read(std::vector < std::pair < std::string, + double >>output_vector, + std::vector < std::pair < std::string, + double >>::iterator & it); + void ORCH_store_global(std::map < std::string, double >output_map); #endif -private: - void add(const cxxPPassemblage &addee, double extensive); + private: + void add(const cxxPPassemblage & addee, double extensive); // not written - void dump_xml(std::ostream& os, unsigned int indent = 0)const; + void dump_xml(std::ostream & os, unsigned int indent = 0) const; -protected: - std::list ppAssemblageComps; - cxxNameDouble eltList; + protected: + std::list < cxxPPassemblageComp > ppAssemblageComps; + cxxNameDouble eltList; cxxNameDouble totals; -public: - //static std::map& map; + public: + //static std::map& map; }; diff --git a/PPassemblageComp.h b/PPassemblageComp.h index fbb6aa72..b64096ee 100644 --- a/PPassemblageComp.h +++ b/PPassemblageComp.h @@ -4,60 +4,65 @@ #include "NameDouble.h" #define EXTERNAL extern #include "global.h" -#include // assert -#include // std::map -#include // std::string -#include // std::list -#include // std::vector +#include // assert +#include // std::map +#include // std::string +#include // std::list +#include // std::vector #include "char_star.h" class cxxPPassemblageComp { -public: - cxxPPassemblageComp(); - cxxPPassemblageComp(struct pure_phase *); - ~cxxPPassemblageComp(); + public: + cxxPPassemblageComp(); + cxxPPassemblageComp(struct pure_phase *); + ~cxxPPassemblageComp(); - static struct pure_phase *cxxPPassemblageComp2pure_phase(std::list& el); + static struct pure_phase *cxxPPassemblageComp2pure_phase(std::list < + cxxPPassemblageComp + > &el); - void dump_xml(std::ostream& os, unsigned int indent = 0)const; + void dump_xml(std::ostream & os, unsigned int indent = 0) const; - void dump_raw(std::ostream& s_oss, unsigned int indent)const; + void dump_raw(std::ostream & s_oss, unsigned int indent) const; - void read_raw(CParser& parser); + void read_raw(CParser & parser); - char *get_name()const {return this->name;} + char *get_name() const + { + return this->name; + } - struct phase *get_phase(); + struct phase *get_phase(); void totalize(); - const cxxNameDouble &get_totals()const + const cxxNameDouble & get_totals() const { - return (this->totals); + return (this->totals); }; - void add(const cxxPPassemblageComp &comp, double extensive); + void add(const cxxPPassemblageComp & comp, double extensive); void multiply(double extensive); #ifdef USE_MPI - void mpi_pack(std::vector& ints, std::vector& doubles); + void mpi_pack(std::vector < int >&ints, std::vector < double >&doubles); void mpi_unpack(int *ints, int *ii, double *doubles, int *dd); #endif -protected: - char *name; - char *add_formula; - double si; - double moles; - double delta; - double initial_moles; + protected: + char *name; + char *add_formula; + double si; + double moles; + double delta; + double initial_moles; bool force_equality; - bool dissolve_only; + bool dissolve_only; cxxNameDouble totals; -public: + public: }; diff --git a/Parser.h b/Parser.h index 335d552c..4a433053 100644 --- a/Parser.h +++ b/Parser.h @@ -2,84 +2,92 @@ #define PARSER_H_INCLUDED extern int input_error; -#include // std::string -#include // std::map -#include // std::vector -#include // std::istringstream std::ostringstream -#include // std::ostream -#include // std::istream +#include // std::string +#include // std::map +#include // std::vector +#include // std::istringstream std::ostringstream +#include // std::ostream +#include // std::istream #include "char_star.h" class CParser { -public: - CParser(std::istream& input); - CParser(std::istream& input, std::ostream& output); - CParser(std::istream& input, std::ostream& output, std::ostream& error); + public: + CParser(std::istream & input); + CParser(std::istream & input, std::ostream & output); + CParser(std::istream & input, std::ostream & output, + std::ostream & error); - virtual ~CParser(); + virtual ~ CParser(); - enum LINE_TYPE { - LT_EOF = -1, - LT_OK = 1, - LT_EMPTY = 2, - LT_KEYWORD = 3, - LT_OPTION = 8 - }; + enum LINE_TYPE + { + LT_EOF = -1, + LT_OK = 1, + LT_EMPTY = 2, + LT_KEYWORD = 3, + LT_OPTION = 8 + }; - enum TOKEN_TYPE { - TT_EMPTY = 2, - TT_UPPER = 4, - TT_LOWER = 5, - TT_DIGIT = 6, - TT_UNKNOWN = 7 - }; + enum TOKEN_TYPE + { + TT_EMPTY = 2, + TT_UPPER = 4, + TT_LOWER = 5, + TT_DIGIT = 6, + TT_UNKNOWN = 7 + }; - enum FIND_TYPE { - FT_OK = 0, - FT_ERROR = 1 - }; + enum FIND_TYPE + { + FT_OK = 0, + FT_ERROR = 1 + }; - enum KEY_TYPE { - KT_NONE = -1, - KT_END = 0, - KT_EOF = 1, - KT_SOLUTION_RAW = 5, - KT_EXCHANGE_RAW = 6, - KT_GASPHASE_RAW = 7, - KT_KINETICS_RAW = 8, - KT_PPASSEMBLAGE_RAW = 9, - KT_SSASSEMBLAGE_RAW = 10, - KT_SURFACE_RAW = 11 + enum KEY_TYPE + { + KT_NONE = -1, + KT_END = 0, + KT_EOF = 1, + KT_SOLUTION_RAW = 5, + KT_EXCHANGE_RAW = 6, + KT_GASPHASE_RAW = 7, + KT_KINETICS_RAW = 8, + KT_PPASSEMBLAGE_RAW = 9, + KT_SSASSEMBLAGE_RAW = 10, + KT_SURFACE_RAW = 11 + }; - }; + enum OPT_TYPE + { + OPT_DEFAULT = -4, + OPT_ERROR = -3, + OPT_KEYWORD = -2, + OPT_EOF = -1 + }; - enum OPT_TYPE { - OPT_DEFAULT = -4, - OPT_ERROR = -3, - OPT_KEYWORD = -2, - OPT_EOF = -1 - }; + enum ONERROR_TYPE + { + OT_CONTINUE = 0, + OT_STOP = 1 + }; - enum ONERROR_TYPE { - OT_CONTINUE = 0, - OT_STOP = 1 - }; - - enum ECHO_OPTION { - EO_NONE = 0, - EO_ALL = 1, - EO_KEYWORDS = 2, - EO_NOKEYWORDS = 3 - }; + enum ECHO_OPTION + { + EO_NONE = 0, + EO_ALL = 1, + EO_KEYWORDS = 2, + EO_NOKEYWORDS = 3 + }; - enum STATUS_TYPE { - PARSER_ERROR = 0, - PARSER_OK = 1 - }; + enum STATUS_TYPE + { + PARSER_ERROR = 0, + PARSER_OK = 1 + }; - /** + /** Function gets a new line and checks for empty, eof, and keywords. Arguments: @@ -98,9 +106,10 @@ public: Terminates if EOF and allow_eof == false. */ - LINE_TYPE check_line(const std::string& str, bool allow_empty, bool allow_eof, bool allow_keyword, bool print); + LINE_TYPE check_line(const std::string & str, bool allow_empty, + bool allow_eof, bool allow_keyword, bool print); - /** + /** Read a line from input file put in "line". Copy of input line is stored in "line_save". Characters after # are discarded in line but retained in "line_save" @@ -114,30 +123,54 @@ public: LT_OK, LT_OPTION */ - LINE_TYPE get_line(); + LINE_TYPE get_line(); - // bool check_key(const std::string::iterator ptr); - bool check_key(std::string::iterator begin, std::string::iterator end); + // bool check_key(const std::string::iterator ptr); + bool check_key(std::string::iterator begin, std::string::iterator end); - STATUS_TYPE check_units(std::string& tot_units, bool alkalinity, bool check_compatibility, - const std::string& default_units, bool print); + STATUS_TYPE check_units(std::string & tot_units, bool alkalinity, + bool check_compatibility, + const std::string & default_units, bool print); - KEY_TYPE next_keyword()const { return m_next_keyword; } - int get_option(const std::vector& opt_list, std::string::iterator& next_char); - int get_option(const std::vector& opt_list, std::istream::pos_type& next_pos); - int getOptionFromLastLine(const std::vector& opt_list, std::string::iterator& next_char); - int getOptionFromLastLine(const std::vector& opt_list, std::istream::pos_type& next_pos); + KEY_TYPE next_keyword() const + { + return m_next_keyword; + } + int get_option(const std::vector < std::string > &opt_list, + std::string::iterator & next_char); + int get_option(const std::vector < std::string > &opt_list, + std::istream::pos_type & next_pos); + int getOptionFromLastLine(const std::vector < std::string > &opt_list, + std::string::iterator & next_char); + int getOptionFromLastLine(const std::vector < std::string > &opt_list, + std::istream::pos_type & next_pos); - std::string& line() {return m_line;} - std::istringstream& get_iss() {return m_line_iss;} - int incr_input_error() {++::input_error; return ++m_input_error;} - std::ostream& get_output() {return m_output_stream;} - int get_input_error() {return m_input_error;} + std::string & line() + { + return m_line; + } + std::istringstream & get_iss() + { + return m_line_iss; + } + int incr_input_error() + { + ++::input_error; + return ++m_input_error; + } + std::ostream & get_output() + { + return m_output_stream; + } + int get_input_error() + { + return m_input_error; + } - /** + /** Copies from begin to token until first space is encountered. Arguments: @@ -152,13 +185,15 @@ public: TT_DIGIT TT_UNKNOWN */ - static TOKEN_TYPE copy_token(std::string& token, std::string::iterator& begin, std::string::iterator& end); - static TOKEN_TYPE token_type(const std::string& token); - static TOKEN_TYPE copy_token(std::string& token, std::istream& is); - TOKEN_TYPE copy_token(std::string& token, std::istream::pos_type& pos); - CParser::TOKEN_TYPE peek_token(); + static TOKEN_TYPE copy_token(std::string & token, + std::string::iterator & begin, + std::string::iterator & end); + static TOKEN_TYPE token_type(const std::string & token); + static TOKEN_TYPE copy_token(std::string & token, std::istream & is); + TOKEN_TYPE copy_token(std::string & token, std::istream::pos_type & pos); + CParser::TOKEN_TYPE peek_token(); - /** + /** Function reads an element name out of the equation string. An element name is composed of a capital letter followed by any number of lower case characters. @@ -170,10 +205,12 @@ public: end input, points to last position in the equation element input pointer to place to return element character string */ - STATUS_TYPE get_elt(std::string::iterator& begin, const std::string::iterator end, std::string& element); + STATUS_TYPE get_elt(std::string::iterator & begin, + const std::string::iterator end, + std::string & element); - /** + /** Compares a string value to match beginning letters of a list of options Arguments: @@ -189,39 +226,58 @@ public: n -1 item not matched i position of match in list */ - static FIND_TYPE find_option(const std::string& item, int *n, const std::vector& list, bool exact); + static FIND_TYPE find_option(const std::string & item, int *n, + const std::vector < std::string > &list, + bool exact); - int error_msg(const std::ostringstream& err_str, ONERROR_TYPE stop) {return error_msg(err_str.str().c_str(), stop);} - int error_msg(const char *err_str, ONERROR_TYPE stop); - int warning_msg(const char *err_str); - - void set_echo_file(ECHO_OPTION opt) {echo_file = opt;} - ECHO_OPTION get_echo_file() {return this->echo_file;}; + int error_msg(const std::ostringstream & err_str, ONERROR_TYPE stop) + { + return error_msg(err_str.str().c_str(), stop); + } + int error_msg(const char *err_str, ONERROR_TYPE stop); + int warning_msg(const char *err_str); - void set_echo_stream(ECHO_OPTION opt) {echo_stream = opt;} - ECHO_OPTION get_echo_stream() {return this->echo_stream;}; + void set_echo_file(ECHO_OPTION opt) + { + echo_file = opt; + } + ECHO_OPTION get_echo_file() + { + return this->echo_file; + }; - STATUS_TYPE parse_couple(std::string& token); + void set_echo_stream(ECHO_OPTION opt) + { + echo_stream = opt; + } + ECHO_OPTION get_echo_stream() + { + return this->echo_stream; + }; - STATUS_TYPE addPair(std::map &totals, std::istream::pos_type& pos); - STATUS_TYPE addPair(std::map &totals, std::istream::pos_type& pos); + STATUS_TYPE parse_couple(std::string & token); -protected: - LINE_TYPE get_logical_line(); + STATUS_TYPE addPair(std::map < char *, double, CHARSTAR_LESS > &totals, + std::istream::pos_type & pos); + STATUS_TYPE addPair(std::map < char *, double >&totals, + std::istream::pos_type & pos); -private: - std::istream& m_input_stream; - std::ostream& m_output_stream; - std::ostream& m_error_stream; - int m_input_error; - KEY_TYPE m_next_keyword; - std::string m_line; - std::string m_line_save; - std::istringstream m_line_iss; - LINE_TYPE m_line_type; - ECHO_OPTION echo_stream; - ECHO_OPTION echo_file; + protected: + LINE_TYPE get_logical_line(); + + private: + std::istream & m_input_stream; + std::ostream & m_output_stream; + std::ostream & m_error_stream; + int m_input_error; + KEY_TYPE m_next_keyword; + std::string m_line; + std::string m_line_save; + std::istringstream m_line_iss; + LINE_TYPE m_line_type; + ECHO_OPTION echo_stream; + ECHO_OPTION echo_file; }; #endif // PARSER_H_INCLUDED diff --git a/Reaction.h b/Reaction.h index 8c5e6dd0..7705302e 100644 --- a/Reaction.h +++ b/Reaction.h @@ -5,40 +5,40 @@ #include "NameDouble.h" #define EXTERNAL extern #include "global.h" -#include // assert -#include // std::map -#include // std::string -#include // std::list -#include // std::vector +#include // assert +#include // std::map +#include // std::string +#include // std::list +#include // std::vector #include "char_star.h" -class cxxReaction : public cxxNumKeyword +class cxxReaction:public cxxNumKeyword { -public: - cxxReaction(); - cxxReaction(struct irrev *); - ~cxxReaction(); + public: + cxxReaction(); + cxxReaction(struct irrev *); + ~cxxReaction(); - struct irrev *cxxReaction2irrev(); + struct irrev *cxxReaction2irrev(); - //void dump_xml(std::ostream& os, unsigned int indent = 0)const; + //void dump_xml(std::ostream& os, unsigned int indent = 0)const; - void dump_raw(std::ostream& s_oss, unsigned int indent)const; + void dump_raw(std::ostream & s_oss, unsigned int indent) const; - void read_raw(CParser& parser); + void read_raw(CParser & parser); -protected: - cxxNameDouble reactantList; - cxxNameDouble elementList; - std::vector steps; + protected: + cxxNameDouble reactantList; + cxxNameDouble elementList; + std::vector < double >steps; int countSteps; bool equalIncrements; char *units; -public: - //static std::map& map; + public: + //static std::map& map; }; diff --git a/SAXPhreeqc.h b/SAXPhreeqc.h index 68a1f587..62b0da05 100644 --- a/SAXPhreeqc.h +++ b/SAXPhreeqc.h @@ -2,15 +2,16 @@ #define _INC_SAXPHREEQC_H #if defined(__cplusplus) | defined(_CPP) -extern "C" { +extern "C" +{ #endif -void SAX_StartSystem (); -int SAX_AddSolution (struct solution* solution_ptr); -void SAX_EndSystem (); -int SAX_GetXMLLength (); -const char* SAX_GetXMLStr (); -int SAX_UnpackSolutions(void* pvBuffer, int buf_size); + void SAX_StartSystem(); + int SAX_AddSolution(struct solution *solution_ptr); + void SAX_EndSystem(); + int SAX_GetXMLLength(); + const char *SAX_GetXMLStr(); + int SAX_UnpackSolutions(void *pvBuffer, int buf_size); #if defined(__cplusplus) | defined(_CPP) diff --git a/SSassemblage.h b/SSassemblage.h index 00c5f99d..c3255ec3 100644 --- a/SSassemblage.h +++ b/SSassemblage.h @@ -4,56 +4,57 @@ #include "NumKeyword.h" #define EXTERNAL extern #include "global.h" -#include // assert -#include // std::map -#include // std::string -#include // std::list -#include // std::vector +#include // assert +#include // std::map +#include // std::string +#include // std::list +#include // std::vector #include "char_star.h" #include "SSassemblageSS.h" #include "cxxMix.h" -class cxxSSassemblage : public cxxNumKeyword +class cxxSSassemblage:public cxxNumKeyword { -public: - cxxSSassemblage(); - cxxSSassemblage(struct s_s_assemblage *); - cxxSSassemblage(const std::map &entity_map, cxxMix &mx, int n_user); - ~cxxSSassemblage(); + public: + cxxSSassemblage(); + cxxSSassemblage(struct s_s_assemblage *); + cxxSSassemblage(const std::map < int, cxxSSassemblage > &entity_map, + cxxMix & mx, int n_user); + ~cxxSSassemblage(); - struct s_s_assemblage *cxxSSassemblage2s_s_assemblage(); + struct s_s_assemblage *cxxSSassemblage2s_s_assemblage(); - struct s_s *cxxSSassemblageComp2s_s(); + struct s_s *cxxSSassemblageComp2s_s(); - //void dump_xml(std::ostream& os, unsigned int indent = 0)const; + //void dump_xml(std::ostream& os, unsigned int indent = 0)const; - void dump_raw(std::ostream& s_oss, unsigned int indent)const; + void dump_raw(std::ostream & s_oss, unsigned int indent) const; - void read_raw(CParser& parser); + void read_raw(CParser & parser); #ifdef USE_MPI - void mpi_pack(std::vector& ints, std::vector& doubles); + void mpi_pack(std::vector < int >&ints, std::vector < double >&doubles); void mpi_unpack(int *ints, int *ii, double *doubles, int *dd); #endif void totalize(); - const cxxNameDouble& get_totals()const + const cxxNameDouble & get_totals() const { - return this->totals; + return this->totals; }; -private: - void add(const cxxSSassemblage &addee, double extensive); + private: + void add(const cxxSSassemblage & addee, double extensive); -protected: - std::list ssAssemblageSSs; + protected: + std::list < cxxSSassemblageSS > ssAssemblageSSs; cxxNameDouble totals; -public: - //static std::map& map; + public: + //static std::map& map; }; diff --git a/SSassemblageSS.h b/SSassemblageSS.h index ca23b2e4..c999d104 100644 --- a/SSassemblageSS.h +++ b/SSassemblageSS.h @@ -4,70 +4,75 @@ #include "NameDouble.h" #define EXTERNAL extern #include "global.h" -#include // assert -#include // std::map -#include // std::string -#include // std::list -#include // std::vector +#include // assert +#include // std::map +#include // std::string +#include // std::list +#include // std::vector #include "char_star.h" -class cxxSSassemblageSS +class cxxSSassemblageSS { -public: - cxxSSassemblageSS(); - cxxSSassemblageSS(struct s_s *); - ~cxxSSassemblageSS(); + public: + cxxSSassemblageSS(); + cxxSSassemblageSS(struct s_s *); + ~cxxSSassemblageSS(); - enum SS_PARAMETER_TYPE { - SS_PARM_NONE = -1, - SS_PARM_A0_A1 = 0, - SS_PARM_GAMMAS = 1, - SS_PARM_DIST_COEF = 2, - SS_PARM_MISCIBILITY = 3, - SS_PARM_SPINODAL = 4, - SS_PARM_CRITICAL = 5, - SS_PARM_ALYOTROPIC = 6, - SS_PARM_DIM_GUGG = 7, - SS_PARM_WALDBAUM = 8, - SS_PARM_MARGULES = 9 - }; + enum SS_PARAMETER_TYPE + { + SS_PARM_NONE = -1, + SS_PARM_A0_A1 = 0, + SS_PARM_GAMMAS = 1, + SS_PARM_DIST_COEF = 2, + SS_PARM_MISCIBILITY = 3, + SS_PARM_SPINODAL = 4, + SS_PARM_CRITICAL = 5, + SS_PARM_ALYOTROPIC = 6, + SS_PARM_DIM_GUGG = 7, + SS_PARM_WALDBAUM = 8, + SS_PARM_MARGULES = 9 + }; - static struct s_s *cxxSSassemblageSS2s_s(std::list& el); + static struct s_s *cxxSSassemblageSS2s_s(std::list < cxxSSassemblageSS > + &el); - void dump_xml(std::ostream& os, unsigned int indent = 0)const; + void dump_xml(std::ostream & os, unsigned int indent = 0) const; - void dump_raw(std::ostream& s_oss, unsigned int indent)const; + void dump_raw(std::ostream & s_oss, unsigned int indent) const; - void read_raw(CParser& parser); - - char *get_name()const {return this->name;} + void read_raw(CParser & parser); + + char *get_name() const + { + return this->name; + } void totalize(); - const cxxNameDouble &get_totals()const + const cxxNameDouble & get_totals() const { - return (this->totals); + return (this->totals); }; #ifdef USE_MPI - void mpi_pack(std::vector& ints, std::vector& doubles); + void mpi_pack(std::vector < int >&ints, std::vector < double >&doubles); void mpi_unpack(int *ints, int *ii, double *doubles, int *dd); #endif - void add(const cxxSSassemblageSS &comp, double extensive); + void add(const cxxSSassemblageSS & comp, double extensive); void multiply(double extensive); -protected: - char *name; + protected: + char *name; cxxNameDouble comps; - double a0, a1; - double ag0, ag1; - bool miscibility; + double a0, a1; + double ag0, ag1; + bool miscibility; double xb1, xb2; cxxNameDouble totals; -public: + public: }; diff --git a/SaxPhreeqcHandlers.h b/SaxPhreeqcHandlers.h index 2eb590a7..eb247ed9 100644 --- a/SaxPhreeqcHandlers.h +++ b/SaxPhreeqcHandlers.h @@ -9,8 +9,8 @@ #pragma once #endif // _MSC_VER > 1000 -#include // iswspace sprintf -#include // SAX2XMLReader +#include // iswspace sprintf +#include // SAX2XMLReader /** #include **/ @@ -25,10 +25,17 @@ #define LDBLE double #endif -struct XMLCH_LESS : std::binary_function { -bool operator()(const XMLCh* _X, const XMLCh* _Y) const +struct XMLCH_LESS: +std::binary_function < const XMLCh *, const XMLCh *, + bool > { - return xns::XMLString::compareString( _X, _Y) < 0;} + bool + operator() (const XMLCh * _X, const XMLCh * _Y) const + { + return + xns::XMLString::compareString(_X, _Y) < + 0; + } }; #include @@ -41,114 +48,159 @@ bool operator()(const XMLCh* _X, const XMLCh* _Y) const //} -class Cconc : public conc +class + Cconc: + public + conc { -public: - Cconc() { conc_init(this); } - ~Cconc() { ; } + public: + Cconc() + { + conc_init(this); + } + ~ + Cconc() + {; + } }; -class SaxPhreeqcHandlers : public xns::DefaultHandler +class + SaxPhreeqcHandlers: + public + xns::DefaultHandler { -public: - SaxPhreeqcHandlers(); - virtual ~SaxPhreeqcHandlers(); + public: + SaxPhreeqcHandlers(); + virtual ~ + SaxPhreeqcHandlers(); - // ----------------------------------------------------------------------- - // Implementations of the SAX DocumentHandler interface - // ----------------------------------------------------------------------- - void endDocument(); + // ----------------------------------------------------------------------- + // Implementations of the SAX DocumentHandler interface + // ----------------------------------------------------------------------- + void + endDocument(); - void endElement(const XMLCh* const uri, const XMLCh* const name, const XMLCh* const qname); + void + endElement(const XMLCh * const uri, const XMLCh * const name, + const XMLCh * const qname); - void characters(const XMLCh* const chars, const unsigned int length); + void + characters(const XMLCh * const chars, const unsigned int length); - void ignorableWhitespace(const XMLCh* const chars, const unsigned int length); + void + ignorableWhitespace(const XMLCh * const chars, const unsigned int length); - void processingInstruction(const XMLCh* const target, const XMLCh* const data); + void + processingInstruction(const XMLCh * const target, + const XMLCh * const data); - void startDocument(); + void + startDocument(); - void startElement(const XMLCh* const uri, const XMLCh* const name, const XMLCh* const qname, const xns::Attributes& attributes); + void + startElement(const XMLCh * const uri, const XMLCh * const name, + const XMLCh * const qname, + const xns::Attributes & attributes); - // element types - enum elementType - { - typeNULL, - typePHAST_STATE, - typeSYSTEM, - typeSOLUTION, - typeSOLN_PE, - typeSOLN_TOTAL, - typeSOLN_MASTER_ACTIVITY, - typeSOLN_ISOTOPE, - typeSOLN_SPECIES_GAMMA - } eltType; - // attribute types - enum attributeType - { - attNULL, - attSOLN_new_def, - attSOLN_n_user, - attSOLN_n_user_end, - attSOLN_description, - attSOLN_tc, - attSOLN_ph, - attSOLN_solution_pe, - attSOLN_mu, - attSOLN_ah2o, - attSOLN_density, - attSOLN_total_h, - attSOLN_total_o, - attSOLN_cb, - attSOLN_mass_water, - attSOLN_total_alkalinity, - attSOLN_total_co2, - attSOLN_units, - attSOLN_default_pe, - attSOLN_count_master_activity, - attSOLN_count_isotopes, - attSOLN_count_species_gamma, - attSOLN_PE_name, - attM_A_description, - attM_A_la, - attM_A_list, - attISO_isotope_number, - attISO_elt_name, - attISO_isotope_name, - attISO_total, - attISO_ratio, - attISO_ratio_uncertainty, - attISO_x_ratio_uncertainty, - attISO_coef, - attCONC_description, - attCONC_moles, - attCONC_input_conc, - attCONC_units, - attCONC_equation_name, - attCONC_phase_si, - attCONC_n_pe, - attCONC_as, - attCONC_gfw, - } attType; + // element types + enum elementType + { + typeNULL, + typePHAST_STATE, + typeSYSTEM, + typeSOLUTION, + typeSOLN_PE, + typeSOLN_TOTAL, + typeSOLN_MASTER_ACTIVITY, + typeSOLN_ISOTOPE, + typeSOLN_SPECIES_GAMMA + } eltType; + // attribute types + enum attributeType + { + attNULL, + attSOLN_new_def, + attSOLN_n_user, + attSOLN_n_user_end, + attSOLN_description, + attSOLN_tc, + attSOLN_ph, + attSOLN_solution_pe, + attSOLN_mu, + attSOLN_ah2o, + attSOLN_density, + attSOLN_total_h, + attSOLN_total_o, + attSOLN_cb, + attSOLN_mass_water, + attSOLN_total_alkalinity, + attSOLN_total_co2, + attSOLN_units, + attSOLN_default_pe, + attSOLN_count_master_activity, + attSOLN_count_isotopes, + attSOLN_count_species_gamma, + attSOLN_PE_name, + attM_A_description, + attM_A_la, + attM_A_list, + attISO_isotope_number, + attISO_elt_name, + attISO_isotope_name, + attISO_total, + attISO_ratio, + attISO_ratio_uncertainty, + attISO_x_ratio_uncertainty, + attISO_coef, + attCONC_description, + attCONC_moles, + attCONC_input_conc, + attCONC_units, + attCONC_equation_name, + attCONC_phase_si, + attCONC_n_pe, + attCONC_as, + attCONC_gfw, + } attType; - int processSolutionAttributes(const xns::Attributes& attributes); - int processSolutionTotalAttributes(const xns::Attributes& attributes, struct conc *c); - int processMasterActivityAttributes(const xns::Attributes& attributes, struct master_activity *ma); - //int processMasterActivityAttributes(const xns::Attributes& attributes, std::vector *v); - int processIsotopeAttributes(const xns::Attributes& attributes, struct isotope *iso); + int + processSolutionAttributes(const xns::Attributes & attributes); + int + processSolutionTotalAttributes(const xns::Attributes & attributes, + struct conc *c); + int + processMasterActivityAttributes(const xns::Attributes & attributes, + struct master_activity *ma); + //int processMasterActivityAttributes(const xns::Attributes& attributes, std::vector *v); + int + processIsotopeAttributes(const xns::Attributes & attributes, + struct isotope *iso); -protected: - std::vector totals; - std::vector acts, s_gammas; - std::vector isotopes; - std::map< const XMLCh*, elementType, XMLCH_LESS > mapXMLCh2Type; - std::map< const XMLCh*, attributeType, XMLCH_LESS > mapXMLCh2AttType; - /** + protected: + std::vector < + conc > + totals; + std::vector < + master_activity > + acts, + s_gammas; + std::vector < + isotope > + isotopes; + std::map < const XMLCh *, + elementType, + XMLCH_LESS > + mapXMLCh2Type; + std::map < const XMLCh *, + attributeType, + XMLCH_LESS > + mapXMLCh2AttType; + /** std::hash_map, XMLCH_EQUALS> m_hashmapXMLCh2Type; **/ - struct solution* solution_ptr; + struct solution * + solution_ptr; }; #endif // !defined(AFX_SAXPHREEQCHANDLERS_H__4A69D5F5_2E57_4001_911D_4ABF6F2C0A0B__INCLUDED_) diff --git a/Solution.h b/Solution.h index 04261ee8..8804d8d5 100644 --- a/Solution.h +++ b/Solution.h @@ -8,116 +8,193 @@ //#define EXTERNAL extern //#include "global.h" -#include // assert -#include // std::map -#include // std::string -#include // std::vector +#include // assert +#include // std::map +#include // std::string +#include // std::vector #include #include "char_star.h" -class cxxSolution : public cxxNumKeyword +class cxxSolution:public cxxNumKeyword { -public: - cxxSolution(); - cxxSolution(struct solution *); - cxxSolution(int n_user); - cxxSolution(const std::map &solution_map, cxxMix &mx, int n_user); - ~cxxSolution(); + public: + cxxSolution(); + cxxSolution(struct solution *); + cxxSolution(int n_user); + cxxSolution(const std::map < int, cxxSolution > &solution_map, + cxxMix & mx, int n_user); + ~cxxSolution(); - //static cxxSolution& read(CParser& parser); + //static cxxSolution& read(CParser& parser); - double get_tc()const {return this->tc;} - void set_tc(double tc) {this->tc = tc;} + double get_tc() const + { + return this->tc; + } + void set_tc(double tc) + { + this->tc = tc; + } - double get_ph()const {return this->ph;} - void set_ph(double pH) {this->ph = pH;} + double get_ph() const + { + return this->ph; + } + void set_ph(double pH) + { + this->ph = pH; + } - double get_pe()const {return this->pe;} - void set_pe(double pe) {this->pe =pe;} + double get_pe() const + { + return this->pe; + } + void set_pe(double pe) + { + this->pe = pe; + } - double get_mu()const {return this->mu;} - void set_mu(double mu) {this->mu = mu;} + double get_mu() const + { + return this->mu; + } + void set_mu(double mu) + { + this->mu = mu; + } - double get_ah2o()const {return this->ah2o;} - void set_ah2o(double ah2o) {this->ah2o = ah2o;} + double get_ah2o() const + { + return this->ah2o; + } + void set_ah2o(double ah2o) + { + this->ah2o = ah2o; + } - double get_total_h()const {return this->total_h;} - void set_total_h(double total_h) {this->total_h = total_h;} + double get_total_h() const + { + return this->total_h; + } + void set_total_h(double total_h) + { + this->total_h = total_h; + } - double get_total_o()const {return this->total_o;} - void set_total_o(double total_o) {this->total_o = total_o;} + double get_total_o() const + { + return this->total_o; + } + void set_total_o(double total_o) + { + this->total_o = total_o; + } - double get_cb()const {return this->cb;} - void set_cb(double cb) {this->cb = cb;} + double get_cb() const + { + return this->cb; + } + void set_cb(double cb) + { + this->cb = cb; + } - double get_mass_water()const {return this->mass_water;} - void set_mass_water(long double mass_water) {this->mass_water = mass_water;} + double get_mass_water() const + { + return this->mass_water; + } + void set_mass_water(long double mass_water) + { + this->mass_water = mass_water; + } - double get_total_alkalinity()const {return this->total_alkalinity;} - void set_total_alkalinity(double total_alkalinity) {this->total_alkalinity = total_alkalinity;} + double get_total_alkalinity() const + { + return this->total_alkalinity; + } + void set_total_alkalinity(double total_alkalinity) + { + this->total_alkalinity = total_alkalinity; + } - double get_total(char *string)const; - double get_total_element(char *string)const; + double get_total(char *string) const; + double get_total_element(char *string) const; void set_total(char *string, double value); - const cxxNameDouble& get_totals(void)const {return this->totals;} - void set_totals(cxxNameDouble &nd) {this->totals = nd; this->totals.type = cxxNameDouble::ND_ELT_MOLES;} - void clear_totals() {this->totals.clear();} + const cxxNameDouble & get_totals(void) const + { + return this->totals; + } + void set_totals(cxxNameDouble & nd) + { + this->totals = nd; + this->totals.type = cxxNameDouble::ND_ELT_MOLES; + } + void clear_totals() + { + this->totals.clear(); + } - const cxxNameDouble& get_master_activity(void)const {return this->master_activity;} - double get_master_activity(char *string)const; + const cxxNameDouble & get_master_activity(void) const + { + return this->master_activity; + } + double get_master_activity(char *string) const; void set_master_activity(char *string, double value); /* - double get_species_gamma(char *string)const; - void set_species_gamma(char *string, double value); + double get_species_gamma(char *string)const; + void set_species_gamma(char *string, double value); - double get_isotope(char *string)const; - void set_isotope(char *string, double value); - */ + double get_isotope(char *string)const; + void set_isotope(char *string, double value); + */ - struct solution *cxxSolution2solution(); + struct solution *cxxSolution2solution(); - void dump_raw(std::ostream& s_oss, unsigned int indent)const; + void dump_raw(std::ostream & s_oss, unsigned int indent) const; - void read_raw(CParser& parser); + void read_raw(CParser & parser); void multiply(double extensive); #ifdef ORCHESTRA - void ORCH_write(std::ostream& headings, std::ostream& input_data)const; - void ORCH_read(std::vector > output_vector, std::vector < std::pair < std::string, double > >::iterator &it); - void ORCH_store_global(std::map < std::string, double > output_map); + void ORCH_write(std::ostream & headings, std::ostream & input_data) const; + void ORCH_read(std::vector < std::pair < std::string, + double >>output_vector, + std::vector < std::pair < std::string, + double >>::iterator & it); + void ORCH_store_global(std::map < std::string, double >output_map); #endif #ifdef USE_MPI - void mpi_pack(std::vector& ints, std::vector& doubles); - void mpi_unpack(int *ints, int *ii, double *doubles, int *dd); - void mpi_send(int task_number); - void mpi_recv(int task_number); + void mpi_pack(std::vector < int >&ints, std::vector < double >&doubles); + void mpi_unpack(int *ints, int *ii, double *doubles, int *dd); + void mpi_send(int task_number); + void mpi_recv(int task_number); #endif -private: - void zero(); - void add(const cxxSolution &addee, double extensive); + private: + void zero(); + void add(const cxxSolution & addee, double extensive); // not checked - void dump_xml(std::ostream& os, unsigned int indent = 0)const; + void dump_xml(std::ostream & os, unsigned int indent = 0) const; -protected: - double tc; - double ph; - double pe; - double mu; - double ah2o; - double total_h; - double total_o; - double cb; - double mass_water; - double total_alkalinity; - cxxNameDouble totals; - //std::list isotopes; - cxxNameDouble master_activity; - cxxNameDouble species_gamma; + protected: + double tc; + double ph; + double pe; + double mu; + double ah2o; + double total_h; + double total_o; + double cb; + double mass_water; + double total_alkalinity; + cxxNameDouble totals; + //std::list isotopes; + cxxNameDouble master_activity; + cxxNameDouble species_gamma; cxxSolutionIsotopeList isotopes; }; diff --git a/SolutionIsotope.h b/SolutionIsotope.h index 50c40eaf..6ccce2fb 100644 --- a/SolutionIsotope.h +++ b/SolutionIsotope.h @@ -2,64 +2,98 @@ #define SOLUTIONISOTOPE_H_INCLUDED #include "Parser.h" -#include // std::ostream -#include // std::string -#include // std::list +#include // std::ostream +#include // std::string +#include // std::list class cxxSolutionIsotope { -public: - cxxSolutionIsotope(void); - cxxSolutionIsotope(struct isotope *isotope_ptr); - ~cxxSolutionIsotope(void); + public: + cxxSolutionIsotope(void); + cxxSolutionIsotope(struct isotope *isotope_ptr); + ~cxxSolutionIsotope(void); /* - enum STATUS { - ERROR = 0, - OK = 1 - }; - */ - //cxxSolutionIsotope::STATUS read(CParser& parser); - static struct isotope * list2isotope(std::list &t); + enum STATUS { + ERROR = 0, + OK = 1 + }; + */ + //cxxSolutionIsotope::STATUS read(CParser& parser); + static struct isotope *list2isotope(std::list < cxxSolutionIsotope > &t); - void dump_xml(std::ostream& os, unsigned int indent)const; - void dump_raw(std::ostream& os, unsigned int indent)const; + void dump_xml(std::ostream & os, unsigned int indent) const; + void dump_raw(std::ostream & os, unsigned int indent) const; - CParser::STATUS_TYPE read_raw(CParser& parser); + CParser::STATUS_TYPE read_raw(CParser & parser); - double get_isotope_number()const { return this->isotope_number;} - void set_isotope_number(double d) { this->isotope_number = d;} - char * get_elt_name()const { return this->elt_name;} - void set_elt_name(char * cstring) { this->elt_name = cstring;} - char * get_isotope_name()const { return this->isotope_name;} - void set_isotope_name(char * cstring) { this->isotope_name = cstring;} - double get_total()const { return this->total;} - void set_total(double d) { this->total = d;} + double get_isotope_number() const + { + return this->isotope_number; + } + void set_isotope_number(double d) + { + this->isotope_number = d; + } + char *get_elt_name() const + { + return this->elt_name; + } + void set_elt_name(char *cstring) + { + this->elt_name = cstring; + } + char *get_isotope_name() const + { + return this->isotope_name; + } + void set_isotope_name(char *cstring) + { + this->isotope_name = cstring; + } + double get_total() const + { + return this->total; + } + void set_total(double d) + { + this->total = d; + } - double get_ratio()const { return this->ratio; } + double get_ratio() const + { + return this->ratio; + } - double get_ratio_uncertainty()const { return this->ratio_uncertainty; } + double get_ratio_uncertainty() const + { + return this->ratio_uncertainty; + } - bool get_ratio_uncertainty_defined()const { return this->ratio_uncertainty_defined; } + bool get_ratio_uncertainty_defined() const + { + return this->ratio_uncertainty_defined; + } - bool operator<(const cxxSolutionIsotope& conc)const; - - struct master *master(void); - struct master *primary(void); + bool operator<(const cxxSolutionIsotope & conc) const; - void add(const cxxSolutionIsotope &isotope_ptr, double intensive, double extensive); + struct master *master(void); + struct master *primary(void); + + void add(const cxxSolutionIsotope & isotope_ptr, double intensive, + double extensive); void multiply(double extensive); -protected: + protected: friend class cxxSolutionIsotopeList; - double isotope_number; - char * elt_name; - char * isotope_name; - double total; - double ratio; - double ratio_uncertainty; - //struct master *master; - //struct master *primary; - bool ratio_uncertainty_defined; + double isotope_number; + char *elt_name; + char *isotope_name; + double total; + double ratio; + double ratio_uncertainty; + //struct master *master; + //struct master *primary; + bool ratio_uncertainty_defined; }; #endif // SOLUTIONISOTOPE_H_INCLUDED diff --git a/SolutionIsotopeList.h b/SolutionIsotopeList.h index 21a40d8a..02e22f3e 100644 --- a/SolutionIsotopeList.h +++ b/SolutionIsotopeList.h @@ -4,32 +4,38 @@ //#define EXTERNAL extern #include "SolutionIsotope.h" //#include "global.h" -#include // assert -#include // std::string -#include // std::list +#include // assert +#include // std::string +#include // std::list #include "char_star.h" #include "Parser.h" -class cxxSolutionIsotopeList : public std::list +class cxxSolutionIsotopeList:public + std::list < + cxxSolutionIsotope > { -public: - cxxSolutionIsotopeList(); + public: + cxxSolutionIsotopeList(); - cxxSolutionIsotopeList(struct solution *solution_ptr); + cxxSolutionIsotopeList(struct solution *solution_ptr); - ~cxxSolutionIsotopeList(); + ~ + cxxSolutionIsotopeList(); - struct isotope *cxxSolutionIsotopeList2isotope(); + struct isotope * + cxxSolutionIsotopeList2isotope(); - void add(cxxSolutionIsotopeList oldlist, double intensive, double extensive); - void multiply(double extensive); - -protected: + void + add(cxxSolutionIsotopeList oldlist, double intensive, double extensive); + void + multiply(double extensive); + + protected: -public: + public: }; diff --git a/StorageBin.h b/StorageBin.h index f806e08b..5803a832 100644 --- a/StorageBin.h +++ b/StorageBin.h @@ -15,21 +15,21 @@ #include "Reaction.h" #include "Temperature.h" -#include // assert -#include // std::map -#include // std::string -#include // std::list -#include // std::vector +#include // assert +#include // std::map +#include // std::string +#include // std::list +#include // std::vector -class cxxStorageBin +class cxxStorageBin { -public: - cxxStorageBin(); - cxxStorageBin(struct Use *use_ptr); - ~cxxStorageBin(); + public: + cxxStorageBin(); + cxxStorageBin(struct Use *use_ptr); + ~cxxStorageBin(); - void import_phreeqc(void); + void import_phreeqc(void); void cxxStorageBin2phreeqc(int n); @@ -37,200 +37,270 @@ public: void remove(int n); - cxxSolution *getSolution(int n_user) { - if (this->Solutions.find(n_user) != this->Solutions.end()) { - return(&(this->Solutions.find(n_user)->second)); - } + cxxSolution *getSolution(int n_user) + { + if (this->Solutions.find(n_user) != this->Solutions.end()) + { + return (&(this->Solutions.find(n_user)->second)); + } return (NULL); } - void setSolution(int n_user, cxxSolution *entity) { - if (entity == NULL) return; + void setSolution(int n_user, cxxSolution * entity) + { + if (entity == NULL) + return; Solutions[n_user] = *entity; } - void removeSolution(int n_user) { + void removeSolution(int n_user) + { Solutions.erase(n_user); } - cxxExchange *getExchange(int n_user) { - if (this->Exchangers.find(n_user) != this->Exchangers.end()) { - return(&(this->Exchangers.find(n_user)->second)); - } + cxxExchange *getExchange(int n_user) + { + if (this->Exchangers.find(n_user) != this->Exchangers.end()) + { + return (&(this->Exchangers.find(n_user)->second)); + } return (NULL); } - void setExchange(int n_user, cxxExchange *entity) { - if (entity == NULL) return; - Exchangers[n_user] = *entity; + void setExchange(int n_user, cxxExchange * entity) + { + if (entity == NULL) + return; + Exchangers[n_user] = *entity; } - void removeExchange(int n_user) { + void removeExchange(int n_user) + { Exchangers.erase(n_user); } - cxxPPassemblage *getPPassemblage(int n_user) { - if (this->PPassemblages.find(n_user) != this->PPassemblages.end()) { - return(&(this->PPassemblages.find(n_user)->second)); - } + cxxPPassemblage *getPPassemblage(int n_user) + { + if (this->PPassemblages.find(n_user) != this->PPassemblages.end()) + { + return (&(this->PPassemblages.find(n_user)->second)); + } return (NULL); } - void setPPassemblage(int n_user, cxxPPassemblage *entity) { - if (entity == NULL) return; + void setPPassemblage(int n_user, cxxPPassemblage * entity) + { + if (entity == NULL) + return; PPassemblages[n_user] = *entity; } - void removePPassemblage(int n_user) { + void removePPassemblage(int n_user) + { PPassemblages.erase(n_user); } - cxxGasPhase *getGasPhase(int n_user) { - if (this->GasPhases.find(n_user) != this->GasPhases.end()) { - return(&(this->GasPhases.find(n_user)->second)); - } + cxxGasPhase *getGasPhase(int n_user) + { + if (this->GasPhases.find(n_user) != this->GasPhases.end()) + { + return (&(this->GasPhases.find(n_user)->second)); + } return (NULL); } - void setGasPhase(int n_user, cxxGasPhase *entity) { - if (entity == NULL) return; - GasPhases[n_user] = *entity; + void setGasPhase(int n_user, cxxGasPhase * entity) + { + if (entity == NULL) + return; + GasPhases[n_user] = *entity; } - void removeGasPhase(int n_user) { + void removeGasPhase(int n_user) + { GasPhases.erase(n_user); } - cxxSSassemblage *getSSassemblage(int n_user) { - if (this->SSassemblages.find(n_user) != this->SSassemblages.end()) { - return(&(this->SSassemblages.find(n_user)->second)); - } + cxxSSassemblage *getSSassemblage(int n_user) + { + if (this->SSassemblages.find(n_user) != this->SSassemblages.end()) + { + return (&(this->SSassemblages.find(n_user)->second)); + } return (NULL); } - void setSSassemblage(int n_user, cxxSSassemblage *entity) { - if (entity == NULL) return; - SSassemblages[n_user] = *entity; + void setSSassemblage(int n_user, cxxSSassemblage * entity) + { + if (entity == NULL) + return; + SSassemblages[n_user] = *entity; } - void removeSSassemblage(int n_user) { + void removeSSassemblage(int n_user) + { SSassemblages.erase(n_user); } - cxxKinetics *getKinetics(int n_user) { - if (this->Kinetics.find(n_user) != this->Kinetics.end()) { - return(&(this->Kinetics.find(n_user)->second)); - } + cxxKinetics *getKinetics(int n_user) + { + if (this->Kinetics.find(n_user) != this->Kinetics.end()) + { + return (&(this->Kinetics.find(n_user)->second)); + } return (NULL); } - void setKinetics(int n_user, cxxKinetics *entity) { - if (entity == NULL) return; - Kinetics[n_user] = *entity; + void setKinetics(int n_user, cxxKinetics * entity) + { + if (entity == NULL) + return; + Kinetics[n_user] = *entity; } - void removeKinetics(int n_user) { + void removeKinetics(int n_user) + { Kinetics.erase(n_user); } - cxxSurface *getSurface(int n_user) - { - if (this->Surfaces.find(n_user) != this->Surfaces.end()) - { - return(&(this->Surfaces.find(n_user)->second)); - } - return (NULL); + cxxSurface *getSurface(int n_user) + { + if (this->Surfaces.find(n_user) != this->Surfaces.end()) + { + return (&(this->Surfaces.find(n_user)->second)); + } + return (NULL); } - void setSurface(int n_user, cxxSurface *entity) { - if (entity == NULL) return; - Surfaces[n_user] = *entity; + void setSurface(int n_user, cxxSurface * entity) + { + if (entity == NULL) + return; + Surfaces[n_user] = *entity; } - void removeSurface(int n_user) { + void removeSurface(int n_user) + { Surfaces.erase(n_user); } - cxxMix *getMix(int n_user) { - if (this->Mixes.find(n_user) != this->Mixes.end()) { - return(&(this->Mixes.find(n_user)->second)); - } + cxxMix *getMix(int n_user) + { + if (this->Mixes.find(n_user) != this->Mixes.end()) + { + return (&(this->Mixes.find(n_user)->second)); + } return (NULL); } - void setMix(int n_user, cxxMix *entity) { - if (entity == NULL) return; - Mixes[n_user] = *entity; + void setMix(int n_user, cxxMix * entity) + { + if (entity == NULL) + return; + Mixes[n_user] = *entity; } - void removeMix(int n_user) { + void removeMix(int n_user) + { Mixes.erase(n_user); } - cxxReaction *getReaction(int n_user) { - if (this->Reactions.find(n_user) != this->Reactions.end()) { - return(&(this->Reactions.find(n_user)->second)); - } + cxxReaction *getReaction(int n_user) + { + if (this->Reactions.find(n_user) != this->Reactions.end()) + { + return (&(this->Reactions.find(n_user)->second)); + } return (NULL); } - void setReaction(int n_user, cxxReaction *entity) { - if (entity == NULL) return; - Reactions[n_user] = *entity; + void setReaction(int n_user, cxxReaction * entity) + { + if (entity == NULL) + return; + Reactions[n_user] = *entity; } - void removeReaction(int n_user) { + void removeReaction(int n_user) + { Reactions.erase(n_user); } - cxxTemperature *getTemperature(int n_user) { - if (this->Temperatures.find(n_user) != this->Temperatures.end()) { - return(&(this->Temperatures.find(n_user)->second)); - } + cxxTemperature *getTemperature(int n_user) + { + if (this->Temperatures.find(n_user) != this->Temperatures.end()) + { + return (&(this->Temperatures.find(n_user)->second)); + } return (NULL); } - void setTemperature(int n_user, cxxTemperature *entity) { - if (entity == NULL) return; - Temperatures[n_user] = *entity; + void setTemperature(int n_user, cxxTemperature * entity) + { + if (entity == NULL) + return; + Temperatures[n_user] = *entity; } - void removeTemperature(int n_user) { + void removeTemperature(int n_user) + { Temperatures.erase(n_user); } - void setSystem(struct Use *use_ptr); + void setSystem(struct Use *use_ptr); - void dump_raw(std::ostream& s_oss, unsigned int indent)const; + void dump_raw(std::ostream & s_oss, unsigned int indent) const; - void dump_raw(std::ostream& s_oss, int i, unsigned int indent); + void dump_raw(std::ostream & s_oss, int i, unsigned int indent); - void read_raw(CParser& parser); - int read_raw_keyword(CParser& parser); + void read_raw(CParser & parser); + int read_raw_keyword(CParser & parser); void add(struct system *sys_ptr); struct system *cxxStorageBin2system(int i); //cxxSolution *mix_cxxSolutions(cxxMix &mixmap); - cxxExchange *mix_cxxExchange(cxxMix &mixmap); + cxxExchange *mix_cxxExchange(cxxMix & mixmap); - const std::map& getSolutions()const {return this->Solutions;}; - const std::map& getExchangers()const {return this->Exchangers;}; - const std::map& getGasPhases()const {return this->GasPhases;}; - const std::map& getKinetics()const {return this->Kinetics;}; - const std::map& getPPassemblages()const {return this->PPassemblages;}; - const std::map& getSSassemblages()const {return this->SSassemblages;}; - const std::map& getSurfaces()const {return this->Surfaces;}; + const std::map < int, cxxSolution > &getSolutions() const + { + return this->Solutions; + }; + const std::map < int, cxxExchange > &getExchangers() const + { + return this->Exchangers; + }; + const std::map < int, cxxGasPhase > &getGasPhases() const + { + return this->GasPhases; + }; + const std::map < int, cxxKinetics > &getKinetics() const + { + return this->Kinetics; + }; + const std::map < int, cxxPPassemblage > &getPPassemblages() const + { + return this->PPassemblages; + }; + const std::map < int, cxxSSassemblage > &getSSassemblages() const + { + return this->SSassemblages; + }; + const std::map < int, cxxSurface > &getSurfaces() const + { + return this->Surfaces; + }; #ifdef USE_MPI void mpi_send(int n, int task_number); void mpi_recv(int task_number); #endif #ifdef ORCHESTRA - void ORCH_write(std::ostream &chemistry_dat, std::ostream &input_dat, std::ostream &output_dat); + void ORCH_write(std::ostream & chemistry_dat, std::ostream & input_dat, + std::ostream & output_dat); #endif -protected: + protected: // Tidied classes - std::map Solutions; - std::map Exchangers; - std::map GasPhases; - std::map Kinetics; - std::map PPassemblages; - std::map SSassemblages; - std::map Surfaces; + 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; //bool b = exists (Solutions, 5); // Initial classes //std::map ISolutions; // Reaction classes - std::map Mixes; - std::map Reactions; - std::map Temperatures; - cxxSystem system; -public: - //static std::map& map; + std::map < int, cxxMix > Mixes; + std::map < int, cxxReaction > Reactions; + std::map < int, cxxTemperature > Temperatures; + cxxSystem system; + public: + //static std::map& map; }; diff --git a/Surface.h b/Surface.h index f14d2d91..b9d94fba 100644 --- a/Surface.h +++ b/Surface.h @@ -4,74 +4,75 @@ #include "NumKeyword.h" #define EXTERNAL extern #include "global.h" -#include // assert -#include // std::map -#include // std::string -#include // std::list -#include // std::vector +#include // assert +#include // std::map +#include // std::string +#include // std::list +#include // std::vector #include "char_star.h" #include "SurfaceComp.h" #include "SurfaceCharge.h" #include "cxxMix.h" -class cxxSurface : public cxxNumKeyword +class cxxSurface:public cxxNumKeyword { -public: - cxxSurface(); - cxxSurface(struct surface *); - cxxSurface(const std::map &entity_map, cxxMix &mx, int n_user); - ~cxxSurface(); + public: + cxxSurface(); + cxxSurface(struct surface *); + cxxSurface(const std::map < int, cxxSurface > &entity_map, cxxMix & mx, + int n_user); + ~cxxSurface(); - //enum SURFACE_STYPE { UNKNOWN_DL, NO_EDL, DDL, CD_MUSIC }; - //enum SURFACE_DL_TYPE { NO_DL, BORKOVEC_DL, DONNAN_DL } ; - //enum SURFACE_SITES_UNITS { SITES_ABSOLUTE, SITES_DENSITY } ; + //enum SURFACE_STYPE { UNKNOWN_DL, NO_EDL, DDL, CD_MUSIC }; + //enum SURFACE_DL_TYPE { NO_DL, BORKOVEC_DL, DONNAN_DL } ; + //enum SURFACE_SITES_UNITS { SITES_ABSOLUTE, SITES_DENSITY } ; - struct surface *cxxSurface2surface(); + struct surface *cxxSurface2surface(); - struct surf_comp *cxxSurfaceComp2surf_comp(); + struct surf_comp *cxxSurfaceComp2surf_comp(); - void dump_xml(std::ostream& os, unsigned int indent = 0)const; + void dump_xml(std::ostream & os, unsigned int indent = 0) const; - void dump_raw(std::ostream& s_oss, unsigned int indent)const; + void dump_raw(std::ostream & s_oss, unsigned int indent) const; - void read_raw(CParser& parser); + void read_raw(CParser & parser); - bool get_related_phases(void); + bool get_related_phases(void); + + bool get_related_rate(void); - bool get_related_rate(void); - void totalize(); - const cxxNameDouble& get_totals()const + const cxxNameDouble & get_totals() const { - return this->totals; + return this->totals; }; #ifdef USE_MPI - void mpi_pack(std::vector& ints, std::vector& doubles); + void mpi_pack(std::vector < int >&ints, std::vector < double >&doubles); void mpi_unpack(int *ints, int *ii, double *doubles, int *dd); #endif -private: - void add(const cxxSurface &addee, double extensive); + private: + void add(const cxxSurface & addee, double extensive); -protected: - std::list surfaceComps; - std::list surfaceCharges; + protected: + std::list < cxxSurfaceComp > surfaceComps; + std::list < cxxSurfaceCharge > surfaceCharges; enum SURFACE_TYPE type; enum DIFFUSE_LAYER_TYPE dl_type; enum SITES_UNITS sites_units; - bool only_counter_ions; - double thickness; - double debye_lengths; + bool only_counter_ions; + double thickness; + double debye_lengths; double DDL_viscosity; double DDL_limit; - bool transport; + bool transport; cxxNameDouble totals; -public: - //static std::map& map; + public: + //static std::map& map; }; #endif // !defined(SURFACE_H_INCLUDED) diff --git a/SurfaceCharge.h b/SurfaceCharge.h index a5d68890..c2e434ec 100644 --- a/SurfaceCharge.h +++ b/SurfaceCharge.h @@ -4,57 +4,62 @@ #include "NameDouble.h" #define EXTERNAL extern #include "global.h" -#include // assert -#include // std::map -#include // std::string -#include // std::list -#include // std::vector +#include // assert +#include // std::map +#include // std::string +#include // std::list +#include // std::vector #include "char_star.h" -class cxxSurfaceCharge +class cxxSurfaceCharge { -public: + public: - cxxSurfaceCharge(); - cxxSurfaceCharge(struct surface_charge *); - ~cxxSurfaceCharge(); + cxxSurfaceCharge(); + cxxSurfaceCharge(struct surface_charge *); + ~cxxSurfaceCharge(); - struct master *get_psi_master(); + struct master *get_psi_master(); - static struct surface_charge *cxxSurfaceCharge2surface_charge(std::list& el); + static struct surface_charge *cxxSurfaceCharge2surface_charge(std::list < + cxxSurfaceCharge + > &el); - void dump_xml(std::ostream& os, unsigned int indent = 0)const; + void dump_xml(std::ostream & os, unsigned int indent = 0) const; - void dump_raw(std::ostream& s_oss, unsigned int indent)const; + void dump_raw(std::ostream & s_oss, unsigned int indent) const; - void read_raw(CParser& parser); + void read_raw(CParser & parser); - char *get_name()const {return this->name;} + char *get_name() const + { + return this->name; + } - void add(const cxxSurfaceCharge &comp, double extensive); + void add(const cxxSurfaceCharge & comp, double extensive); void multiply(double extensive); #ifdef USE_MPI - void mpi_pack(std::vector& ints, std::vector& doubles); + void mpi_pack(std::vector < int >&ints, std::vector < double >&doubles); void mpi_unpack(int *ints, int *ii, double *doubles, int *dd); #endif -protected: - char * name; - double specific_area; - double grams; - double charge_balance; - double mass_water; - double la_psi, la_psi1, la_psi2; + protected: + char *name; + double specific_area; + double grams; + double charge_balance; + double mass_water; + double la_psi, la_psi1, la_psi2; double capacitance[2]; - //std::map g; - //char * psi_master_name; - cxxNameDouble diffuse_layer_totals; + //std::map g; + //char * psi_master_name; + cxxNameDouble diffuse_layer_totals; -public: + public: }; diff --git a/SurfaceComp.h b/SurfaceComp.h index 67a4cce0..4c462536 100644 --- a/SurfaceComp.h +++ b/SurfaceComp.h @@ -5,81 +5,102 @@ #define EXTERNAL extern #include "global.h" #include "phrqproto.h" -#include // assert -#include // std::map -#include // std::string -#include // std::list -#include // std::vector +#include // assert +#include // std::map +#include // std::string +#include // std::list +#include // std::vector #include "char_star.h" class cxxSurfaceComp { -public: + public: - cxxSurfaceComp(); - cxxSurfaceComp(struct surface_comp *); - ~cxxSurfaceComp(); + cxxSurfaceComp(); + cxxSurfaceComp(struct surface_comp *); + ~cxxSurfaceComp(); - struct master *get_master(); - char *get_phase_name()const {return this->phase_name;} - char *get_rate_name()const {return this->rate_name;} - char *get_formula()const {return this->formula;} - double get_charge_balance()const { return this->charge_balance;} - void set_charge_balance(double d) { this->charge_balance = d;} - - static struct surface_comp *cxxSurfaceComp2surface_comp(std::list& el); - - 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); - const cxxNameDouble &get_totals()const + struct master *get_master(); + char *get_phase_name() const { - return (this->totals); + return this->phase_name; + } + char *get_rate_name() const + { + return this->rate_name; + } + char *get_formula() const + { + return this->formula; + } + double get_charge_balance() const + { + return this->charge_balance; + } + void set_charge_balance(double d) + { + this->charge_balance = d; + } + + static struct surface_comp *cxxSurfaceComp2surface_comp(std::list < + cxxSurfaceComp > + &el); + + 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); + const cxxNameDouble & get_totals() const + { + return (this->totals); }; - void add(const cxxSurfaceComp &comp, double extensive); + void add(const cxxSurfaceComp & comp, double extensive); void multiply(double extensive); - char *charge_name() {return(get_charge_name(this->formula));}; + char *charge_name() + { + return (get_charge_name(this->formula)); + }; - static char *get_charge_name(char * token) { - char name[100]; - int l; - char *ptr1 = token; - get_elt (&ptr1, name, &l); - ptr1 = strchr (name, '_'); - if (ptr1 != NULL) - { - ptr1[0] = '\0'; - } - return(string_hsave(name)); + static char *get_charge_name(char *token) + { + char name[100]; + int l; + char *ptr1 = token; + get_elt(&ptr1, name, &l); + ptr1 = strchr(name, '_'); + if (ptr1 != NULL) + { + ptr1[0] = '\0'; + } + return (string_hsave(name)); }; #ifdef USE_MPI - void mpi_pack(std::vector& ints, std::vector& doubles); + void mpi_pack(std::vector < int >&ints, std::vector < double >&doubles); void mpi_unpack(int *ints, int *ii, double *doubles, int *dd); #endif -protected: - char * formula; - cxxNameDouble formula_totals; + protected: + char *formula; + cxxNameDouble formula_totals; double formula_z; - double moles; - cxxNameDouble totals; - double la; - //int charge_number; - double charge_balance; - char *phase_name; - double phase_proportion; - char *rate_name; + double moles; + cxxNameDouble totals; + double la; + //int charge_number; + double charge_balance; + char *phase_name; + double phase_proportion; + char *rate_name; double Dw; -public: + public: }; diff --git a/System.h b/System.h index f3439283..4fb27500 100644 --- a/System.h +++ b/System.h @@ -1,75 +1,76 @@ -#if !defined(SYSTEM_H_INCLUDED) -#define SYSTEM_H_INCLUDED -#include "Solution.h" -#include "Exchange.h" -#include "GasPhase.h" -#include "cxxKinetics.h" -#include "PPassemblage.h" -#include "SSassemblage.h" -#include "Surface.h" -#include "cxxMix.h" -#include "Reaction.h" -#include "Temperature.h" -class cxxSystem -{ -public: - cxxSystem(void); -public: - ~cxxSystem(void); - void Initialize(void); - void setSolution(cxxSolution *entity) { - this->solution = entity; - } - void setExchange(cxxExchange *entity) { - this->exchange = entity; - } - void setPPassemblage(cxxPPassemblage *entity) { - this->ppassemblage = entity; - } - void setGasPhase(cxxGasPhase *entity) { - this->gasphase = entity; - } - void setSSassemblage(cxxSSassemblage *entity) { - this->ssassemblage = entity; - } - void setKinetics(cxxKinetics *entity) { - this->kinetics = entity; - } - void setSurface(cxxSurface *entity) { - this->surface = entity; - } - void setMix(cxxMix *entity) { - this->mix = entity; - } - void setReaction(cxxReaction *entity) { - this->reaction = entity; - } - void setTemperature(cxxTemperature *entity) { - this->temperature = entity; - } - void totalize(); -#ifdef ORCHESTRA - void ORCH_components(); - void ORCH_write(std::ostream &chemistry_dat, std::ostream &input_dat, std::ostream &output_dat); - void ORCH_write_chemistry_water(std::ostream &chemistry_dat); - void ORCH_write_chemistry_primary(std::ostream &chemistry_dat); - void ORCH_write_chemistry_total_O_H(std::ostream &chemistry_dat); - void ORCH_write_output_vars(std::ostream &outstream); - void ORCH_write_input(std::ostream &input_dat); -#endif - -private: - cxxSolution *solution; - cxxExchange *exchange; - cxxPPassemblage *ppassemblage; - cxxGasPhase *gasphase; - cxxSSassemblage *ssassemblage; - cxxKinetics *kinetics; - cxxSurface *surface; - cxxMix *mix; - cxxReaction *reaction; - cxxTemperature *temperature; - cxxNameDouble totals; - cxxNameDouble orch_totals; -}; -#endif // !defined(SYSTEM_H_INCLUDED) +#if !defined(SYSTEM_H_INCLUDED) +#define SYSTEM_H_INCLUDED +#include "Solution.h" +#include "Exchange.h" +#include "GasPhase.h" +#include "cxxKinetics.h" +#include "PPassemblage.h" +#include "SSassemblage.h" +#include "Surface.h" +#include "cxxMix.h" +#include "Reaction.h" +#include "Temperature.h" +class cxxSystem +{ + public:cxxSystem(void); + public: ~cxxSystem(void); + void Initialize(void); + void setSolution(cxxSolution * entity) + { + this->solution = entity; + } void setExchange(cxxExchange * entity) + { + this->exchange = entity; + } void setPPassemblage(cxxPPassemblage * entity) + { + this->ppassemblage = entity; + } void setGasPhase(cxxGasPhase * entity) + { + this->gasphase = entity; + } void setSSassemblage(cxxSSassemblage * entity) + { + this->ssassemblage = entity; + } void setKinetics(cxxKinetics * entity) + { + this->kinetics = entity; + } void setSurface(cxxSurface * entity) + { + this->surface = entity; + } void setMix(cxxMix * entity) + { + this->mix = entity; + } void setReaction(cxxReaction * entity) + { + this->reaction = entity; + } void setTemperature(cxxTemperature * entity) + { + this->temperature = entity; + } void totalize(); + +#ifdef ORCHESTRA + void ORCH_components(); + void ORCH_write(std::ostream & chemistry_dat, std::ostream & input_dat, + std::ostream & output_dat); + void ORCH_write_chemistry_water(std::ostream & chemistry_dat); + void ORCH_write_chemistry_primary(std::ostream & chemistry_dat); + void ORCH_write_chemistry_total_O_H(std::ostream & chemistry_dat); + void ORCH_write_output_vars(std::ostream & outstream); + void ORCH_write_input(std::ostream & input_dat); + +#endif /* */ + private:cxxSolution * solution; + cxxExchange * exchange; + cxxPPassemblage * ppassemblage; + cxxGasPhase * gasphase; + cxxSSassemblage * ssassemblage; + cxxKinetics * kinetics; + cxxSurface * surface; + cxxMix * mix; + cxxReaction * reaction; + cxxTemperature * temperature; + cxxNameDouble totals; + cxxNameDouble orch_totals; +}; + + +#endif // !defined(SYSTEM_H_INCLUDED) diff --git a/Temperature.h b/Temperature.h index d0ea2f90..3997903a 100644 --- a/Temperature.h +++ b/Temperature.h @@ -4,37 +4,37 @@ #include "NumKeyword.h" #define EXTERNAL extern #include "global.h" -#include // assert -#include // std::map -#include // std::string -#include // std::list -#include // std::vector +#include // assert +#include // std::map +#include // std::string +#include // std::list +#include // std::vector #include "char_star.h" -class cxxTemperature : public cxxNumKeyword +class cxxTemperature:public cxxNumKeyword { -public: - cxxTemperature(); - cxxTemperature(struct temperature *); - ~cxxTemperature(); + public: + cxxTemperature(); + cxxTemperature(struct temperature *); + ~cxxTemperature(); - struct temperature *cxxTemperature2temperature(); + struct temperature *cxxTemperature2temperature(); - //void dump_xml(std::ostream& os, unsigned int indent = 0)const; + //void dump_xml(std::ostream& os, unsigned int indent = 0)const; - void dump_raw(std::ostream& s_oss, unsigned int indent)const; + void dump_raw(std::ostream & s_oss, unsigned int indent) const; - void read_raw(CParser& parser); + void read_raw(CParser & parser); -protected: - std::vector temps; + protected: + std::vector < double >temps; int countTemps; bool equalIncrements; -public: - //static std::map& map; + public: + //static std::map& map; }; diff --git a/Utils.h b/Utils.h index 23f25776..2bed81de 100644 --- a/Utils.h +++ b/Utils.h @@ -2,65 +2,72 @@ #define UTILITIES_H_INCLUDED #include -#include // std::istringstream std::ostringstream -#include // std::ostream -#include // std::istream -#include // std::map +#include // std::istringstream std::ostringstream +#include // std::ostream +#include // std::istream +#include // std::map #include "char_star.h" -namespace Utilities { +namespace Utilities +{ - const char INDENT[] = " "; + const char INDENT[] = " "; - enum STATUS_TYPE { - OK = 0, - ERROR = 1 - }; + enum STATUS_TYPE + { + OK = 0, + ERROR = 1 + }; - STATUS_TYPE parse_couple(std::string& token); + STATUS_TYPE parse_couple(std::string & token); - int strcmp_nocase(const char *str1, const char *str2); + int strcmp_nocase(const char *str1, const char *str2); - int strcmp_nocase_arg1(const char *str1, const char *str2); + int strcmp_nocase_arg1(const char *str1, const char *str2); - void str_tolower(std::string& str); + void str_tolower(std::string & str); - bool replace(const char* str1, const char* str2, std::string& str); + bool replace(const char *str1, const char *str2, std::string & str); - void squeeze_white(std::string& s_l); + void squeeze_white(std::string & s_l); - //void error_msg(const std::string&, const int stopflag); + //void error_msg(const std::string&, const int stopflag); // operations on maps of entities (Solution, Exchange, ...) - template - void dump_raw (const T &b, std::ostream& s_oss, unsigned int indent) + template < typename T > + void dump_raw(const T & b, std::ostream & s_oss, unsigned int indent) + { + //std :: map < int, T > :: const_iterator it; + typename T::const_iterator it; + for (it = b.begin(); it != b.end(); ++it) { - //std :: map < int, T > :: const_iterator it; - typename T::const_iterator it; - for (it = b.begin(); it != b.end(); ++it) { - it->second.dump_raw(s_oss, indent); - } - return; + it->second.dump_raw(s_oss, indent); } - template - bool exists (const T &b, int i){ - return (b.find(i) != b.end());} + return; + } + template < typename T > bool exists(const T & b, int i) + { + return (b.find(i) != b.end()); + } - template - T *get_entity(std::map b, int i) { - if (b.find(i) != b.end()) { - return(&(b.find(i)->second)); - } else { + template < typename T > T * get_entity(std::map < int, T > b, int i) + { + if (b.find(i) != b.end()) + { + return (&(b.find(i)->second)); + } + else + { return (NULL); } } - + /* - template - bool exists (std::map b, int i){ - return (b.find(i) != b.end());} - */ + template + bool exists (std::map b, int i){ + return (b.find(i) != b.end());} + */ } diff --git a/char_star.h b/char_star.h index 9d5b65f5..24fdbdf7 100644 --- a/char_star.h +++ b/char_star.h @@ -1,11 +1,16 @@ #if !defined(CHARSTAR_H_INCLUDED) #define CHARSTAR_H_INCLUDED -struct CHARSTAR_LESS : std::binary_function { -bool operator()(const char* _X, const char* _Y) const +struct CHARSTAR_LESS: +std::binary_function < const char *, const char *, + bool > { - return ::strcmp( _X, _Y) < 0;} + bool + operator() (const char *_X, const char *_Y) const + { + return::strcmp(_X, _Y) < + 0; + } }; #endif - diff --git a/cxxKinetics.h b/cxxKinetics.h index 595695ea..aa5f3edc 100644 --- a/cxxKinetics.h +++ b/cxxKinetics.h @@ -4,58 +4,59 @@ #include "NumKeyword.h" #define EXTERNAL extern #include "global.h" -#include // assert -#include // std::map -#include // std::string -#include // std::list -#include // std::vector +#include // assert +#include // std::map +#include // std::string +#include // std::list +#include // std::vector #include "char_star.h" #include "KineticsComp.h" #include "cxxMix.h" -class cxxKinetics : public cxxNumKeyword +class cxxKinetics:public cxxNumKeyword { -public: - cxxKinetics(); - cxxKinetics(struct kinetics *); - cxxKinetics(const std::map &entity_map, cxxMix &mx, int n_user); - ~cxxKinetics(); + public: + cxxKinetics(); + cxxKinetics(struct kinetics *); + cxxKinetics(const std::map < int, cxxKinetics > &entity_map, cxxMix & mx, + int n_user); + ~cxxKinetics(); - struct kinetics *cxxKinetics2kinetics(); + struct kinetics *cxxKinetics2kinetics(); - struct kinetics_comp *cxxKineticsComp2kinetics_comp(); + struct kinetics_comp *cxxKineticsComp2kinetics_comp(); - //void dump_xml(std::ostream& os, unsigned int indent = 0)const; + //void dump_xml(std::ostream& os, unsigned int indent = 0)const; - void dump_raw(std::ostream& s_oss, unsigned int indent)const; + void dump_raw(std::ostream & s_oss, unsigned int indent) const; - void read_raw(CParser& parser); + void read_raw(CParser & parser); - bool get_related_phases(void); + bool get_related_phases(void); - bool get_related_rate(void); + bool get_related_rate(void); #ifdef USE_MPI void mpi_unpack(int *ints, int *ii, double *doubles, int *dd); - void mpi_pack(std::vector& ints, std::vector& doubles); + void mpi_pack(std::vector < int >&ints, std::vector < double >&doubles); #endif -private: - void add(const cxxKinetics &addee, double extensive); + private: + void add(const cxxKinetics & addee, double extensive); -protected: - std::list kineticsComps; - std::vector steps; - cxxNameDouble totals; - double step_divide; - int rk; - int bad_step_max; - bool use_cvode; + protected: + std::list < cxxKineticsComp > kineticsComps; + std::vector < double >steps; + cxxNameDouble totals; + double step_divide; + int rk; + int bad_step_max; + bool use_cvode; int cvode_steps; int cvode_order; -public: - //static std::map& map; + public: + //static std::map& map; }; diff --git a/cxxMix.h b/cxxMix.h index 0131d937..05fb92e6 100644 --- a/cxxMix.h +++ b/cxxMix.h @@ -4,48 +4,53 @@ #include "NumKeyword.h" //#define EXTERNAL extern //#include "global.h" -#include // assert -#include // std::map -#include // std::string -#include // std::list -#include // std::vector +#include // assert +#include // std::map +#include // std::string +#include // std::list +#include // std::vector #include "char_star.h" -class cxxMix : public cxxNumKeyword +class cxxMix:public cxxNumKeyword { -public: - cxxMix(); - cxxMix(struct mix *); - ~cxxMix(); + public: + cxxMix(); + cxxMix(struct mix *); + ~cxxMix(); - struct mix *cxxMix2mix(); + struct mix *cxxMix2mix(); - //void dump_xml(std::ostream& os, unsigned int indent = 0)const; + //void dump_xml(std::ostream& os, unsigned int indent = 0)const; - void dump_raw(std::ostream& s_oss, unsigned int indent)const; + void dump_raw(std::ostream & s_oss, unsigned int indent) const; - void read_raw(CParser& parser); + void read_raw(CParser & parser); - void add(int n, double f) { - if (this->mixComps.find(n) != this->mixComps.end()) - { - mixComps[n] += f; - } else - { - mixComps[n] = f; - } + void add(int n, double f) + { + if (this->mixComps.find(n) != this->mixComps.end()) + { + mixComps[n] += f; + } + else + { + mixComps[n] = f; + } }; - std::map *comps() {return &mixComps;} + std::map < int, double >*comps() + { + return &mixComps; + } -protected: + protected: friend class cxxStorageBin; - std::map mixComps; + std::map < int, double >mixComps; -public: - //static std::map& map; + public: + //static std::map& map; };