shells/driverCC/SVertexFunctors.h

Go to the documentation of this file.

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

#include <functional>
#include <cassert>
#include <cstdlib>

namespace shells {
    struct SVertexCoordinate;
    struct SVertexDisplacement;
    struct SVertexVelocity;
    struct SVertexAcceleration;
    struct SVertexMass;
    struct SVertexResidual;
    struct SVertexNodeID;

    template <typename Inserter, typename OP>
    struct SVertexCollector;
    template <typename IT, typename OP>
    class SVertexDistributor;
}



struct shells::SVertexCoordinate : 
    public std::unary_function<shells::SVertex *, double *> {
      
    typedef double DataType;
#if defined(_AIX)
    static const std::size_t numVar; // IBM compiler workaround
#else
    static const std::size_t numVar = 3;
#endif

    double * operator()(shells::SVertex* const vtx) const 
        {
            return vtx->xyz;
        }
};

#if defined(_AIX)
// IBM compiler workaround
const std::size_t shells::SVertexCoordinate::numVar = 3;
#endif



struct shells::SVertexDisplacement : 
    public std::unary_function<shells::SVertex *, double *> {
      
    typedef double DataType;
#if defined(_AIX)
    static const std::size_t numVar; // IBM compiler workaround
#else
    static const std::size_t numVar = 3;
#endif

    double * operator()(shells::SVertex* const vtx) const 
        {
            return vtx->disp;
        }
};

#if defined(_AIX)
// IBM compiler workaround
const std::size_t shells::SVertexDisplacement::numVar = 3;
#endif



struct shells::SVertexVelocity : 
    public std::unary_function<shells::SVertex *, double *> {
      
    typedef double DataType;
#if defined(_AIX)
    static const std::size_t numVar; // IBM compiler workaround
#else
    static const std::size_t numVar = 3;
#endif

    double * operator()(shells::SVertex* const vtx) const 
        {
            return vtx->vel;
        }
};

#if defined(_AIX)
// IBM compiler workaround
const std::size_t shells::SVertexVelocity::numVar = 3;
#endif



struct shells::SVertexAcceleration : 
    public std::unary_function<shells::SVertex *, double *> {
      
    typedef double DataType;
#if defined(_AIX)
    static const std::size_t numVar; // IBM compiler workaround
#else
    static const std::size_t numVar = 3;
#endif

    double * operator()(shells::SVertex* const vtx) const 
        {
            return vtx->acc;
        }
};

#if defined(_AIX)
// IBM compiler workaround
const std::size_t shells::SVertexAcceleration::numVar = 3;
#endif



struct shells::SVertexMass : 
    public std::unary_function<shells::SVertex *, double *> {
    
    typedef double DataType;
#if defined(_AIX)
    static const std::size_t numVar; // IBM compiler workaround
#else
    static const std::size_t numVar = 1;
#endif

    double * operator()(shells::SVertex* const vtx) const 
        {
            return &(vtx->mass);
        }
};

#if defined(_AIX)
// IBM compiler workaround
const std::size_t shells::SVertexMass::numVar = 1;
#endif



struct shells::SVertexResidual : 
    public std::unary_function<shells::SVertex*, double *> {
      
    typedef double DataType;
#if defined(_AIX)
    static const std::size_t numVar; // IBM compiler workaround
#else
    static const std::size_t numVar = 3;
#endif

    double * operator()(shells::SVertex* const vtx) const 
        {
            return vtx->resi;
        }
};

#if defined(_AIX)
// IBM compiler workaround
const std::size_t shells::SVertexResidual::numVar = 3;
#endif



struct shells::SVertexNodeID : 
    public std::unary_function<shells::SVertex *, int> {
    
    typedef int DataType;
#if defined(_AIX)
    static const std::size_t numVar; // IBM compiler workaround
#else
    static const std::size_t numVar = 1;
#endif

    int * operator()(shells::SVertex* const vtx) const 
        {
            return &(vtx->number);
        }
};

#if defined(_AIX)
// IBM compiler workaround
const std::size_t shells::SVertexNodeID::numVar = 1;
#endif



namespace shells {

template <typename Inserter, typename OP>
struct SVertexCollector : 
    public std::binary_function<shells::SVertex *, Inserter, void > {
    
    void operator()(shells::SVertex * vtx, Inserter ins) const
        {
            OP op;
            typename OP::DataType *vtxVar = op(vtx);
            
            for (std::size_t i=0; i< OP::numVar; ++i) 
                {
                    *ins++ = *vtxVar++;
                }
        }
};



template <typename IT, typename OP>
class SVertexDistributor : 
    public std::unary_function<shells::SVertex *, void > {
public:    
    SVertexDistributor(IT begin, IT end):_begin(begin), _end(end) {}

    void operator()(shells::SVertex * vtx)
        {
            OP op;
            typename OP::DataType *vtxVar = op(vtx);
            
            for (std::size_t i=0; i< OP::numVar; ++i) 
                {
                    assert(_begin!=_end);
                    *vtxVar++ = *_begin++;
                }
        }
    
private:
    IT              _begin;
    const IT        _end;
};

} // namespace shells

#endif

---