Namespaces
namespace	detail
Classes
class	CellSet
class	DataSetConverter
class	ExtractShell
class	FaceCellSet
struct	FacesAdjRegions
class	Tag
class	MaterialTag
class	DirichletTag
class	NeumannTag
class	GroupTag
class	GeomTag
class	Interface
Typedefs
typedef std::vector< CellSet >	CellSets
typedef std::vector< FaceCellSet >	FaceCellSets
typedef moab::Range	Range
typedef moab::EntityHandle	EntityHandle
typedef moab::EntityType	EntityType
Enumerations
enum	adjacency_type { INTERSECT = moab::Interface::INTERSECT, UNION = moab::Interface::UNION }
Functions
template<typename T >
smoab::Range	getParents (const T &set)
template<typename T >
smoab::Range	getAllCells (const T &set)
smoab::FaceCellSets	findFaceSets (smoab::CellSets shells, smoab::CellSets boundaries, std::set< smoab::FacesAdjRegions > &faceMaps)
template<typename T >
std::vector< T >	faceIdsPerCell (const smoab::FaceCellSets &faces)
template<typename T >
std::pair< T, T >	FaceAdjRegionValues (const smoab::FacesAdjRegions &faceAdj, smoab::Tag *t, const smoab::Interface &interface)
void	RangeToVector (const smoab::Range &range, std::vector< smoab::EntityHandle > &vector)

Typedef Documentation

typedef std::vector<CellSet> smoab::CellSets

Definition at line 39 of file CellSets.h.

typedef moab::EntityHandle smoab::EntityHandle

Definition at line 23 of file SimpleMoab.h.

typedef moab::EntityType smoab::EntityType

Examples:: LaplacianSmoother.cpp, and QuadTriConv.cpp.

Definition at line 24 of file SimpleMoab.h.

typedef std::vector<FaceCellSet> smoab::FaceCellSets

Definition at line 27 of file FaceSets.h.

typedef moab::Range smoab::Range

Definition at line 22 of file SimpleMoab.h.

Enumeration Type Documentation

enum smoab::adjacency_type

Enumerator:

INTERSECT
UNION

Definition at line 18 of file SimpleMoab.h.

                   {INTERSECT=moab::Interface::INTERSECT,
                    UNION=moab::Interface::UNION};

Function Documentation

template<typename T >

std::pair<T,T> smoab::FaceAdjRegionValues	(	const smoab::FacesAdjRegions &	faceAdj,
		smoab::Tag *	t,
		const smoab::Interface &	interface
	)

Definition at line 213 of file FaceSets.h.

References smoab::Interface::getDefaultTagVaue(), smoab::Interface::getTagData(), smoab::FacesAdjRegions::Region0, smoab::FacesAdjRegions::Region1, and T.

  {
  std::pair<T,T> returnValue;
  const int defaultValue = interface.getDefaultTagVaue<int>(*t);

  /*
   *  IF A REGION IS SET TO -1 WE NEED TO PUSH THAT VALUE DOWN
   *  AS THE MATERIAL, SINCE THE MOAB DEFAULT TAG VALUE WILL
   *  BE CONSIDIERED A REGION, AND WE WANT TO SAY IT BOUNDS THE
   *  VOID REGION
   */
  int tagValue = defaultValue; //use tagValue to pass in default value
  if(faceAdj.Region0 != -1)
    {
    tagValue = interface.getTagData(*t,faceAdj.Region0,tagValue);
    }
  else
    {
    tagValue = -1;
    }

  //set the first region tag value into the pair we are returing
  returnValue.first = static_cast<T>(tagValue);

  tagValue = defaultValue; //use tagValue to pass in default value
  tagValue = interface.getTagData(*t,faceAdj.Region1,tagValue);
  if(faceAdj.Region1 != -1)
    {
    tagValue = interface.getTagData(*t,faceAdj.Region1,tagValue);
    }
  else
    {
    tagValue = -1;
    }
 returnValue.second = static_cast<T>(tagValue);

  return returnValue;
  }

template<typename T >

std::vector<T> smoab::faceIdsPerCell ( const smoab::FaceCellSets & faces )

Definition at line 173 of file FaceSets.h.

References moab::Range::begin(), moab::Range::end(), getAllCells(), RangeToVector(), T, and value().

{
  typedef smoab::FaceCellSets::const_iterator iterator;
  typedef std::vector<smoab::EntityHandle>::const_iterator EntityHandleIterator;
  typedef smoab::Range::const_iterator RangeIterator;

  //find all the cells that are in the faceCellSet, and than map
  //the proper face id to that relative position, here comes lower_bounds!
  std::vector<smoab::EntityHandle> searchableCells;
  smoab::Range faceRange = smoab::getAllCells(faces);
  smoab::RangeToVector(faceRange,searchableCells);

  //faceIds will be the resulting array
  std::vector<T> faceIds(searchableCells.size());

  //construct the start and end iterators for the lower bounds call

  EntityHandleIterator s_begin = searchableCells.begin();
  EntityHandleIterator s_end = searchableCells.end();

  //search the face cell sets
  for(iterator i=faces.begin(); i!=faces.end(); ++i)
    {
    T value = static_cast<T>(i->faceId());
    const smoab::Range& entitiesCells = i->cells();
    for(RangeIterator j=entitiesCells.begin(); j != entitiesCells.end();++j)
      {
      EntityHandleIterator result = std::lower_bound(s_begin,
                                                     s_end,
                                                     *j);
      std::size_t newId = std::distance(s_begin,result);
      faceIds[newId] = value;
      }
    }
  return faceIds;
}

smoab::FaceCellSets smoab::findFaceSets	(	smoab::CellSets	shells,
		smoab::CellSets	boundaries,
		std::set< smoab::FacesAdjRegions > &	faceMaps
	)

Definition at line 70 of file FaceSets.h.

References moab::Range::empty(), MBMesquite::faces, moab::intersect(), smoab::FacesAdjRegions::otherId(), and moab::Range::size().

{
  typedef smoab::CellSets::iterator iterator;
  typedef smoab::FaceCellSets::iterator faceIterator;
  typedef std::set<smoab::FacesAdjRegions>::const_iterator FaceAdjIterator;

  //we need to properly label each unique face in shells
  //we do this by intersecting each shell with each other shell
  //to find shell on shell contact, and than we intersect each
  //resulting shell with the boundary conditions
  //the end result of these intersections will be the new modelfaces
  int faceId = 1;
  smoab::FaceCellSets shellFaces;

  //first intersect each shell with each other shell
  std::set<smoab::FacesAdjRegions> shellFaceContacts;
  for(iterator i=shells.begin();i!= shells.end();++i)
    {
    //copy the cells so we can add a face that represents
    //all the cells of the region that aren't shared with another region
    int numCells = i->cells().size(); //size() on range is slow, so cache it
    for(iterator j = i+1;
        j != shells.end() && numCells > 0;
        ++j)
      {
      //intersect i and j to make a new face
      smoab::Range intersection = smoab::intersect(i->cells(),j->cells());
      if(!intersection.empty())
        {
        //don't want to increment faceId when the intersection is empty
        smoab::FaceCellSet face(faceId++,i->entity(),intersection);
        shellFaces.push_back(face);
        i->erase(intersection);
        j->erase(intersection);
        numCells -= intersection.size();

        //add this to the face map
        smoab::FacesAdjRegions faceInfo(faceId-1,i->entity(),j->entity());
        shellFaceContacts.insert(faceInfo);
        }
      }
    //if all the cells for shell i are used, don't add a new
    //empty face
    if(numCells > 0)
      {
      smoab::FaceCellSet face(faceId++,i->entity(),i->cells());
      shellFaces.push_back(face);

      //add this to the face map
      smoab::FacesAdjRegions faceInfo(faceId-1,-1,i->entity());
      shellFaceContacts.insert(faceInfo);
      }
    }

  //now we have all the faces that match shell on shell contact
  //we know process all the new faces to see if they intersect
  //with any boundary sets. A boundary set can span multiple
  //shells so we want to process it as a second loop

  //store the end before we start adding boundary faces, which
  //we don't need to check agianst other boundaries
  faceId = 1; //reset the faced id

  //store in a new face set, expanding the current one causes incorrect results
  smoab::FaceCellSets faces;
  for(faceIterator i=shellFaces.begin();i != shellFaces.end();++i)
    {
    //determine from the shell faces if the new face we are creating
    //is bounded by two regions or just one
    smoab::FacesAdjRegions idToSearchFor(i->faceId());
    FaceAdjIterator adjRegions = shellFaceContacts.find(idToSearchFor);
    smoab::EntityHandle otherRegionId = adjRegions->otherId(i->entity());

    int numCells = i->cells().size(); //size() on range is slow, so cache it
    for(iterator j=boundaries.begin();j != boundaries.end(); ++j)
      {
      smoab::Range intersect = smoab::intersect(i->cells(),j->cells());
      if(!intersect.empty())
          {
          //don't want to increment faceId when the intersection is empty
          smoab::FaceCellSet face(faceId++,j->entity(),intersect);
          faces.push_back(face);
          i->erase(intersect);
          numCells -= intersect.size();
          smoab::FacesAdjRegions faceInfo(faceId-1,i->entity(),otherRegionId);
          faceMaps.insert(faceInfo);
          }
      }
    if(numCells > 0)
      {
      smoab::FaceCellSet face(faceId++,i->entity(),i->cells());
      faces.push_back(face);
      smoab::FacesAdjRegions faceInfo(faceId-1,i->entity(),otherRegionId);
      faceMaps.insert(faceInfo);
      }
    }
  return faces;
}

template<typename T >

smoab::Range smoab::getAllCells ( const T & set )

Definition at line 59 of file CellSets.h.

References moab::Range::begin(), moab::Range::end(), and moab::Range::insert().

Referenced by faceIdsPerCell(), and smoab::DataSetConverter::fill().

{
  typedef typename T::const_iterator iterator;
  smoab::Range result;

  for(iterator i=set.begin(); i != set.end(); ++i)
    {
    smoab::Range c = i->cells();
    result.insert(c.begin(),c.end());
    }
  return result;
}

template<typename T >

smoab::Range smoab::getParents ( const T & set )

Definition at line 44 of file CellSets.h.

References moab::Range::insert().

{
  typedef typename T::const_iterator iterator;
  smoab::Range result;

  for(iterator i=set.begin(); i != set.end(); ++i)
    {
    result.insert(i->entity());
    }
  return result;
}

void smoab::RangeToVector	(	const smoab::Range &	range,
		std::vector< smoab::EntityHandle > &	vector
	)

Definition at line 492 of file SimpleMoab.h.

References moab::Range::begin(), moab::Range::end(), and moab::Range::size().

Referenced by faceIdsPerCell(), and smoab::detail::ReadSparseTag::multiSetRead().

{
  vector.reserve(range.size());
  std::copy(range.begin(),
            range.end(),
            std::back_inserter(vector));
}

Namespaces

Classes

Typedefs

Enumerations

Functions

Typedef Documentation

Enumeration Type Documentation

Function Documentation