EXPORT void stripcomm(
char *scfname, /*Strip commented file name*/
const char *fname) /*Raw input file name*/
{
FILE *file = fopen(fname,"r");
FILE *scfile;
char *c, line[2048];
static const char *separator = ": ";
boolean status;
size_t sep_len = strlen(separator);
long io_pid;
if (file == NULL)
{
screen("ERROR in stripcomm(), can't open %s\n",fname);
clean_up(ERROR);
}
if (fgetstring(file,separator) == FUNCTION_FAILED)
{
/*File is already stripcommented*/
(void) strcpy(scfname,fname);
(void) fclose(file);
return;
}
io_pid = (is_io_node(pp_mynode())) ? (long) getpid() : 0;
pp_global_lmax(&io_pid,1L);
(void) sprintf(scfname,"%s-%ld.sc",fname,io_pid);
if (is_io_node(pp_mynode()))
{
rewind(file);
if ((scfile = fopen(scfname,"w")) == NULL)
status = NO;
else
{
status = YES;
while (fgets(line,2046,file) != NULL)
if ((c = strstr(line,separator)) != NULL)
(void) fprintf(scfile,"%s",c+sep_len);
(void) fclose(scfile);
}
}
else
status = YES;
(void) fclose(file);
if (pp_min_status(status) == NO)
{
screen("ERROR in stripcomm(), can't open %s\n",scfname);
clean_up(ERROR);
}
return;
} /*end stripcomm*/
EXPORT INTERFACE *pp_copy_interface(
INTERFACE *intfc)
{
INTERFACE *new_intfc;
boolean stat;
boolean delete_status;
DEBUG_ENTER(pp_copy_interface)
new_intfc = copy_interface(intfc);
stat = (new_intfc != NULL) ? YES : NO;
if (stat == NO)
{
(void) printf("WARNING in pp_copy_interface(), "
"unable to copy interface");
if (pp_numnodes() > 1)
(void) printf(" on processor %d\n",pp_mynode());
else
(void) printf("\n");
}
delete_status = YES;
if (pp_min_status(stat) == NO)
{
if (stat == YES)
{
(void) printf("WARNING in pp_copy_interface(), "
"unable to copy interface "
"on a remote processor\n");
delete_status = (delete_interface(new_intfc)) ? YES : NO;
if (delete_status == NO)
{
screen("ERROR in pp_copy_interface() "
"unable to delete interface ");
if (pp_numnodes() > 1)
screen(" on processor %d\n",pp_mynode());
else
screen("\n");
}
new_intfc = NULL;
}
}
if (pp_min_status(delete_status) == NO)
{
if (delete_status == YES)
{
screen("ERROR in pp_copy_interface(), unable to delete "
"interface on a remote processor\n");
}
clean_up(ERROR);
}
DEBUG_LEAVE(pp_copy_interface)
return new_intfc;
} /*end pp_copy_interface*/
LOCAL char *set_ppfname(
char *ppfname,
const char *fname,
size_t *ppfname_len)
{
size_t len;
if (pp_numnodes() > 1 )
{
const char *nd;
nd = right_flush(pp_mynode(),4);
if (fname == NULL)
fname = "";
len = strlen(fname)+1+strlen(nd)+1;
if (*ppfname_len < len)
{
*ppfname_len = len;
if (ppfname != NULL)
free(ppfname);
uni_array(&ppfname,*ppfname_len,CHAR);
}
(void) sprintf(ppfname,"%s.%s",fname,nd);
}
else
{
if (fname == NULL)
fname = "";
len = strlen(fname)+1;
if (*ppfname_len < len)
{
*ppfname_len = len;
if (ppfname != NULL)
free(ppfname);
uni_array(&ppfname,*ppfname_len,CHAR);
}
(void) strcpy(ppfname,fname);
}
return ppfname;
} /*end set_ppfname*/
EXPORT PP_GRID *set_pp_grid(
INIT_DATA *init,
RECT_GRID *comp_glbgr)
{
float L[MAXD], U[MAXD], *GL, *GU;
float *h = comp_glbgr->h;
int lbuf[MAXD], ubuf[MAXD];
int gmax[MAXD];
int icoords[MAXD];
int i, dim = comp_glbgr->dim;
int myid = pp_mynode();
static PP_GRID Pp_grid;
PP_GRID *pp_grid = &Pp_grid;
char s[1028];
debug_print("init_pp_grid","Entered set_pp_grid():\n");
copy_rect_grid(&pp_grid->Global_grid,comp_glbgr);
pp_grid->nn = 1;
for (i = 0; i < dim; ++i)
{
int Gmax, Pmax, k;
int basic_slices, extra_slices;
pp_grid->buf[i] = buffer_zones(init)[i];
Pmax = pp_grid->gmax[i] = subdomains(init)[i];
pp_grid->nn *= Pmax;
uni_array(&pp_grid->dom[i],Pmax + 1,FLOAT);
pp_grid->dom[i][0] = comp_glbgr->L[i];
pp_grid->dom[i][Pmax] = comp_glbgr->U[i];
Gmax = comp_glbgr->gmax[i];
basic_slices = Gmax / Pmax;
extra_slices = Gmax % Pmax;
for (k = 1; k < Pmax; ++k)
{
if (k < extra_slices)
pp_grid->dom[i][k] = k*(basic_slices + 1)*h[i]
+ pp_grid->dom[i][0];
else
pp_grid->dom[i][k] = (k*basic_slices + extra_slices)*h[i]
+ pp_grid->dom[i][0];
}
}
/* Clip rectangular grid to subdomain */
GL = pp_grid->Global_grid.L; GU = pp_grid->Global_grid.U;
find_Cartesian_coordinates(myid,pp_grid,icoords);
for (i = 0; i < dim; ++i)
{
L[i] = pp_grid->dom[i][icoords[i]];
U[i] = pp_grid->dom[i][icoords[i] + 1];
gmax[i] = irint((U[i] - L[i])/h[i]);
switch (dim) /* TODO Unify 2 and 3 D */
{
case 1:
case 2:
lbuf[i] = (icoords[i] > 0) ? pp_grid->buf[i] : 0;
ubuf[i] = (icoords[i]<(pp_grid->gmax[i]-1))?pp_grid->buf[i]:0;
break;
case 3:
lbuf[i] = pp_grid->buf[i];
ubuf[i] = pp_grid->buf[i];
break;
}
}
set_rect_grid(L,U,GL,GU,lbuf,ubuf,gmax,dim,&comp_glbgr->Remap,
&pp_grid->Zoom_grid);
if (debugging("init_pp_grid"))
{
(void) printf("pp_grid after set_pp_grid()\n");
(void) print_PP_GRID_structure(pp_grid);
}
debug_print("init_pp_grid","Left i_set_pp_grid():\n");
return pp_grid;
} /*end set_pp_grid*/
/*ARGSUSED*/
EXPORT void u_pp_send(
int tag,
POINTER buf,
size_t len,
int node,
const char *file,
int line)
{
#if defined(__MPI__)
static byte *msg_buf = NULL;
int mpi_return_status;
#endif /* defined(__MPI__) */
if (debugging("pp_clock"))
start_clock("pp_send");
if (DEBUG)
{
(void) printf("Node %d sending message with tag %d ",
pp_mynode(),tag);
(void) printf("and len %d to node %d, ",(int)len,node);
(void) printf("File %s, line %d\n",file,line);
}
pp_okay_to_proceed("u_pp_send","no message sent");
#if defined(__MPI__)
if (msg_buf == NULL)
{
uni_array(&msg_buf,MSG_BUF_SIZE,sizeof(byte));
mpi_return_status = MPI_Buffer_attach(msg_buf,(int)MSG_BUF_SIZE);
(void) printf("In first call to u_pp_send(), ");
(void) printf("setting the buffer size to %lu bytes.\n",
MSG_BUF_SIZE);
if (mpi_return_status != MPI_SUCCESS)
{
screen("ERROR in u_pp_send(), "
"MPI_Buffer_attach failed, "
"mpi_return_status = %d\n",mpi_return_status);
clean_up(ERROR);
}
}
mpi_return_status = MPI_Bsend(buf,(int)len,MPI_BYTE,
node,tag,FronTier_COMM);
if (mpi_return_status != MPI_SUCCESS)
{
screen("ERROR in u_pp_send(), MPI_Send() failed, "
"mpi_return_status = %d\n",mpi_return_status);
clean_up(ERROR);
}
#else /* defined(__MPI__) */
COMMAND_NOT_IMPLEMENTED("u_pp_send","scalar mode");
#endif /* defined(__MPI__) */
if (debugging("pp_clock"))
stop_clock("pp_send");
DEBUG_LEAVE(u_pp_send)
} /*end u_pp_send*/
int main(int argc, char **argv)
{
static Front front;
static RECT_GRID comp_grid;
static F_BASIC_DATA f_basic;
static LEVEL_FUNC_PACK level_func_pack;
static VELO_FUNC_PACK velo_func_pack;
TNORV_PARAMS norm_params; /* velocity function parameters */
TMC_PARAMS mc_params;
Locstate sl;
f_basic.dim = 2;
FrontInitStandardIO(argc,argv,&f_basic);
/* Initialize basic computational data */
f_basic.L[0] = 0.0; f_basic.L[1] = 0.0;
f_basic.U[0] = 1.0; f_basic.U[1] = 1.0;
f_basic.gmax[0] = 100; f_basic.gmax[1] = 100;
f_basic.boundary[0][0] = f_basic.boundary[0][1] = PERIODIC_BOUNDARY;
f_basic.boundary[1][0] = f_basic.boundary[1][1] = PERIODIC_BOUNDARY;
f_basic.size_of_intfc_state = 0;
in_name = f_basic.in_name;
restart_state_name = f_basic.restart_state_name;
out_name = f_basic.out_name;
restart_name = f_basic.restart_name;
RestartRun = f_basic.RestartRun;
RestartStep = f_basic.RestartStep;
sprintf(restart_name,"%s.ts%s",restart_name,right_flush(RestartStep,7));
#if defined(__MPI__)
sprintf(restart_name,"%s-nd%s",restart_name,right_flush(pp_mynode(),4));
#endif /* defined(__MPI__) */
FrontStartUp(&front,&f_basic);
if (!RestartRun)
{
/* Initialize interface through level function */
mc_params.num_cir = 3;
vector(&mc_params.rad,mc_params.num_cir,FLOAT);
matrix(&mc_params.cen,mc_params.num_cir,2,FLOAT);
mc_params.cen[0][0] = 0.3;
mc_params.cen[0][1] = 0.3;
mc_params.cen[1][0] = 0.7;
mc_params.cen[1][1] = 0.3;
mc_params.cen[2][0] = 0.5;
mc_params.cen[2][1] = 0.7;
mc_params.rad[0] = 0.1;
mc_params.rad[1] = 0.1;
mc_params.rad[2] = 0.1;
level_func_pack.neg_component = 1;
level_func_pack.pos_component = 2;
level_func_pack.func_params = (POINTER)&mc_params;
level_func_pack.func = multi_circle_func;
FrontInitIntfc(&front,&level_func_pack);
}
/* Initialize velocity field function */
norm_params.dim = 2;
norm_params.coeff = 0.1;
velo_func_pack.func_params = (POINTER)&norm_params;
velo_func_pack.func = norm_vel_func;
velo_func_pack.point_propagate = first_order_point_propagate;
FrontInitVelo(&front,&velo_func_pack);
/* For geometry-dependent velocity, use first
* order point propagation function, higher order
* propagation requires surface propagate, currently
* in writing, not yet in use. The following override
* the assigned fourth_order_point_propagate.
*/
front._point_propagate = first_order_point_propagate;
/* Propagate the front */
test_propagate(&front);
clean_up(0);
return 0;
}
EXPORT int check_comps_at_nodes(
INTERFACE *intfc,
O_NODE **onode_list)
{
NODE **n;
O_NODE O_node;
O_NODE *onode, *on;
COMPONENT compi, compj;
int i, j;
int num_inconsistent = 0;
debug_print("ccn","Entered check_comps_at_nodes()\n");
O_node.prev = O_node.next = NULL;
on = &O_node;
if (intfc->dim != 2)
return 0;
for (n = intfc->nodes; n && *n; ++n)
{
onode = make_onode(*n);
for (i = 0; i < onode->num_c; ++i)
{
j = (i + 1) % onode->num_c;
if (onode->orient[i] == POSITIVE_ORIENTATION)
compi = negative_component(onode->nc[i]);
else
compi = positive_component(onode->nc[i]);
if (onode->orient[j] == POSITIVE_ORIENTATION)
compj = positive_component(onode->nc[j]);
else
compj = negative_component(onode->nc[j]);
if (compi != compj)
{
if (debugging("inconsis"))
{
char xname[100];
double radius = 3.0*topological_grid(intfc).h[0];
int ii,jj;
print_node(*n);
sprintf(xname,"inconsis_comp-%d-%d",pp_mynode(),
num_inconsistent);
xgraph_2d_intfc_within_range(xname,intfc,
Coords((*n)->posn),radius,NO);
for (ii = 0; ii < onode->num_c; ++ii)
{
jj = (ii + 1) % onode->num_c;
if (onode->orient[ii] == POSITIVE_ORIENTATION)
compi = negative_component(onode->nc[ii]);
else
compi = positive_component(onode->nc[ii]);
if (onode->orient[jj] == POSITIVE_ORIENTATION)
compj = positive_component(onode->nc[jj]);
else
compj = negative_component(onode->nc[jj]);
printf("compi = %d\n",compi);
printf("compj = %d\n",compj);
print_curve(onode->nc[jj]);
}
}
++num_inconsistent;
on->next = onode;
onode->prev = on;
on = onode;
break;
}
}
}
if (onode_list!= NULL)
{
*onode_list = O_node.next;
if (*onode_list)
(*onode_list)->prev = NULL;
}
if ((num_inconsistent > 0) && debugging("ccn"))
{
(void) printf("Inconsistent components found at nodes\n");
for (onode = *onode_list; onode != NULL; onode = onode->next)
print_onode(onode);
print_interface(intfc);
}
debug_print("ccn","Left check_comps_at_nodes(), num_inconsistent = %d\n",
num_inconsistent);
return num_inconsistent;
} /*end check_comps_at_node*/
int main(int argc, char **argv)
{
static Front front;
static RECT_GRID comp_grid;
static F_BASIC_DATA f_basic;
static LEVEL_FUNC_PACK level_func_pack;
static VELO_FUNC_PACK velo_func_pack;
DOUBLE_VORTEX_PARAMS dv_params; /* velocity function parameters */
f_basic.dim = 2;
FrontInitStandardIO(argc,argv,&f_basic);
/* Initialize basic computational data */
f_basic.L[0] = 0.0; f_basic.L[1] = 0.0;
f_basic.U[0] = 1.0; f_basic.U[1] = 1.0;
f_basic.gmax[0] = 200; f_basic.gmax[1] = 200;
f_basic.boundary[0][0] = f_basic.boundary[0][1] = DIRICHLET_BOUNDARY;
f_basic.boundary[1][0] = f_basic.boundary[1][1] = DIRICHLET_BOUNDARY;
f_basic.size_of_intfc_state = 0;
in_name = f_basic.in_name;
restart_state_name = f_basic.restart_state_name;
out_name = f_basic.out_name;
restart_name = f_basic.restart_name;
RestartRun = f_basic.RestartRun;
RestartStep = f_basic.RestartStep;
sprintf(restart_name,"%s.ts%s",restart_name,right_flush(RestartStep,7));
#if defined(__MPI__)
sprintf(restart_name,"%s-nd%s",restart_name,right_flush(pp_mynode(),4));
#endif /* defined(__MPI__) */
FrontStartUp(&front,&f_basic);
if (!RestartRun)
{
/* Initialize interface through level function */
level_func_pack.neg_component = 1;
level_func_pack.pos_component = 2;
level_func_pack.func_params = NULL;
level_func_pack.func = NULL;
level_func_pack.num_points = 500;
level_func_pack.is_closed_curve = YES;
matrix(&level_func_pack.point_array,500,2,sizeof(float));
int i;
for (i = 0; i < 500; ++i)
{
float phi = i*2.0*PI/500.0;
level_func_pack.point_array[i][0] = 0.5 + 0.3*cos(phi);
level_func_pack.point_array[i][1] = 0.5 + 0.3*sin(phi);
}
FrontInitIntfc(&front,&level_func_pack);
}
/* Initialize velocity field function */
dv_params.cen1[0] = 0.25;
dv_params.cen1[1] = 0.50;
dv_params.cen2[0] = 0.75;
dv_params.cen2[1] = 0.50;
dv_params.i1 = -0.5;
dv_params.i2 = 0.5;
velo_func_pack.func_params = (POINTER)&dv_params;
velo_func_pack.func = test_vortex_vel;
velo_func_pack.point_propagate = fourth_order_point_propagate;
FrontInitVelo(&front,&velo_func_pack);
/* Propagate the front */
test_propagate(&front);
clean_up(0);
}
LOCAL int advance_front2d(
double dt,
double *dt_frac,
Front *front,
Front **newfront,
POINTER wave)
{
CURVE *oldc,*tempc,*newc;
CURVE **c;
INTERFACE *tempintfc;
NODE *oldn,*tempn,*newn;
NODE_FLAG flag;
RPROBLEM *rp;
RPROBLEM *rp1;
boolean scatter_normally_propagated_front = YES;
boolean scatter_tangentially_propagated_front = YES;
boolean stat;
boolean do_redist;
int status;
long intfc_modified;
long redo_advance_front;
static const char *fname = "advance_front2d()";
int debug_flag = NO;
debug_print("front","Entered %s(step %d time %g dt %g)\n",fname,
front->step,front->time,dt);
debug_front("old_front","into advance front",front);
*newfront = copy_front(front);
Interface_redistributed(*newfront) = NO;
do_redist = (front->num_mts == 0) ? YES : NO;
begin_advance_front2d:
redo_advance_front = 0;
tempintfc = NULL;
rp = NULL;
set_to_next_node_only(flag);
set_node_doubly_linked_list(front->interf);
/* Initialize Newfront */
start_clock("init_new_front");
capture_waves(front);
print_storage("before init_new_front","ADV_storage");
/* TODO: Remove this option!!!!! */
if (front->init_topology_of_new_interface)
status = (*front->init_topology_of_new_interface)(front,*newfront);
else
{
set_size_of_intfc_state(size_of_state(front->interf));
set_copy_intfc_states(NO);
set_add_to_correspond_list(YES);
(*newfront)->interf = pp_copy_interface(front->interf);
reset_hs_flags_on_intfc((*newfront)->interf);
status = ((*newfront)->interf != NULL) ? GOOD_STEP : ERROR_IN_STEP;
set_copy_intfc_states(YES);
}
if (front->pp_grid)
status = syncronize_time_step_status(status,front->pp_grid);
if (status != GOOD_STEP)
{
(void) printf("WARNING in advance_front2d(), "
"unable to copy interface\n");
status = ERROR_IN_STEP;
stop_clock("init_new_front");
return return_advance_front(front,newfront,status,fname);
}
print_storage("after init_new_front","ADV_storage");
stop_clock("init_new_front");
/* Set Default Propagation Limits */
set_propagation_limits(front,*newfront);
/* Propagate the Curves */
if (front->intfc_propagate != NULL)
{
start_clock("intfc_propagate");
intfc_propagate(front,wave,front->interf,(*newfront)->interf,dt);
debug_front("cp_front","after intfc prop",*newfront);
stop_clock("curve_propagate");
}
else if (front->curve_propagate != NULL)
{
start_clock("curve_propagate");
if (debugging("front"))
(void) printf("Loop over Curves\n");
for (c = front->interf->curves; c && *c; ++c)
{
oldc = *c;
if (((newc = correspond_curve(oldc)) != NULL) &&
(correspond_curve(newc) != NULL))
{
if (debugging("propagate"))
(void) printf("\t\tpropagating curve %llu\n",
(long long unsigned int)curve_number(oldc));
curve_propagate(front,wave,oldc,newc,dt);
/*f_curve_propagate2d */
}
}
debug_front("cp_front","after curve prop",*newfront);
stop_clock("curve_propagate");
}
/* Propagate the Nodes */
if (debugging("front"))
{
print_correspond_hyper_surf_list(front->interf);
print_correspond_hyper_surf_list((*newfront)->interf);
}
if (front->node_propagate != NULL)
{
start_clock("node_propagate");
set_corresponds_for_node_prop(front->interf,(*newfront)->interf);
oldn = first_node(front->interf);
while (oldn != NULL)
{
newn = correspond_node(oldn);
if (debugging("crx_status"))
print_linked_node_list((*newfront)->interf);
status = (newn != NULL) ?
(*front->node_propagate)(front,wave,oldn,newn,&rp,
dt,dt_frac,flag,NULL) : GOOD_NODE;
if (debugging("crx_status"))
if (is_bad_status(status) &&
(point_in_buffer(Coords(oldn->posn),front->rect_grid) == YES))
{
print_node_status("WARNING in advance_front2d(), "
"node_propagation returns ",status,"\n");
(void) printf("Problem occurs in buffer zone - ignoring\n");
if (set_node_states_and_continue(oldn,newn,front))
status = GOOD_NODE;
}
switch (status)
{
case GOOD_NODE:
oldn = adv_node_loop_after_good_prop(oldn,newn,&rp);
break;
case PSEUDOCROSS_NODE_NODE:
debug_print("PSEUDOCROSS","PSEUDOCROSS case\n");
oldn = reorder_node_loop(oldn,newn);
break;
case CROSS_NODE_NODE:
case BIFURCATION_NODE:
debug_print("CROSS","CROSS case\n");
oldn = next_node(oldn);
break;
case CROSS_PAST_CURVE_NODE:
print_node_status("WARNING in advance_front2d(), "
"node_propagate failed with status ",
status,"\n");
print_node(oldn);
if (debugging("CROSS_PAST"))
{
(void) printf("Cross past curve case\n"
"dt_frac = %g\n",*dt_frac);
(void) printf("Reducing time step\n");
}
status = node_modify_time_step(oldn,front,dt_frac,
MODIFY_TIME_STEP);
free_rp_list(&rp);
goto sync_prop_stat1;
case MODIFY_TIME_STEP_NODE:
(void) printf("WARNING in advance_front2d(), "
"node_propagate returns "
"MODIFY_TIME_STEP_NODE\n");
free_rp_list(&rp);
status = node_modify_time_step(oldn,front,NULL,
MODIFY_TIME_STEP);
goto sync_prop_stat1;
case REPEAT_TIME_STEP_NODE:
(void) printf("WARNING in advance_front2d(), "
"node_propagate returns "
"REPEAT_TIME_STEP_NODE\n");
free_rp_list(&rp);
status = node_modify_time_step(oldn,front,NULL,
REPEAT_TIME_STEP);
goto sync_prop_stat1;
case NO_CROSS_NODE:
print_node_status("WARNING in advance_front2d(), "
"node_propagate failed with status ",
status,"\n");
print_node(oldn);
if (debugging("NO_CROSS"))
{
(void) printf("No cross case\n");
(void) printf("dt_frac = %g\n",*dt_frac);
(void) printf("Reducing time step\n");
}
free_rp_list(&rp);
status = node_modify_time_step(oldn,front,dt_frac,
MODIFY_TIME_STEP);
goto sync_prop_stat1;
case ERROR_NODE:
default:
print_node_status("WARNING in advance_front2d(), "
"node_propagate failed with status ",
status,"\n");
print_node(oldn);
if (debugging("ERROR_NODE"))
{
(void) printf("Old interface:\n");
print_interface(front->interf);
print_correspond_hyper_surf_list(front->interf);
(void) printf("New interface:\n");
print_interface((*newfront)->interf);
print_correspond_hyper_surf_list((*newfront)->interf);
}
status = node_modify_time_step(oldn,front,dt_frac,
ERROR_IN_STEP);
free_rp_list(&rp);
goto sync_prop_stat1;
}
} /* end of while (oldn != NULL) */
set_correspond_hyper_surf_bdrys_to_NULL(front->interf);
set_correspond_hyper_surf_bdrys_to_NULL((*newfront)->interf);
if (rp && (front->twodrproblem != NULL))
{
for (rp1 = rp; rp1; rp1 = rp1->prev)
{
debug_front("2drp_front",
"new between node loop and rp loop",*newfront);
status = (*front->twodrproblem)(front,*newfront,wave,&rp1);
/* At this point, rp is nothing more than a valid element
* of the list which provides a starting point
* for deleting the list. If we delete an element of
* the list in front->twodrproblem (presumably due to
* merging two RPROBLEM's), then rp may point to freed
* storage and will need to be updated. rp1 should still
* be a valid element of the list.
*/
rp = rp1;
if (status != GOOD_STEP)
{
print_time_step_status("WARNING in advance_front2d(), "
"rp failed with status = ",
status,"\n");
switch (status)
{
case GOOD_STEP:
break;
case REPEAT_TIME_STEP:
break;
case MODIFY_TIME_STEP:
status = rp_modify_time_step(rp1,front,status);
if (status == MODIFY_TIME_STEP)
{
*dt_frac = rp1->dt_frac;
if (debugging("2drp"))
{
print_rproblem(rp1);
(void) printf("dt_frac %g\n",*dt_frac);
(void) printf("Reducing time step\n");
}
*dt_frac = limit_dt_frac(*dt_frac,front);
}
break;
case ERROR_IN_STEP:
default:
print_rproblem(rp1);
/* Try reducing the time step */
status = rp_modify_time_step(rp1,front,status);
if (status == MODIFY_TIME_STEP)
*dt_frac *=
TIME_STEP_REDUCTION_FACTOR(front->interf);
break;
}
}
if (status != GOOD_STEP)
break;
}
free_rp_list(&rp);
debug_front("2drp_front","after 2drp loop",*newfront);
}
else if (rp)
{
for (rp1 = rp; rp1; rp1 = rp1->prev)
print_rproblem(rp1);
free_rp_list(&rp);
(void) printf("WARNING in advance_front2d(), "
"CROSS code needed\n");
status = ERROR_IN_STEP;
}
sync_prop_stat1:
stop_clock("node_propagate");
if (front->pp_grid)
status = syncronize_time_step_status(status,front->pp_grid);
if (status != GOOD_STEP)
return return_advance_front(front,newfront,status,fname);
}
if (*front->max_scaled_propagation > 0.5)
{
(void) printf("WARNING in advance_front2d(), "
"front->max_scaled_propagation = %f\n",
*(front->max_scaled_propagation));
*dt_frac = 0.4/(*front->max_scaled_propagation);
status = MODIFY_TIME_STEP;
goto sync_prop_stat2;
}
stat = consistent_propagated_loop_orientations(dt,dt_frac,front,wave);
if (stat == NO)
{
(void) printf("WARNING in advance_front2d(), "
"Inconsistent orientation of propagated loop "
"detected after point and node propagations");
if (pp_numnodes() > 1)
(void) printf(" on processor %d\n",pp_mynode());
else
(void) printf("\n");
}
if (pp_min_status(stat) == NO)
{
if (stat == YES)
{
(void) printf("WARNING in advance_front2d(), "
"Inconsistent orientation of propagated loop "
"detected on a remote processor "
"after point and node propagations ");
}
status = MODIFY_TIME_STEP;
goto sync_prop_stat2;
}
/* Make Temp Interface for Tangential Propagation */
set_node_doubly_linked_list((*newfront)->interf);
if (front->snd_node_propagate)
{
start_clock("snd_copy_interface");
print_storage("before snd_copy_interface","ADV_storage");
tempintfc = (*newfront)->interf;
set_size_of_intfc_state(size_of_state(tempintfc));
set_add_to_correspond_list(YES);
if (((*newfront)->interf = pp_copy_interface(tempintfc)) == NULL)
{
(void) printf("WARNING in advance_front2d(), "
"unable to copy interface\n");
status = ERROR_IN_STEP;
goto sync_prop_stat2;
}
copy_hypersurface_flags((*newfront)->interf);
print_storage("after snd_copy_interface","ADV_storage");
stop_clock("snd_copy_interface");
}
interpolate_intfc_states((*newfront)->interf) = YES;
/* Second Propagation for the States Around the Nodes */
if (front->snd_node_propagate)
{
start_clock("snd_node_propagate");
if (debugging("front"))
(void) printf("Second Loop over Nodes\n");
tempn = first_node(tempintfc);
newn = first_node((*newfront)->interf);
while (newn != NULL)
{
(*front->snd_node_propagate)(front,*newfront,wave,
tempintfc,tempn,newn,dt);
tempn = next_node(tempn);
newn = next_node(newn);
}
debug_front("snd_front","after snd_node prop",*newfront);
stop_clock("snd_node_propagate");
}
if (tempintfc)
(void) delete_interface(tempintfc);
print_storage("after delete tempintfc","ADV_storage");
/* Redistribute the New Front */
switch (redistribute(*newfront,do_redist,NO))
{
case GOOD_REDISTRIBUTION:
status = GOOD_STEP;
break;
case UNABLE_TO_UNTANGLE:
(void) printf("WARNING in advance_front2d(), "
"redistribution of front failed\n"
"Restarting advance_front2d()\n");
*dt_frac = Min_time_step_modification_factor(front);
status = MODIFY_TIME_STEP;
break;
case MODIFY_TIME_STEP_REDISTRIBUTE:
(void) printf("WARNING in advance_front2d(), "
"redistribute returns\n"
"\t\tMODIFY_TIME_STEP_REDISTRIBUTE, dt_frac = %g\n",
*dt_frac);
*dt_frac = Min_time_step_modification_factor(front);
status = MODIFY_TIME_STEP;
break;
case BAD_REDISTRIBUTION:
default:
(void) printf("WARNING in advance_front2d(), "
"redistribution of front failed\n");
debug_front("ERROR_front","after error",*newfront);
*dt_frac = Min_time_step_modification_factor(front);
status = MODIFY_TIME_STEP;
break;
}
if (front->pp_grid)
status = syncronize_time_step_status(status,front->pp_grid);
if (status != GOOD_STEP)
return return_advance_front(front,newfront,status,fname);
Redistribution_count(front) = Redistribution_count(*newfront);
(*newfront)->step = front->step + 1;
(*newfront)->time = front->time + dt;
debug_front("redist_front","after redistribution",*newfront);
/* Communicate topologically propagated front */
if (scatter_normally_propagated_front == YES)
{
start_clock("scatter_front");
if (!scatter_front(*newfront))
{
(void) printf("WARNING in advance_front2d(), "
"scatter_front() failed for "
"normally propagated front\n");
scatter_normally_propagated_front = NO;
scatter_tangentially_propagated_front = NO;
(void) delete_interface((*newfront)->interf);
(*newfront)->interf = NULL;
goto begin_advance_front2d;
}
stop_clock("scatter_front");
}
debug_front("node_front","after node loop",*newfront);
if (debugging("front"))
{
print_correspond_hyper_surf_list(front->interf);
print_correspond_hyper_surf_list((*newfront)->interf);
}
if (front->mass_consv_diagn_driver)
(*front->mass_consv_diagn_driver)(front,wave,dt);
if (debugging("bond_lengths"))
check_bond_lengths((*newfront)->interf);
/* Check for the geometric orientation of loops */
/* ONLY check loops that will not be deleted !!!! */
delete_small_loops(*newfront);
/* Delete non-boundary curves that lie */
/* fully on or exterior to the boundary */
delete_exterior_curves(*newfront,front->interf);
intfc_delete_fold_back_bonds(*newfront);
debug_front("dec_front","after delete_exterior_curves:",*newfront);
interpolate_intfc_states((*newfront)->interf) = YES;
/* Make Temp Interface for Tangential Propagation */
if (front->tan_curve_propagate)
{
start_clock("snd_copy_interface");
print_storage("before snd_copy_interface","ADV_storage");
tempintfc = (*newfront)->interf;
set_size_of_intfc_state(size_of_state(tempintfc));
set_add_to_correspond_list(YES);
if (((*newfront)->interf = pp_copy_interface(tempintfc)) == NULL)
{
(void) printf("WARNING in advance_front2d(), "
"unable to copy interface\n");
status = ERROR_IN_STEP;
goto sync_prop_stat2;
}
copy_hypersurface_flags((*newfront)->interf);
interpolate_intfc_states((*newfront)->interf) = YES;
print_storage("after snd_copy_interface","ADV_storage");
stop_clock("snd_copy_interface");
}
/* Tangential Sweep for States on the Curves */
if (front->tan_curve_propagate)
{
start_clock("tan_curve_propagate");
if (debugging("front"))
(void) printf("Second Loop over Curves\n");
for (c = tempintfc->curves; c && *c; ++c)
{
tempc = *c;
newc = correspond_curve(tempc);
(*front->tan_curve_propagate)(front,*newfront,
tempintfc,tempc,newc,dt);
}
debug_front("tcp_front","after tan_curve_propagate:",*newfront);
stop_clock("tan_curve_propagate");
}
if (tempintfc)
(void) delete_interface(tempintfc);
print_storage("after delete tempintfc","ADV_storage");
/* Provide robustness for untangle algorithms */
/* delete remnants of scalar physical */
/* curves sticking to NEUMANN boundaries */
/* Add to delete_exterior_curves()? */
if (pp_min_status(delete_phys_remn_on_bdry(*newfront)) == NO)
{
(void) printf("WARNING in advance_front2d(), "
"delete_phys_remn_on_bdry() detected error\n");
debug_front("ERROR_front","after error",*newfront);
*dt_frac = Min_time_step_modification_factor(front);
status = MODIFY_TIME_STEP;
goto sync_prop_stat2;
}
debug_front("dspr_front",
"after 1st delete_phys_remn_on_bdry():",*newfront);
sync_prop_stat2:
if (front->pp_grid)
status = syncronize_time_step_status(status,front->pp_grid);
if (status != GOOD_STEP)
return return_advance_front(front,newfront,status,fname);
/* Communicate tangentially propagated front */
if (scatter_tangentially_propagated_front == YES)
{
start_clock("scatter_front");
if (!scatter_front(*newfront))
{
(void) printf("WARNING in advance_front2d(), "
"scatter_front() failed for "
"tangentially propagated front\n");
scatter_normally_propagated_front = NO;
scatter_tangentially_propagated_front = NO;
(void) delete_interface((*newfront)->interf);
(*newfront)->interf = NULL;
goto begin_advance_front2d;
}
stop_clock("scatter_front");
}
if (status != GOOD_STEP)
return return_advance_front(front,newfront,status,fname);
/* Post-process newfront->interf */
/* Provide robustness after redistribution */
/* for node propagate on next time step */
/* Delete non-boundary curves that lie */
/* fully on or exterior to the boundary */
delete_exterior_curves(*newfront,front->interf);
debug_front("dec_front","after delete_exterior_curves:",*newfront);
/* delete remnants of scalar physical */
/* curves sticking to NEUMANN boundaries */
/* Add to delete_exterior_curves()? */
if (pp_min_status(delete_phys_remn_on_bdry(*newfront)) == NO)
{
(void) printf("WARNING in advance_front2d(), "
"delete_phys_remn_on_bdry() detected error\n");
debug_front("ERROR_front","after error",*newfront);
*dt_frac = Min_time_step_modification_factor(front);
status = MODIFY_TIME_STEP;
return return_advance_front(front,newfront,status,fname);
}
debug_front("dspr_front",
"after 2nd delete_phys_remn_on_bdry():",*newfront);
/* These guys keep sneaking through !! */
/* This should be the most effective place for this call */
/* Brent - I believe it is better to have the function at
* the end of advance_front2d() applied to the newfront
* instead of at the beginning applied to front.
* In general our policy should be never to modify the
* old interface data.
*/
delete_small_loops(*newfront);
debug_front("dsloop_front","after delete_small_loops():",*newfront);
test_for_mono_comp_curves((*newfront)->interf);
/* Check if post processing has changed topology */
intfc_modified = (*newfront)->interf->modified;
pp_global_lmax(&intfc_modified,1L);
if (intfc_modified)
{
if (!scatter_front(*newfront))
{
(void) printf("WARNING in advance_front2d(), "
"final scatter_front() failed\n");
*dt_frac = Max_time_step_modification_factor(front);
return return_advance_front(front,newfront,
MODIFY_TIME_STEP,fname);
}
stat = make_bond_comp_lists((*newfront)->interf);
if (pp_min_status(stat) == FUNCTION_FAILED)
{
screen("ERROR in advance_front2d(), "
"make_bond_comp_lists() failed\n");
clean_up(ERROR);
}
}
return return_advance_front(front,newfront,GOOD_STEP,fname);
} /*end advance_front2d*/
EXPORT void FrontInitStandardIO(
int argc,
char **argv,
F_BASIC_DATA *f_basic)
{
char *in_name = f_basic->in_name;
char *out_name = f_basic->out_name;
char *restart_name = f_basic->restart_name;
int *subdomains = f_basic->subdomains;
f_basic->ReadFromInput = NO;
f_basic->RestartRun = NO;
#if defined(__MPI__)
pp_init(&argc,&argv);
#endif /* defined(__MPI__) */
argc--;
argv++;
strcpy(out_name,"intfc");
while (argc >= 1)
{
if (argv[0][0] != '-')
{
printf("Usage: example -o output\n");
exit(1);
}
switch(argv[0][1]) {
case 'i':
case 'I':
f_basic->ReadFromInput = YES;
zero_scalar(in_name,200);
strcpy(in_name,argv[1]);
argc -= 2;
argv += 2;
break;
case 'r':
case 'R':
f_basic->RestartRun = YES;
zero_scalar(restart_name,200);
strcpy(restart_name,argv[1]);
argc -= 2;
argv += 2;
break;
case 't':
case 'T':
f_basic->RestartStep = atoi(argv[1]);
argc -= 2;
argv += 2;
break;
case 'd':
case 'D':
f_basic->dim = atoi(argv[1]);
argc -= 2;
argv += 2;
break;
case 'o':
case 'O':
zero_scalar(out_name,200);
strcpy(out_name,argv[1]);
#if defined(__MPI__)
sprintf(out_name,"%s.%d",out_name,pp_mynode());
#endif /* defined(__MPI__) */
freopen(out_name,"w",stdout);
zero_scalar(out_name,200);
strcpy(out_name,argv[1]);
argc -= 2;
argv += 2;
break;
#if defined(__MPI__)
case 'p':
case 'P':
{
int i,total_num_proc = 1;
for (i = 0; i < MAXD; ++i)
{
if (argc < 2 || argv[1][0] == '-') break;
argc -= 1;
argv += 1;
subdomains[i] = atoi(argv[0]);
total_num_proc *= subdomains[i];
}
argc -= 1;
argv += 1;
if (total_num_proc != pp_numnodes())
{
printf("total number of processors for the partition %d "
"does not equal to requested np %d\n",
total_num_proc,pp_numnodes());
clean_up(ERROR);
}
}
#endif /* defined(__MPI__) */
}
}
} /* end FrontInitStatndardIO */
EXPORT void geomview_amr_fronts_plot2d(
const char *dname,
Front **frs,
int num_patches,
Wv_on_pc **redistr_table,
int max_n_patch)
{
FILE *fp;
int i;
char fmt[256];
static const char *indent = " ";
static char *fname = NULL, *ppfname = NULL;
static size_t fname_len = 0, ppfname_len = 0;
INTERFACE *intfc = frs[0]->interf;
INTERFACE *tmpintfc;
CURVE **c;
INTERFACE *sav_intfc;
bool sav_copy;
float **clrmap = NULL;
float ccolor[4] = {0.0, 0.0, 0.0, 1.0};
int myid, numnodes;
const char *nstep;
char outname[256],outdir[256];
myid = pp_mynode(); numnodes = pp_numnodes();
sprintf(outdir,"%s/%s",dname,"geomintfc");
ppfname = set_ppfname(ppfname,"intfc",&ppfname_len);
nstep = right_flush(frs[0]->step,7);
sprintf(outname,"%s.ts%s",ppfname,nstep);
if (create_directory(dname,YES) == FUNCTION_FAILED)
{
(void) printf("WARNING in geomview_intfc_plot2d(), directory "
"%s doesn't exist and can't be created\n",dname);
return;
}
if (create_directory(outdir,YES) == FUNCTION_FAILED)
{
(void) printf("WARNING in geomview_intfc_plot2d(), directory "
"%s doesn't exist and can't be created\n",outdir);
return;
}
sav_intfc = current_interface();
sav_copy = copy_intfc_states();
set_size_of_intfc_state(size_of_state(intfc));
set_copy_intfc_states(YES);
tmpintfc = copy_interface(intfc);
/*
clip_to_interior_region(tmpintfc,
frs[0]->rect_grid->lbuf,frs[0]->rect_grid->ubuf);
*/
uni_array(&clrmap,6,sizeof(float*));
for(i = 0; i < 6; i++)
uni_array(&clrmap[i],4,sizeof(float));
i = 0;
clrmap[i][0] = 0.098; clrmap[i][1] = 0.647;
clrmap[i][2] = 0.400; clrmap[i][3] = 1.000;
i++;
clrmap[i][0] = 0.898; clrmap[i][1] = 0.400;
clrmap[i][2] = 0.000; clrmap[i][3] = 1.000;
i++;
clrmap[i][0] = 0.500; clrmap[i][1] = 1.000;
clrmap[i][2] = 0.500; clrmap[i][3] = 1.000;
i++;
clrmap[i][0] = 1.000; clrmap[i][1] = 0.000;
clrmap[i][2] = 1.000; clrmap[i][3] = 1.000;
i++;
clrmap[i][0] = 0.000; clrmap[i][1] = 0.800;
clrmap[i][2] = 1.000; clrmap[i][3] = 1.000;
i++;
clrmap[i][0] = 0.250; clrmap[i][1] = 0.808;
clrmap[i][2] = 0.098; clrmap[i][3] = 1.000;
i++;
fname = get_list_file_name(fname,outdir,outname,&fname_len);
if ((fp = fopen(fname,"w")) == NULL)
{
(void) printf("WARNING in gview_plot_intfc2d(), "
"can't open %s\n",fname);
delete_interface(tmpintfc);
set_current_interface(sav_intfc);
set_copy_intfc_states(sav_copy);
return;
}
fprintf(fp,"{ LIST \n");
/* beginning of writting Vect to file */
for(c = tmpintfc->curves; c and *c; c++)
gview_plot_curve2d(fp,*c,ccolor);
for(int i = 0; i < num_patches; i++)
{
int use_clr;
/*
gview_plot_box2d(fp, frs[i]->rect_grid->L,
frs[i]->rect_grid->U,clrmap[i%3]);
*/
if(NULL != redistr_table)
use_clr = redistr_table[myid][i].pc_id % 6;
else
use_clr = 1;
gview_plot_grid2d(fp,frs[i]->rect_grid,clrmap[use_clr]);
}
/* end of LIST OBJ */
fprintf(fp,"}\n");
fclose(fp);
set_current_interface(sav_intfc);
set_copy_intfc_states(sav_copy);
delete_interface(tmpintfc);
for(int i = 0; i < 6; i++)
free(clrmap[i]);
free(clrmap);
}
EXPORT int tangnt_advance_front2d(
float dt,
float *dt_frac,
Front *front,
Front **newfront,
POINTER wave)
{
CURVE *tempc,*newc;
CURVE **c;
NODE *tempn,*newn;
INTERFACE *tempintfc;
bool stat;
bool sav_copy;
int status = GOOD_STEP;
long intfc_modified;
const char *fname = "tangnt_advance_front2d()";
debug_print("front","Entered %s(step %d time %g dt %g)\n",fname,
front->step,front->time,dt);
if ( front->interf == NULL || front->interf->nodes == NULL )
return return_advance_front(front,newfront,GOOD_STEP,fname);
/* 050703 added, The interface regularization is performed here. */
/* In advance_front2d(), these functions are called after
normal_scatter_front, we call them here */
delete_small_loops(*newfront);
stat = consistent_propagated_loop_orientations(dt,dt_frac,*newfront,wave);
if(debugging("tangnt_advance_front2d"))
printf("In tangnt_advance_front2d() for patch %d\n", front->patch_number);
if (stat == NO)
{
(void) printf("WARNING in tangnt_advance_front2d(), "
"Inconsistent orientation of propagated loop "
"detected after point and node propagations");
if (pp_numnodes() > 1)
(void) printf(" on processor %d\n",pp_mynode());
else
(void) printf("\n");
status = MODIFY_TIME_STEP;
goto sync_prop_stat2;
}
delete_exterior_curves(*newfront,front->interf);
intfc_delete_very_short_bonds(*newfront);
stat = intfc_delete_fold_back_bonds(*newfront);
if(stat == FUNCTION_FAILED)
{
(void) printf("WARNING in tangnt_advance_front2d(), "
"intfc_delete_fold_back_bonds() loop "
"detected error");
if (pp_numnodes() > 1)
(void) printf(" on processor %d\n",pp_mynode());
else
(void) printf("\n");
status = MODIFY_TIME_STEP;
goto sync_prop_stat2;
}
delete_small_loops(*newfront);
/* 060303 added */
measure_front(*newfront);
/* Make Temp Interface for Second/Tangential Propagation */
interpolate_intfc_states((*newfront)->interf) = YES;
set_node_doubly_linked_list((*newfront)->interf);
if (front->snd_node_propagate || front->tan_curve_propagate)
{
start_clock("snd_copy_interface");
print_storage("before snd_copy_interface","ADV_storage");
tempintfc = (*newfront)->interf;
set_size_of_intfc_state(size_of_state(tempintfc));
set_add_to_correspond_list(YES);
/* 060303, added copy_interface flag */
sav_copy = copy_intfc_states();
set_copy_intfc_states(YES);
(*newfront)->interf = copy_interface(tempintfc);
copy_hypersurface_flags((*newfront)->interf);
interpolate_intfc_states((*newfront)->interf) = YES;
/* 060303, added copy_interface flag */
set_copy_intfc_states(sav_copy);
print_storage("after snd_copy_interface","ADV_storage");
stop_clock("snd_copy_interface");
}
/* Second Propagation for the States Around the Nodes */
if (front->snd_node_propagate)
{
start_clock("snd_node_propagate");
if (debugging("front"))
(void) printf("Second Loop over Nodes\n");
tempn = first_node(tempintfc);
newn = first_node((*newfront)->interf);
while (newn != NULL)
{
(*front->snd_node_propagate)(front,*newfront,wave,
tempintfc,tempn,newn,dt);
tempn = next_node(tempn);
newn = next_node(newn);
}
debug_front("snd_front","after snd_node prop",*newfront);
stop_clock("snd_node_propagate");
}
/* Tangential Sweep for States on the Curves */
if (front->tan_curve_propagate)
{
start_clock("tan_curve_propagate");
if (debugging("front"))
(void) printf("Second Loop over Curves\n");
for (c = tempintfc->curves; c && *c; c++)
{
tempc = *c;
newc = correspond_curve(tempc);
(*front->tan_curve_propagate)(front,*newfront,
tempintfc,tempc,newc,dt);
}
debug_front("tcp_front","after tan_curve_propagate:",*newfront);
stop_clock("tan_curve_propagate");
}
if (tempintfc)
(void) delete_interface(tempintfc);
print_storage("after delete tempintfc","ADV_storage");
/* 060303, delete_phys_remn_on_bdry() added */
/* Provide robustness for untangle algorithms */
/* delete remnants of scalar physical */
/* curves sticking to NEUMANN boundaries */
/* Add to delete_exterior_curves()? */
if (delete_phys_remn_on_bdry(*newfront) == NO)
{
(void) printf("WARNING in tangnt_advance_front2d(), "
"delete_phys_remn_on_bdry() detected error\n");
debug_front("ERROR_front","after error",*newfront);
*dt_frac = Min_time_step_modification_factor(front);
status = MODIFY_TIME_STEP;
goto sync_prop_stat2;
}
debug_front("dspr_front",
"after 1st delete_phys_remn_on_bdry():",*newfront);
sync_prop_stat2:
if (status != GOOD_STEP)
return return_advance_front(front,newfront,status,fname);
return return_advance_front(front,newfront,GOOD_STEP,fname);
} /*end tangnt_advance_front2d*/
