mirror of
https://git.gfz-potsdam.de/naaice/iphreeqc.git
synced 2025-12-15 16:18:22 +01:00
ccdbd0ce20
b4a42445 Merge commit '1ebe8191c254ea7a50f20876ef1bf21450f7887a' 1ebe8191 Squashed 'phreeqcpp/' changes from 87919a0..7284fed git-subtree-dir: src git-subtree-split: b4a424453b03269c6af9be2fd5f0d7a7e63b5eb4
618 lines
17 KiB
C++
618 lines
17 KiB
C++
// SurfaceCharge.cxx: implementation of the cxxSurfaceCharge 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 "SurfaceCharge.h"
|
|
#include "phqalloc.h"
|
|
#include "Dictionary.h"
|
|
|
|
#if defined(PHREEQCI_GUI)
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
#endif
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
// Construction/Destruction
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
cxxSurfaceCharge::cxxSurfaceCharge(PHRQ_io *io)
|
|
:
|
|
PHRQ_base(io)
|
|
//
|
|
// default constructor for cxxSurfaceCharge
|
|
//
|
|
{
|
|
specific_area = 0.0;
|
|
grams = 0.0;
|
|
charge_balance = 0.0;
|
|
mass_water = 0.0;
|
|
DDL_viscosity = 0.0;
|
|
f_free = 0.0;
|
|
la_psi = 0.0;
|
|
capacitance[0] = 1.0;
|
|
capacitance[1] = 5.0;
|
|
sigma0 = sigma1 = sigma2 = sigmaddl = 0;
|
|
diffuse_layer_totals.type = cxxNameDouble::ND_ELT_MOLES;
|
|
}
|
|
cxxSurfaceCharge::~cxxSurfaceCharge()
|
|
{
|
|
}
|
|
|
|
void
|
|
cxxSurfaceCharge::dump_xml(std::ostream & s_oss, unsigned int indent) const
|
|
{
|
|
unsigned int i;
|
|
s_oss.precision(DBL_DIG - 1);
|
|
std::string indent0(""), indent1(""), indent2("");
|
|
for (i = 0; i < indent; ++i)
|
|
indent0.append(Utilities::INDENT);
|
|
for (i = 0; i < indent + 1; ++i)
|
|
indent1.append(Utilities::INDENT);
|
|
for (i = 0; i < indent + 2; ++i)
|
|
indent2.append(Utilities::INDENT);
|
|
|
|
// Surf_Charge element and attributes
|
|
s_oss << indent0 << "name=\"" << this->name << "\"" << "\n";
|
|
s_oss << indent0 << "specific_area=\"" << this->
|
|
specific_area << "\"" << "\n";
|
|
s_oss << indent0 << "grams=\"" << this->grams << "\"" << "\n";
|
|
s_oss << indent0 << "charge_balance=\"" << this->
|
|
charge_balance << "\"" << "\n";
|
|
s_oss << indent0 << "mass_water=\"" << this->
|
|
mass_water << "\"" << "\n";
|
|
s_oss << indent0 << "f_free=\"" << this->f_free << "\"" << "\n";
|
|
s_oss << indent0 << "la_psi=\"" << this->la_psi << "\"" << "\n";
|
|
s_oss << indent0 << "capacitance=\"" << this->
|
|
capacitance[0] << " " << this->capacitance[0] << "\"" << "\n";
|
|
|
|
// totals
|
|
s_oss << indent0;
|
|
s_oss << "<diffuse_layer_totals " << "\n";
|
|
this->diffuse_layer_totals.dump_xml(s_oss, indent + 1);
|
|
|
|
}
|
|
|
|
void
|
|
cxxSurfaceCharge::dump_raw(std::ostream & s_oss, unsigned int indent) const
|
|
{
|
|
unsigned int i;
|
|
s_oss.precision(DBL_DIG - 1);
|
|
std::string indent0(""), indent1(""), indent2("");
|
|
for (i = 0; i < indent; ++i)
|
|
indent0.append(Utilities::INDENT);
|
|
for (i = 0; i < indent + 1; ++i)
|
|
indent1.append(Utilities::INDENT);
|
|
for (i = 0; i < indent + 2; ++i)
|
|
indent2.append(Utilities::INDENT);
|
|
|
|
// Surf_Charge element and attributes
|
|
s_oss << indent0 << "# SURFACE_MODIFY candidate identifiers #\n";
|
|
s_oss << indent0 << "-specific_area " << this->specific_area << "\n";
|
|
s_oss << indent0 << "-grams " << this->grams << "\n";
|
|
s_oss << indent0 << "-charge_balance " << this->charge_balance << "\n";
|
|
s_oss << indent0 << "-mass_water " << this->mass_water << "\n";
|
|
s_oss << indent0 << "-f_free " << this->f_free << "\n";
|
|
s_oss << indent0 << "-ddl_viscosity " << this->DDL_viscosity << "\n";
|
|
s_oss << indent0 << "-la_psi " << this->la_psi << "\n";
|
|
s_oss << indent0 << "-capacitance0 " << this->capacitance[0] << "\n";
|
|
s_oss << indent0 << "-capacitance1 " << this->capacitance[1] << "\n";
|
|
// totals
|
|
s_oss << indent0;
|
|
s_oss << "-diffuse_layer_totals" << "\n";
|
|
this->diffuse_layer_totals.dump_raw(s_oss, indent + 1);
|
|
|
|
// DL species
|
|
//s_oss << indent0;
|
|
//s_oss << "-diffuse_layer_species" << "\n";
|
|
if (dl_species_map.size() > 0)
|
|
{
|
|
s_oss << indent0;
|
|
s_oss << "-diffuse_layer_species" << "\n";
|
|
std::map<int, double>::const_iterator it = this->dl_species_map.begin();
|
|
for ( ; it != dl_species_map.end(); it++)
|
|
{
|
|
s_oss << indent1;
|
|
s_oss << it->first << " " << it->second << "\n";
|
|
}
|
|
}
|
|
s_oss << indent0 << "# Surface workspace variables #\n";
|
|
s_oss << indent0 << "-sigma0 " << this->sigma0 << "\n";
|
|
s_oss << indent0 << "-sigma1 " << this->sigma1 << "\n";
|
|
s_oss << indent0 << "-sigma2 " << this->sigma2 << "\n";
|
|
s_oss << indent0 << "-sigmaddl " << this->sigmaddl << "\n";
|
|
std::map<LDBLE, cxxSurfDL>::const_iterator git;
|
|
for (git = this->g_map.begin(); git != g_map.end(); git++)
|
|
{
|
|
s_oss << indent0 << "-g_map " << git->first << "\t";
|
|
s_oss << git->second.Get_g() << "\t";
|
|
s_oss << git->second.Get_dg() << "\t";
|
|
s_oss << git->second.Get_psi_to_z() << "\n";
|
|
}
|
|
}
|
|
|
|
void
|
|
cxxSurfaceCharge::read_raw(CParser & parser, bool check)
|
|
{
|
|
std::string str;
|
|
|
|
|
|
std::istream::pos_type ptr;
|
|
std::istream::pos_type next_char;
|
|
std::string token;
|
|
int opt_save;
|
|
|
|
opt_save = CParser::OPT_ERROR;
|
|
bool specific_area_defined(false);
|
|
bool grams_defined(false);
|
|
bool charge_balance_defined(false);
|
|
bool mass_water_defined(false);
|
|
bool la_psi_defined(false);
|
|
bool capacitance0_defined(false);
|
|
bool capacitance1_defined(false);
|
|
bool g_map_first(true);
|
|
bool DDL_viscosity_defined(false);
|
|
|
|
for (;;)
|
|
{
|
|
int opt = parser.get_option(vopts, next_char);
|
|
if (opt == CParser::OPT_DEFAULT)
|
|
{
|
|
opt = opt_save;
|
|
}
|
|
|
|
switch (opt)
|
|
{
|
|
case CParser::OPT_EOF:
|
|
break;
|
|
case CParser::OPT_KEYWORD:
|
|
break;
|
|
case CParser::OPT_DEFAULT:
|
|
case CParser::OPT_ERROR:
|
|
opt = CParser::OPT_KEYWORD;
|
|
// Allow return to Surface for more processing
|
|
break;
|
|
|
|
case 0: // name
|
|
warning_msg("-name ignored. Defined with -charge_component.");
|
|
break;
|
|
|
|
case 1: // specific_area
|
|
if (!(parser.get_iss() >> this->specific_area))
|
|
{
|
|
this->specific_area = 0;
|
|
parser.incr_input_error();
|
|
parser.error_msg("Expected numeric value for specific_area.",
|
|
PHRQ_io::OT_CONTINUE);
|
|
}
|
|
specific_area_defined = true;
|
|
break;
|
|
|
|
case 2: // grams
|
|
if (!(parser.get_iss() >> this->grams))
|
|
{
|
|
this->grams = 0;
|
|
parser.incr_input_error();
|
|
parser.error_msg("Expected numeric value for grams.",
|
|
PHRQ_io::OT_CONTINUE);
|
|
}
|
|
grams_defined = true;
|
|
break;
|
|
|
|
|
|
case 3: // charge_balance
|
|
if (!(parser.get_iss() >> this->charge_balance))
|
|
{
|
|
this->charge_balance = 0;
|
|
parser.incr_input_error();
|
|
parser.error_msg("Expected numeric value for charge_balance.",
|
|
PHRQ_io::OT_CONTINUE);
|
|
}
|
|
charge_balance_defined = true;
|
|
break;
|
|
|
|
case 4: // mass_water
|
|
if (!(parser.get_iss() >> this->mass_water))
|
|
{
|
|
this->mass_water = 0;
|
|
parser.incr_input_error();
|
|
parser.error_msg("Expected numeric value for mass_water.",
|
|
PHRQ_io::OT_CONTINUE);
|
|
}
|
|
mass_water_defined = true;
|
|
break;
|
|
|
|
case 5: // la_psi
|
|
if (!(parser.get_iss() >> this->la_psi))
|
|
{
|
|
this->la_psi = 0;
|
|
parser.incr_input_error();
|
|
parser.error_msg("Expected numeric value for la_psi.",
|
|
PHRQ_io::OT_CONTINUE);
|
|
}
|
|
la_psi_defined = true;
|
|
break;
|
|
|
|
|
|
case 6: // diffuse_layer_totals
|
|
if (this->diffuse_layer_totals.read_raw(parser, next_char) !=
|
|
CParser::PARSER_OK)
|
|
{
|
|
parser.incr_input_error();
|
|
parser.
|
|
error_msg
|
|
("Expected element name and molality for SurfaceCharge diffuse_layer_totals.",
|
|
PHRQ_io::OT_CONTINUE);
|
|
}
|
|
opt_save = 6;
|
|
break;
|
|
|
|
case 7: // la_psi1
|
|
parser.warning_msg("-la_psi1 identifier not used");
|
|
break;
|
|
|
|
case 8: // la_psi2
|
|
parser.warning_msg("-la_psi2 identifier not used");
|
|
break;
|
|
|
|
case 9: // capacitance0
|
|
if (!(parser.get_iss() >> this->capacitance[0]))
|
|
{
|
|
this->capacitance[0] = 0;
|
|
parser.incr_input_error();
|
|
parser.error_msg("Expected numeric value for capacitance0.",
|
|
PHRQ_io::OT_CONTINUE);
|
|
}
|
|
capacitance0_defined = true;
|
|
break;
|
|
|
|
case 10: // capacitance1
|
|
if (!(parser.get_iss() >> this->capacitance[1]))
|
|
{
|
|
this->capacitance[1] = 0;
|
|
parser.incr_input_error();
|
|
parser.error_msg("Expected numeric value for capacitance1.",
|
|
PHRQ_io::OT_CONTINUE);
|
|
}
|
|
capacitance1_defined = true;
|
|
break;
|
|
case 11: // sigma0
|
|
if (!(parser.get_iss() >> this->sigma0))
|
|
{
|
|
this->sigma0 = 0;
|
|
parser.incr_input_error();
|
|
parser.error_msg("Expected numeric value for sigma0.",
|
|
PHRQ_io::OT_CONTINUE);
|
|
}
|
|
break;
|
|
case 12: // sigma1
|
|
if (!(parser.get_iss() >> this->sigma1))
|
|
{
|
|
this->sigma1 = 0;
|
|
parser.incr_input_error();
|
|
parser.error_msg("Expected numeric value for sigma1.",
|
|
PHRQ_io::OT_CONTINUE);
|
|
}
|
|
break;
|
|
case 13: // sigma2
|
|
if (!(parser.get_iss() >> this->sigma2))
|
|
{
|
|
this->sigma2 = 0;
|
|
parser.incr_input_error();
|
|
parser.error_msg("Expected numeric value for sigma2.",
|
|
PHRQ_io::OT_CONTINUE);
|
|
}
|
|
break;
|
|
case 14: // sigmaddl
|
|
if (!(parser.get_iss() >> this->sigmaddl))
|
|
{
|
|
this->sigmaddl = 0;
|
|
parser.incr_input_error();
|
|
parser.error_msg("Expected numeric value for sigmaddl.",
|
|
PHRQ_io::OT_CONTINUE);
|
|
}
|
|
break;
|
|
case 15: // g_map
|
|
{
|
|
if (g_map_first)
|
|
{
|
|
this->g_map.clear();
|
|
g_map_first = false;
|
|
}
|
|
LDBLE z, dummy;
|
|
if (!(parser.get_iss() >> z))
|
|
break;
|
|
cxxSurfDL temp_surf_dl;
|
|
this->g_map[z] = temp_surf_dl;
|
|
std::map<LDBLE, cxxSurfDL>::iterator git = g_map.find(z);
|
|
if (!(parser.get_iss() >> dummy))
|
|
break;
|
|
else
|
|
git->second.Set_g(dummy);
|
|
if (!(parser.get_iss() >> dummy))
|
|
break;
|
|
else
|
|
git->second.Set_dg(dummy);
|
|
if (!(parser.get_iss() >> dummy))
|
|
break;
|
|
else
|
|
git->second.Set_psi_to_z(dummy);
|
|
}
|
|
break;
|
|
case 16: // dl_species_map
|
|
int s_num;
|
|
if (parser.peek_token() != CParser::TT_EMPTY)
|
|
{
|
|
if (!(parser.get_iss() >> s_num))
|
|
{
|
|
parser.incr_input_error();
|
|
parser.error_msg("Expected integer for species number.",
|
|
PHRQ_io::OT_CONTINUE);
|
|
}
|
|
else
|
|
{
|
|
double d;
|
|
if (!(parser.get_iss() >> d))
|
|
{
|
|
parser.incr_input_error();
|
|
parser.error_msg("Expected double for species concentration.",
|
|
PHRQ_io::OT_CONTINUE);
|
|
}
|
|
this->dl_species_map[s_num] = d;
|
|
}
|
|
}
|
|
opt_save = 16;
|
|
break;
|
|
case 17: // f_free of water
|
|
if (!(parser.get_iss() >> this->f_free))
|
|
{
|
|
this->f_free = 0;
|
|
parser.incr_input_error();
|
|
parser.error_msg("Expected numeric value for f_free of mass_water.",
|
|
PHRQ_io::OT_CONTINUE);
|
|
}
|
|
break;
|
|
case 18: // 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;
|
|
|
|
}
|
|
if (opt == CParser::OPT_EOF || opt == CParser::OPT_KEYWORD)
|
|
break;
|
|
}
|
|
if (check)
|
|
{
|
|
// members that must be defined
|
|
if (specific_area_defined == false)
|
|
{
|
|
parser.incr_input_error();
|
|
parser.error_msg("Specific_area not defined for SurfaceCharge input.",
|
|
PHRQ_io::OT_CONTINUE);
|
|
}
|
|
if (grams_defined == false)
|
|
{
|
|
parser.incr_input_error();
|
|
parser.error_msg("Grams not defined for SurfaceCharge input.",
|
|
PHRQ_io::OT_CONTINUE);
|
|
}
|
|
if (charge_balance_defined == false)
|
|
{
|
|
parser.incr_input_error();
|
|
parser.
|
|
error_msg("Charge_balance not defined for SurfaceCharge input.",
|
|
PHRQ_io::OT_CONTINUE);
|
|
}
|
|
if (mass_water_defined == false)
|
|
{
|
|
parser.incr_input_error();
|
|
parser.error_msg("Mass_water not defined for SurfaceCharge input.",
|
|
PHRQ_io::OT_CONTINUE);
|
|
}
|
|
if (la_psi_defined == false)
|
|
{
|
|
parser.incr_input_error();
|
|
parser.error_msg("La_psi not defined for SurfaceCharge input.",
|
|
PHRQ_io::OT_CONTINUE);
|
|
}
|
|
if (capacitance0_defined == false)
|
|
{
|
|
parser.incr_input_error();
|
|
parser.error_msg("Capacitance0 not defined for SurfaceCharge input.",
|
|
PHRQ_io::OT_CONTINUE);
|
|
}
|
|
if (capacitance1_defined == false)
|
|
{
|
|
parser.incr_input_error();
|
|
parser.error_msg("Capacitance1 not defined for SurfaceCharge input.",
|
|
PHRQ_io::OT_CONTINUE);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
cxxSurfaceCharge::add(const cxxSurfaceCharge & addee, LDBLE extensive)
|
|
{
|
|
if (extensive == 0.0)
|
|
return;
|
|
|
|
if (this->name.size() == 0 && addee.name.size() == 0)
|
|
{
|
|
return;
|
|
}
|
|
assert(this->name == addee.name);
|
|
|
|
LDBLE ext1, ext2, f1, f2;
|
|
ext1 = this->specific_area * this->grams;
|
|
ext2 = addee.specific_area * addee.grams * extensive;
|
|
if (ext1 + ext2 != 0)
|
|
{
|
|
f1 = ext1 / (ext1 + ext2);
|
|
f2 = ext2 / (ext1 + ext2);
|
|
}
|
|
else
|
|
{
|
|
f1 = 0.5;
|
|
f2 = 0.5;
|
|
}
|
|
this->specific_area = f1 * this->specific_area + f2 * addee.specific_area;
|
|
this->grams += addee.grams * extensive;
|
|
this->charge_balance += addee.charge_balance * extensive;
|
|
this->mass_water += addee.mass_water * extensive;
|
|
this->la_psi = this->la_psi * f1 + addee.la_psi * f2;
|
|
this->capacitance[0] =
|
|
this->capacitance[0] * f1 + addee.capacitance[0] * f2;
|
|
this->capacitance[1] =
|
|
this->capacitance[1] * f1 + addee.capacitance[1] * f2;
|
|
this->f_free = this->f_free * f1 + addee.f_free * f2;
|
|
this->DDL_viscosity = this->DDL_viscosity * f1 + addee.DDL_viscosity * f2;
|
|
this->diffuse_layer_totals.add_extensive(addee.diffuse_layer_totals, extensive);
|
|
}
|
|
|
|
void
|
|
cxxSurfaceCharge::multiply(LDBLE extensive)
|
|
{
|
|
this->grams *= extensive;
|
|
this->charge_balance *= extensive;
|
|
this->mass_water *= extensive;
|
|
this->diffuse_layer_totals.multiply(extensive);
|
|
}
|
|
void
|
|
cxxSurfaceCharge::Serialize(Dictionary & dictionary, std::vector < int >&ints,
|
|
std::vector < double >&doubles)
|
|
{
|
|
|
|
ints.push_back(dictionary.Find(this->name));
|
|
doubles.push_back(this->specific_area);
|
|
doubles.push_back(this->grams);
|
|
doubles.push_back(this->charge_balance);
|
|
doubles.push_back(this->mass_water);
|
|
doubles.push_back(this->la_psi);
|
|
doubles.push_back(this->capacitance[0]);
|
|
doubles.push_back(this->capacitance[1]);
|
|
this->diffuse_layer_totals.Serialize(dictionary, ints, doubles);
|
|
doubles.push_back(this->sigma0);
|
|
doubles.push_back(this->sigma1);
|
|
doubles.push_back(this->sigma2);
|
|
doubles.push_back(this->sigmaddl);
|
|
doubles.push_back(this->f_free);
|
|
doubles.push_back(this->DDL_viscosity);
|
|
ints.push_back((int) this->g_map.size());
|
|
{
|
|
std::map<LDBLE, cxxSurfDL>::iterator it;
|
|
for (it = this->g_map.begin(); it != this->g_map.end(); it++)
|
|
{
|
|
doubles.push_back(it->first);
|
|
it->second.Serialize(dictionary, ints, doubles);
|
|
}
|
|
}
|
|
ints.push_back((int) this->dl_species_map.size());
|
|
{
|
|
std::map<int, double>::iterator it;
|
|
for (it = this->dl_species_map.begin(); it != this->dl_species_map.end(); it++)
|
|
{
|
|
ints.push_back(it->first);
|
|
doubles.push_back(it->second);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
cxxSurfaceCharge::Deserialize(Dictionary & dictionary, std::vector < int >&ints,
|
|
std::vector < double >&doubles, int &ii, int &dd)
|
|
{
|
|
this->name = dictionary.GetWords()[ints[ii++]];
|
|
this->specific_area = doubles[dd++];
|
|
this->grams = doubles[dd++];
|
|
this->charge_balance = doubles[dd++];
|
|
this->mass_water = doubles[dd++];
|
|
this->la_psi = doubles[dd++];
|
|
this->capacitance[0] = doubles[dd++];
|
|
this->capacitance[1] = doubles[dd++];
|
|
this->diffuse_layer_totals.Deserialize(dictionary, ints, doubles, ii, dd);
|
|
this->sigma0 = doubles[dd++];
|
|
this->sigma1 = doubles[dd++];
|
|
this->sigma2 = doubles[dd++];
|
|
this->sigmaddl = doubles[dd++];
|
|
this->f_free = doubles[dd++];
|
|
this->DDL_viscosity = doubles[dd++];
|
|
{
|
|
this->g_map.clear();
|
|
int count = ints[ii++];
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
double d = doubles[dd++];
|
|
cxxSurfDL sdl;
|
|
sdl.Deserialize(dictionary, ints, doubles, ii, dd);
|
|
this->g_map[d] = sdl;
|
|
}
|
|
}
|
|
{
|
|
this->dl_species_map.clear();
|
|
int count = ints[ii++];
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
int j = ints[ii++];
|
|
double d = doubles[dd++];
|
|
dl_species_map[j] = d;
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
void
|
|
cxxSurfDL::Serialize(Dictionary & dictionary, std::vector < int >&ints,
|
|
std::vector < double >&doubles)
|
|
{
|
|
doubles.push_back(this->g);
|
|
doubles.push_back(this->dg);
|
|
doubles.push_back(this->psi_to_z);
|
|
}
|
|
|
|
void
|
|
cxxSurfDL::Deserialize(Dictionary & dictionary, std::vector < int >&ints,
|
|
std::vector < double >&doubles, int &ii, int &dd)
|
|
{
|
|
this->g = doubles[dd++];
|
|
this->dg = doubles[dd++];
|
|
this->psi_to_z = doubles[dd++];
|
|
}
|
|
const std::vector< std::string >::value_type temp_vopts[] = {
|
|
std::vector< std::string >::value_type("name"), // 0
|
|
std::vector< std::string >::value_type("specific_area"), // 1
|
|
std::vector< std::string >::value_type("grams"), // 2
|
|
std::vector< std::string >::value_type("charge_balance"), // 3
|
|
std::vector< std::string >::value_type("mass_water"), // 4
|
|
std::vector< std::string >::value_type("la_psi"), // 5
|
|
std::vector< std::string >::value_type("diffuse_layer_totals"), // 6
|
|
std::vector< std::string >::value_type("la_psi1"), // 7
|
|
std::vector< std::string >::value_type("la_psi2"), // 8
|
|
std::vector< std::string >::value_type("capacitance0"), // 9
|
|
std::vector< std::string >::value_type("capacitance1"), // 10
|
|
std::vector< std::string >::value_type("sigma0"), // 11
|
|
std::vector< std::string >::value_type("sigma1"), // 12
|
|
std::vector< std::string >::value_type("sigma2"), // 13
|
|
std::vector< std::string >::value_type("sigmaddl"), // 14
|
|
std::vector< std::string >::value_type("g_map"), // 15
|
|
std::vector< std::string >::value_type("diffuse_layer_species"),// 16
|
|
std::vector< std::string >::value_type("f_free"), // 17
|
|
std::vector< std::string >::value_type("ddl_viscosity") // 18
|
|
|
|
};
|
|
const std::vector< std::string > cxxSurfaceCharge::vopts(temp_vopts, temp_vopts + sizeof temp_vopts / sizeof temp_vopts[0]);
|