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
iphreeqc/phreeqcpp/Surface.cxx
Darth Vader ccdbd0ce20 Squashed 'src/' changes from 2dcf4062..b4a42445 
b4a42445 Merge commit '1ebe8191c254ea7a50f20876ef1bf21450f7887a'
1ebe8191 Squashed 'phreeqcpp/' changes from 87919a0..7284fed

git-subtree-dir: src
git-subtree-split: b4a424453b03269c6af9be2fd5f0d7a7e63b5eb4
2024-04-17 00:17:30 +00:00

838 lines
23 KiB
C++
Raw Blame History

// Surface.cxx: implementation of the cxxSurface class.
//
//////////////////////////////////////////////////////////////////////
#ifdef _DEBUG
#pragma warning(disable : 4786) // disable truncation warning (Only used by debugger)
#endif
#include <cassert> // assert
#include <algorithm> // std::sort
#include "Utils.h" // define first
#include "Phreeqc.h"
#include "Surface.h"
#include "cxxMix.h"
#include "phqalloc.h"
#if defined(PHREEQCI_GUI)
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
#endif
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
cxxSurface::cxxSurface(PHRQ_io *io)
//
// default constructor for cxxSurface
//
: cxxNumKeyword(io)
{
new_def = false;
tidied = false;
type = DDL;
dl_type = NO_DL;
sites_units = SITES_ABSOLUTE;
only_counter_ions = false;
correct_D = false;
thickness = 1e-8;
debye_lengths = 0.0;
calc_DDL_viscosity = false;
DDL_viscosity = 1.0;
DDL_limit = 0.8;
transport = false;
solution_equilibria = false;
n_solution = -999;
}
cxxSurface::cxxSurface(std::map < int, cxxSurface > &entities,
cxxMix & mix, int l_n_user, PHRQ_io *io):
cxxNumKeyword(io)
{
this->n_user = this->n_user_end = l_n_user;
this->new_def = false;
this->tidied = true;
type = DDL;
dl_type = NO_DL;
sites_units = SITES_ABSOLUTE;
only_counter_ions = false;
correct_D = false;
thickness = 1e-8;
debye_lengths = 0.0;
calc_DDL_viscosity = false;
DDL_viscosity = 1.0;
DDL_limit = 0.8;
transport = false;
solution_equilibria = false;
n_solution = -999;
//
// Mix surfaces
//
const std::map < int, LDBLE >&mixcomps = mix.Get_mixComps();
std::map < int, LDBLE >::const_iterator it;
for (it = mixcomps.begin(); it != mixcomps.end(); it++)
{
if (entities.find(it->first) != entities.end())
{
this->add(entities.find(it->first)->second, it->second);
}
}
}
cxxSurface::~cxxSurface()
{
}
bool
cxxSurface::Get_related_phases() const
{
for (size_t i = 0; i != this->surface_comps.size(); i++)
{
if (this->surface_comps[i].Get_phase_name().size() == 0)
continue;
return (true);
}
return (false);
}
bool
cxxSurface::Get_related_rate() const
{
for (size_t i = 0; i != this->surface_comps.size(); i++)
{
if (this->surface_comps[i].Get_rate_name().size() == 0)
continue;
return (true);
}
return (false);
}
void
cxxSurface::dump_raw(std::ostream & s_oss, unsigned int indent, int *n_out) const
{
unsigned int i;
s_oss.precision(DBL_DIG - 1);
std::string indent0(""), indent1(""), indent2("");
for (i = 0; i < indent; ++i)
indent0.append(Utilities::INDENT);
for (i = 0; i < indent + 1; ++i)
indent1.append(Utilities::INDENT);
for (i = 0; i < indent + 2; ++i)
indent2.append(Utilities::INDENT);
// Surface element and attributes
s_oss << indent0;
int n_user_local = (n_out != NULL) ? *n_out : this->n_user;
s_oss << "SURFACE_RAW " << n_user_local << " " << this->description << "\n";
s_oss << indent1 << "# SURFACE_MODIFY candidate identifiers #\n";
s_oss << indent1;
s_oss << "-type " << this->type << "\n";
s_oss << indent1;
s_oss << "-dl_type " << this->dl_type << "\n";
s_oss << indent1;
s_oss << "-only_counter_ions " << this->only_counter_ions << "\n";
s_oss << indent1;
s_oss << "-correct_D " << this->correct_D << "\n";
s_oss << indent1;
s_oss << "-thickness " << this->thickness << "\n";
s_oss << indent1;
s_oss << "-debye_lengths " << this->debye_lengths << "\n";
s_oss << indent1;
s_oss << "-DDL_viscosity " << this->DDL_viscosity << "\n";
s_oss << indent1;
s_oss << "-DDL_limit " << this->DDL_limit << "\n";
// surfaceComps
for (size_t i = 0; i != this->surface_comps.size(); i++)
{
const cxxSurfaceComp * comp_ptr = &(this->surface_comps[i]);
s_oss << indent1;
s_oss << "-component " << comp_ptr->Get_formula() << "\n";
comp_ptr->dump_raw(s_oss, indent + 2);
}
// surface charge
for (size_t i = 0; i != this->surface_charges.size(); i++)
{
const cxxSurfaceCharge * charge_ptr = &(this->surface_charges[i]);
s_oss << indent1;
s_oss << "-charge_component " << charge_ptr->Get_name() << "\n";
charge_ptr->dump_raw(s_oss, indent + 2);
}
s_oss << indent1 << "# SURFACE_MODIFY candidates with new_def=true #\n";
s_oss << indent1;
s_oss << "-new_def " << this->new_def << "\n";
s_oss << indent1;
s_oss << "-tidied " << this->tidied << "\n";
s_oss << indent1;
s_oss << "-sites_units " << this->sites_units << "\n";
s_oss << indent1;
s_oss << "-solution_equilibria " << this->solution_equilibria << "\n";
s_oss << indent1;
s_oss << "-n_solution " << this->n_solution << "\n";
s_oss << indent1 << "# Surface workspace variables #\n";
s_oss << indent1;
s_oss << "-transport " << this->transport << "\n";
s_oss << indent1;
s_oss << "-totals " << "\n";
this->totals.dump_raw(s_oss, indent + 2);
return;
}
void
cxxSurface::read_raw(CParser & parser, bool check)
{
int i = 0;
std::istream::pos_type ptr;
std::istream::pos_type next_char;
std::string token;
bool useLastLine(false);
// Read surface number and description
this->read_number_description(parser);
this->Set_new_def(false);
this->Set_tidied(true);
bool only_counter_ions_defined(false);
//bool correct_D_defined(false);
bool thickness_defined(false);
bool type_defined(false);
bool dl_type_defined(false);
bool sites_units_defined(false);
bool debye_lengths_defined(false);
bool DDL_viscosity_defined(false);
bool DDL_limit_defined(false);
bool transport_defined(false);
for (;;)
{
int opt;
if (useLastLine == false)
{
opt = parser.get_option(vopts, next_char);
}
else
{
opt = parser.getOptionFromLastLine(vopts, next_char, true);
}
useLastLine = false;
switch (opt)
{
case CParser::OPT_EOF:
break;
case CParser::OPT_KEYWORD:
break;
case CParser::OPT_DEFAULT:
case CParser::OPT_ERROR:
opt = CParser::OPT_EOF;
parser.error_msg("Unknown input in SURFACE keyword.",
PHRQ_io::OT_CONTINUE);
parser.error_msg(parser.line().c_str(), PHRQ_io::OT_CONTINUE);
break;
case 0: // diffuse_layer
parser.incr_input_error();
parser.error_msg("Diffuse layer is obsolete, use -type.",
PHRQ_io::OT_CONTINUE);
break;
case 1: // edl
parser.incr_input_error();
parser.error_msg("-edl is obsolete, use -type.",
PHRQ_io::OT_CONTINUE);
break;
case 2: // only_counter_ions
if (!(parser.get_iss() >> this->only_counter_ions))
{
this->only_counter_ions = false;
parser.incr_input_error();
parser.
error_msg("Expected boolean value for only_counter_ions.",
PHRQ_io::OT_CONTINUE);
}
only_counter_ions_defined = true;
break;
case 3: // donnan
parser.incr_input_error();
parser.error_msg("-Donnan is obsolete, use -dl_type.",
PHRQ_io::OT_CONTINUE);
break;
case 4: // thickness
if (!(parser.get_iss() >> this->thickness))
{
this->thickness = 0.0;
parser.incr_input_error();
parser.error_msg("Expected numeric value for thickness.",
PHRQ_io::OT_CONTINUE);
}
thickness_defined = true;
break;
case 5: // component
{
std::string str;
if (!(parser.get_iss() >> str))
{
parser.incr_input_error();
parser.error_msg("Expected string value for component name.",
PHRQ_io::OT_CONTINUE);
}
else
{
cxxSurfaceComp temp_comp(this->io);
temp_comp.Set_formula(str.c_str());
cxxSurfaceComp *comp_ptr = this->Find_comp(str);
if (comp_ptr)
{
temp_comp = *comp_ptr;
}
temp_comp.read_raw(parser, check);
if (comp_ptr)
{
for (size_t j = 0; j < this->surface_comps.size(); j++)
{
if (Utilities::strcmp_nocase(this->surface_comps[j].Get_formula().c_str(), str.c_str()) == 0)
{
this->surface_comps[j] = temp_comp;
}
}
}
else
{
this->surface_comps.push_back(temp_comp);
}
useLastLine = true;
}
}
break;
case 6: // charge_component
{
std::string str;
if (!(parser.get_iss() >> str))
{
parser.incr_input_error();
parser.error_msg("Expected string value for charge name.",
PHRQ_io::OT_CONTINUE);
}
else
{
cxxSurfaceCharge temp_charge(this->io);
temp_charge.Set_name(str.c_str());
cxxSurfaceCharge *charge_ptr = this->Find_charge(str);
if (charge_ptr)
{
temp_charge = *charge_ptr;
}
temp_charge.read_raw(parser, check);
if (charge_ptr)
{
for (size_t j = 0; j < this->surface_charges.size(); j++)
{
if (Utilities::strcmp_nocase(this->surface_charges[j].Get_name().c_str(), str.c_str()) == 0)
{
this->surface_charges[j] = temp_charge;
}
}
}
else
{
this->surface_charges.push_back(temp_charge);
}
useLastLine = true;
}
}
useLastLine = true;
break;
case 7: // type
i = 0;
if (!(parser.get_iss() >> i))
{
this->type = NO_EDL;
parser.incr_input_error();
parser.error_msg("Expected numeric value for type.",
PHRQ_io::OT_CONTINUE);
}
this->type = (SURFACE_TYPE) i;
type_defined = true;
break;
case 8: // dl_type
i = 0;
if (!(parser.get_iss() >> i))
{
this->dl_type = NO_DL;
parser.incr_input_error();
parser.error_msg("Expected numeric value for dl_type.",
PHRQ_io::OT_CONTINUE);
}
this->dl_type = (DIFFUSE_LAYER_TYPE) i;
dl_type_defined = true;
break;
case 9: // sites_units
i = 0;
if (!(parser.get_iss() >> i))
{
this->sites_units = SITES_ABSOLUTE;
parser.incr_input_error();
parser.error_msg("Expected numeric value for sites_units.",
PHRQ_io::OT_CONTINUE);
}
this->sites_units = (SITES_UNITS) i;
sites_units_defined = true;
break;
case 10: // debye_lengths
if (!(parser.get_iss() >> this->debye_lengths))
{
this->debye_lengths = 0.0;
parser.incr_input_error();
parser.error_msg("Expected numeric value for debye_lengths.",
PHRQ_io::OT_CONTINUE);
}
debye_lengths_defined = true;
break;
case 11: // DDL_viscosity
if (!(parser.get_iss() >> this->DDL_viscosity))
{
this->DDL_viscosity = 1.0;
parser.incr_input_error();
parser.error_msg("Expected numeric value for DDL_viscosity.",
PHRQ_io::OT_CONTINUE);
}
DDL_viscosity_defined = true;
break;
case 12: // DDL_limit
if (!(parser.get_iss() >> this->DDL_limit))
{
this->DDL_limit = 0.0;
parser.incr_input_error();
parser.error_msg("Expected numeric value for DDL_limit.",
PHRQ_io::OT_CONTINUE);
}
DDL_limit_defined = true;
break;
case 13: // transport
if (!(parser.get_iss() >> this->transport))
{
this->transport = false;
parser.incr_input_error();
parser.error_msg("Expected boolean value for transport.",
PHRQ_io::OT_CONTINUE);
}
transport_defined = true;
break;
case 14: // new_def
if (!(parser.get_iss() >> this->new_def))
{
this->new_def = false;
parser.incr_input_error();
parser.error_msg("Expected boolean value for new_def.",
PHRQ_io::OT_CONTINUE);
}
break;
case 15: // new_def
if (!(parser.get_iss() >> this->solution_equilibria))
{
this->solution_equilibria = false;
parser.incr_input_error();
parser.error_msg("Expected boolean value for solution_equilibria.",
PHRQ_io::OT_CONTINUE);
}
break;
case 16: // n_solution
if (!(parser.get_iss() >> this->n_solution))
{
this->n_solution = -999;
parser.incr_input_error();
parser.error_msg("Expected integer value for n_solution.",
PHRQ_io::OT_CONTINUE);
}
break;
case 17: // totals
if (this->totals.read_raw(parser, next_char) != CParser::PARSER_OK)
{
parser.incr_input_error();
parser.
error_msg
("Expected element name and molality for Surface totals.",
PHRQ_io::OT_CONTINUE);
}
break;
case 18: // tidied
if (!(parser.get_iss() >> this->tidied))
{
this->tidied = false;
parser.incr_input_error();
parser.error_msg("Expected boolean value for tidied.",
PHRQ_io::OT_CONTINUE);
}
break;
case 19: // correct_D
if (!(parser.get_iss() >> this->correct_D))
{
this->correct_D = false;
parser.incr_input_error();
parser.
error_msg("Expected boolean value for correct_D.",
PHRQ_io::OT_CONTINUE);
}
//correct_D_defined = true;
break;
}
if (opt == CParser::OPT_EOF || opt == CParser::OPT_KEYWORD)
break;
}
if (check)
{
// members that must be defined
if (only_counter_ions_defined == false)
{
parser.incr_input_error();
parser.
error_msg("Only_counter_ions not defined for SURFACE_RAW input.",
PHRQ_io::OT_CONTINUE);
}
//if (correct_D_defined == false)
//{
// parser.incr_input_error();
// parser.
// error_msg("correct_D not defined for SURFACE_RAW input.",
// PHRQ_io::OT_CONTINUE);
//}
if (thickness_defined == false)
{
parser.incr_input_error();
parser.error_msg("Thickness not defined for SURFACE_RAW input.",
PHRQ_io::OT_CONTINUE);
}
if (type_defined == false)
{
parser.incr_input_error();
parser.error_msg("Surface type not defined for SURFACE_RAW input.",
PHRQ_io::OT_CONTINUE);
}
if (dl_type_defined == false)
{
parser.incr_input_error();
parser.error_msg("Dl_type not defined for SURFACE_RAW input.",
PHRQ_io::OT_CONTINUE);
}
if (sites_units_defined == false)
{
parser.incr_input_error();
parser.error_msg("Sites_units not defined for SURFACE_RAW input.",
PHRQ_io::OT_CONTINUE);
}
if (debye_lengths_defined == false)
{
parser.incr_input_error();
parser.error_msg("Debye_lengths not defined for SURFACE_RAW input.",
PHRQ_io::OT_CONTINUE);
}
if (DDL_viscosity_defined == false)
{
parser.incr_input_error();
parser.error_msg("DDL_viscosity not defined for SURFACE_RAW input.",
PHRQ_io::OT_CONTINUE);
}
if (DDL_limit_defined == false)
{
parser.incr_input_error();
parser.error_msg("DDL_limit not defined for SURFACE_RAW input.",
PHRQ_io::OT_CONTINUE);
}
if (transport_defined == false)
{
parser.incr_input_error();
parser.error_msg("Transport not defined for SURFACE_RAW input.",
PHRQ_io::OT_CONTINUE);
}
}
this->Sort_comps();
}
void
cxxSurface::totalize()
{
this->totals.clear();
// component structures
for (size_t i = 0; i != this->surface_comps.size(); i++)
{
cxxSurfaceComp * comp_ptr = &(this->surface_comps[i]);
this->totals.add_extensive(comp_ptr->Get_totals(), 1.0);
this->totals.add("Charge", comp_ptr->Get_charge_balance());
}
return;
}
void
cxxSurface::add(const cxxSurface & addee_in, LDBLE extensive)
//
// Add surface to "this" surface
//
{
cxxSurface addee = addee_in;
if (extensive == 0.0)
return;
if (this->surface_comps.size() == 0)
{
this->only_counter_ions = addee.only_counter_ions;
this->correct_D = addee.correct_D;
this->dl_type = addee.dl_type;
this->type = addee.type;
this->sites_units = addee.sites_units;
this->thickness = addee.thickness;
this->debye_lengths = addee.debye_lengths;
this->DDL_viscosity = addee.DDL_viscosity;
this->DDL_limit = addee.DDL_limit;
this->solution_equilibria = addee.solution_equilibria;
this->n_solution = addee.n_solution;
this->transport = addee.transport;
}
for (size_t i_add = 0; i_add < addee.Get_surface_comps().size(); i_add++)
{
const cxxSurfaceComp & comp_add_ptr = addee.Get_surface_comps()[i_add];
size_t i_this;
for (i_this = 0; i_this < this->surface_comps.size(); i_this++)
{
cxxSurfaceComp & comp_this_ptr = this->surface_comps[i_this];
if(comp_add_ptr.Get_formula() == comp_this_ptr.Get_formula())
{
comp_this_ptr.add(addee.surface_comps[i_add], extensive);
break;
}
}
if (i_this == this->surface_comps.size())
{
cxxSurfaceComp entity = comp_add_ptr;
entity.multiply(extensive);
this->surface_comps.push_back(entity);
}
}
for (size_t i_add = 0; i_add < addee.Get_surface_charges().size(); i_add++)
{
const cxxSurfaceCharge & charge_add_ptr = addee.Get_surface_charges()[i_add];
size_t i_this;
for (i_this = 0; i_this < this->surface_charges.size(); i_this++)
{
cxxSurfaceCharge & charge_this_ptr = this->Get_surface_charges()[i_this];
if(charge_add_ptr.Get_name() == charge_this_ptr.Get_name())
{
charge_this_ptr.add(addee.surface_charges[i_add], extensive);
break;
}
}
if (i_this == this->surface_charges.size())
{
cxxSurfaceCharge entity = charge_add_ptr;
entity.multiply(extensive);
this->surface_charges.push_back(entity);
}
}
}
void
cxxSurface::multiply(LDBLE extensive)
//
// Add surface to "this" surface
//
{
for (size_t i = 0; i < this->surface_comps.size(); i++)
{
cxxSurfaceComp *comp_ptr = &(this->surface_comps[i]);
comp_ptr->multiply(extensive);
}
for (size_t i = 0; i < this->surface_charges.size(); i++)
{
cxxSurfaceCharge *charge_ptr = &(this->surface_charges[i]);
charge_ptr->multiply(extensive);
}
}
cxxSurfaceComp * cxxSurface::
Find_comp(std::string str)
{
for (size_t i = 0; i < this->surface_comps.size(); i++)
{
if (Utilities::strcmp_nocase(str.c_str(), this->surface_comps[i].Get_formula().c_str()) == 0)
return &(this->surface_comps[i]);
}
return NULL;
}
cxxSurfaceCharge * cxxSurface::
Find_charge(std::string str)
{
for (size_t i = 0; i < this->surface_charges.size(); i++)
{
if (Utilities::strcmp_nocase(str.c_str(), this->surface_charges[i].Get_name().c_str()) == 0)
return &(this->surface_charges[i]);
}
return NULL;
}
const cxxSurfaceCharge * cxxSurface::
Find_charge(std::string str)const
{
for (size_t i = 0; i < this->surface_charges.size(); i++)
{
if (Utilities::strcmp_nocase(str.c_str(), this->surface_charges[i].Get_name().c_str()) == 0)
return &(this->surface_charges[i]);
}
return NULL;
}
void cxxSurface::
Sort_comps(void)
{
// sort comps
{
std::map<std::string, cxxSurfaceComp> comp_map;
for (size_t i = 0; i < this->surface_comps.size(); i++)
{
comp_map[this->surface_comps[i].Get_formula()] = this->surface_comps[i];
}
this->surface_comps.clear();
std::map<std::string, cxxSurfaceComp>::iterator it;
for (it = comp_map.begin(); it != comp_map.end(); it++)
{
this->surface_comps.push_back(it->second);
}
}
// sort charge too
{
std::map<std::string, cxxSurfaceCharge> charge_map;
for (size_t i = 0; i < this->surface_charges.size(); i++)
{
charge_map[this->surface_charges[i].Get_name()] = this->surface_charges[i];
}
this->surface_charges.clear();
std::map<std::string, cxxSurfaceCharge>::iterator it;
for (it = charge_map.begin(); it != charge_map.end(); it++)
{
this->surface_charges.push_back(it->second);
}
}
}
/* ---------------------------------------------------------------------- */
void
cxxSurface::Serialize(Dictionary & dictionary, std::vector < int >&ints,
std::vector < double >&doubles)
/* ---------------------------------------------------------------------- */
{
ints.push_back(this->n_user);
ints.push_back((int) this->surface_comps.size());
{
for (size_t i = 0; i < this->surface_comps.size(); i++)
{
surface_comps[i].Serialize(dictionary, ints, doubles);
}
}
ints.push_back((int) this->surface_charges.size());
{
for (size_t i = 0; i < this->surface_charges.size(); i++)
{
surface_charges[i].Serialize(dictionary, ints, doubles);
}
}
ints.push_back(this->new_def ? 1 : 0);
ints.push_back(this->tidied ? 1 : 0);
ints.push_back((int) this->type);
ints.push_back((int) this->dl_type);
ints.push_back((int) this->sites_units);
ints.push_back(this->only_counter_ions ? 1 : 0);
doubles.push_back(this->thickness);
doubles.push_back(this->debye_lengths);
doubles.push_back(this->DDL_viscosity);
doubles.push_back(this->DDL_limit);
ints.push_back(this->correct_D ? 1 : 0);
ints.push_back(this->transport ? 1 : 0);
this->totals.Serialize(dictionary, ints, doubles);
ints.push_back(this->solution_equilibria ? 1 : 0);
ints.push_back((int) this->n_solution);
}
/* ---------------------------------------------------------------------- */
void
cxxSurface::Deserialize(Dictionary & dictionary, std::vector < int >&ints,
std::vector < double >&doubles, int &ii, int &dd)
/* ---------------------------------------------------------------------- */
{
this->n_user = ints[ii++];
this->n_user_end = this->n_user;
this->description = " ";
{
int count = ints[ii++];
this->surface_comps.clear();
for (int n = 0; n < count; n++)
{
cxxSurfaceComp sc(this->io);
sc.Deserialize(dictionary, ints, doubles, ii, dd);
this->surface_comps.push_back(sc);
}
}
{
int count = ints[ii++];
this->surface_charges.clear();
for (int n = 0; n < count; n++)
{
cxxSurfaceCharge sc(this->io);
sc.Deserialize(dictionary, ints, doubles, ii, dd);
this->surface_charges.push_back(sc);
}
}
this->new_def = (ints[ii++] != 0);
this->tidied = (ints[ii++] != 0);
this->type = (SURFACE_TYPE) ints[ii++];
this->dl_type = (DIFFUSE_LAYER_TYPE) ints[ii++];
this->sites_units = (SITES_UNITS) ints[ii++];
this->only_counter_ions = (ints[ii++] != 0);
this->thickness = doubles[dd++];
this->debye_lengths = doubles[dd++];
this->DDL_viscosity = doubles[dd++];
this->DDL_limit = doubles[dd++];
this->correct_D = (ints[ii++] != 0);
this->transport = (ints[ii++] != 0);
this->totals.Deserialize(dictionary, ints, doubles, ii, dd);
this->solution_equilibria = (ints[ii++] != 0);
this->n_solution = ints[ii++];
}
const std::vector< std::string >::value_type temp_vopts[] = {
std::vector< std::string >::value_type("diffuse_layer"), // 0
std::vector< std::string >::value_type("edl"), // 1
std::vector< std::string >::value_type("only_counter_ions"), // 2
std::vector< std::string >::value_type("donnan"), // 3
std::vector< std::string >::value_type("thickness"), // 4
std::vector< std::string >::value_type("component"), // 5
std::vector< std::string >::value_type("charge_component"), // 6
std::vector< std::string >::value_type("type "), // 7
std::vector< std::string >::value_type("dl_type"), // 8
std::vector< std::string >::value_type("sites_units"), // 9
std::vector< std::string >::value_type("debye_lengths"), // 10
std::vector< std::string >::value_type("ddl_viscosity"), // 11
std::vector< std::string >::value_type("ddl_limit"), // 12
std::vector< std::string >::value_type("transport"), // 13
std::vector< std::string >::value_type("new_def"), // 14
std::vector< std::string >::value_type("solution_equilibria"), // 15
std::vector< std::string >::value_type("n_solution"), // 16
std::vector< std::string >::value_type("totals"), // 17
std::vector< std::string >::value_type("tidied"), // 18
std::vector< std::string >::value_type("correct_d") // 19
};
const std::vector< std::string > cxxSurface::vopts(temp_vopts, temp_vopts + sizeof temp_vopts / sizeof temp_vopts[0]);
Reference in New Issue View Git Blame Copy Permalink