int find_color(t_img *img)
{
int sv;
int color;
float light;
int dist;
dist = find_inter(img, &sv);
if (sv != -1)
{
light = find_light(&img->scene.ray, dist,
img->scene.obj[sv].pos, img->scene.light);
color = chg_color(img->scene.obj[sv].color, light);
}
else
color = BGD_COLOR;
return (color);
}
static int find_adjacency(int Proc, MESH_INFO_PTR mesh,
int **sur_elem, int *nsurnd, int max_nsur)
{
/* Local declarations. */
int i, iblk, nsides, ielem, nscnt, inode, entry;
int side_cnt, nnodes, sid;
int side_nodes[MAX_SIDE_NODES], mirror_nodes[MAX_SIDE_NODES];
int *hold_elem, *pt_list, nhold, nelem;
ELEM_INFO_PTR elements = mesh->elements;
int *eb_etype;
/***************************** BEGIN EXECUTION ******************************/
/*
* Use face definition of adjacencies. So, one elements that are
* connected by an entire face will be considered adjacent. This
* is temporary, and will be expanded. This will make determining
* off processor adjacencies much easier.
*
* Adjacency info for an element's side i will be stored in the (i-1) entry
* of adj array for the element. Sides without adjacencies will have -1
* as the adj array entries for those sides. This system allows easy
* identification of side ids for recomputing element comm maps after
* migration.
*/
eb_etype = mesh->eb_etypes;
/* allocate space to hold info about surounding elements */
pt_list = (int *) malloc(2 * max_nsur * sizeof(int));
if(!pt_list) {
Gen_Error(0, "fatal: insufficient memory");
return 0;
}
hold_elem = pt_list + max_nsur;
for (ielem = 0; ielem < mesh->num_elems; ielem++) {
iblk = elements[ielem].elem_blk;
/* exclude circle and sphere elements from graph */
if (mesh->eb_nnodes[iblk] > 1) {
if ((nsides = get_elem_info(NSIDES, (E_Type) (eb_etype[iblk]), 0)) < 0) {
Gen_Error(0, "fatal: could not get element information");
return 0;
}
elements[ielem].adj = (int *) malloc(nsides*sizeof(int));
elements[ielem].adj_proc = (int *) malloc(nsides*sizeof(int));
elements[ielem].edge_wgt = (float *) malloc(nsides*sizeof(float));
if(!(elements[ielem].adj) || !(elements[ielem].edge_wgt) ||
!(elements[ielem].adj_proc)) {
Gen_Error(0, "fatal: insufficient memory");
return 0;
}
/* NOTE: nadj set in read_elem_info in case graph not generated */
elements[ielem].adj_len = nsides;
/* Initialize adjacency entries to -1 for each side. */
for (nscnt = 0; nscnt < nsides; nscnt++) {
elements[ielem].adj[nscnt] = -1;
elements[ielem].adj_proc[nscnt] = -1;
elements[ielem].edge_wgt[nscnt] = 0;
}
/* check each side of this element */
for (nscnt = 0; nscnt < nsides; nscnt++) {
/* get the list of nodes on this side set */
side_cnt = ss_to_node_list((E_Type) (eb_etype[iblk]),
elements[ielem].connect,
(nscnt+1), side_nodes);
/*
* now I need to determine how many side set nodes I
* need to use to determine if there is an element
* connected to this side.
*
* 2-D - need two nodes, so find one intersection
* 3-D - need three nodes, so find two intersections
* NOTE: must check to make sure that this number is not
* larger than the number of nodes on the sides (ie - SHELL).
*/
nnodes = mesh->num_dims;
if (side_cnt < nnodes) nnodes = side_cnt;
nnodes--; /* decrement to find the number of intersections */
nelem = 0; /* reset this in case no intersections are needed */
/* copy the first array into temp storage */
nhold = nsurnd[side_nodes[0]];
for (i = 0; i < nhold; i++)
hold_elem[i] = sur_elem[side_nodes[0]][i];
for (inode = 0; inode < nnodes; inode++) {
nelem = find_inter(hold_elem, sur_elem[side_nodes[(inode+1)]],
nhold, nsurnd[side_nodes[(inode+1)]], 2, pt_list);
if (nelem < 2) break;
else {
nhold = nelem;
for (i = 0; i < nelem; i++)
hold_elem[i] = hold_elem[pt_list[i]];
}
}
/*
* if there is an element on this side of ielem, then there
* will be at least two elements in the intersection (one
* will be ielem)
*/
if (nelem > 1) {
/*
* now go through and check each element in the list
* to see if it is different than ielem.
*/
for(i=0; i < nelem; i++) {
entry = hold_elem[i];
if(entry != ielem) {
/*
* get the side id of entry. Make sure that ielem is
* trying to communicate to a valid side of elem
*/
side_cnt = get_ss_mirror((E_Type) (eb_etype[iblk]),
side_nodes, (nscnt+1),
mirror_nodes);
/*
* in order to get the correct side order for elem,
* get the mirror of the side of ielem
*/
sid = get_side_id((E_Type) (eb_etype[elements[entry].elem_blk]),
elements[entry].connect,
side_cnt, mirror_nodes);
if (sid > 0) {
(elements[ielem].nadj)++;
/*
* store the adjacency info in the entry for this side.
*/
elements[ielem].adj[nscnt] = entry;
elements[ielem].adj_proc[nscnt] = Proc;
/*
* the edge weight is the number of nodes in the
* connecting face
*/
elements[ielem].edge_wgt[nscnt] =
(float) get_elem_info(NSNODES, (E_Type) (eb_etype[iblk]),
(nscnt+1));
} /* End: "if (sid > 0)" */
else if (sid < 0) {
Gen_Error(0, "fatal: could not find side id");
return 0;
}
} /* End: "if(ielem != entry)" */
} /* End: "for(i=0; i < nelem; i++)" */
} /* End: "if (nelem > 1)" */
} /* End: "for (nscnt = 0; ...)" */
} /* End: "if (nnode > 1)" */
} /* End: "for (ielem=0; ...)" */
free(pt_list);
return 1;
}