shells/driverCC/SElementFunctors.h

Go to the documentation of this file.

// -*- C++ -*- 
//
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
//                                   Fehmi Cirak
//                        California Institute of Technology
//                           (C) 2004 All Rights Reserved
//
// <LicenseText>
//
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
#ifndef SELEMENTFUNCTORS_H
#define SELEMENTFUNCTORS_H
#include "../fem/definitions.h"
#include "../fem/selement.h"
#include "../fem/internalStorage.h"

#include "SVertexFunctors.h"

#include <vector>
#include <functional>


namespace shells {
    template<typename Inserter>
    struct SElementTriangleVertices;
    template<typename Inserter, typename OP>
    struct SElementTriangleCollector;
    template<typename Inserter, typename OP>
    struct SElementTriangleAverage;

    template <typename Inserter>
    struct SELementInternalDataAverage;
    template <typename Inserter>
    struct SELementInternalDataCollect;
    template <typename IT>
    class SELementInternalDataDistrib;
    
    struct SElementOneNeighborhood;
}


namespace shells {

template<typename Inserter>
struct SElementTriangleVertices  : 
    public std::binary_function<shells::SElement *, Inserter, void> {
public:
    // insert the three pointers to the triangle vertices into inserter

#if defined(_AIX)    
    static const std::size_t numVert; // IBM compiler workaround
#else
    static const std::size_t numVert = 3; // each element has three vertices
#endif

    void operator()(shells::SElement *element, Inserter ins) const 
        {
            for (unsigned i=0; i<numVert; ++i) {
                *ins++ = element->vtx[i];
            }
        }
};

#if defined(_AIX)
// IBM compiler workaround
template<typename Inserter>
const std::size_t SElementTriangleVertices<Inserter>::numVert = 3;
#endif



template<typename Inserter, typename OP=shells::SVertexCoordinate>
struct SElementTriangleCollector  : 
    public std::binary_function<shells::SElement *, Inserter, void> {
public:
    // collect the data at the triangle vertices (default coordinates)
    
    void operator()(shells::SElement *element, Inserter ins) const
        {
            const std::size_t numVert = SElementTriangleVertices<Inserter>::numVert; 

            SVertex *vtx[numVert]; 
            SElementTriangleVertices<SVertex **> getVertices;
            getVertices(element, vtx);

            OP getData;
            for (std::size_t ivtx=0; ivtx<numVert; ++ivtx) {

                // insert data to ins
                typename OP::DataType *data = getData(vtx[ivtx]);
                for (std::size_t dim=0; dim<OP::numVar; ++dim) {
                    *ins++ = data[dim];
                }
            }
        }
};


template<typename Inserter, typename OP=shells::SVertexCoordinate>
struct SElementTriangleAverage  : 
    public std::binary_function<shells::SElement *, Inserter, void> {
public:
    // compute the average of triangle data (default coordinates)
    
    void operator()(shells::SElement *element, Inserter ins) const
        {
            const std::size_t numVert = SElementTriangleVertices<Inserter>::numVert;

            SVertex *vtx[numVert]; 
            SElementTriangleVertices<SVertex **> getVertices;
            getVertices(element, vtx);

            OP getData;
            typename OP::DataType average[OP::numVar];
            std::size_t numVar = OP::numVar;

            for (std::size_t dim=0; dim<numVar; ++dim) {
                average[dim] = 0.0;
            }
                
            for (std::size_t ivtx=0; ivtx<numVert; ++ivtx) {
                typename OP::DataType *data = getData(vtx[ivtx]);
                for (std::size_t dim=0; dim<OP::numVar; ++dim) {
                    average[dim] += data[dim];
                }
            }
                            
            for (std::size_t dim=0; dim<numVar; ++dim) {
                *ins++ = average[dim]/3.0;
            }
        }
};


template <typename Inserter>
struct SELementInternalDataAverage : 
        public std::binary_function<shells::SElement *, Inserter, void> {
    void operator()(shells::SElement *element, Inserter ins) const 
        {           
            double stress[9];
            const int maxSize = 20;
            double internal[maxSize];
            
            int size = shells::getNumInternal(element->matStorage);
            assert(size<maxSize);
            shells::averageInternalStorage(element->matStorage, stress, internal, maxSize);
            
            // don't store the stress for the moment
            for (unsigned i=0; i<static_cast<unsigned>(size); ++i) {
                *ins++ = internal[i];
            }
            
            return;
        }    
};


template <typename Inserter>
struct SELementInternalDataCollect : 
        public std::binary_function<shells::SElement *, Inserter, void> {
    void operator()(shells::SElement *element, Inserter ins) const 
        {           
            int size;
            double *data;
            
            shells::selementPtrToHistory(element, &data, &size);
            
            for (unsigned i=0; i<static_cast<unsigned>(size); ++i) {
                *ins++ = *data++;
            }
            
            return;
        }    
};
    
                

template <typename IT>
class SELementInternalDataDistrib :
        public std::unary_function<shells::SElement *, void > {
public:     
    SELementInternalDataDistrib(IT begin, IT end):_begin(begin), _end(end){}
    
    void operator()(shells::SElement * element) 
        {                   
            double *dummy;
            int size;              
            shells::selementPtrToHistory(element, &dummy, &size);
            _tmpCont.resize(size);              
            std::copy(_begin, _begin+size, _tmpCont.begin());
            
            shells::selementResetHistory(element, &(_tmpCont[0]));                  
            
            // advance begin iterator by the size of internal data size
            std::advance(_begin, static_cast<unsigned>(size));              
        }
    
private:
    IT           _begin;
    const IT     _end;
    
    std::vector<double> _tmpCont;
};
        
} // namespace shells


namespace shells {
    // pair for collecting elements as well as vertices
    typedef std::pair<std::back_insert_iterator<std::vector<shells::SElementS*> >,
                      std::back_insert_iterator<std::vector<shells::SVertexS*> > >  
                                                                InserterSElemSVtx;
}



struct shells::SElementOneNeighborhood :
    public std::binary_function<shells::SElementS *, shells::InserterSElemSVtx , void> {
    // find all the elements and vertices in *element's one neigborhood 
    // all elements except *element are inserted in inserters.first
    // vertices are inserted in inserters.second
    void operator()(shells::SElementS *element, shells::InserterSElemSVtx inserters) const;
};

#endif

---