From d54c04039a344c724947c0dcae7b8c2b7a04ab78 Mon Sep 17 00:00:00 2001 From: David L Parkhurst Date: Wed, 28 Oct 2009 19:15:17 +0000 Subject: [PATCH] Have converted std::list to std::map for all entities. surface is completed but needs testing. SS and kinetics need to have reread of components implemented for MODIFY option. gas_phase may be done, needs to be tested. git-svn-id: svn://136.177.114.72/svn_GW/phreeqcpp/trunk@3726 1feff8c3-07ed-0310-ac33-dd36852eb9cd --- GasPhase.h | 2 +- KineticsComp.cxx | 29 ++++---- KineticsComp.h | 10 ++- ReadClass.cxx | 35 ++++----- SSassemblage.cxx | 48 ++++++++++--- SSassemblage.h | 16 ++--- SSassemblageSS.cxx | 30 ++++---- SSassemblageSS.h | 2 +- Surface.cxx | 164 +++++++++++++++++++++++++++++++++++------- Surface.h | 4 +- SurfaceCharge.cxx | 175 +++++++++++++++++++++++---------------------- SurfaceCharge.h | 6 +- SurfaceComp.cxx | 143 ++++++++++++++++++------------------ SurfaceComp.h | 6 +- cxxKinetics.cxx | 52 ++++++++++++-- cxxKinetics.h | 4 +- 16 files changed, 458 insertions(+), 268 deletions(-) diff --git a/GasPhase.h b/GasPhase.h index 8b40b860..2fa6e96b 100644 --- a/GasPhase.h +++ b/GasPhase.h @@ -56,7 +56,7 @@ class cxxGasPhase:public cxxNumKeyword void add(const cxxGasPhase & addee, double extensive); protected: - cxxNameDouble gasPhaseComps; + cxxNameDouble gasPhaseComps; GP_TYPE type; double total_p; double volume; diff --git a/KineticsComp.cxx b/KineticsComp.cxx index 2d5a3eab..61461cbf 100644 --- a/KineticsComp.cxx +++ b/KineticsComp.cxx @@ -55,7 +55,7 @@ cxxKineticsComp::~cxxKineticsComp() } struct kinetics_comp * -cxxKineticsComp::cxxKineticsComp2kinetics_comp(std::list < cxxKineticsComp > + cxxKineticsComp::cxxKineticsComp2kinetics_comp(std::map < std::string, cxxKineticsComp > &el) // // Builds kinetics_comp structure from of cxxKineticsComp @@ -68,17 +68,17 @@ cxxKineticsComp::cxxKineticsComp2kinetics_comp(std::list < cxxKineticsComp > malloc_error(); int i = 0; - for (std::list < cxxKineticsComp >::iterator it = el.begin(); + for (std::map < std::string, cxxKineticsComp >::iterator it = el.begin(); it != el.end(); ++it) { - kinetics_comp_ptr[i].rate_name = it->rate_name; - kinetics_comp_ptr[i].list = it->namecoef.name_coef(); - kinetics_comp_ptr[i].count_list = (int) it->namecoef.size(); - kinetics_comp_ptr[i].tol = it->tol; - kinetics_comp_ptr[i].m = it->m; + kinetics_comp_ptr[i].rate_name = (*it).second.rate_name; + kinetics_comp_ptr[i].list = (*it).second.namecoef.name_coef(); + kinetics_comp_ptr[i].count_list = (int) (*it).second.namecoef.size(); + kinetics_comp_ptr[i].tol = (*it).second.tol; + kinetics_comp_ptr[i].m = (*it).second.m; kinetics_comp_ptr[i].initial_moles = 0.; - kinetics_comp_ptr[i].m0 = it->m0; - kinetics_comp_ptr[i].moles = it->moles; + kinetics_comp_ptr[i].m0 = (*it).second.m0; + kinetics_comp_ptr[i].moles = (*it).second.moles; kinetics_comp_ptr[i].count_c_params = 0; kinetics_comp_ptr[i].c_params = NULL; /* @@ -86,16 +86,15 @@ cxxKineticsComp::cxxKineticsComp2kinetics_comp(std::list < cxxKineticsComp > kinetics_comp_ptr[i].d_params = NULL; */ - kinetics_comp_ptr[i].count_d_params = (int) it->d_params.size(); + kinetics_comp_ptr[i].count_d_params = (int) (*it).second.d_params.size(); kinetics_comp_ptr[i].d_params = NULL; - if (it->d_params.size() > 0) + if ((*it).second.d_params.size() > 0) { - kinetics_comp_ptr[i].d_params = - (double *) - PHRQ_malloc((size_t) (it->d_params.size() * sizeof(double))); + kinetics_comp_ptr[i].d_params = (double *) + PHRQ_malloc((size_t) ((*it).second.d_params.size() * sizeof(double))); if (kinetics_comp_ptr[i].d_params == NULL) malloc_error(); - std::copy(it->d_params.begin(), it->d_params.end(), + std::copy((*it).second.d_params.begin(), (*it).second.d_params.end(), kinetics_comp_ptr[i].d_params); } i++; diff --git a/KineticsComp.h b/KineticsComp.h index c51a62b1..3cf86f58 100644 --- a/KineticsComp.h +++ b/KineticsComp.h @@ -15,14 +15,12 @@ class cxxKineticsComp { - public: +public: cxxKineticsComp(); cxxKineticsComp(struct kinetics_comp *); - ~cxxKineticsComp(); + ~cxxKineticsComp(); - static struct kinetics_comp *cxxKineticsComp2kinetics_comp(std::list < - cxxKineticsComp - > &el); + static struct kinetics_comp *cxxKineticsComp2kinetics_comp(std::map < std::string, cxxKineticsComp > &el); void dump_xml(std::ostream & os, unsigned int indent = 0) const; @@ -49,7 +47,7 @@ class cxxKineticsComp double m; double m0; double moles; - std::vector < double >d_params; + std::vector < double >d_params; public: diff --git a/ReadClass.cxx b/ReadClass.cxx index bb45031b..ca860825 100644 --- a/ReadClass.cxx +++ b/ReadClass.cxx @@ -1366,6 +1366,24 @@ read_surface_modify(void) * */ int return_value; + + // find surface number + char token[MAX_LENGTH]; + char *next; + int l, n_user, n; + next = line; + copy_token(token, &next, &l); + if (copy_token(token, &next, &l) != DIGIT) + { + input_error++; + sprintf(error_string, "Expected surface number following SURFACE_MODIFY.\n%s\n", line_save); + error_msg(error_string, CONTINUE); + return (ERROR); + } + else + { + sscanf(token,"%d", &n_user); + } /* * Make parser */ @@ -1391,23 +1409,6 @@ read_surface_modify(void) parser.set_echo_file(CParser::EO_NOKEYWORDS); } - // find surface number - char token[MAX_LENGTH]; - char *next; - int l, n_user, n; - next = line; - copy_token(token, &next, &l); - if (copy_token(token, &next, &l) != DIGIT) - { - input_error++; - sprintf(error_string, "Expected surface number following SURFACE_MODIFY.\n%s\n", line_save); - error_msg(error_string, CONTINUE); - return (ERROR); - } - else - { - sscanf(token,"%d", &n_user); - } if (surface_bsearch(n_user, &n) == NULL) { input_error++; diff --git a/SSassemblage.cxx b/SSassemblage.cxx index 724426f3..a62ee9de 100644 --- a/SSassemblage.cxx +++ b/SSassemblage.cxx @@ -41,7 +41,8 @@ cxxNumKeyword() for (i = 0; i < s_s_assemblage_ptr->count_s_s; i++) { cxxSSassemblageSS ssSS(&(s_s_assemblage_ptr->s_s[i])); - ssAssemblageSSs.push_back(ssSS); + std::string str(ssSS.get_name()); + ssAssemblageSSs[str] = ssSS; } } cxxSSassemblage::cxxSSassemblage(const std::map < int, @@ -141,12 +142,12 @@ cxxSSassemblage::dump_raw(std::ostream & s_oss, unsigned int indent) const description << std::endl; // ssAssemblageSSs - for (std::list < cxxSSassemblageSS >::const_iterator it = + for (std::map < std::string, cxxSSassemblageSS >::const_iterator it = ssAssemblageSSs.begin(); it != ssAssemblageSSs.end(); ++it) { s_oss << indent1; s_oss << "-solid_solution" << std::endl; - it->dump_raw(s_oss, indent + 2); + (*it).second.dump_raw(s_oss, indent + 2); } } @@ -206,7 +207,8 @@ cxxSSassemblage::read_raw(CParser & parser, bool check) { cxxSSassemblageSS ssSS; ssSS.read_raw(parser); - this->ssAssemblageSSs.push_back(ssSS); + std::string str(ssSS.get_name()); + this->ssAssemblageSSs[str] = ssSS; } useLastLine = true; break; @@ -264,15 +266,15 @@ cxxSSassemblage::totalize() { this->totals.clear(); // component structures - for (std::list < cxxSSassemblageSS >::iterator it = + for (std::map < std::string, cxxSSassemblageSS >::iterator it = ssAssemblageSSs.begin(); it != ssAssemblageSSs.end(); ++it) { - it->totalize(); - this->totals.add_extensive(it->get_totals(), 1.0); + (*it).second.totalize(); + this->totals.add_extensive((*it).second.get_totals(), 1.0); } return; } - +#ifdef SKIP void cxxSSassemblage::add(const cxxSSassemblage & addee, double extensive) // @@ -306,3 +308,33 @@ cxxSSassemblage::add(const cxxSSassemblage & addee, double extensive) } } } +#endif +void +cxxSSassemblage::add(const cxxSSassemblage & addee, double extensive) + // + // Add to existing ssassemblage to "this" ssassemblage + // +{ + if (extensive == 0.0) + return; + + for (std::map < std::string, cxxSSassemblageSS >::const_iterator itadd = + addee.ssAssemblageSSs.begin(); itadd != addee.ssAssemblageSSs.end(); + ++itadd) + { + std::map < std::string, cxxSSassemblageSS >::iterator it = + this->ssAssemblageSSs.find((*itadd).first); + if (it != this->ssAssemblageSSs.end()) + { + (*it).second.add((*itadd).second, extensive); + } + else + { + cxxSSassemblageSS entity = (*itadd).second; + entity.multiply(extensive); + std::string str(entity.get_name()); + this->ssAssemblageSSs[str] = entity; + } + } +} + diff --git a/SSassemblage.h b/SSassemblage.h index d3784752..a592c918 100644 --- a/SSassemblage.h +++ b/SSassemblage.h @@ -17,12 +17,12 @@ class cxxSSassemblage:public cxxNumKeyword { - public: +public: cxxSSassemblage(); cxxSSassemblage(struct s_s_assemblage *); - cxxSSassemblage(const std::map < int, cxxSSassemblage > &entity_map, - cxxMix & mx, int n_user); - ~cxxSSassemblage(); + cxxSSassemblage(const std::map < int, cxxSSassemblage > &entity_map, + cxxMix & mx, int n_user); + ~cxxSSassemblage(); struct s_s_assemblage *cxxSSassemblage2s_s_assemblage(); @@ -46,14 +46,14 @@ class cxxSSassemblage:public cxxNumKeyword }; - private: +private: void add(const cxxSSassemblage & addee, double extensive); - protected: - std::list < cxxSSassemblageSS > ssAssemblageSSs; +protected: + std::map < std::string, cxxSSassemblageSS > ssAssemblageSSs; cxxNameDouble totals; - public: +public: //static std::map& map; }; diff --git a/SSassemblageSS.cxx b/SSassemblageSS.cxx index 918c80c3..9a9d2cf7 100644 --- a/SSassemblageSS.cxx +++ b/SSassemblageSS.cxx @@ -74,7 +74,7 @@ cxxSSassemblageSS::~cxxSSassemblageSS() } struct s_s * -cxxSSassemblageSS::cxxSSassemblageSS2s_s(std::list < cxxSSassemblageSS > &el) + cxxSSassemblageSS::cxxSSassemblageSS2s_s(std::map < std::string, cxxSSassemblageSS > &el) // // Builds s_s structure from of cxxSSassemblageSS // @@ -88,27 +88,27 @@ cxxSSassemblageSS::cxxSSassemblageSS2s_s(std::list < cxxSSassemblageSS > &el) if (s_s_ptr == NULL) malloc_error(); int j = 0; - for (std::list < cxxSSassemblageSS >::iterator it = el.begin(); + for (std::map < std::string, cxxSSassemblageSS >::iterator it = el.begin(); it != el.end(); ++it) { - s_s_ptr[j].name = it->name; + s_s_ptr[j].name = (*it).second.name; //s_s_ptr[j].total_moles = it->total_moles; s_s_ptr[j].total_moles = 0; s_s_ptr[j].dn = 0; - s_s_ptr[j].a0 = it->a0; - s_s_ptr[j].a1 = it->a1; - s_s_ptr[j].ag0 = it->ag0; - s_s_ptr[j].ag1 = it->ag1; + s_s_ptr[j].a0 = (*it).second.a0; + s_s_ptr[j].a1 = (*it).second.a1; + s_s_ptr[j].ag0 = (*it).second.ag0; + s_s_ptr[j].ag1 = (*it).second.ag1; //s_s_ptr[j].ag0 = 0; //s_s_ptr[j].ag1 = 0; s_s_ptr[j].s_s_in = TRUE; - s_s_ptr[j].miscibility = it->miscibility; + s_s_ptr[j].miscibility = (*it).second.miscibility; //s_s_ptr[j].spinodal = it->spinodal; s_s_ptr[j].spinodal = FALSE; //s_s_ptr[j].tk = it->tk; s_s_ptr[j].tk = 273.15; - s_s_ptr[j].xb1 = it->xb1; - s_s_ptr[j].xb2 = it->xb2; + s_s_ptr[j].xb1 = (*it).second.xb1; + s_s_ptr[j].xb2 = (*it).second.xb2; s_s_ptr[j].input_case = 0; s_s_ptr[j].p[0] = 0; s_s_ptr[j].p[1] = 0; @@ -117,20 +117,20 @@ cxxSSassemblageSS::cxxSSassemblageSS2s_s(std::list < cxxSSassemblageSS > &el) // // generate s_s_comp structures // - s_s_ptr[j].count_comps = (int) it->comps.size(); + s_s_ptr[j].count_comps = (int) (*it).second.comps.size(); s_s_ptr[j].comps = NULL; - if (it->comps.size() > 0) + if ((*it).second.comps.size() > 0) { int i = 0; int n; struct s_s_comp *s_s_comp_ptr = (struct s_s_comp *) PHRQ_malloc((size_t) - (it->comps.size() * sizeof(struct s_s_comp))); + ((*it).second.comps.size() * sizeof(struct s_s_comp))); if (s_s_comp_ptr == NULL) malloc_error(); - for (cxxNameDouble::iterator itc = it->comps.begin(); - itc != it->comps.end(); ++itc) + for (cxxNameDouble::iterator itc = (*it).second.comps.begin(); + itc != (*it).second.comps.end(); ++itc) { s_s_comp_ptr[i].name = itc->first; s_s_comp_ptr[i].phase = phase_bsearch(itc->first, &n, TRUE); diff --git a/SSassemblageSS.h b/SSassemblageSS.h index c999d104..73df9a3f 100644 --- a/SSassemblageSS.h +++ b/SSassemblageSS.h @@ -35,7 +35,7 @@ class cxxSSassemblageSS SS_PARM_MARGULES = 9 }; - static struct s_s *cxxSSassemblageSS2s_s(std::list < cxxSSassemblageSS > + static struct s_s *cxxSSassemblageSS2s_s(std::map < std::string, cxxSSassemblageSS > &el); void dump_xml(std::ostream & os, unsigned int indent = 0) const; diff --git a/Surface.cxx b/Surface.cxx index 4023d439..e1ed2f24 100644 --- a/Surface.cxx +++ b/Surface.cxx @@ -67,13 +67,15 @@ cxxNumKeyword() for (i = 0; i < surface_ptr->count_comps; i++) { cxxSurfaceComp ec(&(surface_ptr->comps[i])); - surfaceComps.push_back(ec); + std::string str(ec.get_formula()); + surfaceComps[str] = ec; } // Surface charge for (i = 0; i < surface_ptr->count_charge; i++) { cxxSurfaceCharge ec(&(surface_ptr->charge[i])); - surfaceCharges.push_back(ec); + std::string str(ec.get_name()); + surfaceCharges[str] = ec; } } cxxSurface::cxxSurface(const std::map < int, cxxSurface > &entities, @@ -113,10 +115,10 @@ cxxSurface::~cxxSurface() bool cxxSurface::get_related_phases() { - for (std::list < cxxSurfaceComp >::const_iterator it = + for (std::map < std::string, cxxSurfaceComp >::const_iterator it = this->surfaceComps.begin(); it != this->surfaceComps.end(); ++it) { - if (it->get_phase_name() == NULL) + if ((*it).second.get_phase_name() == NULL) continue; return (true); } @@ -126,10 +128,10 @@ cxxSurface::get_related_phases() bool cxxSurface::get_related_rate() { - for (std::list < cxxSurfaceComp >::const_iterator it = + for (std::map < std::string, cxxSurfaceComp >::const_iterator it = this->surfaceComps.begin(); it != this->surfaceComps.end(); ++it) { - if (it->get_rate_name() == NULL) + if ((*it).second.get_rate_name() == NULL) continue; return (true); } @@ -181,8 +183,7 @@ cxxSurface::cxxSurface2surface() { surface_ptr->count_charge = (int) this->surfaceCharges.size(); surface_ptr->charge = - cxxSurfaceCharge::cxxSurfaceCharge2surface_charge(this-> - surfaceCharges); + cxxSurfaceCharge::cxxSurfaceCharge2surface_charge(this->surfaceCharges); } else { @@ -267,19 +268,19 @@ cxxSurface::dump_xml(std::ostream & s_oss, unsigned int indent) const s_oss << indent1; s_oss << "::const_iterator it = + for (std::map < std::string, cxxSurfaceComp >::const_iterator it = this->surfaceComps.begin(); it != this->surfaceComps.end(); ++it) { - it->dump_xml(s_oss, indent + 2); + (*it).second.dump_xml(s_oss, indent + 2); } } // surface charge structures s_oss << indent1; s_oss << "::const_iterator it = + for (std::map < std::string, cxxSurfaceCharge >::const_iterator it = surfaceCharges.begin(); it != surfaceCharges.end(); ++it) { - it->dump_xml(s_oss, indent + 2); + (*it).second.dump_xml(s_oss, indent + 2); } return; @@ -337,21 +338,21 @@ cxxSurface::dump_raw(std::ostream & s_oss, unsigned int indent) const s_oss << "-transport " << this->transport << std::endl; // surfaceComps structures - for (std::list < cxxSurfaceComp >::const_iterator it = + for (std::map < std::string, cxxSurfaceComp >::const_iterator it = surfaceComps.begin(); it != surfaceComps.end(); ++it) { s_oss << indent1; s_oss << "-component" << std::endl; - it->dump_raw(s_oss, indent + 2); + (*it).second.dump_raw(s_oss, indent + 2); } // surface charge structures { - for (std::list < cxxSurfaceCharge >::const_iterator it = + for (std::map < std::string, cxxSurfaceCharge >::const_iterator it = surfaceCharges.begin(); it != surfaceCharges.end(); ++it) { s_oss << indent1; s_oss << "-charge_component " << std::endl; - it->dump_raw(s_oss, indent + 2); + (*it).second.dump_raw(s_oss, indent + 2); } } @@ -507,8 +508,31 @@ cxxSurface::read_raw(CParser & parser, bool check) case 5: // component { cxxSurfaceComp ec; - ec.read_raw(parser); - this->surfaceComps.push_back(ec); + + // preliminary read + std::istream::pos_type pos = parser.tellg(); + CParser::ECHO_OPTION eo = parser.get_echo_file(); + parser.set_echo_file(CParser::EO_NONE); + CParser::ECHO_OPTION eo_s = parser.get_echo_stream(); + parser.set_echo_stream(CParser::EO_NONE); + ec.read_raw(parser, false); + parser.set_echo_file(eo); + parser.set_echo_file(eo_s); + parser.seekg(pos).clear(); + parser.seekg(pos); + + if (this->surfaceComps.find(ec.get_formula()) != this->surfaceComps.end()) + { + cxxSurfaceComp & comp = this->surfaceComps.find(ec.get_formula())->second; + comp.read_raw(parser, false); + } + else + { + cxxSurfaceComp ec1; + ec1.read_raw(parser, false); + std::string str(ec1.get_formula()); + this->surfaceComps[str] = ec1; + } } useLastLine = true; break; @@ -516,8 +540,31 @@ cxxSurface::read_raw(CParser & parser, bool check) case 6: // charge_component { cxxSurfaceCharge ec; - ec.read_raw(parser); - this->surfaceCharges.push_back(ec); + + // preliminary read + std::istream::pos_type pos = parser.tellg(); + CParser::ECHO_OPTION eo = parser.get_echo_file(); + parser.set_echo_file(CParser::EO_NONE); + CParser::ECHO_OPTION eo_s = parser.get_echo_stream(); + parser.set_echo_stream(CParser::EO_NONE); + ec.read_raw(parser, false); + parser.set_echo_file(eo); + parser.set_echo_file(eo_s); + parser.seekg(pos).clear(); + parser.seekg(pos); + + if (this->surfaceCharges.find(ec.get_name()) != this->surfaceCharges.end()) + { + cxxSurfaceCharge & comp = this->surfaceCharges.find(ec.get_name())->second; + comp.read_raw(parser, false); + } + else + { + cxxSurfaceCharge ec1; + ec1.read_raw(parser, false); + std::string str(ec1.get_name()); + this->surfaceCharges[str] = ec1; + } } useLastLine = true; break; @@ -775,15 +822,15 @@ cxxSurface::totalize() { this->totals.clear(); // component structures - for (std::list < cxxSurfaceComp >::const_iterator it = + for (std::map < std::string, cxxSurfaceComp >::const_iterator it = surfaceComps.begin(); it != surfaceComps.end(); ++it) { - this->totals.add_extensive(it->get_totals(), 1.0); - this->totals.add("Charge", it->get_charge_balance()); + this->totals.add_extensive((*it).second.get_totals(), 1.0); + this->totals.add("Charge", (*it).second.get_charge_balance()); } return; } - +#ifdef SKIP void cxxSurface::add(const cxxSurface & addee, double extensive) // @@ -876,3 +923,72 @@ cxxSurface::add(const cxxSurface & addee, double extensive) } } +#endif +void +cxxSurface::add(const cxxSurface & addee, double extensive) + // + // Add surface to "this" exchange + // +{ + if (extensive == 0.0) + return; + if (this->surfaceComps.size() == 0) + { + //enum SURFACE_TYPE type; + this->type = addee.type; + //enum DIFFUSE_LAYER_TYPE dl_type; + this->dl_type = addee.dl_type; + //enum SITES_UNITS sites_units; + this->sites_units = addee.sites_units; + //bool only_counter_ions; + this->only_counter_ions = addee.only_counter_ions; + //double thickness; + this->thickness = addee.thickness; + //double debye_lengths; + this->debye_lengths = addee.debye_lengths; + //double DDL_viscosity; + this->DDL_viscosity = addee.DDL_viscosity; + //double DDL_limit; + this->DDL_limit = addee.DDL_limit; + //bool transport; + this->transport = addee.transport; + } + + //std::map surfaceComps; + for (std::map < std::string, cxxSurfaceComp >::const_iterator itadd = + addee.surfaceComps.begin(); itadd != addee.surfaceComps.end(); + ++itadd) + { + std::map < std::string, cxxSurfaceComp >::iterator it = this->surfaceComps.find((*itadd).first); + if (it != this->surfaceComps.end()) + { + (*it).second.add( (*itadd).second, extensive); + } + else + { + cxxSurfaceComp entity = (*itadd).second; + entity.multiply(extensive); + std::string str(entity.get_formula()); + this->surfaceComps[str] = entity; + } + } + + //std::map < std::string, cxxSurfaceCharge > surfaceCharges; + for (std::map < std::string, cxxSurfaceCharge >::const_iterator itadd = + addee.surfaceCharges.begin(); itadd != addee.surfaceCharges.end(); + ++itadd) + { + std::map < std::string, cxxSurfaceCharge >::iterator it = this->surfaceCharges.find((*itadd).first); + if (it != this->surfaceCharges.end()) + { + (*it).second.add( (*itadd).second, extensive); + } + else + { + cxxSurfaceCharge entity = (*itadd).second; + entity.multiply(extensive); + std::string str(entity.get_name()); + this->surfaceCharges[str] = entity; + } + } +} diff --git a/Surface.h b/Surface.h index 9ad68f5a..983cd88f 100644 --- a/Surface.h +++ b/Surface.h @@ -58,8 +58,8 @@ class cxxSurface:public cxxNumKeyword void add(const cxxSurface & addee, double extensive); protected: - std::list < cxxSurfaceComp > surfaceComps; - std::list < cxxSurfaceCharge > surfaceCharges; + std::map < std::string, cxxSurfaceComp > surfaceComps; + std::map < std::string, cxxSurfaceCharge > surfaceCharges; enum SURFACE_TYPE type; enum DIFFUSE_LAYER_TYPE dl_type; enum SITES_UNITS sites_units; diff --git a/SurfaceCharge.cxx b/SurfaceCharge.cxx index de98f183..f7529eaa 100644 --- a/SurfaceCharge.cxx +++ b/SurfaceCharge.cxx @@ -81,8 +81,7 @@ cxxSurfaceCharge::get_psi_master() } struct surface_charge * -cxxSurfaceCharge::cxxSurfaceCharge2surface_charge(std::list < - cxxSurfaceCharge > &el) + cxxSurfaceCharge::cxxSurfaceCharge2surface_charge(std::map < std::string, cxxSurfaceCharge > &el) // // Builds surface_charge structure from of cxxSurfaceCharge // @@ -94,25 +93,24 @@ cxxSurfaceCharge::cxxSurfaceCharge2surface_charge(std::list < malloc_error(); int i = 0; - for (std::list < cxxSurfaceCharge >::iterator it = el.begin(); + for (std::map < std::string, cxxSurfaceCharge >::iterator it = el.begin(); it != el.end(); ++it) { - surf_charge_ptr[i].name = it->name; - surf_charge_ptr[i].specific_area = it->specific_area; - surf_charge_ptr[i].grams = it->grams; - surf_charge_ptr[i].charge_balance = it->charge_balance; - surf_charge_ptr[i].mass_water = it->mass_water; - surf_charge_ptr[i].la_psi = it->la_psi; - surf_charge_ptr[i].la_psi1 = it->la_psi1; - surf_charge_ptr[i].la_psi2 = it->la_psi2; - surf_charge_ptr[i].capacitance[0] = it->capacitance[0]; - surf_charge_ptr[i].capacitance[1] = it->capacitance[1]; + surf_charge_ptr[i].name = (*it).second.name; + surf_charge_ptr[i].specific_area = (*it).second.specific_area; + surf_charge_ptr[i].grams = (*it).second.grams; + surf_charge_ptr[i].charge_balance = (*it).second.charge_balance; + surf_charge_ptr[i].mass_water = (*it).second.mass_water; + surf_charge_ptr[i].la_psi = (*it).second.la_psi; + surf_charge_ptr[i].la_psi1 = (*it).second.la_psi1; + surf_charge_ptr[i].la_psi2 = (*it).second.la_psi2; + surf_charge_ptr[i].capacitance[0] = (*it).second.capacitance[0]; + surf_charge_ptr[i].capacitance[1] = (*it).second.capacitance[1]; surf_charge_ptr[i].sigma0 = 0; surf_charge_ptr[i].sigma1 = 0; surf_charge_ptr[i].sigma2 = 0; surf_charge_ptr[i].sigmaddl = 0; - surf_charge_ptr[i].diffuse_layer_totals = - it->diffuse_layer_totals.elt_list(); + surf_charge_ptr[i].diffuse_layer_totals = (*it).second.diffuse_layer_totals.elt_list(); //surf_charge_ptr[i].psi_master = it->get_psi_master(); surf_charge_ptr[i].count_g = 0; surf_charge_ptr[i].g = NULL; @@ -175,33 +173,33 @@ cxxSurfaceCharge::dump_raw(std::ostream & s_oss, unsigned int indent) const // Surf_Charge element and attributes s_oss << indent0 << "-name " << this->name << std::endl; - s_oss << indent0 << "-specific_area " << this-> + s_oss << indent1 << "-specific_area " << this-> specific_area << std::endl; - s_oss << indent0 << "-grams " << this->grams << std::endl; - s_oss << indent0 << "-charge_balance " << this-> + s_oss << indent1 << "-grams " << this->grams << std::endl; + s_oss << indent1 << "-charge_balance " << this-> charge_balance << std::endl; - s_oss << indent0 << "-mass_water " << this-> + s_oss << indent1 << "-mass_water " << this-> mass_water << std::endl; - s_oss << indent0 << "-la_psi " << this-> + s_oss << indent1 << "-la_psi " << this-> la_psi << std::endl; - s_oss << indent0 << "-la_psi1 " << this-> + s_oss << indent1 << "-la_psi1 " << this-> la_psi1 << std::endl; - s_oss << indent0 << "-la_psi2 " << this-> + s_oss << indent1 << "-la_psi2 " << this-> la_psi2 << std::endl; - s_oss << indent0 << "-capacitance0 " << this-> + s_oss << indent1 << "-capacitance0 " << this-> capacitance[0] << std::endl; - s_oss << indent0 << "-capacitance1 " << this-> + s_oss << indent1 << "-capacitance1 " << this-> capacitance[1] << std::endl; // totals - s_oss << indent0; + s_oss << indent1; s_oss << "-diffuse_layer_totals" << std::endl; - this->diffuse_layer_totals.dump_raw(s_oss, indent + 1); + this->diffuse_layer_totals.dump_raw(s_oss, indent + 2); } void -cxxSurfaceCharge::read_raw(CParser & parser) +cxxSurfaceCharge::read_raw(CParser & parser, bool check) { std::string str; @@ -395,67 +393,70 @@ cxxSurfaceCharge::read_raw(CParser & parser) if (opt == CParser::OPT_EOF || opt == CParser::OPT_KEYWORD) break; } - // members that must be defined - if (name_defined == false) + if (check) { - parser.incr_input_error(); - parser.error_msg("Name not defined for SurfaceCharge input.", - CParser::OT_CONTINUE); - } - if (specific_area_defined == false) - { - parser.incr_input_error(); - parser.error_msg("Specific_area not defined for SurfaceCharge input.", - CParser::OT_CONTINUE); - } - if (grams_defined == false) - { - parser.incr_input_error(); - parser.error_msg("Grams not defined for SurfaceCharge input.", - CParser::OT_CONTINUE); - } - if (charge_balance_defined == false) - { - parser.incr_input_error(); - parser. - error_msg("Charge_balance not defined for SurfaceCharge input.", - CParser::OT_CONTINUE); - } - if (mass_water_defined == false) - { - parser.incr_input_error(); - parser.error_msg("Mass_water not defined for SurfaceCharge input.", - CParser::OT_CONTINUE); - } - if (la_psi_defined == false) - { - parser.incr_input_error(); - parser.error_msg("La_psi not defined for SurfaceCharge input.", - CParser::OT_CONTINUE); - } - if (la_psi1_defined == false) - { - parser.incr_input_error(); - parser.error_msg("La_psi1 not defined for SurfaceCharge input.", - CParser::OT_CONTINUE); - } - if (la_psi2_defined == false) - { - parser.incr_input_error(); - parser.error_msg("La_psi2 not defined for SurfaceCharge input.", - CParser::OT_CONTINUE); - } - if (capacitance0_defined == false) - { - parser.incr_input_error(); - parser.error_msg("Capacitance0 not defined for SurfaceCharge input.", - CParser::OT_CONTINUE); - } - if (capacitance1_defined == false) - { - parser.incr_input_error(); - parser.error_msg("Capacitance1 not defined for SurfaceCharge input.", - CParser::OT_CONTINUE); + // members that must be defined + if (name_defined == false) + { + parser.incr_input_error(); + parser.error_msg("Name not defined for SurfaceCharge input.", + CParser::OT_CONTINUE); + } + if (specific_area_defined == false) + { + parser.incr_input_error(); + parser.error_msg("Specific_area not defined for SurfaceCharge input.", + CParser::OT_CONTINUE); + } + if (grams_defined == false) + { + parser.incr_input_error(); + parser.error_msg("Grams not defined for SurfaceCharge input.", + CParser::OT_CONTINUE); + } + if (charge_balance_defined == false) + { + parser.incr_input_error(); + parser. + error_msg("Charge_balance not defined for SurfaceCharge input.", + CParser::OT_CONTINUE); + } + if (mass_water_defined == false) + { + parser.incr_input_error(); + parser.error_msg("Mass_water not defined for SurfaceCharge input.", + CParser::OT_CONTINUE); + } + if (la_psi_defined == false) + { + parser.incr_input_error(); + parser.error_msg("La_psi not defined for SurfaceCharge input.", + CParser::OT_CONTINUE); + } + if (la_psi1_defined == false) + { + parser.incr_input_error(); + parser.error_msg("La_psi1 not defined for SurfaceCharge input.", + CParser::OT_CONTINUE); + } + if (la_psi2_defined == false) + { + parser.incr_input_error(); + parser.error_msg("La_psi2 not defined for SurfaceCharge input.", + CParser::OT_CONTINUE); + } + if (capacitance0_defined == false) + { + parser.incr_input_error(); + parser.error_msg("Capacitance0 not defined for SurfaceCharge input.", + CParser::OT_CONTINUE); + } + if (capacitance1_defined == false) + { + parser.incr_input_error(); + parser.error_msg("Capacitance1 not defined for SurfaceCharge input.", + CParser::OT_CONTINUE); + } } } diff --git a/SurfaceCharge.h b/SurfaceCharge.h index c2e434ec..b1faa769 100644 --- a/SurfaceCharge.h +++ b/SurfaceCharge.h @@ -24,15 +24,13 @@ class cxxSurfaceCharge struct master *get_psi_master(); - static struct surface_charge *cxxSurfaceCharge2surface_charge(std::list < - cxxSurfaceCharge - > &el); + static struct surface_charge *cxxSurfaceCharge2surface_charge(std::map < std::string, cxxSurfaceCharge > &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); + void read_raw(CParser & parser, bool check = true); char *get_name() const { diff --git a/SurfaceComp.cxx b/SurfaceComp.cxx index 829e4c3f..28865cc8 100644 --- a/SurfaceComp.cxx +++ b/SurfaceComp.cxx @@ -101,7 +101,7 @@ cxxSurfaceComp::get_master() } struct surface_comp * -cxxSurfaceComp::cxxSurfaceComp2surface_comp(std::list < cxxSurfaceComp > &el) + cxxSurfaceComp::cxxSurfaceComp2surface_comp(std::map < std::string, cxxSurfaceComp > &el) // // Builds surface_comp structure from of cxxSurfaceComp // @@ -113,23 +113,23 @@ cxxSurfaceComp::cxxSurfaceComp2surface_comp(std::list < cxxSurfaceComp > &el) malloc_error(); int i = 0; - for (std::list < cxxSurfaceComp >::iterator it = el.begin(); + for (std::map < std::string, cxxSurfaceComp >::iterator it = el.begin(); it != el.end(); ++it) { - surf_comp_ptr[i].formula = it->formula; - surf_comp_ptr[i].formula_totals = it->formula_totals.elt_list(); - surf_comp_ptr[i].formula_z = it->formula_z; - surf_comp_ptr[i].moles = it->moles; - surf_comp_ptr[i].master = it->get_master(); - surf_comp_ptr[i].totals = it->totals.elt_list(); - surf_comp_ptr[i].la = it->la; + surf_comp_ptr[i].formula = (*it).second.formula; + surf_comp_ptr[i].formula_totals = (*it).second.formula_totals.elt_list(); + surf_comp_ptr[i].formula_z = (*it).second.formula_z; + surf_comp_ptr[i].moles = (*it).second.moles; + surf_comp_ptr[i].master = (*it).second.get_master(); + surf_comp_ptr[i].totals = (*it).second.totals.elt_list(); + surf_comp_ptr[i].la = (*it).second.la; //surf_comp_ptr[i].charge = it->charge_number; - surf_comp_ptr[i].cb = it->charge_balance; - surf_comp_ptr[i].phase_name = it->phase_name; - surf_comp_ptr[i].phase_proportion = it->phase_proportion; - surf_comp_ptr[i].rate_name = it->rate_name; - surf_comp_ptr[i].Dw = it->Dw; - surf_comp_ptr[i].master = it->get_master(); + surf_comp_ptr[i].cb = (*it).second.charge_balance; + surf_comp_ptr[i].phase_name = (*it).second.phase_name; + surf_comp_ptr[i].phase_proportion = (*it).second.phase_proportion; + surf_comp_ptr[i].rate_name = (*it).second.rate_name; + surf_comp_ptr[i].Dw = (*it).second.Dw; + surf_comp_ptr[i].master = (*it).second.get_master(); i++; } return (surf_comp_ptr); @@ -203,41 +203,41 @@ cxxSurfaceComp::dump_raw(std::ostream & s_oss, unsigned int indent) const s_oss << indent0 << "-formula " << this-> formula << std::endl; - s_oss << indent0 << "-formula_z " << this-> + s_oss << indent1 << "-formula_z " << this-> formula_z << std::endl; - s_oss << indent0 << "-moles " << this->moles << std::endl; - s_oss << indent0 << "-la " << this->la << std::endl; - //s_oss << indent0 << "-charge_number " << this->charge_number << std::endl; - s_oss << indent0 << "-charge_balance " << this-> + s_oss << indent1 << "-moles " << this->moles << std::endl; + s_oss << indent1 << "-la " << this->la << std::endl; + //s_oss << indent1 << "-charge_number " << this->charge_number << std::endl; + s_oss << indent1 << "-charge_balance " << this-> charge_balance << std::endl; if (this->phase_name != NULL) { - s_oss << indent0 << "-phase_name " << this-> + s_oss << indent1 << "-phase_name " << this-> phase_name << std::endl; } if (this->rate_name != NULL) { - s_oss << indent0 << "-rate_name " << this-> + s_oss << indent1 << "-rate_name " << this-> rate_name << std::endl; } - s_oss << indent0 << "-phase_proportion " << this-> + s_oss << indent1 << "-phase_proportion " << this-> phase_proportion << std::endl; - s_oss << indent0 << "-Dw " << this->Dw << std::endl; + s_oss << indent1 << "-Dw " << this->Dw << std::endl; // formula_totals - s_oss << indent0; + s_oss << indent1; s_oss << "-formula_totals" << std::endl; - this->formula_totals.dump_raw(s_oss, indent + 1); + this->formula_totals.dump_raw(s_oss, indent + 2); // totals - s_oss << indent0; + s_oss << indent1; s_oss << "-totals" << std::endl; - this->totals.dump_raw(s_oss, indent + 1); + this->totals.dump_raw(s_oss, indent + 2); } void -cxxSurfaceComp::read_raw(CParser & parser) +cxxSurfaceComp::read_raw(CParser & parser, bool check) { std::string str; @@ -444,50 +444,53 @@ cxxSurfaceComp::read_raw(CParser & parser) if (opt == CParser::OPT_EOF || opt == CParser::OPT_KEYWORD) break; } - // members that must be defined - if (formula_defined == false) + if (check) { - parser.incr_input_error(); - parser.error_msg("Formula not defined for SurfaceComp input.", - CParser::OT_CONTINUE); - } - if (formula_z_defined == false) - { - parser.incr_input_error(); - parser.error_msg("Formula_z not defined for ExchComp input.", - CParser::OT_CONTINUE); - } - if (moles_defined == false) - { - parser.incr_input_error(); - parser.error_msg("Moles not defined for SurfaceComp input.", - CParser::OT_CONTINUE); - } - if (la_defined == false) - { - parser.incr_input_error(); - parser.error_msg("La not defined for SurfaceComp input.", - CParser::OT_CONTINUE); - } + // members that must be defined + if (formula_defined == false) + { + parser.incr_input_error(); + parser.error_msg("Formula not defined for SurfaceComp input.", + CParser::OT_CONTINUE); + } + if (formula_z_defined == false) + { + parser.incr_input_error(); + parser.error_msg("Formula_z not defined for ExchComp input.", + CParser::OT_CONTINUE); + } + if (moles_defined == false) + { + parser.incr_input_error(); + parser.error_msg("Moles not defined for SurfaceComp input.", + CParser::OT_CONTINUE); + } + if (la_defined == false) + { + parser.incr_input_error(); + parser.error_msg("La not defined for SurfaceComp input.", + CParser::OT_CONTINUE); + } #ifdef SKIP - if (charge_number_defined == false) - { - parser.incr_input_error(); - parser.error_msg("Charge_number not defined for SurfaceComp input.", - CParser::OT_CONTINUE); - } + if (charge_number_defined == false) + { + parser.incr_input_error(); + parser.error_msg("Charge_number not defined for SurfaceComp input.", + CParser::OT_CONTINUE); + } #endif - if (charge_balance_defined == false) - { - parser.incr_input_error(); - parser.error_msg("Charge_balance not defined for SurfaceComp input.", - CParser::OT_CONTINUE); - } - if (Dw_defined == false) - { - parser.incr_input_error(); - parser.error_msg("Dw not defined for SurfaceComp input.", - CParser::OT_CONTINUE); + if (charge_balance_defined == false) + { + parser.incr_input_error(); + parser.error_msg("Charge_balance not defined for SurfaceComp input.", + CParser::OT_CONTINUE); + } + if (Dw_defined == false) + { + parser.incr_input_error(); + parser.error_msg("Dw not defined for SurfaceComp input.", + CParser::OT_CONTINUE); + } } } diff --git a/SurfaceComp.h b/SurfaceComp.h index 4c462536..c968eb91 100644 --- a/SurfaceComp.h +++ b/SurfaceComp.h @@ -45,15 +45,13 @@ class cxxSurfaceComp this->charge_balance = d; } - static struct surface_comp *cxxSurfaceComp2surface_comp(std::list < - cxxSurfaceComp > - &el); + static struct surface_comp *cxxSurfaceComp2surface_comp(std::map < std::string, 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); + void read_raw(CParser & parser, bool check = true); const cxxNameDouble & get_totals() const { return (this->totals); diff --git a/cxxKinetics.cxx b/cxxKinetics.cxx index 3fb83d62..5f97d402 100644 --- a/cxxKinetics.cxx +++ b/cxxKinetics.cxx @@ -58,7 +58,8 @@ totals(kinetics_ptr->totals) for (i = 0; i < kinetics_ptr->count_comps; i++) { cxxKineticsComp ec(&(kinetics_ptr->comps[i])); - this->kineticsComps.push_back(ec); + std::string str(ec.get_rate_name()); + this->kineticsComps[str] = ec; } // steps @@ -223,12 +224,12 @@ cxxKinetics::dump_raw(std::ostream & s_oss, unsigned int indent) const s_oss << "-cvode_order " << this->cvode_order << std::endl; // kineticsComps structures - for (std::list < cxxKineticsComp >::const_iterator it = + for (std::map < std::string, cxxKineticsComp >::const_iterator it = kineticsComps.begin(); it != kineticsComps.end(); ++it) { s_oss << indent1; s_oss << "-component" << std::endl; - it->dump_raw(s_oss, indent + 2); + (*it).second.dump_raw(s_oss, indent + 2); } // totals @@ -377,7 +378,8 @@ cxxKinetics::read_raw(CParser & parser, bool check) { cxxKineticsComp kc; kc.read_raw(parser); - this->kineticsComps.push_back(kc); + std::string str(kc.get_rate_name()); + this->kineticsComps[str] = kc; } useLastLine = true; break; @@ -546,6 +548,7 @@ cxxKinetics::mpi_unpack(int *ints, int *ii, double *doubles, int *dd) *dd = d; } #endif +#ifdef SKIP void cxxKinetics::add(const cxxKinetics & addee, double extensive) // @@ -592,3 +595,44 @@ cxxKinetics::add(const cxxKinetics & addee, double extensive) this->cvode_steps = addee.cvode_steps; this->cvode_order = addee.cvode_order; } +#endif +void +cxxKinetics::add(const cxxKinetics & addee, double extensive) + // + // Add to existing ppassemblage to "this" ppassemblage + // +{ + if (extensive == 0.0) + return; + //std::map < std::string, cxxKineticsComp> kineticsComps; + for (std::map < std::string, cxxKineticsComp >::const_iterator itadd = + addee.kineticsComps.begin(); itadd != addee.kineticsComps.end(); + ++itadd) + { + std::map < std::string, cxxKineticsComp >::iterator it = this->kineticsComps.find((*itadd).first); + if (it != this->kineticsComps.end()) + { + (*it).second.add((*itadd).second, extensive); + } + else + { + cxxKineticsComp entity = (*itadd).second; + entity.multiply(extensive); + std::string str(entity.get_rate_name()); + this->kineticsComps[str] = entity; + } + } + //std::vector steps; + this->steps = addee.steps; + //cxxNameDouble totals; + //double step_divide; + this->step_divide = addee.step_divide; + //int rk; + this->rk = addee.rk; + //int bad_step_max; + this->bad_step_max = addee.bad_step_max; + //bool use_cvode; + this->use_cvode = addee.use_cvode; + this->cvode_steps = addee.cvode_steps; + this->cvode_order = addee.cvode_order; +} diff --git a/cxxKinetics.h b/cxxKinetics.h index 8f42b3e7..a38a4311 100644 --- a/cxxKinetics.h +++ b/cxxKinetics.h @@ -46,8 +46,8 @@ class cxxKinetics:public cxxNumKeyword void add(const cxxKinetics & addee, double extensive); protected: - std::list < cxxKineticsComp > kineticsComps; - std::vector < double >steps; + std::map < std::string, cxxKineticsComp > kineticsComps; + std::vector < double >steps; cxxNameDouble totals; double step_divide; int rk;