/* ---------------------------------------------------------------------- */
int
P_step (LDBLE step_fraction)
/* ---------------------------------------------------------------------- */
{
/*
* zero global solution, add solution or mixture, add exchange,
* add surface, add gas phase, add solid solutions,
* set temperature, and add reaction.
* Ensure all elements
* included in any of these are present in small amounts.
* Save result as n_user -1.
*/
LDBLE difftemp;
int step_number;
struct pp_assemblage *pp_assemblage_save = NULL;
struct s_s_assemblage *s_s_assemblage_save = NULL;
if (svnid == NULL)
fprintf (stderr, " ");
/*
* Zero out global solution data
*/
xsolution_zero ();
/*
* Set reaction to zero
*/
step_x = 0.0;
step_number = reaction_step;
/*
* Mixing or solution
*/
if (use.mix_ptr != NULL)
{
add_mix (use.mix_ptr);
}
else if (use.solution_ptr != NULL)
{
add_solution (use.solution_ptr, 1.0, 1.0);
}
else
{
input_error++;
error_msg ("Neither mixing nor an initial solution have "
"been defined in reaction step.", STOP);
}
/*
* Reaction
*/
if (use.irrev_ptr != NULL)
{
add_reaction (use.irrev_ptr, step_number, step_fraction);
}
/*
* Kinetics
*/
if (use.kinetics_ptr != NULL)
{
add_kinetics (use.kinetics_ptr);
/*
master_ptr =master_bsearch("S(6)");
output_msg(OUTPUT_MESSAGE,"Added kinetics, S(6) %e\n", master_ptr->total);
master_ptr =master_bsearch("S");
output_msg(OUTPUT_MESSAGE,"Added kinetics, S %e\n", master_ptr->total);
*/
}
/*
* Exchange
*/
if (use.exchange_ptr != NULL)
{
add_exchange (use.exchange_ptr);
}
/*
* Surface
*/
if (use.surface_ptr != NULL)
{
add_surface (use.surface_ptr);
}
/*
* Gases
*/
if (use.gas_phase_ptr != NULL)
{
add_gas_phase (use.gas_phase_ptr);
}
/*
* Temperature
*/
if (use.temperature_ptr != NULL)
{
add_temperature (use.temperature_ptr, step_number);
}
if ((state == TRANSPORT) && (transport_step != 0) &&
(cell > 0) && (cell != count_cells + 1))
{
difftemp = tc_x - cell_data[cell - 1].temp;
cell_data[cell - 1].temp += difftemp / tempr;
tc_x = cell_data[cell - 1].temp;
}
/*
* Pure phases and solid solutions are added to avoid
* zero or negative concentrations
*/
/*
* Pure phases
*/
if (use.pp_assemblage_ptr != NULL)
{
pp_assemblage_save =
(struct pp_assemblage *) PHRQ_malloc (sizeof (struct pp_assemblage));
if (pp_assemblage_save == NULL)
malloc_error ();
pp_assemblage_copy (use.pp_assemblage_ptr, pp_assemblage_save,
use.pp_assemblage_ptr->n_user);
add_pp_assemblage (use.pp_assemblage_ptr);
}
/*
* Solid solutions
*/
if (use.s_s_assemblage_ptr != NULL)
{
s_s_assemblage_save =
(struct s_s_assemblage *) PHRQ_malloc (sizeof (struct s_s_assemblage));
if (s_s_assemblage_save == NULL)
malloc_error ();
s_s_assemblage_copy (use.s_s_assemblage_ptr, s_s_assemblage_save,
use.s_s_assemblage_ptr->n_user);
add_s_s_assemblage (use.s_s_assemblage_ptr);
}
/*
* Check that elements are available for gas components,
* pure phases, and solid solutions
*/
if (use.gas_phase_ptr != NULL)
{
gas_phase_check (use.gas_phase_ptr);
}
if (use.pp_assemblage_ptr != NULL)
{
pp_assemblage_check (use.pp_assemblage_ptr);
}
if (use.s_s_assemblage_ptr != NULL)
{
s_s_assemblage_check (use.s_s_assemblage_ptr);
}
/*
* Check that element moles are >= zero
*/
if (solution_check () == MASS_BALANCE)
{
/* reset moles and deltas */
if (use.pp_assemblage_ptr != NULL)
{
pp_assemblage_free (use.pp_assemblage_ptr);
pp_assemblage_copy (pp_assemblage_save, use.pp_assemblage_ptr,
use.pp_assemblage_ptr->n_user);
pp_assemblage_free (pp_assemblage_save);
pp_assemblage_save =
(struct pp_assemblage *) free_check_null (pp_assemblage_save);
}
if (use.s_s_assemblage_ptr != NULL)
{
s_s_assemblage_free (use.s_s_assemblage_ptr);
s_s_assemblage_copy (s_s_assemblage_save, use.s_s_assemblage_ptr,
use.s_s_assemblage_ptr->n_user);
s_s_assemblage_free (s_s_assemblage_save);
s_s_assemblage_save =
(struct s_s_assemblage *) free_check_null (s_s_assemblage_save);
}
return (MASS_BALANCE);
}
/*
* Copy global into solution n_user = -1
*/
xsolution_save (-1);
step_save_surf (-1);
step_save_exch (-1);
/*
* Clean up temporary space
*/
if (pp_assemblage_save != NULL)
{
pp_assemblage_free (pp_assemblage_save);
pp_assemblage_save =
(struct pp_assemblage *) free_check_null (pp_assemblage_save);
}
if (s_s_assemblage_save != NULL)
{
s_s_assemblage_free (s_s_assemblage_save);
s_s_assemblage_save =
(struct s_s_assemblage *) free_check_null (s_s_assemblage_save);
}
return (OK);
}
const char *
gen_board_load(struct obj_data *self, char *param, int *err_line)
{
char *line, *param_key;
const char *err = NULL;
struct board_data *board;
int lineno = 0;
CREATE(board, struct board_data, 1);
board->name = "world";
board->deny_read =
"Try as you might, you cannot bring yourself to read this board.";
board->deny_post =
"Try as you might, you cannot bring yourself to write on this board.";
board->deny_edit =
"Try as you might, you cannot bring yourself to edit this board.";
board->deny_remove =
"Try as you might, you cannot bring yourself to delete anything on this board.";
board->not_author = "You can only delete your own posts on this board.";
CREATE(board->read_perms, struct reaction, 1);
CREATE(board->post_perms, struct reaction, 1);
CREATE(board->edit_perms, struct reaction, 1);
CREATE(board->remove_perms, struct reaction, 1);
while ((line = tmp_getline(¶m)) != NULL) {
lineno++;
if (!*line)
continue;
param_key = tmp_getword(&line);
if (!strcmp(param_key, "board"))
board->name = strdup(tmp_tolower(line));
else if (!strcmp(param_key, "deny-read"))
board->deny_read = strdup(line);
else if (!strcmp(param_key, "deny-post"))
board->deny_post = strdup(line);
else if (!strcmp(param_key, "deny-edit"))
board->deny_edit = strdup(line);
else if (!strcmp(param_key, "deny-remove"))
board->deny_remove = strdup(line);
else if (!strcmp(param_key, "not-author"))
board->not_author = strdup(line);
else if (!strcmp(param_key, "read")) {
if (!add_reaction(board->read_perms, line)) {
err = "invalid read permission";
break;
}
} else if (!strcmp(param_key, "post")) {
if (!add_reaction(board->post_perms, line)) {
err = "invalid post permission";
break;
}
} else if (!strcmp(param_key, "edit")) {
if (!add_reaction(board->edit_perms, line)) {
err = "invalid edit permission";
break;
}
} else if (!strcmp(param_key, "remove")) {
if (!add_reaction(board->remove_perms, line)) {
err = "invalid delete permission";
break;
}
} else {
err = "invalid directive";
break;
}
}
if (err) {
free_reaction(board->read_perms);
free_reaction(board->post_perms);
free_reaction(board->edit_perms);
free_reaction(board->remove_perms);
free(board);
} else
self->func_data = board;
if (err_line)
*err_line = lineno;
return err;
}
