status_t
unregister_domain(net_domain* _domain)
{
TRACE(("unregister_domain(%p, %d, %s)\n", _domain, _domain->family,
_domain->name));
net_domain_private* domain = (net_domain_private*)_domain;
MutexLocker locker(sDomainLock);
sDomains.Remove(domain);
net_interface_private* interface = NULL;
while (true) {
interface = (net_interface_private*)list_remove_head_item(
&domain->interfaces);
if (interface == NULL)
break;
delete_interface(interface);
}
recursive_lock_destroy(&domain->lock);
delete domain;
return B_OK;
}
int
main(int argc, char** argv)
{
if (argc > 1 && (!strcmp(argv[1], "--help") || !strcmp(argv[1], "-h")))
usage(0);
int socket = ::socket(AF_LINK, SOCK_DGRAM, 0);
if (socket < 0) {
fprintf(stderr, "%s: The networking stack doesn't seem to be "
"available.\n", kProgramName);
return 1;
}
close(socket);
if (argc > 1
&& (!strcmp(argv[1], "--delete")
|| !strcmp(argv[1], "--del")
|| !strcmp(argv[1], "-d")
|| !strcmp(argv[1], "del")
|| !strcmp(argv[1], "delete"))) {
// Delete interface (addresses)
if (argc < 3)
usage(1);
const char* name = argv[2];
delete_interface(name, argv + 3, argc - 3);
return 0;
}
if (argc > 1 && !strcmp(argv[1], "-a")) {
// Accept an optional "-a" option to list all interfaces for those
// that are used to it from other platforms.
if (argc > 2)
usage(1);
list_interfaces(NULL);
return 0;
}
const char* name = argv[1];
if (argc > 2) {
if (configure_wireless(name, argv + 2, argc - 2))
return 0;
// Add or configure an interface
configure_interface(name, argv + 2, argc - 2);
return 0;
}
// list interfaces
list_interfaces(name);
return 0;
}
/*! Removes the interface from its domain, and deletes it.
You need to hold the domain's lock when calling this function.
*/
status_t
remove_interface_from_domain(net_interface* interface)
{
net_domain_private* domain = (net_domain_private*)interface->domain;
list_remove_item(&domain->interfaces, interface);
notify_interface_removed(interface);
delete_interface((net_interface_private*)interface);
return B_OK;
}
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*/
int
main(int argc, char** argv)
{
if (argc > 1 && (!strcmp(argv[1], "--help") || !strcmp(argv[1], "-h")))
usage(0);
bool deleteInterfaces = false;
if (argc > 1
&& (!strcmp(argv[1], "--delete")
|| !strcmp(argv[1], "--del")
|| !strcmp(argv[1], "-d"))) {
// delete interfaces
if (argc < 3)
usage(1);
deleteInterfaces = true;
}
// we need a socket to talk to the networking stack
int socket = ::socket(AF_INET, SOCK_DGRAM, 0);
if (socket < 0) {
fprintf(stderr, "%s: The networking stack doesn't seem to be "
"available.\n", kProgramName);
return 1;
}
if (deleteInterfaces) {
for (int i = 2; i < argc; i++) {
delete_interface(socket, argv[i]);
}
return 0;
} else if (argc > 1 && !strcmp(argv[1], "-a")) {
// accept -a option for those that are used to it from other platforms
if (argc > 2)
usage(1);
list_interfaces(socket, NULL);
return 0;
}
const char* name = argv[1];
if (argc > 2) {
// add or configure an interface
configure_interface(socket, name, argv + 2, argc - 2);
return 0;
}
// list interfaces
list_interfaces(socket, name);
return 0;
}
extern SDMLIB_API int delete_xteds(xteds* p)
{
if(p==NULL) return 0;
delete_app_dev_attr(p->header);
delete_interface(p->interfaces);
free(p->name);
free(p->version);
free(p->description);
free(p->xmlns);
free(p->xmlns_xsi);
free(p->schema_location);
free(p);
return 1;
}
LOCAL void f_second_order_intfc_propagate3d(
Front *fr,
POINTER wave,
INTERFACE *old_intfc,
INTERFACE *new_intfc,
double dt)
{
INTERFACE *tmp_intfc;
HYPER_SURF *oldhs, *tmphs, *newhs;
HYPER_SURF_ELEMENT *oldhse, *tmphse, *newhse;
POINT *oldp, *tmpp, *newp;
int i;
double V[MAXD];
printf("Entering f_second_order_intfc_propagate3d()\n");
set_copy_intfc_states(NO);
tmp_intfc = pp_copy_interface(fr->interf);
(void) next_point(old_intfc,NULL,NULL,NULL);
(void) next_point(tmp_intfc,NULL,NULL,NULL);
while (next_point(old_intfc,&oldp,&oldhse,&oldhs) &&
next_point(tmp_intfc,&tmpp,&tmphse,&tmphs))
{
point_propagate(fr,wave,oldp,tmpp,oldhse,oldhs,dt,V);
}
(void) next_point(tmp_intfc,NULL,NULL,NULL);
(void) next_point(new_intfc,NULL,NULL,NULL);
while (next_point(tmp_intfc,&tmpp,&tmphse,&tmphs) &&
next_point(new_intfc,&newp,&newhse,&newhs))
{
point_propagate(fr,wave,tmpp,newp,tmphse,tmphs,dt,V);
}
(void) next_point(old_intfc,NULL,NULL,NULL);
(void) next_point(tmp_intfc,NULL,NULL,NULL);
(void) next_point(new_intfc,NULL,NULL,NULL);
while (next_point(old_intfc,&oldp,&oldhse,&oldhs) &&
next_point(tmp_intfc,&tmpp,&tmphse,&tmphs) &&
next_point(new_intfc,&newp,&newhse,&newhs))
{
for (i = 0; i < 3; ++i)
Coords(newp)[i] = Coords(oldp)[i] + 0.5*(oldp->vel[i] +
tmpp->vel[i])*dt;
}
delete_interface(tmp_intfc);
printf("Leaving f_second_order_intfc_propagate3d()\n");
} /* end f_second_order_intfc_propagate3d */
int delete_interface(interface* p)
{
if(p==NULL) return 0;
delete_interface(p->next);
delete_qualifier(p->qualifiers);
delete_variable(p->variables);
delete_command(p->commands);
delete_notification(p->notifications);
delete_request(p->requests);
free(p->name);
free(p->extends);
free(p->id);
free(p->description);
free(p);
return 1;
}
status_t
add_interface_to_domain(net_domain* _domain,
struct ifreq& request)
{
net_domain_private* domain = (net_domain_private*)_domain;
const char* deviceName = request.ifr_parameter.device[0]
? request.ifr_parameter.device : request.ifr_name;
const char* baseName = request.ifr_parameter.base_name[0]
? request.ifr_parameter.base_name : request.ifr_name;
net_device_interface* deviceInterface = get_device_interface(deviceName);
if (deviceInterface == NULL)
return ENODEV;
RecursiveLocker locker(domain->lock);
net_interface_private* interface = NULL;
status_t status;
if (find_interface(domain, request.ifr_name) == NULL) {
// We must not hold the domain's link when creating the interface:
// this will call get_module() which might want to access a network
// device when booting from network.
locker.Unlock();
status = create_interface(domain, request.ifr_name,
baseName, deviceInterface, &interface);
locker.Lock();
if (find_interface(domain, request.ifr_name) != NULL) {
delete_interface(interface);
status = B_NAME_IN_USE;
}
} else
status = B_NAME_IN_USE;
put_device_interface(deviceInterface);
if (status == B_OK) {
list_add_item(&domain->interfaces, interface);
notify_interface_added(interface);
}
return status;
}
Manager::~Manager() {
// delete all the managed interfaces
if( interfaces_.empty() ) return;
/*
InterfaceMap::iterator it = interfaces_.begin();
for( ; it != interfaces_.end() ; ++it ) {
std::cerr << "deleting interface " << std::string("/") + it->first << std::endl;
delete_interface( std::string("/") + it->first );
}
*/
while(true) {
if(interfaces_.empty()) break;
InterfaceMap::iterator it = interfaces_.begin();
delete_interface( "/" + it->first, false );
}
/*
while( !interfaces_.empty() ) {
InterfaceMap::iterator it = interfaces_.begin();
delete_interface( "/" + it->first );
}
*/
}
EXPORT int redist_advance_front2d(
float dt,
float *dt_frac,
Front *front,
Front **newfront,
POINTER wave)
{
int status, do_redist = YES;
const char *fname = "redist_advance_front2d()";
switch (redistribute(*newfront,do_redist,NO))
{
case GOOD_REDISTRIBUTION:
status = GOOD_STEP;
break;
case UNABLE_TO_UNTANGLE:
(void) printf("WARNING in redist_advance_front2d(), "
"redistribution of front failed\n"
"Restarting redist_advance_front2d()\n");
(void) delete_interface((*newfront)->interf);
(*newfront)->interf = NULL;
do_redist = NO;
status = ERROR_IN_STEP;
break;
case MODIFY_TIME_STEP_REDISTRIBUTE:
(void) printf("WARNING in redist_advance_front2d(), "
"redistribute returns\n"
"\t\tMODIFY_TIME_STEP_REDISTRIBUTE\n");
status = MODIFY_TIME_STEP;
break;
case BAD_REDISTRIBUTION:
default:
(void) printf("WARNING in redist_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 (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);
/* Delete non-boundary curves that lie */
/* fully on or exterior to the boundary */
delete_exterior_curves(*newfront,front->interf);
if(delete_phys_remn_on_bdry(*newfront) == NO)
{
(void) printf("WARNING in redist_advance_front2d(), "
"delete_phys_remn_on_bdry() detected error\n");
debug_front("ERROR_front","after error",*newfront);
status = MODIFY_TIME_STEP;
return return_advance_front(front,newfront,status,fname);
}
delete_small_loops(*newfront);
measure_front(*newfront);
test_for_mono_comp_curves((*newfront)->interf);
/*
if((*newfront)->step > 5111)
{
printf("LEAVING redist_advance_front2d, front[%d], level[%d]\n",
(*newfront)->patch_number, (*newfront)->patch_level);
for(CURVE **c = (*newfront)->interf->curves; c && *c; c++)
{
if(wave_type(*c) < FIRST_PHYSICS_WAVE_TYPE)
continue;
print_curve(*c);
}
}
*/
return return_advance_front(front,newfront,GOOD_STEP,fname);
} /*end redist_advance_front2d*/
LOCAL int second_node_propagate2d(
float dt,
float *dt_frac,
Front *front,
Front **newfront,
POINTER wave)
{
NODE *tempn,*newn;
INTERFACE *tempintfc;
bool stat;
int status = GOOD_STEP;
long intfc_modified;
const char *fname = "second_node_propagate2d()";
debug_print("front","Entered %s(step %d time %g dt %g)\n",fname,
front->step,front->time,dt);
/* Make Temp Interface for Second/Tangential Propagation */
if ( front->interf == NULL || front->interf->nodes == NULL )
return GOOD_STEP;
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);
(*newfront)->interf = copy_interface(tempintfc);
copy_hypersurface_flags((*newfront)->interf);
interpolate_intfc_states((*newfront)->interf) = YES;
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");
}
if (tempintfc)
(void) delete_interface(tempintfc);
print_storage("after delete tempintfc","ADV_storage");
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*/
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);
}
LOCAL void f_second_order_intfc_propagate2d(
Front *fr,
POINTER wave,
INTERFACE *old_intfc,
INTERFACE *new_intfc,
double dt)
{
INTERFACE *tmp_intfc;
HYPER_SURF *oldhs, *tmphs, *newhs;
HYPER_SURF_ELEMENT *oldhse, *tmphse, *newhse;
CURVE **oldc, **tmpc, **newc;
BOND *oldb, *tmpb, *newb;
POINT *oldp, *tmpp, *newp;
int i;
double V[MAXD];
set_copy_intfc_states(NO);
tmp_intfc = pp_copy_interface(fr->interf);
/* Compute v(x^n, t^n) */
for (oldc = old_intfc->curves, tmpc = tmp_intfc->curves;
oldc && *oldc; ++oldc, ++tmpc)
{
for (oldb = (*oldc)->first, tmpb = (*tmpc)->first;
oldb != NULL; oldb = oldb->next, tmpb = tmpb->next)
{
if (oldb == (*oldc)->last && !is_closed_node((*oldc)->end))
continue;
oldp = oldb->end; tmpp = tmpb->end;
oldhse = Hyper_surf_element(oldb);
oldhs = Hyper_surf(*oldc);
point_propagate(fr,wave,oldp,tmpp,oldhse,oldhs,dt,V);
}
}
/* Compute v(x^(n+1), t^(n+1)) */
for (newc = new_intfc->curves, tmpc = tmp_intfc->curves;
newc && *newc; ++newc, ++tmpc)
{
for (newb = (*newc)->first, tmpb = (*tmpc)->first;
newb != NULL; newb = newb->next, tmpb = tmpb->next)
{
tmpp = tmpb->end; newp = newb->end;
tmphse = Hyper_surf_element(tmpb);
tmphs = Hyper_surf(*tmpc);
point_propagate(fr,wave,tmpp,newp,tmphse,tmphs,dt,V);
}
}
/* Compute x^(n+1) = x^n + 0.5*dt*(v(x^n,t^n) + v(x^(n+1), t^(n+1)) */
for (oldc = old_intfc->curves, tmpc = tmp_intfc->curves,
newc = new_intfc->curves;
oldc && *oldc; ++oldc, ++tmpc, ++newc)
{
for (oldb = (*oldc)->first, tmpb = (*tmpc)->first,
newb = (*newc)->first; oldb != NULL;
oldb = oldb->next, tmpb = tmpb->next, newb = newb->next)
{
oldp = oldb->end;
tmpp = tmpb->end;
newp = newb->end;
for (i = 0; i < 2; ++i)
Coords(newp)[i] = Coords(oldp)[i] + 0.5*(oldp->vel[i] +
tmpp->vel[i])*dt;
if (newb == (*newc)->last && is_closed_node((*newc)->end))
{
propagation_status((*newc)->end) = PROPAGATED_NODE;
set_bond_length((*newc)->first,2);
set_bond_length((*newc)->last,2);
}
else
set_bond_length(newb,2);
}
}
delete_interface(tmp_intfc);
} /* end f_second_order_intfc_propagate2d */
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*/
static void test_propagate(
Front *front)
{
int ip,im,status,count;
Front *newfront;
float dt,dt_frac,CFL;
bool is_print_time, is_movie_time, time_limit_reached;
char s[10];
float fcrds[MAXD];
int dim = front->rect_grid->dim;
front->max_time = 2.0;
front->max_step = 10000;
front->print_time_interval = 1.0;
front->movie_frame_interval = 0.02;
CFL = Time_step_factor(front);
printf("dim = %d\n", dim);
printf("CFL = %f\n",CFL);
printf("Frequency_of_redistribution(front,GENERAL_WAVE) = %d\n",
Frequency_of_redistribution(front,GENERAL_WAVE));
if (!RestartRun)
{
redistribute(front,YES,NO);
front->time = 0.0;
front->dt = 0.0;
front->step = 0;
// Always output the initial interface.
FrontPrintOut(front,out_name);
FrontMovieFrame(front,out_name,binary);
ip = im = 1;
// This is a virtual propagation to get maximum front
// speed to determine the first time step.
status = FrontAdvance(front->dt,&dt_frac,front,&newfront,
(POINTER)NULL);
front->dt = CFL*FrontHypTimeStep(front);
}
else
{
ip = (int)(front->time/front->print_time_interval + 1.0);
im = (int)(front->time/front->movie_frame_interval + 1.0);
}
front->dt = FrontOutputTimeControl(front,
&is_movie_time,
&is_print_time,
&time_limit_reached,
&im,&ip);
for (;;)
{
/* Propagating interface for time step dt */
status = FrontAdvance(front->dt,&dt_frac,front,&newfront,
(POINTER)NULL);
assign_interface_and_free_front(front,newfront);
++front->step;
front->time += front->dt;
//Next time step determined by maximum speed of previous
//step, assuming the propagation is hyperbolic and
//is not dependent on second order derivatives of
//the interface such as curvature, and etc.
front->dt = CFL*FrontHypTimeStep(front);
/* Output section */
printf("\ntime = %f step = %5d next dt = %f\n",
front->time,front->step,front->dt);
fflush(stdout);
if (is_print_time || time_limit_reached)
print_front_output(front,out_name);
if (is_movie_time || time_limit_reached)
show_front_output(front,out_name,binary);
if (time_limit_reached)
break;
front->dt = FrontOutputTimeControl(front,
&is_movie_time,
&is_print_time,
&time_limit_reached,
&im,&ip);
}
(void) delete_interface(front->interf);
} /* end test_propagate */
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*/