General connectivity object. More...

#include <Mesh.H>

Inheritance diagram for Mesh::Connectivity:

Collaboration diagram for Mesh::Connectivity:

Public Member Functions
	Connectivity ()

	Connectivity (unsigned int N)

void	Resize (unsigned int N=0)

	~Connectivity ()

std::vector< IndexType > &	Element (IndexType n)

std::vector< IndexType >	Element (IndexType n) const

IndexType &	Node (IndexType e, IndexType n)

IndexType	Node (IndexType e, IndexType n) const

IndexType	Nelem () const

IndexType	Esize (IndexType n) const

void	AddElement (const std::vector< IndexType > &elem)

void	AddElement ()

void	Sync ()

void	ShrinkWrap ()

void	Truncate ()

void	destroy ()

void	SyncSizes ()

void	DestroySizes ()

void	Inverse (Connectivity &, IndexType nnodes=0) const

void	InverseDegenerate (Connectivity &, IndexType nnodes=0) const

void	GetNeighborhood (NeighborHood &, const Connectivity &dc, IndexType size=0)

void	GetNeighborhood (Connectivity &, Connectivity &dc, bool exclude_self=true, bool sortit=false)

void	GetAdjacent (Connectivity &rl, Connectivity &dc, IndexType n=0, bool sortit=false)

void	graph_mode (IndexType offset=0)

void	matrix_mode (IndexType offset=0)

void	BuildFaceConnectivity (Connectivity &fcon, Connectivity &ef, std::vector< Mesh::SymbolicFace > &sf, Connectivity &dc) const

template<typename T >
void	Flatten (std::vector< T > &outcon) const

void	BreadthFirstRenumber (std::vector< Mesh::IndexType > &remap)

void	ElementsOn (std::vector< Mesh::IndexType > &nodes, Connectivity &dc, std::vector< Mesh::IndexType > &subset)

Private Attributes
IndexType	_nelem

std::vector< IndexType >	_sizes

Friends
std::ostream &	operator<< (std::ostream &oSt, const Connectivity &ec)

std::istream &	operator>> (std::istream &iSt, Connectivity &ec)

Additional Inherited Members
Public Attributes inherited from vector< T >
T	elements
	STL member. More...

Detailed Description

General connectivity object.

The Connectivity is a very useful object which allows the description of adjacency of many types of things. Currently the most obvious is describing the connectivity of mesh cells.

Definition at line 334 of file Mesh.H.

Constructor & Destructor Documentation

Connectivity ( )

Definition at line 222 of file Mesh.C.

                                  : std::vector<std::vector<IndexType> >()
   {
         this ->_nelem = 0;
     this->resize(0);
     std::vector<std::vector<Mesh::IndexType> >(*this).swap(*this);
   };

Connectivity ( unsigned int N )

Definition at line 229 of file Mesh.C.

                                                : std::vector<std::vector<IndexType> >(N)
   {
     std::vector<std::vector<Mesh::IndexType> >(*this).swap(*this);
   };

~Connectivity ( )

Definition at line 234 of file Mesh.C.

234 { destroy(); };

Mesh::Connectivity::destroy

void destroy()

Definition: Mesh.C:269

Member Function Documentation

void AddElement ( const std::vector< IndexType > & elem )

Definition at line 235 of file Mesh.C.

Referenced by Rocon::burnout(), Mesh::BSExtent< T >::CreateUnstructuredMesh(), main(), TRAIL_SurfaceMesh2Window(), and TRAIL_UnstructuredMesh2Pane().

   {
     _nelem++;
     this->push_back(elem);
   };

Here is the caller graph for this function:

void AddElement ( )

Definition at line 240 of file Mesh.C.

   {
     _nelem++;
     std::vector<IndexType> a;
     this->push_back(a);
   };

void BreadthFirstRenumber ( std::vector< Mesh::IndexType > & remap )

Definition at line 593 of file Mesh.C.

References _nelem, i, and ni.

   {
     remap.resize(_nelem,0);
     IndexType renumber = 1;
     for(IndexType i = 0;i < _nelem && renumber <= _nelem;i++){
       //    while(renumber <= _nelem){
       if(remap[i] == 0){
         remap[i] = renumber++; 
         std::list<IndexType> processing_queue;
         std::vector<IndexType>::iterator ni = (*this)[i].begin();
         while(ni != (*this)[i].end()){
           IndexType index = *ni++ - 1;
           if(remap[index] == 0){
             processing_queue.push_back(index);
             remap[index] = renumber++;
           }
         }
         std::list<IndexType>::iterator pqi = processing_queue.begin();
         while(pqi != processing_queue.end()){
           IndexType index = *pqi;
           std::vector<IndexType>::iterator ini = (*this)[index].begin();
           while(ini != (*this)[index].end()){
             IndexType iindex = *ini++ - 1;
             if(remap[iindex] == 0){
               processing_queue.push_back(iindex);
               remap[iindex] = renumber++;
             }
           }
           pqi++;
         }
       }
     }
     assert((renumber == (_nelem+1)));
   };

void BuildFaceConnectivity	(	Connectivity &	fcon,
		Connectivity &	ef,
		std::vector< Mesh::SymbolicFace > &	sf,
		Connectivity &	dc
	)		const

Definition at line 337 of file Mesh.C.

References Esize(), Mesh::GenericElement::get_face_connectivities(), Nelem(), Mesh::GenericElement::nfaces(), Resize(), Sync(), and SyncSizes().

   {
     //    this->Sync();
     //    this->SyncSizes();
     ef.Resize(this->Nelem());
     Mesh::IndexType number_of_elements = this->Nelem();
     Mesh::IndexType nface_estimate = static_cast<Mesh::IndexType>(2.2 * number_of_elements);
     fcon.Resize(0);
     fcon.reserve(nface_estimate);
     sf.reserve(nface_estimate);
     Mesh::IndexType number_of_faces = 0;
     std::vector<Mesh::Connectivity> all_face_conn;
     all_face_conn.resize(this->Nelem());
     //    std::vector<Mesh::IndexType> element_nfaces;
     //    element_nfaces.resize(this->Nelem());
     // This loop sizes the C[F] array (i.e. for each cell, which faces)
     // They're init'd to 0 so that we can tell which faces have been processed
     for(Mesh::IndexType element_being_processed = 1;
         element_being_processed <= number_of_elements;
         element_being_processed++)
       {
         Mesh::IndexType index = element_being_processed - 1;
         Mesh::IndexType size_of_element = this->Esize(element_being_processed);
         Mesh::GenericElement ge(size_of_element);
         //      element_nfaces[index] = nfaces;
         ef[index].resize(ge.nfaces(),0);
         //      std::vector<Mesh::IndexType>(ef[index]).swap(ef[index]);
         ge.get_face_connectivities(all_face_conn[index],(*this)[index]);
       }
     ef.Sync();
     ef.SyncSizes();
     // This loop populates the F[N] (i.e. for each face, which nodes), and
     // the C[F] arrays.
     for(Mesh::IndexType element_being_processed = 1;
         element_being_processed <= number_of_elements;
         element_being_processed++)
       {
         Mesh::IndexType index = element_being_processed - 1;
         Mesh::IndexType size_of_element = this->Esize(element_being_processed);
         Mesh::GenericElement ge(size_of_element);
         Mesh::IndexType nfaces = ef.Esize(element_being_processed);
         //      Mesh::Connectivity efc;
         // This call populates the F[N] for the faces local
         // to the element_being_processed.
         //      ge.get_face_connectivities(efc,(*this)[index]);
         // This loop goes through each face of the element_being_processed
         // and updates the F[N] and C[F] arrays.
         for(Mesh::IndexType face_being_processed = 1;
             face_being_processed <= nfaces;
             face_being_processed++){
           Mesh::IndexType findex = face_being_processed - 1;
           if(!ef[index][findex]){ // 0 if face hasn't yet been processed
             fcon.push_back(all_face_conn[index][findex]); // add the new face to the F[N] array
             ef[index][findex] = number_of_faces + 1; // add the face id to the C[F] array
             SubEntityId seid1;
             SubEntityId seid2;
             sf.push_back(std::make_pair(seid1,seid2));
             sf[number_of_faces].first.first = element_being_processed;
             sf[number_of_faces].first.second = face_being_processed;
             // Now look at each cell containing each node of the current face and determine
             // which one (if any) have the same face.   This will be the face neighbor of the
             // element_being_processed for the face identified by (number_of_faces + 1).
             //      std::list<Mesh::IndexType> element_nbrlist;
             bool found = false;
             std::vector<Mesh::IndexType>::iterator fni = fcon[number_of_faces].begin();
             while(fni != fcon[number_of_faces].end() && !found){ // for every node in this face
               Mesh::IndexType face_node_index = *fni++ - 1;
               std::vector<Mesh::IndexType>::iterator enbri = dc[face_node_index].begin();
               while(enbri != dc[face_node_index].end() && !found){ // look thru all the node's cells
                 Mesh::IndexType enbr_index = *enbri++ - 1;
                 if(enbr_index+1 > element_being_processed){
                   Mesh::IndexType nbr_nfaces = ef.Esize(enbr_index+1);
                   for(Mesh::IndexType nbrface = 1;nbrface <= nbr_nfaces && !found;nbrface++){
                     Mesh::IndexType nbr_face_index = nbrface -1;
                     if(!ef[enbr_index][nbr_face_index]){
                       if(IRAD::Util::HaveOppositeOrientation(all_face_conn[index][findex],
                                                  all_face_conn[enbr_index][nbr_face_index])){
                         found = true;
                         ef[enbr_index][nbr_face_index] = number_of_faces + 1;
                         sf[number_of_faces].second.first = enbr_index+1;
                         sf[number_of_faces].second.second = nbr_face_index+1;
                       } // if faces match
                     }
                   }
                 }
               }
             }
             number_of_faces++;
           }
         }
       }
     fcon.Sync();
   };

Here is the call graph for this function:

void destroy ( )

Definition at line 269 of file Mesh.C.

Referenced by main().

                                 {
     DestroySizes();
     Connectivity::iterator ti = this->begin();
     while(ti != this->end()){
       ti->resize(0);
       std::vector<IndexType> tmp(*ti);
       ti->swap(tmp);
       ti++;
     }
     this->resize(0);
     std::vector<std::vector<IndexType> >(*this).swap(*this);
   };

Here is the caller graph for this function:

void DestroySizes ( )

Definition at line 289 of file Mesh.C.

289 { _sizes.resize(0);};

Mesh::Connectivity::_sizes

std::vector< IndexType > _sizes

Definition: Mesh.H:340

std::vector<IndexType>& Element ( IndexType n )

inline

Definition at line 346 of file Mesh.H.

References _nelem.

                                                      {
       assert(n > 0 && n <= _nelem);
       return((*this)[n-1]);
     };

std::vector<IndexType> Element ( IndexType n ) const

inline

Definition at line 350 of file Mesh.H.

References _nelem.

                                                            {
       assert(n > 0 && n <= _nelem);
       return((*this)[n-1]);
     };

void ElementsOn	(	std::vector< Mesh::IndexType > &	nodes,
		Connectivity &	dc,
		std::vector< Mesh::IndexType > &	subset
	)

Definition at line 569 of file Mesh.C.

References ni.

   {
     std::list<Mesh::IndexType> alist;
     std::vector<Mesh::IndexType>::iterator ni = nodes.begin();
     while(ni != nodes.end()){
       Mesh::IndexType node_index = *ni++ - 1;
       std::vector<Mesh::IndexType>::iterator dci = dc[node_index].begin();
       while(dci != dc[node_index].end())
         alist.push_back(*dci++);
     }
     alist.sort();
     alist.unique();
     subset.resize(alist.size());
     std::vector<Mesh::IndexType>::iterator ssi = subset.begin();
     std::list<Mesh::IndexType>::iterator li = alist.begin();
     while(li != alist.end())
       *ssi++ = *li++;
   };

IndexType Esize ( IndexType n ) const

inline

Definition at line 365 of file Mesh.H.

References _nelem, and _sizes.

Referenced by BuildFaceConnectivity(), Rocon::burnout(), GetStatistics(), main(), stitchGrids(), Mesh::writeVtkData(), and writeVtkData().

     {
       assert(n > 0 && n <= _nelem);
       return (_sizes.empty() ? (*this)[n-1].size() : _sizes[n-1]);
     };

Here is the caller graph for this function:

void Flatten ( std::vector< T > & outcon ) const

inline

Definition at line 394 of file Mesh.H.

Referenced by TRAIL_FD2FE_WinCreate(), and TRAIL_FD2FE_WinCreate2().

     {
       outcon.resize(0);
       std::vector<std::vector<IndexType> >::const_iterator eci = this->begin();
       while(eci != this->end()){
         std::vector<IndexType>::const_iterator eni = eci->begin();
         while(eni != eci->end())
           outcon.push_back(*eni++);
         eci++;
       }
     };

Here is the caller graph for this function:

void GetAdjacent	(	Connectivity &	rl,
		Connectivity &	dc,
		IndexType	n = `0`,
		bool	sortit = `false`
	)

Definition at line 520 of file Mesh.C.

References _nelem, i, j, n, ni, and Resize().

Referenced by main().

   {
     rl.Resize(_nelem);
     rl._nelem = _nelem;
     IndexType nadj = n;
     if(n == 0){
       std::cout << "GETADJACENT: Determining MaxNodeId" << std::endl;
       nadj = MaxNodeId<Connectivity,std::vector<IndexType> >(dc);
     }
     std::vector<bool> added(nadj,false);
     for(IndexType i = 0; i < _nelem;i++){
       //      IndexType current_element = i + 1;
       std::vector<IndexType>::iterator ni = (*this)[i].begin();
       std::list<IndexType> nbrlist;
       while(ni != (*this)[i].end()){
         IndexType index = *ni - 1;
         std::vector<IndexType>::iterator dci = dc[index].begin();
         while(dci != dc[index].end()){
           IndexType ai = *dci - 1;
           if(!added[ai]){
             nbrlist.push_back(*dci);
             added[ai] = true;
           }
           dci++;
         }
         ni++;
       }
       if(sortit)
         nbrlist.sort();
       //      nbrlist.unique();
       rl[i].resize(nbrlist.size());
       IndexType j = 0;
       std::list<IndexType>::iterator si = nbrlist.begin();
       while(si != nbrlist.end()){
         rl[i][j++] = *si;
         added[*si-1] = false;
         si++;
       }
     }
   };

Here is the call graph for this function:

Here is the caller graph for this function:

void GetNeighborhood	(	NeighborHood &	rl,
		const Connectivity &	dc,
		IndexType	size = `0`
	)

Definition at line 456 of file Mesh.C.

References _nelem, i, and ni.

Referenced by main().

   {
     rl.resize(_nelem);
     //    rl._nelem = _nelem;
     for(IndexType i = 0; i < _nelem;i++){
       std::vector<IndexType>::const_iterator ni = (*this)[i].begin();
       while(ni != (*this)[i].end()){
         IndexType index = *ni - 1;
         std::vector<IndexType>::const_iterator dci = dc[index].begin();
         while(dci != dc[index].end())
           rl[i].insert(*dci++);
         ni++;
       }
       rl[i].erase(i+1);
     }
   };

Here is the caller graph for this function:

void GetNeighborhood	(	Connectivity &	rl,
		Connectivity &	dc,
		bool	exclude_self = `true`,
		bool	sortit = `false`
	)

Definition at line 476 of file Mesh.C.

References _nelem, i, j, ni, and Resize().

   {
     rl.Resize(_nelem);
     rl._nelem = _nelem;
     std::vector<bool> added(_nelem,false);
     for(IndexType i = 0; i < _nelem;i++){
       IndexType current_element = i + 1;
       std::vector<IndexType>::iterator ni = (*this)[i].begin();
       std::list<IndexType> nbrlist;
       while(ni != (*this)[i].end()){
         IndexType index = *ni - 1;
         std::vector<IndexType>::iterator dci = dc[index].begin();
         while(dci != dc[index].end()){
           IndexType ai = *dci - 1;
           if(!added[ai]){
             nbrlist.push_back(*dci);
             added[ai] = true;
           }
           dci++;
         }
         ni++;
       }
       if(sortit)
         nbrlist.sort();
       //      nbrlist.unique();
       if(exclude_self){
         nbrlist.remove(current_element);
         added[i] = false;
       }
       rl[i].resize(nbrlist.size());
       IndexType j = 0;
       std::list<IndexType>::iterator si = nbrlist.begin();
       while(si != nbrlist.end()){
         rl[i][j++] = *si;
         added[*si-1] = false;
         si++;
       }
     }
   };

Here is the call graph for this function:

void graph_mode ( IndexType offset = 0 )

Definition at line 434 of file Mesh.C.

Referenced by main().

   {
     Connectivity::iterator ci = this->begin();
     IndexType n = 1;
     while(ci != this->end()){
       ci->erase(std::lower_bound(ci->begin(),ci->end(),offset+n++));
       ci++;
     }
   };

Here is the caller graph for this function:

void Inverse	(	Connectivity &	rc,
		IndexType	nnodes = `0`
	)		const

Definition at line 312 of file Mesh.C.

References _nelem, i, Resize(), and Sync().

Referenced by BuildBorderStiffness(), Mesh::MeshUtilityObject::FormConnectivity(), GlobalDofReMapExchange(), and main().

   {
     if(nnodes <= 0)
       nnodes = MaxNodeId<Connectivity,std::vector<IndexType> >(*this);
     //      Connectivity::const_iterator ci = this->begin();
     //      while(ci != this->end()){
     //  std::vector<IndexType>::const_iterator ii = ci->begin();
     //  while(ii != ci->end()){
     //    nnodes = (nnodes > *ii ? nnodes : *ii);
     //    ii++;
     //  }
     //  ci++;
     //      }
     //    }
     rc.Resize(nnodes);
     rc.Sync();
     for(IndexType i = 0;i < _nelem;i++){
       std::vector<IndexType>::const_iterator ii = (*this)[i].begin();
       while(ii != (*this)[i].end()){
         rc[*ii-1].push_back(i+1);
         ii++;
       }
     }
   };

Here is the call graph for this function:

Here is the caller graph for this function:

void InverseDegenerate	(	Connectivity &	rc,
		IndexType	nnodes = `0`
	)		const

Definition at line 293 of file Mesh.C.

References i, Resize(), and Sync().

Referenced by main().

   {
     if(nnodes <= 0)
       nnodes = MaxNodeId<Connectivity,std::vector<IndexType> >(*this);
     rc.Resize(nnodes);
     rc.Sync();
     for(IndexType i = 0;i < _nelem;i++){
       if((*this)[i].size() > 1){
         std::vector<IndexType>::const_iterator ii = (*this)[i].begin();
         while(ii != (*this)[i].end()){
           rc[*ii-1].push_back(i+1);
           ii++;
         }
       }
     }
   };

Here is the call graph for this function:

Here is the caller graph for this function:

void matrix_mode ( IndexType offset = 0 )

Definition at line 444 of file Mesh.C.

References n.

Referenced by main().

   {
     Connectivity::iterator ci = this->begin();
     IndexType n = 1;
     while(ci != this->end()){
       ci->insert(std::lower_bound(ci->begin(),ci->end(),offset+n),1,offset+n);
       n++;
       ci++;
     }
   };

Here is the caller graph for this function:

IndexType Nelem ( ) const

inline

Definition at line 364 of file Mesh.H.

References _nelem.

Referenced by BuildFaceConnectivity(), Rocon::burnout(), GetStatistics(), main(), stitchGrids(), TRAIL_FD2FE_WinCreate(), TRAIL_FD2FE_WinCreate2(), TRAIL_SurfaceMesh2Window(), and TRAIL_UnstructuredMesh2Pane().

364 { return _nelem;};

Mesh::Connectivity::_nelem

IndexType _nelem

Definition: Mesh.H:339

Here is the caller graph for this function:

IndexType& Node	(	IndexType	e,
		IndexType	n
	)

inline

Definition at line 354 of file Mesh.H.

Referenced by Rocon::burnout(), Mesh::GenericCell_2::GetNormalSet(), Mesh::GenericCell_2::GetPointSet(), Mesh::GenericElement::shapef_jacobian_at(), and stitchGrids().

                                                    {
       assert(e > 0 && e <= _nelem && n > 0);
       assert(n <= (*this)[e-1].size());
       return((*this)[e-1][n-1]);
     };

Here is the caller graph for this function:

IndexType Node	(	IndexType	e,
		IndexType	n
	)		const

inline

Definition at line 359 of file Mesh.H.

                                                          {
       assert(e > 0 && e <= _nelem && n > 0);
       assert(n <= (*this)[e-1].size());
       return((*this)[e-1][n-1]);
     };

void Resize ( unsigned int N = 0 )

Definition at line 233 of file Mesh.C.

Referenced by BuildFaceConnectivity(), Mesh::GenericElement::get_face_connectivities(), GetAdjacent(), GetNeighborhood(), Inverse(), InverseDegenerate(), and Mesh::operator>>().

233 {this->resize(N);};

Here is the caller graph for this function:

void ShrinkWrap ( )

Definition at line 247 of file Mesh.C.

Referenced by main(), and Mesh::Partition::Read().

   {
     _nelem = this->size();
     Connectivity::iterator ti = this->begin();
     while(ti != this->end()){
       std::vector<Mesh::IndexType>(*ti).swap(*ti);
       ti++;
     }
     std::vector<std::vector<Mesh::IndexType> >(*this).swap(*this);
   };

Here is the caller graph for this function:

void Sync ( )

Definition at line 246 of file Mesh.C.

Referenced by BuildFaceConnectivity(), Rocon::burnout(), Mesh::BSExtent< T >::CreateUnstructuredMesh(), Inverse(), InverseDegenerate(), main(), Mesh::Partition::Read(), test(), and TRAIL_FD2FE_WinCreate2().

246 { _nelem = this->size();};

Mesh::Connectivity::_nelem

IndexType _nelem

Definition: Mesh.H:339

Here is the caller graph for this function:

void SyncSizes ( )

Definition at line 281 of file Mesh.C.

References i.

Referenced by BuildFaceConnectivity(), main(), TRAIL_FD2FE_WinCreate2(), Mesh::writeVtkData(), and writeVtkData().

                                   {
     _sizes.resize(_nelem);
     for(IndexType i = 0;i < _nelem;i++){
       _sizes[i] = (*this)[i].size();
       //        std::vector<IndexType> tmp((*this)[i]);
       //        ((*this)[i].swap(tmp));
     }
   };

Here is the caller graph for this function:

void Truncate ( )

Definition at line 257 of file Mesh.C.

Referenced by main().

   {
     Connectivity::iterator ti = this->begin();
     while(ti != this->end()){
       if(ti->empty()){
         ti = this->erase(ti);
         _nelem--;
       }
       else
         ti++;
     }
   };

Here is the caller graph for this function:

Friends And Related Function Documentation

std::ostream& operator<<	(	std::ostream &	oSt,
		const Connectivity &	ec
	)

friend

Definition at line 2146 of file Mesh.C.

   {
     oSt << std::setiosflags(std::ios::left) << ec.size();
     if(ec.size() == 0) return(oSt);
     oSt << "\n";
     Mesh::Connectivity::const_iterator ci = ec.begin();
     while(ci != ec.end()){
       std::vector<IndexType>::const_iterator ni = ci->begin();
       while(ni != ci->end()){
         oSt << *ni++;
         if(ni != ci->end())
           oSt << "\t";
       }
       ci++;
       if(ci != ec.end())
         oSt << "\n";
     }
     return(oSt);
   }

std::istream& operator>>	(	std::istream &	iSt,
		Mesh::Connectivity &	ec
	)

friend

Definition at line 2085 of file Mesh.C.

   {
     std::string line;
     std::getline(iSt,line);
     std::istringstream Istr(line);
     IndexType nelem = 0;
     Istr >> nelem;
     if(nelem > 0){
       ec.Resize(nelem);
       ec._nelem = nelem;
       for(IndexType i = 0;i < nelem;i++){
         std::getline(iSt,line);
         std::istringstream Istr2(line);
         IndexType node;
         ec[i].reserve(8);
         while(Istr2 >> node)
           ec[i].push_back(node);
         std::vector<Mesh::IndexType>(ec[i]).swap(ec[i]);
       }
     }
     return(iSt);
   }

Member Data Documentation

IndexType _nelem

private

Definition at line 339 of file Mesh.H.

Referenced by BreadthFirstRenumber(), Element(), Esize(), GetAdjacent(), GetNeighborhood(), Inverse(), Nelem(), and Mesh::operator>>().

std::vector<IndexType> _sizes

private

Definition at line 340 of file Mesh.H.

Referenced by Esize(), and main().

The documentation for this class was generated from the following files:

Public Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation