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

vector elements

Browse Source
This commit is contained in:
David Parkhurst 2021-03-15 12:12:46 -06:00
parent e8af689a39
commit f2c64fef86
6 changed files with 18 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
Phreeqc.cpp
View File

@ -711,9 +711,6 @@ void Phreeqc::init(void)
/*----------------------------------------------------------------------
* Elements
*---------------------------------------------------------------------- */
elements = NULL;
count_elements = 0;
max_elements = MAX_ELEMENTS;
element_h_one = NULL;
/*----------------------------------------------------------------------
* Element List
@ -1644,25 +1641,15 @@ Phreeqc::InternalCopy(const Phreeqc *pSrc)
/*----------------------------------------------------------------------
* Elements
*---------------------------------------------------------------------- */
//max_elements = pSrc->max_elements;
//elements = (struct element **) free_check_null(elements);
//elements = (struct element **) PHRQ_malloc((size_t)max_elements * sizeof(struct element));
space((void **)((void *)&elements), pSrc->max_elements, &max_elements,
sizeof(struct element *));
count_elements = 0;
for (int i = 0; i < pSrc->count_elements; i++)
for (int i = 0; i < (int)pSrc->elements.size(); i++)
{
string_hsave(pSrc->elements[i]->name);
struct element *elt_ptr = element_store(pSrc->elements[i]->name);
const char * ptr = string_hsave(pSrc->elements[i]->name);
struct element *elt_ptr = element_store(ptr);
elt_ptr->gfw = pSrc->elements[i]->gfw;
}
element_h_one = element_store("H(1)");
/*
elements = NULL;
count_elements = 0;
max_elements = MAX_ELEMENTS;
element_h_one = NULL;
*/
/*----------------------------------------------------------------------
* Element List
*---------------------------------------------------------------------- */

5
Phreeqc.h
View File

@ -1457,10 +1457,7 @@ protected:
/*----------------------------------------------------------------------
* Elements
*---------------------------------------------------------------------- */
struct element **elements;
int count_elements;
int max_elements;
std::vector<struct element*> elements;
struct element *element_h_one;
/*----------------------------------------------------------------------

5
mainsubs.cpp
View File

@ -60,9 +60,6 @@ initialize(void)
cell_data[i].print = FALSE;
}
space((void **) ((void *) &elements), INIT, &max_elements,
sizeof(struct element *));
space((void **) ((void *) &elt_list), INIT, &max_elts,
sizeof(struct elt_list));
@ -103,7 +100,7 @@ initialize(void)
*/
hcreate_multi((unsigned) max_logk, &logk_hash_table);
hcreate_multi((unsigned) MAX_ELTS, &master_isotope_hash_table);
hcreate_multi((unsigned) max_elements, &elements_hash_table);
hcreate_multi((unsigned) MAX_ELTS, &elements_hash_table);
hcreate_multi((unsigned) max_s, &species_hash_table);
hcreate_multi((unsigned) max_phases, &phases_hash_table);
// one save_values

22
structures.cpp
View File

@ -81,11 +81,10 @@ clean_up(void)
/* elements */
for (j = 0; j < count_elements; j++)
for (j = 0; j < (int)elements.size(); j++)
{
elements[j] = (struct element *) free_check_null(elements[j]);
}
elements = (struct element **) free_check_null(elements);
/* solutions */
Rxn_solution_map.clear();
@ -312,7 +311,6 @@ clean_up(void)
#endif
title_x = (char *) free_check_null(title_x);
last_title_x.clear();
count_elements = 0;
count_master = 0;
count_phases = 0;
count_s = 0;
@ -407,7 +405,6 @@ element_store(const char *element)
* Returns:
* The address of an elt structure that contains the element data.
*/
int n;
struct element *elts_ptr;
ENTRY item, *found_item;
char token[MAX_LENGTH];
@ -428,8 +425,9 @@ element_store(const char *element)
* Save new elt structure and return pointer to it
*/
/* make sure there is space in elements */
elements[count_elements] =
(struct element *) PHRQ_malloc((size_t) sizeof(struct element));
size_t count_elements = elements.size();
elements.resize(count_elements + 1);
elements[count_elements] = (struct element *) PHRQ_malloc((size_t) sizeof(struct element));
if (elements[count_elements] == NULL)
malloc_error();
/* set name pointer in elements structure */
@ -438,24 +436,18 @@ element_store(const char *element)
elements[count_elements]->master = NULL;
elements[count_elements]->primary = NULL;
elements[count_elements]->gfw = 0.0;
n = count_elements++;
if (count_elements >= max_elements)
{
space((void **) ((void *) &elements), count_elements, &max_elements,
sizeof(struct element *));
}
/*
* Update hash table
*/
item.key = elements[n]->name;
item.data = (void *) elements[n];
item.key = elements[count_elements]->name;
item.data = (void *) elements[count_elements];
found_item = hsearch_multi(elements_hash_table, item, ENTER);
if (found_item == NULL)
{
error_string = sformatf( "Hash table error in element_store.");
error_msg(error_string, CONTINUE);
}
return (elements[n]);
return (elements[count_elements]);
}
/* **********************************************************************

7
tidy.cpp
View File

@ -154,11 +154,10 @@ tidy_model(void)
/* master species */
qsort(master, (unsigned) count_master, sizeof(struct master *), master_compare);
/* elements */
qsort(elements, (size_t) count_elements, (size_t) sizeof(struct element *), element_compare);
qsort(elements.data(), elements.size(), sizeof(struct element *), element_compare);
/* phases */
qsort(phases, (size_t) count_phases, (size_t) sizeof(struct phase *), phase_compare);
qsort(phases, (size_t) count_phases, sizeof(struct phase *), phase_compare);
}
@ -2429,7 +2428,7 @@ tidy_species(void)
/*
* Set pointer in element to master species
*/
for (i = 0; i < count_elements; i++)
for (i = 0; i < (int)elements.size(); i++)
{
elements[i]->master = master_bsearch(elements[i]->name);
if (elements[i]->master == NULL)

2
transport.cpp
View File

@ -135,7 +135,7 @@ transport(void)
ct[i].m_s = NULL;
ct[i].v_m_size = ct[i].J_ij_size = ct[i].m_s_size = 0;
}
count_moles_added = count_elements;
count_moles_added = (int)elements.size();
moles_added = (struct MOLES_ADDED *) PHRQ_malloc((size_t) (count_moles_added)* sizeof(struct MOLES_ADDED));
if (moles_added == NULL)
malloc_error();