max/iphreeqc
1
0
Fork 0
mirror of https://git.gfz-potsdam.de/naaice/iphreeqc.git synced 2025-12-15 16:18:22 +01:00
Code Issues Packages Projects Releases Wiki Activity

Have converted std::list to std::map for all entities.

Browse Source 
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
This commit is contained in:
David L Parkhurst 2009-10-28 19:15:17 +00:00
parent f015759286
commit d54c04039a
16 changed files with 458 additions and 268 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
GasPhase.h
View File

@ -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;

29
KineticsComp.cxx
View File

@ -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++;

10
KineticsComp.h
View File

@ -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:

35
ReadClass.cxx
View File

@ -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++;

48
SSassemblage.cxx
View File

@ -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;
}
}
}

16
SSassemblage.h
View File

@ -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<int, cxxSSassemblage>& map;
};

30
SSassemblageSS.cxx
View File

@ -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);

2
SSassemblageSS.h
View File

@ -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;

164
Surface.cxx
View File

@ -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 << "<component " << std::endl;
{
for (std::list < cxxSurfaceComp >::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 << "<charge_component " << std::endl;
for (std::list < cxxSurfaceCharge >::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 <std::string, cxxSurfaceComp> 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;
}
}
}

4
Surface.h
View File

@ -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;

175
SurfaceCharge.cxx
View File

@ -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);
}
}
}

6
SurfaceCharge.h
View File

@ -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
{

143
SurfaceComp.cxx
View File

@ -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);
}
}
}

6
SurfaceComp.h
View File

@ -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);

52
cxxKinetics.cxx
View File

@ -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<double> 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;
}

4
cxxKinetics.h
View File

@ -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;