EXPORT SIDE physical_side_of_bdry_curve(
CURVE *c)
{
if (wave_type(c) >= FIRST_PHYSICS_WAVE_TYPE)
{
screen("ERROR in physical_side_of_bdry_curve(), non bdry curve\n");
print_curve(c);
clean_up(ERROR);
}
if (is_bdry(c))
{
return is_exterior_comp(negative_component(c),c->interface) ?
POSITIVE_SIDE : NEGATIVE_SIDE;
}
else if (is_excluded_comp(negative_component(c),c->interface))
return POSITIVE_SIDE;
else if (is_excluded_comp(positive_component(c),c->interface))
return NEGATIVE_SIDE;
else
{
screen("ERROR in physical_side_of_bdry_curve(), "
"interior boundary not bounded by an excluded component\n");
print_curve(c);
clean_up(ERROR);
}
return UNKNOWN_SIDE; /* for lint */
} /*end physical_side_of_bdry_curve*/
int main(int argc, char **argv)
{
gnuplot_ctrl *gam;
char kcode;
int exit_flag = 1;
gam = gnuplot_init();
gnuplot_setstyle(gam, "lines");
plot_bezier(gam);
// gnuplot_plot_slope(gam, 2.0, 0.0, "y=2x");
while(1){
switch(getkey()){
case 'x':
exit_flag = 0;
break;
case 'a':
gnuplot_resetplot(gam);
gnuplot_plot_equation(gam, "log(x)", "logarithm") ;
break;
case '=':
gnuplot_resetplot(gam);
bez_adj(gam, target, COARSE, PLUS);
plot_bezier(gam);
break;
case '-':
gnuplot_resetplot(gam);
bez_adj(gam, target, COARSE, MINUS);
plot_bezier(gam);
break;
case '+':
gnuplot_resetplot(gam);
bez_adj(gam, target, FINE, PLUS);
plot_bezier(gam);
break;
case '_':
gnuplot_resetplot(gam);
bez_adj(gam, target, FINE, MINUS);
plot_bezier(gam);
break;
case '1':
target = YONE;
printf("\nset YONE as adjust target: %f\n", yone);
break;
case '2':
target = YTWO;
printf("\nset YTWO as adjust target: %f\n", ytwo);
break;
case '3':
target = XONE;
printf("\nset XONE as adjust target: %f\n", xone);
break;
case '4':
target = XTWO;
printf("\nset XTWO as adjust target: %f\n", xtwo);
break;
default:
break;
}
if (!exit_flag)
break;
usleep(500*1000);
}
print_curve();
gnuplot_close(gam);
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*/
/*ARGSUSED*/
EXPORT boolean consistent_propagated_loop_orientations(
double dt,
double *dt_frac,
Front *fr,
POINTER wave)
{
static const double AREA_FAC = 0.01; /*TOLERANCE*/
static const int num_attempts = 5; /*TOLERANCE*/
CURVE **c,*oldc,*newc;
NODE *oldn, *newn;
double dt_f, dT;
double A_old, A_new;
double min_area = AREA_FAC*fr->rect_grid->h[0]*fr->rect_grid->h[1];
boolean status = YES;
int i;
debug_print("orient_consistency",
"Entered consistent_propagated_loop_orientations()\n");
for (c = fr->interf->curves; c && *c; ++c)
{
oldc = *c;
if (!is_closed_curve(oldc))
continue;
newc = correspond_curve(oldc);
/*TODO: this needs to be solved correctly.*/
if ((newc == NULL) || (newc->interface == NULL) ||
(!is_closed_curve(newc)))
continue;
if (newc->num_points > 20)
continue; /* sufficiently long curve cannot fully flip */
A_old = area_of_closed_curve(oldc);
A_new = area_of_closed_curve(newc);
if (debugging("orient_consistency"))
(void) printf("A_old = %g, A_new = %g\n",A_old,A_new);
if (A_old*A_new > 0.0)
continue;
status = NO;
if (debugging("orient_consistency"))
{
(void) printf("Loop %llu inverted after propagation\n",
(long long unsigned int)curve_number(oldc));
(void) printf("Old loop\n");
print_curve(oldc);
(void) printf("Propagated loop\n");
print_curve(newc);
}
/* Determine dt_frac */
if (A_old < min_area)
{
*dt_frac *= 0.9;
continue;
}
dt_f = 1.0;
oldn = oldc->start; newn = newc->start;
for (i = 0; i < num_attempts; ++i)
{
dt_f *= 0.5;
dT = dt_f * dt;
if (fr->curve_propagate != NULL)
curve_propagate(fr,wave,oldc,newc,dT);
(void) closed_node_propagate(fr,wave,oldn,newn,dT);
A_new = area_of_closed_curve(newc);
if (debugging("orient_consistency"))
{
(void) printf("In loop, dt_f = %g, dT = %g, ",dt_f,dT);
(void) printf("A_old = %g, A_new = %g\n",A_old,A_new);
}
if (A_old*A_new >= 0.0)
break;
}
if (i == num_attempts)
{
(void) printf("WARNING in "
"consistent_propagated_loop_orientations(), "
"cannot produce consistent loop "
"orientations by reduction of time step\n");
(void) printf("modifying interface\n");
(void) delete_curve(newc);
status = YES;
continue;
}
*dt_frac = min(*dt_frac,dt_f);
/* Restore newc to original state ? */
/* This is unnecessary if reduce time step is called, */
/* as the newc->interface will be deleted, but this */
/* may be desirable for consistency reasons if future */
/* resolutions solve this problem without having to */
/* reduce the time step. For now this section is */
/* commented out. */
}
debug_print("orient_consistency",
"Left consistent_propagated_loop_orientations()\n");
return status;
} /*end consistent_propagated_loop_orientation*/
/* ARGSUSED */
EXPORT void f_tan_curve_propagate(
Front *fr,
Front *newfr,
INTERFACE *tempintfc,
CURVE *tempc,
CURVE *newc,
double dt)
{
BOND *tempb, *newb;
Locstate ansl, ansr;
boolean curveIsClosed;
double *h = fr->rect_grid->h;
double tngt[MAXD], ds, sbl;
int i, dim = fr->rect_grid->dim;
static int nrad = 0;
static Tan_stencil *sten = NULL;
debug_print("f_tan_prop","Entered f_tan_curve_propagate()\n");
if (debugging("f_tan_prop"))
{
(void) printf("tempc %llu newc %llu\n",(long long unsigned int)curve_number(tempc),
(long long unsigned int)curve_number(newc));
(void) printf("tempc\n"); print_curve(tempc);
(void) printf("\nnewc\n"); print_curve(newc);
}
if (sten == NULL)
{
nrad = fr->npts_tan_sten/2;
sten = alloc_tan_stencil(fr,nrad);
}
switch (wave_type(tempc))
{
case PASSIVE_BOUNDARY:
case SUBDOMAIN_BOUNDARY:
return;
default:
break;
}
curveIsClosed = (is_closed_node(newc->end)) ? YES : NO;
tempb = tempc->first; newb = newc->first;
/* Check if zero length curve */
if (tempc->first == tempc->last)
{
sbl = scaled_bond_length(tempc->first,h,dim);
if (sbl < MIN_SC_SEP(tempintfc))
{
debug_print("f_tan_prop","Left f_tan_curve_propagate()\n");
return;
}
}
for (; newb; tempb = tempb->next, newb = newb->next)
{
if (t_pt_propagated(newb->end))
continue;
/* stop at tempc->last if no continuation */
if ((tempb == tempc->last) &&
!curveIsClosed && !is_fixed_node(newc->end))
{
break;
}
/* calculate tangential displacement */
/*
* TODO: the upgrade of this function
* to 3 dimensions is non-trivial.
* There will need to be either two
* operator splitting sweeps, or one
* unsplit solver. There is arbitrary
* choice of tangent directions and this
* will have to be resolved.
*/
tangent(newb->end,newb,newc,tngt,newfr);
ds = grid_size_in_direction(tngt,h,dim);
/* find the stencil states */
states_at_distance_along_curve(tempb->end,tempb,tempc,
NEGATIVE_ORIENTATION,ds,nrad,
sten->leftst-1,sten->rightst-1,
sten->hs-1,sten->hse-1,sten->t-1,
sten->p-1,newfr);
if (tempb->next != NULL)
{
ansl = left_state(newb->end);
ansr = right_state(newb->end);
}
else
{
ansl = left_end_state(newc);
ansr = right_end_state(newc);
}
states_at_distance_along_curve(tempb->end,tempb,tempc,
POSITIVE_ORIENTATION,ds,nrad,
sten->leftst+1,sten->rightst+1,
sten->hs+1,sten->hse+1,sten->t+1,
sten->p+1,newfr);
sten->p[0] = tempb->end;
sten->hse[0] = Hyper_surf_element(tempb);
sten->hs[0] = Hyper_surf(tempc);
sten->t[0] = 1.0;
sten->curvature = mean_curvature_at_point(sten->p[0],sten->hse[0],
sten->hs[0],fr);
if (debugging("f_tan_prop"))
{
int j;
static const char *xyz[3] = { "x", "y", "z" };
(void) printf("state locations\n");
(void) printf("%-8s"," ");
for (i = 0; i < dim; ++i)
(void) printf("%-14s",xyz[i]);
(void) printf("\n");
for (j = -nrad; j <= nrad; ++j)
{
for (i = 0; i < dim; ++i)
(void) printf("%-14g",Coords(sten->p[j])[i]);
(void) printf("\n");
}
(void) printf("\n");
(void) printf("State values\n");
for (j = -nrad; j <= nrad; ++j)
{
(void) printf("left state[%d] at ",j);
print_general_vector("",Coords(sten->p[j]),dim,"\n");
(*fr->print_state)(
left_state_at_point_on_curve(sten->p[j],
Bond_of_hse(sten->hse[j]),
Curve_of_hs(sten->hs[j])));
(void) printf("right state[%d] at ",j);
print_general_vector("",Coords(sten->p[j]),dim,"\n");
(*fr->print_state)(
right_state_at_point_on_curve(sten->p[j],
Bond_of_hse(sten->hse[j]),
Curve_of_hs(sten->hs[j])));
(void) printf("\n");
}
}
/* update using n-point stencil tangential op */
sten->newhs = Hyper_surf(newc);
sten->dir = tngt;
npt_tang_solver(ds,dt,sten,ansl,ansr,fr);
if (fr->parab == YES)
npt_parab_tan_solver2d(ds,dt,sten,ansl,ansr,fr);
t_pt_propagated(newb->end) = YES;
if (debugging("f_tan_prop"))
{
(void) printf("answers: left right\n");
(*newfr->print_state)(ansl);
(*newfr->print_state)(ansr);
(void) printf("\n");
}
}
if (curveIsClosed)
{
/* assign start states to end states */
ft_assign(left_start_state(newc),left_end_state(newc),fr->sizest);
ft_assign(right_start_state(newc),right_end_state(newc),fr->sizest);
}
debug_print("f_tan_prop","Left f_tan_curve_propagate()\n");
} /*end f_tan_curve_propagate*/
LOCAL bool check_curve3d(
CURVE *c,
INTERFACE *intfc)
{
BOND *b;
BOND_TRI **bts, **bts0;
NODE *ns, *ne;
SURFACE *s, **ss;
TRI *tri, **tris;
bool status = YES;
char warn[1024];
int nsides, nbts, i;
int ntris;
(void) sprintf(warn,"WARNING in check_curve3d(), curve %llu inconsistent ",
curve_number(c));
if (c->interface != intfc)
{
(void) printf("%s c->interface (%llu) != intfc (%llu)\n",
warn,interface_number(c->interface),
interface_number(intfc));
status = NO;
}
ns = c->start;
if (!pointer_is_in_array(c,ns->out_curves))
{
(void) printf("%s curve in not in start node (%llu) "
"out_curves\n",warn,node_number(ns));
status = NO;
}
ne = c->end;
if (!pointer_is_in_array(c,ne->in_curves))
{
(void) printf("%s curve in not in end node (%llu) "
"in_curves\n",warn,node_number(ne));
status = NO;
}
if (ns->posn != c->first->start)
{
(void) printf("%s ns->posn != c->first->start\n"
"c->first->start = %llu, "
"ns = %llu, ns->posn = %llu\n",
warn,point_number(c->first->start),
node_number(ns),point_number(ns->posn));
status = NO;
}
if (ne->posn != c->last->end)
{
(void) printf("%s ne->posn != c->last->end\n"
"c->last->end = %llu, "
"ne = %llu, ne->posn = %llu\n",
warn,point_number(c->last->end),
node_number(ne),point_number(ne->posn));
print_general_vector("c->last->end", Coords(c->last->end), 3, "\n");
print_general_vector("ne->posn", Coords(ne->posn), 3, "\n");
print_curve(c);
status = NO;
}
if (!Boundary_point(ns->posn))
{
(void) printf("%s ns->posn (ns = %llu, ns->posn = %llu) is not a "
"boundary point\n",
warn,node_number(ns),point_number(ns->posn));
status = NO;
}
if (!Boundary_point(ne->posn))
{
(void) printf("%s ne->posn (ne = %llu, ne->posn = %llu) is not a "
"boundary point\n",
warn,node_number(ne),point_number(ne->posn));
status = NO;
}
if (!Boundary_point(c->first->start))
{
(void) printf("%s c->first->start = %llu is not a "
"boundary point\n",
warn,point_number(c->first->start));
status = NO;
}
if (!Boundary_point(c->last->end))
{
(void) printf("%s c->last->end = %llu is not a "
"boundary point\n",
warn,point_number(c->last->end));
status = NO;
}
for (ss = c->pos_surfaces; ss && *ss; ++ss)
{
if (!pointer_is_in_array(c,(*ss)->pos_curves))
{
(void) printf("%s curve in not s->pos_curves "
" s = %llu but s is in c->neg_surfaces\n",
warn,surface_number(*ss));
status = NO;
}
}
for (ss = c->neg_surfaces; ss && *ss; ++ss)
{
if (!pointer_is_in_array(c,(*ss)->neg_curves))
{
(void) printf("%s curve in not s->neg_curves "
" s = %llu but s is in c->neg_surfaces\n",
warn,surface_number(*ss));
status = NO;
}
}
b = c->first;
bts0 = Btris(b);
for (nbts = 0, bts = Btris(b); bts && *bts; ++nbts, ++bts);
if (nbts == 0)
{
if (c->pos_surfaces || c->neg_surfaces)
{
(void) printf("%s curve has no bond tris but is "
"connected to some surface\n",warn);
status = NO;
}
}
if (c->first->prev != NULL)
{
(void) printf("%s c->first->prev != NULL\n",warn);
print_bond(c->first);
print_bond(c->first->prev);
status = NO;
}
if (c->last->next != NULL)
{
(void) printf("%s c->last->next != NULL\n",warn);
print_bond(c->last);
print_bond(c->last->next);
status = NO;
}
for (b = c->first; b != NULL; b = b->next)
{
if (b->next && b->next->start != b->end)
{
(void) printf("%s bond pair (%llu -> %llu) point pointers "
"inconsistent\n",
warn,bond_number(b,intfc),
bond_number(b->next,intfc));
print_bond(b);
print_bond(b->next);
status = NO;
}
if (!Boundary_point(b->start))
{
(void) printf("%s b->start = %llu is not a "
"boundary point\n",
warn,point_number(b->start));
print_bond(b);
status = NO;
}
if (!Boundary_point(b->end))
{
(void) printf("%s b->end = %llu is not a "
"boundary point\n",
warn,point_number(b->end));
print_bond(b);
status = NO;
}
for (i = 0, bts = Btris(b); bts && *bts; ++i, ++bts)
{
if ((i < nbts) &&
!(((*bts)->surface == bts0[i]->surface) &&
((*bts)->orient == bts0[i]->orient)))
{
(void) printf("%s inconsistent surface numbers on "
"bond tri\n",warn);
(void) printf("surface = %llu surface[%d] = %llu\n",
surface_number((*bts)->surface),i,
surface_number(bts0[i]->surface));
(void) printf("orient = %s orient[%d] = %s\n",
orientation_name((*bts)->orient),i,
orientation_name(bts0[i]->orient));
print_bond(b);
status = NO;
}
}
if (i != nbts)
{
(void) printf("%s inconsistent %d != %d number of bond tris "
"on bond\n",warn,i,nbts);
print_bond(b);
status = NO;
}
for (bts = Btris(b); bts && *bts; ++bts)
{
if ((*bts)->curve != c)
{
(void) printf("%s bond tri curve field (%llu) != c\n",
warn,curve_number((*bts)->curve));
print_bond(b);
status = NO;
}
if ((*bts)->bond != b)
{
(void) printf("%s bond tri bond field (%llu) != b (%llu)\n",
warn,bond_number((*bts)->bond,intfc),
bond_number(b,intfc));
print_bond(b);
status = NO;
}
tri = (*bts)->tri;
s = Surface_of_tri(tri);
if ((*bts)->surface != s)
{
(void) printf("%s bond tri surface field (%llu)"
"!= Surface_of_tri(tri) (%llu)\n",
warn,surface_number((*bts)->surface),
surface_number(s));
print_bond(b);
status = NO;
}
for (nsides = 0, i = 0; i < 3; ++i)
{
if (is_side_bdry(tri,i) && (b==Bond_on_side(tri,i)))
++nsides;
}
if (nsides == 0)
{
(void) printf("%s bond not found on tri side\n",warn);
print_bond(b);
print_tri(tri,intfc);
status = NO;
}
else if (nsides > 1)
{
(void) printf("%s bond found on multiple tri sides\n",warn);
print_bond(b);
print_tri(tri,intfc);
status = NO;
}
else
{
if (orientation_of_bond_at_tri(b,tri) != (*bts)->orient)
{
(void) printf("%s inconsistent orientation at "
"bond tri\n",warn);
print_tri(tri,intfc);
print_bond(b);
status = NO;
}
switch ((*bts)->orient)
{
case POSITIVE_ORIENTATION:
if (!pointer_is_in_array(c,s->pos_curves))
{
(void) printf("%s curve in not s->pos_curves "
" s = %llu\n",
warn,surface_number(s));
print_bond(b);
print_tri(tri,intfc);
status = NO;
}
if (!pointer_is_in_array(s,c->pos_surfaces))
{
(void) printf("%s surface in not c->pos_surfaces "
" s = %llu\n",
warn,surface_number(s));
print_bond(b);
print_tri(tri,intfc);
status = NO;
}
break;
case NEGATIVE_ORIENTATION:
if (!pointer_is_in_array(c,s->neg_curves))
{
(void) printf("%s curve in not s->neg_curves "
" s = %llu\n",
warn,surface_number(s));
print_bond(b);
print_tri(tri,intfc);
status = NO;
}
if (!pointer_is_in_array(s,c->neg_surfaces))
{
(void) printf("%s surface in not c->neg_surfaces "
" s = %llu\n",
warn,surface_number(s));
print_bond(b);
print_tri(tri,intfc);
status = NO;
}
break;
case ORIENTATION_NOT_SET:
(void) printf("%s inconsistent point and tri "
"points\n",warn);
print_bond(b);
print_tri(tri,intfc);
status = NO;
break;
}
}
if (b->prev)
{
TRI *t0, *t1;
ntris = set_tri_list_around_point(b->start,tri,&tris,intfc);
t0 = tris[0]; t1 = tris[ntris-1];
if (!(((side_of_tri_with_bond(b,t0) < 3) &&
(side_of_tri_with_bond(b->prev,t1) < 3))
||
((side_of_tri_with_bond(b,t1) < 3) &&
(side_of_tri_with_bond(b->prev,t0) < 3)))
)
{
(void) printf("%s, corrupt tri list at b->start\n",
warn);
(void) printf("Bond b\n"); print_bond(b);
(void) printf("Bond b->prev\n"); print_bond(b->prev);
print_tri(tri,intfc);
(void) printf("number of tris at point = %d\n",ntris);
for (i = 0; i < ntris; ++i)
{
(void) printf("tris[%d] - ",i);
print_tri(tris[i],intfc);
}
status = NO;
}
}
}
}
return status;
} /*end check_curve3d*/
LOCAL bool i_consistent_interface3d(
INTERFACE *intfc)
{
HYPER_SURF_ELEMENT *hse;
HYPER_SURF *hs;
CURVE **c;
NODE **n;
POINT *p;
SURFACE **ss, *s;
TRI *tri;
bool status = YES;
const char *warn = "WARNING in i_consistent_interface(), ";
/* Check Nodes */
for (n = intfc->nodes; n && *n; ++n)
{
if ((*n)->interface != intfc)
{
(void) printf("%s n = %llu n->interface (%llu) != intfc (%llu)\n",
warn,node_number(*n),
interface_number((*n)->interface),
interface_number(intfc));
status = NO;
}
for (c = (*n)->in_curves; c && *c; ++c)
{
if ((*c)->end != *n)
{
(void) printf("%s inconsistent node (%llu) "
"curve (%llu) pair, "
"curve->end != n\n",
warn,node_number(*n),curve_number(*c));
status = NO;
}
}
for (c = (*n)->out_curves; c && *c; ++c)
{
if ((*c)->start != *n)
{
(void) printf("%s inconsistent node (%llu) "
"curve (%llu) pair, "
"curve->start != n\n",
warn,node_number(*n),curve_number(*c));
status = NO;
}
}
}
/* Check Curves */
for (c = intfc->curves; c && *c; c++)
{
if (!check_curve3d(*c,intfc))
{
(void) printf("%s inconsistency in curve (%llu) found\n",
warn,curve_number(*c));
status = NO;
}
}
for (ss = intfc->surfaces; ss && *ss; ++ss)
{
if (!check_consistency_of_tris_on_surface(*ss))
{
(void) printf("%s inconsistency in surface (%llu) found\n",
warn,surface_number(*ss));
status = NO;
}
}
(void) next_point(intfc,NULL,NULL,NULL);
while (next_point(intfc,&p,&hse,&hs))
{
BOND *b = NULL, *bb;
BOND_TRI **bts;
CURVE **c;
TRI **tris;
int i, ntris;
int v, pside, nside;
tri = Tri_of_hse(hse);
s = Surface_of_hs(hs);
if ((v = Vertex_of_point(tri,p)) == ERROR)
{
(void) printf("%s point not on tri, s = %llu\n",
warn,surface_number(s));
(void) printf("p(%llu) - (%g, %g, %g), ",
point_number(p),
Coords(p)[0],Coords(p)[1],Coords(p)[2]);
print_tri(tri,hs->interface);
status = NO;
}
if (!Boundary_point(p))
{
ntris = set_tri_list_around_point(p,tri,&tris,intfc);
if ((tri != tris[0]) ||
(tri != Prev_tri_at_vertex(tris[ntris-1],p)))
{
bool consistent_tri_list = NO;
if (allow_null_sides)
{
if ((Next_tri_at_vertex(tris[0],p) == NULL) &&
(Prev_tri_at_vertex(tris[ntris-1],p) == NULL))
consistent_tri_list = YES;
}
if (!consistent_tri_list)
{
(void) printf("\n%s Corrupt tri list s (%llu) "
"p(%llu) - (%g, %g, %g)\n",
warn,surface_number(s),
point_number(p),
Coords(p)[0],Coords(p)[1],Coords(p)[2]);
print_tri(tri,hs->interface);
(void) printf("%d tris about point\n",ntris);
for (i = 0; i < ntris; ++i)
{
(void) printf("tris[%d] - ",i);
print_tri(tris[i],hs->interface);
}
(void) printf("End printout of "
"Corrupt tri list s (%llu) "
"p(%llu) - (%g, %g, %g)\n\n",
surface_number(s),point_number(p),
Coords(p)[0],Coords(p)[1],Coords(p)[2]);
status = NO;
}
}
continue;
}
nside = v;
pside = Prev_m3(v);
if (is_side_bdry(tri,nside))
b = Bond_on_side(tri,nside);
else if (is_side_bdry(tri,pside))
b = Bond_on_side(tri,pside);
else //#bjet2
{
ntris = set_tri_list_around_point(p,tri,&tris,intfc);
v = Vertex_of_point(tris[0],p);
nside = v;
pside = Prev_m3(v);
if (is_side_bdry(tris[0],nside))
b = Bond_on_side(tris[0],nside);
else if (is_side_bdry(tris[0],pside))
b = Bond_on_side(tris[0],pside);
else
{
int i;
(void) printf("%s Boundary_point has no adjacent "
"tri with a bond\n",warn);
(void) printf("p(%llu) - (%g, %g, %g), ",
point_number(p),
Coords(p)[0],Coords(p)[1],Coords(p)[2]);
print_tri(tri,hs->interface);
for (i = 0; i < ntris; ++i)
{
(void) printf("tris[%d] - ",i);
print_tri(tris[i],hs->interface);
}
status = NO;
}
tri = tris[0];
}
for (bts = Btris(b); bts && *bts; ++bts)
if ((*bts)->tri == tri)
break;
if ((bts == NULL) || (*bts == NULL))
{
(void) printf("%s bond tri for tri not found\n",warn);
(void) printf("p(%llu) - (%g, %g, %g), ",point_number(p),
Coords(p)[0],Coords(p)[1],Coords(p)[2]);
print_tri(tri,hs->interface);
print_bond(b);
status = NO;
}
else
{
if ((*bts)->bond != b)
{
(void) printf("%s (*bts)->bond != b\n",warn);
(void) printf("p(%llu) - (%g, %g, %g), ",point_number(p),
Coords(p)[0],Coords(p)[1],Coords(p)[2]);
print_tri(tri,hs->interface);
print_bond(b);
status = NO;
}
if ((*bts)->surface != s)
{
(void) printf("%s inconsistent surfaces at bond tri\n",
warn);
(void) printf("p(%llu) - (%g, %g, %g), ",point_number(p),
Coords(p)[0],Coords(p)[1],Coords(p)[2]);
print_tri(tri,hs->interface);
print_bond(b);
status = NO;
}
if (orientation_of_bond_at_tri(b,tri) != (*bts)->orient)
{
(void) printf("%s inconsistent orientation at bond tri\n",
warn);
(void) printf("p(%llu) - (%g, %g, %g), ",point_number(p),
Coords(p)[0],Coords(p)[1],Coords(p)[2]);
print_tri(tri,hs->interface);
print_bond(b);
status = NO;
}
switch ((*bts)->orient)
{
case POSITIVE_ORIENTATION:
for (c = s->pos_curves; c && *c; c++)
if ((*c) == (*bts)->curve)
break;
break;
case NEGATIVE_ORIENTATION:
for (c = s->neg_curves; c && *c; c++)
if ((*c) == (*bts)->curve)
break;
break;
case ORIENTATION_NOT_SET:
c = NULL;
(void) printf("%s undetermined orientation at "
"bond on tri\n",warn);
(void) printf("p(%llu) - (%g, %g, %g), ",point_number(p),
Coords(p)[0],Coords(p)[1],Coords(p)[2]);
print_tri(tri,hs->interface);
print_bond(b);
status = NO;
break;
}
if ((c == NULL) || (*c == NULL))
{
(void) printf("%s curve with bond on tri not found\n",warn);
(void) printf("p(%llu) - (%g, %g, %g), ",point_number(p),
Coords(p)[0],Coords(p)[1],Coords(p)[2]);
print_tri(tri,hs->interface);
print_bond(b);
status = NO;
}
else
{
for (bb = (*c)->first; bb != NULL; bb = bb->next)
if (bb == b)
break;
if (bb == NULL)
{
(void) printf("%s bond not on curve\n",warn);
(void) printf("p(%llu) - (%g, %g, %g), ",point_number(p),
Coords(p)[0],Coords(p)[1],Coords(p)[2]);
print_tri(tri,hs->interface);
print_bond(b);
print_curve(*c);
status = NO;
}
}
}
}
if (status == NO)
{
(void) printf("WARNING in i_consistent_interface(), "
"Inconsistent interface found\n");
print_interface(intfc);
}
allow_null_sides = NO;
return status;
} /*end i_consistent_interface*/
