quadrature.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
//  Main authors:    Pooyan Dadvand
//
//
 
#if !defined(KRATOS_QUADRATURE_H_INCLUDED )
#define  KRATOS_QUADRATURE_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "integration/integration_point.h"
 
 
namespace Kratos
{
template<std::size_t TOrder>
struct Pow
{
    static inline std::size_t Value(std::size_t X)
    {
        return X * Pow<TOrder - 1>::Value(X);
    }
};
 
template<>
struct Pow<1>
{
    static inline std::size_t Value(std::size_t X)
    {
        return X;
    }
};
 
 
 
 
 
 
 
template<class TQuadraturePointsType, std::size_t TDimension = TQuadraturePointsType::Dimension, class TIntegrationPointType = IntegrationPoint<TDimension> >
class Quadrature
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(Quadrature);
 
    typedef TIntegrationPointType IntegrationPointType;
 
    typedef std::vector<IntegrationPointType> IntegrationPointsArrayType;
 
    typedef typename TQuadraturePointsType::IntegrationPointsArrayType InitialIntegrationPointsArrayType;
 
    typedef typename IntegrationPointType::PointType PointType;
 
    typedef std::size_t SizeType;
 
    typedef std::size_t IndexType;
 
 
    Quadrature() {}
 
    Quadrature(Quadrature const& rOther) {}
 
    virtual ~Quadrature() {}
 
 
 
    Quadrature& operator=(Quadrature const& rOther) {}
 
 
 
    static SizeType IntegrationPointsNumber()
    {
        return Pow<TDimension - TQuadraturePointsType::Dimension + 1>::Value(TQuadraturePointsType::IntegrationPointsNumber());
    }
 
    static const IntegrationPointsArrayType& IntegrationPoints()
    {
        return msIntegrationPointsVector;
    }
 
    static const IntegrationPointsArrayType GenerateIntegrationPoints()
    {
        IntegrationPointsArrayType results;
        IntegrationPoints(results, Quadrature<TQuadraturePointsType, TDimension, TIntegrationPointType>());
        return results;
    }
 
    template<class TIntegrationPointsArrayType>
    static void IntegrationPoints(TIntegrationPointsArrayType& Result,
                                          Quadrature<TQuadraturePointsType, TDimension, TIntegrationPointType> const& Dummy)
    {
        typename Quadrature<TQuadraturePointsType, TDimension - 1, TIntegrationPointType>::IntegrationPointsArrayType points;
        Quadrature<TQuadraturePointsType, TDimension - 1, TIntegrationPointType>::IntegrationPoints(points, Quadrature<TQuadraturePointsType, TDimension - 1, TIntegrationPointType>());
 
        const auto integration_points = TQuadraturePointsType::IntegrationPoints();
        for(SizeType i = 0 ; i < TQuadraturePointsType::IntegrationPointsNumber() ; i++)
            for(SizeType j = 0 ; j < points.size() ; j++)
            {
                IntegrationPointType temp(points[j]);
                temp[TDimension -1] = integration_points[i].X();
                temp.Weight() *= integration_points[i].Weight();
                Result.push_back(temp);
            }
    }
 
    static void IntegrationPoints(IntegrationPointsArrayType& Result,
                                          Quadrature<TQuadraturePointsType, TQuadraturePointsType::Dimension, TIntegrationPointType> const& Dummy)
    {
        const auto integration_points = TQuadraturePointsType::IntegrationPoints();
        for(SizeType i = 0 ; i < TQuadraturePointsType::IntegrationPointsNumber() ; i++)
        {
            Result.push_back(integration_points[i]);
        }
    }
 
 
 
 
 
 
    virtual std::string Info() const
    {
        std::stringstream buffer;
        buffer << TDimension << " dimensional quadrature with " << IntegrationPointsNumber() << " integration points";
        return buffer.str();
    }
 
 
    virtual void PrintInfo(std::ostream& rOStream) const
    {
        rOStream << Info();
    }
 
    virtual void PrintData(std::ostream& rOStream) const
    {
        IndexType i;
        for(i = 0 ; i < msIntegrationPointsVector.size() - 1 ; i++)
            rOStream << msIntegrationPointsVector[i] << " , " << std::endl;
        rOStream << msIntegrationPointsVector[i];
    }
 
 
 
    template<class TOtherQuadraturePointsType, std::size_t TOtherDimension, class TOtherIntegrationPointType> friend class Quadrature;
 
 
 
protected:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
private:
 
 
 
    static const IntegrationPointsArrayType msIntegrationPointsVector;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
}; // Class Quadrature
 
#ifdef __SUNPRO_CC
template<class TQuadraturePointsType, std::size_t TDimension, class TIntegrationPointType>
const typename Quadrature<TQuadraturePointsType, TDimension, TIntegrationPointType>::IntegrationPointsArrayType
Quadrature<TQuadraturePointsType, TDimension, TIntegrationPointType>::msIntegrationPointsVector =
    Quadrature<TQuadraturePointsType, TDimension, TIntegrationPointType>::IntegrationPoints();
#else
template<class TQuadraturePointsType, std::size_t TDimension, class TIntegrationPointType> const typename Quadrature<TQuadraturePointsType, TDimension, TIntegrationPointType>::IntegrationPointsArrayType      Quadrature<TQuadraturePointsType, TDimension, TIntegrationPointType>::msIntegrationPointsVector( Quadrature<TQuadraturePointsType, TDimension, TIntegrationPointType>::IntegrationPoints());
#endif
 
 
 
 
template<class TQuadraturePointsType, std::size_t TDimension, class TIntegrationPointType>
inline std::istream& operator >> (std::istream& rIStream,
                                  Quadrature<TQuadraturePointsType, TDimension, TIntegrationPointType>& rThis);
 
template<class TQuadraturePointsType, std::size_t TDimension, class TIntegrationPointType>
inline std::ostream& operator << (std::ostream& rOStream,
                                  const Quadrature<TQuadraturePointsType, TDimension, TIntegrationPointType>& rThis)
{
    rThis.PrintInfo(rOStream);
    rOStream << std::endl;
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
 
}  // namespace Kratos.
 
#endif // KRATOS_QUADRATURE_H_INCLUDED  defined