//-------------------------------------------------------------------------
// Purpose : get bounding box
//
// Special Notes :
//
// Creator : Jason Kraftcheck
//
// Creation Date : 02/14/03
//-------------------------------------------------------------------------
CubitBox PartitionBody::bounding_box() const
{
DLIList<TopologyBridge*> lumps;
real_body()->get_children_virt(lumps);
CubitBox result = dynamic_cast<Lump*>(lumps.step_and_get())->bounding_box();
for( int i = 1; i < lumps.size(); i++ )
result |= dynamic_cast<Lump*>(lumps.step_and_get())->bounding_box();
return result;
}
//-------------------------------------------------------------------------
// Purpose : Get all attributes
//
// Special Notes :
//
// Creator : Jason Kraftcheck
//
// Creation Date : 06/18/02
//-------------------------------------------------------------------------
void CompositeGeom::get_attributes( DLIList<CubitSimpleAttrib>& list )
{
// special case: single-entity 'composite'
if (entityList.size() == 1)
{
TopologyBridge* entity = entityList[0].entity;
entity->get_simple_attribute(list);
// handle 8.1 attribs on single-entity 'composites'
for (int i = list.size(); i--; )
{
const CubitSimpleAttrib& attrib = list.step_and_get();
if (attrib.character_type() == COMPOSITE_DATA_ATTRIB_NAME &&
attrib.int_data_list()[0] == 1)
{
entity->remove_simple_attribute_virt(attrib);
CubitSimpleAttrib newattrib = attrib;
newattrib.string_data_list().erase(newattrib.string_data_list().begin());
newattrib.int_data_list().erase(newattrib.int_data_list().begin());
entity->append_simple_attribute_virt(newattrib);
}
}
}
for (CompositeAttrib* ptr = listHead; ptr; ptr = ptr->next)
list.append(ptr->csa());
}
GeomDataObserver* GeomDataObserver::get( RefEntity* on_this )
{
DLIList<CubitObserver*> list;
GeomDataObserver* eo = NULL;
on_this->get_observer_list(list);
for (int i = list.size(); i--; )
{
if ( (eo = dynamic_cast<GeomDataObserver*>(list.step_and_get()) ))
break;
}
return eo;
}
CubitStatus PartitionShell::mass_properties( CubitVector& centroid,
double& volume )
{
PartitionCoSurf* cosurf = 0;
DLIList<CubitFacetData*> facets;
CubitVector p1, p2, p3, normal;
const CubitVector p0(0.0, 0.0, 0.0);
centroid.set(0.0, 0.0, 0.0 );
volume = 0.0;
while ((cosurf = next_co_surface( cosurf )))
{
if (is_nonmanifold( cosurf->get_surface() ))
continue;
facets.clean_out();
cosurf->get_surface()->get_facet_data( facets );
for (int i = facets.size(); i--; )
{
CubitFacet* facet = facets.step_and_get();
p1 = facet->point(0)->coordinates();
p2 = facet->point(1)->coordinates();
p3 = facet->point(2)->coordinates();
normal = (p3 - p1) * (p2 - p1);
double two_area = normal.length();
if (two_area > CUBIT_RESABS )
{
if (cosurf->sense() == CUBIT_REVERSED)
normal = -normal;
normal /= two_area;
double height = normal % (p0 - p1);
double vol = two_area * height;
volume += vol;
centroid += vol * (p0 + p1 + p2 + p3);
}
}
}
if (volume > CUBIT_RESABS)
centroid /= 4.0 * volume;
volume /= 6.0;
return CUBIT_SUCCESS;
}
// order edges in list beginning at start_point
// report the endpoint
// return CUBIT_SUCCESS if all edges are connected and ordered successfully
// otherwise return CUBIT_FAILURE, in which case no changes are made
CubitStatus CubitFacetEdge::order_edge_list(DLIList<CubitFacetEdge*> &edge_list,
CubitPoint *start_point,
CubitPoint *&end_point)
{
int i;
assert(start_point);
end_point = NULL;
// invalid input
if (0 == edge_list.size())
return CUBIT_FAILURE;
// simple case of a single edge - endpoitn
if (1 == edge_list.size())
{
end_point = edge_list.get()->other_point(start_point);
return end_point ? CUBIT_SUCCESS : CUBIT_FAILURE;
}
edge_list.reset();
// note that a periodic/closed curve will fail
// we could handle that case here if needed, but we may need more information
// to know where to start and end the curve
if (NULL == start_point)
return CUBIT_FAILURE;
// put edges in a set for faster searching
std::set<CubitFacetEdge *> edge_set;
for (i=0; i<edge_list.size(); i++)
edge_set.insert(dynamic_cast<CubitFacetEdge*> (edge_list.step_and_get()));
// a vector for the ordered list
std::vector<CubitFacetEdge*> ordered_edges;
// find connected edges from the start point
CubitPoint *cur_pt = start_point;
do
{
// get edges connected to the current point and find the next edge
DLIList<CubitFacetEdge *> pt_edges;
cur_pt->edges(pt_edges);
std::set<CubitFacetEdge *>::iterator iter_found;
CubitFacetEdge *cur_edge = NULL;
for (i=0; i<pt_edges.size() && !cur_edge; i++)
{
CubitFacetEdge *tmp_edge = pt_edges.get_and_step();
iter_found = edge_set.find(tmp_edge);
if ( iter_found != edge_set.end() )
cur_edge = tmp_edge;
}
// if we don't find a connection before we empty the set
// then not all the edges are connected -- return failure
if (NULL == cur_edge)
return CUBIT_FAILURE;
// add the edge to the ordered list
ordered_edges.push_back( cur_edge );
edge_set.erase(iter_found);
cur_pt = cur_edge->other_point(cur_pt);
}
while ( edge_set.size());
if (ordered_edges.size() != edge_list.size())
return CUBIT_FAILURE;
// store the edges in the correct order
edge_list.clean_out();
std::vector<CubitFacetEdge*>::iterator iter;
for (iter=ordered_edges.begin(); iter!=ordered_edges.end(); iter++)
edge_list.append(*iter);
// get the end point
CubitFacetEdge *edge1 = edge_list[edge_list.size() - 1];
CubitFacetEdge *edge2 = edge_list[edge_list.size() - 2];
end_point = edge1->other_point( edge1->shared_point(edge2) );
return CUBIT_SUCCESS;
}
CubitStatus FacetLump::mass_properties( CubitVector& centroid, double& volume )
{
int i;
DLIList<FacetShell*> shells( myShells.size() );
CAST_LIST( myShells, shells, FacetShell );
assert( myShells.size() == shells.size() );
DLIList<FacetSurface*> surfaces;
DLIList<FacetShell*> surf_shells;
get_surfaces( surfaces );
DLIList<CubitFacet*> facets, surf_facets;
DLIList<CubitPoint*> junk;
DLIList<CubitSense> senses;
for (i = surfaces.size(); i--; )
{
FacetSurface* surf = surfaces.step_and_get();
surf_shells.clean_out();
surf->get_shells( surf_shells );
surf_shells.intersect( shells );
assert( surf_shells.size() );
CubitSense sense = surf->get_shell_sense( surf_shells.get() );
if (surf_shells.size() == 1 && CUBIT_UNKNOWN != sense)
{
surf_facets.clean_out();
junk.clean_out();
surf->get_my_facets( surf_facets, junk );
facets += surf_facets;
for (int j = surf_facets.size(); j--; )
senses.append(sense);
}
}
const CubitVector p0 = bounding_box().center();
CubitVector p1, p2, p3, normal;
centroid.set( 0.0, 0.0, 0.0 );
volume = 0.0;
facets.reset();
senses.reset();
for (i = facets.size(); i--; )
{
CubitFacet* facet = facets.get_and_step();
CubitSense sense = senses.get_and_step();
p1 = facet->point(0)->coordinates();
p2 = facet->point(1)->coordinates();
p3 = facet->point(2)->coordinates();
normal = (p3 - p1) * (p2 - p1);
double two_area = normal.length();
if (two_area > CUBIT_RESABS )
{
if (CUBIT_REVERSED == sense)
normal = -normal;
normal /= two_area;
double height = normal % (p0 - p1);
double vol = two_area * height;
volume += vol;
centroid += vol * (p0 + p1 + p2 + p3);
}
}
if (volume > CUBIT_RESABS)
centroid /= 4.0 * volume;
volume /= 6.0;
return CUBIT_SUCCESS;
}