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

unknown->master now a vector. Using size instead of a null to end list.

Browse Source
This commit is contained in:
David Parkhurst 2021-03-24 21:54:37 -06:00
parent 3c432d0535
commit 5f21dafa04
6 changed files with 50 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Phreeqc.h
View File

@ -587,8 +587,7 @@ public:
int convert_units(cxxSolution *solution_ptr);
LDBLE f_Vm(LDBLE v1);
struct unknown *find_surface_charge_unknown(std::string &str_ptr, int plane);
struct master **get_list_master_ptrs(char *ptr,
struct master *master_ptr);
std::vector<struct master*> get_list_master_ptrs(char* ptr, struct master* master_ptr);
int inout(void);
int is_special(struct species *spec);
int mb_for_species_aq(int n);
@ -600,8 +599,8 @@ public:
int setup_exchange(void);
int setup_gas_phase(void);
int setup_fixed_volume_gas(void);
int setup_master_rxn(struct master **master_ptr_list,
const std::string &pe_rxn);
int setup_master_rxn(const std::vector<struct master *> &master_ptr_list,
const std::string& pe_rxn);
int setup_pure_phases(void);
int adjust_setup_pure_phases(void);
int setup_related_surface(void);
@ -619,7 +618,6 @@ public:
LDBLE coef, LDBLE * gamma_ptr);
int store_sum_deltas(LDBLE * source, LDBLE * target, LDBLE coef);
int tidy_redox(void);
struct master **unknown_alloc_master(void);
int write_mb_eqn_x(void);
int write_mb_for_species_list(int n);
int write_mass_action_eqn_x(int stop);

5
global_structures.h
View File

@ -720,7 +720,7 @@ struct unknown
LDBLE la;
int number;
const char *description;
struct master **master;
std::vector<struct master*> master;
struct phase *phase;
LDBLE si;
int n_gas_phase_user;
@ -739,8 +739,7 @@ struct unknown
LDBLE related_moles;
struct unknown *potential_unknown, *potential_unknown1,
*potential_unknown2;
int count_comp_unknowns;
struct unknown **comp_unknowns; /* list for CD_MUSIC of comps that contribute to 0 plane mass-balance term */
std::vector<struct unknown*> comp_unknowns; /* list for CD_MUSIC of comps that contribute to 0 plane mass-balance term */
struct unknown *phase_unknown;
LDBLE mass_water;
int dissolve_only;

6
model.cpp
View File

@ -4235,7 +4235,7 @@ residuals(void)
cd_psi.push_back(-(master_ptr2->s->la * LOG_10) * R_KJ_DEG_MOL * tk_x /
F_KJ_V_EQ);
sum = 0;
for (j = 0; j < x[i]->count_comp_unknowns; j++)
for (size_t j = 0; j < x[i]->comp_unknowns.size(); j++)
{
sum +=
x[i]->comp_unknowns[j]->moles *
@ -4880,7 +4880,7 @@ sum_species(void)
*
* Sums total valence states and stores in master[i]->total.
*/
int i, j;
int i;
struct master *master_ptr;
/*
* Set global variables
@ -4962,7 +4962,7 @@ sum_species(void)
(x[i]->type == CB && x[i] != ph_unknown && x[i] != pe_unknown))
{
x[i]->sum = 0.0;
for (j = 0; x[i]->master[j] != NULL; j++)
for (size_t j = 0; j < x[i]->master.size(); j++)
{
x[i]->sum += x[i]->master[j]->total;
}

111
prep.cpp
View File

@ -832,7 +832,7 @@ build_ss_assemblage(void)
{
if (x[k]->type != MB)
continue;
for (int l = 0; x[k]->master[l] != NULL; l++)
for (size_t l = 0; l < x[k]->master.size(); l++)
{
if (x[k]->master[l] == master_ptr)
{
@ -1527,7 +1527,7 @@ build_pure_phases(void)
{
if (x[k]->type != MB)
continue;
for (int l = 0; x[k]->master[l] != NULL; l++)
for (size_t l = 0; l < x[k]->master.size(); l++)
{
if (x[k]->master[l] == master_ptr)
{
@ -1987,7 +1987,7 @@ convert_units(cxxSolution *solution_ptr)
}
/* ---------------------------------------------------------------------- */
struct master ** Phreeqc::
std::vector<struct master *> Phreeqc::
get_list_master_ptrs(char *ptr, struct master *master_ptr)
/* ---------------------------------------------------------------------- */
{
@ -1998,13 +1998,13 @@ get_list_master_ptrs(char *ptr, struct master *master_ptr)
*/
int j, l, count_list;
char token[MAX_LENGTH];
struct master **master_ptr_list;
std::vector<struct master*> master_ptr_list;
struct master *master_ptr0;
/*
* Make list of master species pointers
*/
count_list = 0;
master_ptr_list = unknown_alloc_master();
//master_ptr_list = unknown_alloc_master();
master_ptr0 = master_ptr;
if (master_ptr0 == master_ptr->s->primary)
{
@ -2022,7 +2022,7 @@ get_list_master_ptrs(char *ptr, struct master *master_ptr)
*/
if (j >= (int)master.size() || master[j]->elt->primary != master_ptr0)
{
master_ptr_list[count_list++] = master_ptr0;
master_ptr_list.push_back(master_ptr0);
/*
* Element has multiple valences
*/
@ -2037,16 +2037,12 @@ get_list_master_ptrs(char *ptr, struct master *master_ptr)
error_msg(error_string, CONTINUE);
input_error++;
}
master_ptr_list[count_list++] = master_ptr0->s->secondary;
master_ptr_list.push_back(master_ptr0->s->secondary);
while (j < (int)master.size() && master[j]->elt->primary == master_ptr0)
{
if (master[j]->s->primary == NULL)
{
master_ptr_list = (struct master **) PHRQ_realloc((void *)
master_ptr_list, ((size_t)count_list + 2) * sizeof(struct master *));
if (master_ptr_list == NULL)
malloc_error();
master_ptr_list[count_list++] = master[j];
master_ptr_list.push_back(master[j]);
}
j++;
}
@ -2057,21 +2053,16 @@ get_list_master_ptrs(char *ptr, struct master *master_ptr)
/*
* First in list is secondary species, Include all valences from input
*/
master_ptr_list[count_list++] = master_ptr0;
master_ptr_list.push_back(master_ptr0);
while (copy_token(token, &ptr, &l) != EMPTY)
{
master_ptr = master_bsearch(token);
if (master_ptr != NULL)
{
master_ptr_list = (struct master **) PHRQ_realloc((void *) master_ptr_list,
((size_t)count_list + 2) * sizeof(struct master *));
if (master_ptr_list == NULL)
malloc_error();
master_ptr_list[count_list++] = master_ptr;
master_ptr_list.push_back(master_ptr);
}
}
}
master_ptr_list[count_list] = NULL;
return (master_ptr_list);
}
@ -2608,8 +2599,9 @@ resetup_master(void)
if (x[i]->type != MB)
continue;
master_ptr0 = x[i]->master[0];
for (j = 0; (master_ptr = x[i]->master[j]) != NULL; j++)
for (j = 0; j < x[i]->master.size(); j++)
{
master_ptr = x[i]->master[j];
/*
* Set flags
*/
@ -3165,7 +3157,8 @@ setup_exchange(void)
* Fill in data for exchanger in unknowns structures
*/
struct master *master_ptr;
struct master **master_ptr_list;
//struct master **master_ptr_list;
std::vector<struct master*> master_ptr_list;
if (use.Get_exchange_ptr() == NULL)
return (OK);
@ -3216,8 +3209,8 @@ setup_exchange(void)
/*
* Set flags
*/
master_ptr_list = unknown_alloc_master();
master_ptr_list[0] = master_ptr;
master_ptr_list.clear();
master_ptr_list.push_back(master_ptr);
master_ptr->in = TRUE;
/*
* Set unknown data
@ -3332,7 +3325,7 @@ setup_surface(void)
/*
* Fill in data for surface assemblage in unknown structure
*/
struct master **master_ptr_list;
std::vector<struct master*> master_ptr_list;
int mb_unknown_number;
if (use.Get_surface_ptr() == NULL)
@ -3374,8 +3367,8 @@ setup_surface(void)
/*
* Set flags
*/
master_ptr_list = unknown_alloc_master();
master_ptr_list[0] = master_ptr;
master_ptr_list.clear();
master_ptr_list.push_back(master_ptr);
master_ptr->in = TRUE;
/*
* Setup mass balance unknown
@ -3410,8 +3403,8 @@ setup_surface(void)
*/
replace("_CB", "_psi", token);
master_ptr = master_bsearch(token.c_str());
master_ptr_list = unknown_alloc_master();
master_ptr_list[0] = master_ptr;
master_ptr_list.clear();
master_ptr_list.push_back(master_ptr);
master_ptr->in = TRUE;
/*
* Find surface charge structure
@ -3486,8 +3479,8 @@ setup_surface(void)
*/
replace(cb_suffix.c_str(), psi_suffix.c_str(), token);
master_ptr = master_bsearch(token.c_str());
master_ptr_list = unknown_alloc_master();
master_ptr_list[0] = master_ptr;
master_ptr_list.clear();
master_ptr_list.push_back(master_ptr);
master_ptr->in = TRUE;
/*
* Find surface charge structure
@ -3532,12 +3525,8 @@ setup_surface(void)
}
/* Add SURFACE unknown to a list for SURF_PSI */
struct unknown *unknown_ptr = find_surface_charge_unknown(token, SURF_PSI);
unknown_ptr->comp_unknowns = (struct unknown **) PHRQ_realloc(unknown_ptr->comp_unknowns,
(((size_t)unknown_ptr->count_comp_unknowns + 1) * sizeof(struct unknown *)));
if (unknown_ptr->comp_unknowns == NULL)
malloc_error();
unknown_ptr->comp_unknowns[unknown_ptr->count_comp_unknowns++] =
x[mb_unknown_number];
unknown_ptr->comp_unknowns.push_back(x[mb_unknown_number]);
}
}
}
@ -3708,21 +3697,21 @@ find_surface_charge_unknown(std::string &str, int plane)
}
/* ---------------------------------------------------------------------- */
int Phreeqc::
setup_master_rxn(struct master **master_ptr_list, const std::string &pe_rxn)
setup_master_rxn(const std::vector<struct master *> &master_ptr_list, const std::string &pe_rxn)
/* ---------------------------------------------------------------------- */
{
/*
* Rewrites rxn_secondary for all redox states in list
* First, in = TRUE; others, in = REWRITE
*/
int j;
struct master *master_ptr, *master_ptr0;
/*
* Set master_ptr->in, master_ptr->rxn
*/
master_ptr0 = master_ptr_list[0];
for (j = 0; (master_ptr = master_ptr_list[j]) != NULL; j++)
for (size_t j = 0; j < master_ptr_list.size(); j++)
{
master_ptr = master_ptr_list[j];
/*
* Check that data not already given
*/
@ -4290,7 +4279,7 @@ setup_solution(void)
*/
x[count_unknowns]->type = MB;
x[count_unknowns]->description = string_hsave(it->first.c_str());
for (int j = 0; x[count_unknowns]->master[j] != NULL; j++)
for (size_t j = 0; j < x[count_unknowns]->master.size(); j++)
{
x[count_unknowns]->master[j]->unknown = x[count_unknowns];
}
@ -4482,8 +4471,7 @@ setup_solution(void)
ah2o_unknown->description = string_hsave("A(H2O)");
ah2o_unknown->type = AH2O;
ah2o_unknown->number = count_unknowns;
ah2o_unknown->master = unknown_alloc_master();
ah2o_unknown->master[0] = master_bsearch("O");
ah2o_unknown->master.push_back(master_bsearch("O"));
ah2o_unknown->master[0]->unknown = ah2o_unknown;
ah2o_unknown->moles = 0.0;
count_unknowns++;
@ -4499,8 +4487,7 @@ setup_solution(void)
ph_unknown->type = CB;
ph_unknown->moles = solution_ptr->Get_cb();
ph_unknown->number = count_unknowns;
ph_unknown->master = unknown_alloc_master();
ph_unknown->master[0] = s_hplus->primary;
ph_unknown->master.push_back(s_hplus->primary);
ph_unknown->master[0]->unknown = ph_unknown;
charge_balance_unknown = ph_unknown;
count_unknowns++;
@ -4518,8 +4505,7 @@ setup_solution(void)
mass_hydrogen_unknown->moles = solution_ptr->total_h;
#endif
mass_hydrogen_unknown->number = count_unknowns;
mass_hydrogen_unknown->master = unknown_alloc_master();
mass_hydrogen_unknown->master[0] = s_eminus->primary;
mass_hydrogen_unknown->master.push_back(s_eminus->primary);
mass_hydrogen_unknown->master[0]->unknown = mass_hydrogen_unknown;
count_unknowns++;
/*
@ -4530,8 +4516,7 @@ setup_solution(void)
mass_oxygen_unknown->type = MH2O;
mass_oxygen_unknown->moles = solution_ptr->Get_total_o();
mass_oxygen_unknown->number = count_unknowns;
mass_oxygen_unknown->master = unknown_alloc_master();
mass_oxygen_unknown->master[0] = s_h2o->primary;
mass_oxygen_unknown->master.push_back(s_h2o->primary);
count_unknowns++;
}
/*
@ -4593,28 +4578,6 @@ adjust_setup_solution(void)
return (OK);
}
/* ---------------------------------------------------------------------- */
struct master ** Phreeqc::
unknown_alloc_master(void)
/* ---------------------------------------------------------------------- */
{
/*
* Allocates space for a list of 2 master pointers
*/
struct master **master_ptr;
master_ptr = (struct master **) PHRQ_malloc(2 * sizeof(struct master *));
if (master_ptr == NULL)
{
malloc_error();
}
else
{
master_ptr[0] = NULL;
master_ptr[1] = NULL;
}
return (master_ptr);
}
/* ---------------------------------------------------------------------- */
int Phreeqc::
@ -4939,7 +4902,7 @@ switch_bases(void)
* Check if activity of first master species is predominant among activities of
* secondary master species included in mass balance.
*/
int i, j;
int i;
int first;
int return_value;
LDBLE la, la1;
@ -4954,18 +4917,18 @@ switch_bases(void)
break;
first = 0;
la = x[i]->master[0]->s->la;
for (j = 1; x[i]->master[j] != NULL; j++)
for (size_t j = 1; j < x[i]->master.size(); j++)
{
la1 = x[i]->master[j]->s->lm + x[i]->master[j]->s->lg;
if (first == 0 && la1 > la + 10.)
{
la = la1;
first = j;
first = (int)j;
}
else if (first != 0 && la1 > la)
{
la = la1;
first = j;
first = (int)j;
}
}
if (first != 0)

2
print.cpp
View File

@ -1919,7 +1919,7 @@ print_surface_cd_music(void)
charge2 = unknown_ptr2->f;
}
sum = 0;
for (int k = 0; k < x[j]->count_comp_unknowns; k++)
for (size_t k = 0; k < x[j]->comp_unknowns.size(); k++)
{
sum +=
x[j]->comp_unknowns[k]->moles *

15
structures.cpp
View File

@ -2892,9 +2892,7 @@ unknown_alloc(void)
/*
* Allocate space
*/
unknown_ptr = (struct unknown *) PHRQ_malloc(sizeof(struct unknown));
if (unknown_ptr == NULL)
malloc_error();
unknown_ptr = new struct unknown;
/*
* set pointers in structure to NULL
*/
@ -2907,7 +2905,6 @@ unknown_alloc(void)
unknown_ptr->la = 0.0;
unknown_ptr->number = 0;
unknown_ptr->description = NULL;
unknown_ptr->master = NULL;
unknown_ptr->phase = NULL;
unknown_ptr->si = 0.0;
unknown_ptr->s = NULL;
@ -2925,8 +2922,6 @@ unknown_alloc(void)
unknown_ptr->potential_unknown = NULL;
unknown_ptr->potential_unknown1 = NULL;
unknown_ptr->potential_unknown2 = NULL;
unknown_ptr->count_comp_unknowns = 0;
unknown_ptr->comp_unknowns = NULL;
unknown_ptr->phase_unknown = NULL;
unknown_ptr->surface_charge = NULL;
unknown_ptr->mass_water = 0.0;
@ -2964,8 +2959,7 @@ unknown_free(struct unknown *unknown_ptr)
*/
if (unknown_ptr == NULL)
return (ERROR);
unknown_ptr->master =
(struct master **) free_check_null(unknown_ptr->master);
unknown_ptr->master.clear();
if (unknown_ptr->type == SURFACE_CB)
{
/*
@ -2973,9 +2967,8 @@ unknown_free(struct unknown *unknown_ptr)
unknown_ptr->surface_charge = (struct surface_charge *) free_check_null(unknown_ptr->surface_charge);
*/
}
unknown_ptr->comp_unknowns =
(struct unknown **) free_check_null(unknown_ptr->comp_unknowns);
unknown_ptr = (struct unknown *) free_check_null(unknown_ptr);
unknown_ptr->comp_unknowns.clear();
delete unknown_ptr;
return (OK);
}