shells/driverCC/MShell.h

Go to the documentation of this file.

// -*- C++ -*- 
//
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
//                                   Fehmi Cirak
//                        California Institute of Technology
//                           (C) 2004 All Rights Reserved
//
// <LicenseText>
//
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
#ifndef MSHELL_H
#define MSHELL_H
#include <map>
#include <vector>
#include <algorithm>
#include <cassert>
#include <istream>
#include <utility>


namespace shells {
    class MShell;
    struct SVertexS;
    struct SElementS;
    struct SEdgeS;
}


class shells::MShell {
public:
    MShell(std::istream& is);
    virtual ~MShell(){};

    enum ElementType {
        active = 0,          // active element
        parallelGhost = 1,   // ghost element at the processor boundary
        boundaryGhost = 2,   // ghost element at the domain boundary
        fragmentGhost = 3    // ghost element introduced during fragmentation
    };

    enum EdgeType {
        bothActive = 0,      // left and right element active
        boundary = 1,        // left element active, right element for bc enforcement
        procBoundary = 2     // edge on the processor boundary; both elements active
    };
    
    // virtual functions
    virtual void initializeComputation();
    virtual void resetActiveElements(const std::vector<unsigned>& newActiveID);
    virtual void verticesToBeCoupled(std::vector<shells::SVertexS *>& vertices);

    // generic functions for iteration over elements, vertices, and edges
    template <typename T>
    T iterateOverElements(const T& op, const ElementType& type);    
    template <typename T>
    T iterateOverEdges(const T& op, const EdgeType& type); 
    template <typename T>
    T iterateOverVertices(const T& op);

    // visualization
    template <typename VIZ>
    void visualizeMesh(VIZ& v);

    // accessors
    size_t numberOfElements(const ElementType& type) const;
    size_t numberOfVertices() const {return _vertices.size();} 

// copy and assignment constructors    
private:
    MShell(const MShell &);
    const MShell & operator=(const MShell &);

// protected data members
// todo: make them private and provide accessors
protected:
    typedef std::vector<shells::SElementS * >        _SElementCont; 
    typedef std::map<ElementType, _SElementCont>     _SElementTypeCont;
    typedef _SElementCont::iterator                  _SElementIt; 

    typedef std::vector<shells::SEdgeS * >           _SEdgeCont; 
    typedef std::map<EdgeType, _SEdgeCont>           _SEdgeTypeCont;
    typedef _SEdgeCont::iterator                     _SEdgeIt; 
        
    typedef std::vector<shells::SVertexS *>          _VertexCont;
    typedef _VertexCont::iterator                    _VertexIt;
    
    // map to the element vectors
    _SElementTypeCont                                _elements;

    // vertex vector
    _VertexCont                                      _vertices;

    // map to the edges
    _SEdgeTypeCont                                   _edges;    

// helper functions
private:
    void mirrorBoundaryElements();
    void addRemainingGhostElements();
    void createGhostElements();
    void readMesh(std::istream& is);
    void resetProcBoundaryBothActiveEdges(const _SElementCont& newActiveElem);
    void resetBoundaryEdges(_SElementCont& newActiveElem);
    void resetVertices();
};



// templated methods
namespace shells {

    template <typename T>
    T MShell::iterateOverElements(const T& op, const ElementType& type) 
    {
        _SElementTypeCont::iterator it;
        
        it = _elements.find(type);
        if (it==_elements.end()) assert(false); 
        
        _SElementIt begin = it->second.begin();
        _SElementIt end = it->second.end();    

        return std::for_each(begin, end, op);
    }
    
    template <typename T>
    T MShell::iterateOverEdges(const T& op, const EdgeType& type) 
    {
        _SEdgeTypeCont::iterator it;
        
        it = _edges.find(type);
        if (it==_edges.end()) assert(false); 
        
        _SEdgeIt begin = it->second.begin();
        _SEdgeIt end = it->second.end();    
        
        return std::for_each(begin, end, op);
    }    

    template <typename T>
    T MShell::iterateOverVertices(const T& op) 
    {
        _VertexIt begin = _vertices.begin();
        _VertexIt end = _vertices.end();
        return std::for_each(begin, end, op);
    }
 
    template <typename VIZ>
    void MShell::visualizeMesh(VIZ& v) 
    {
        v.initialize(this);
        iterateOverVertices(v);
        iterateOverElements(v, v.elementType());
        v.finalize(this);
    }    
}

#endif

/* End of file */

---