integration_info.h

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ `
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:         BSD License
//                   Kratos default license: kratos/license.txt
//
 
#if !defined(KRATOS_INTEGRATION_INFO_H_INCLUDED )
#define  KRATOS_INTEGRATION_INFO_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "includes/define.h"
#include "geometries/geometry_data.h"
#include "containers/data_value_container.h"
#include "containers/flags.h"
 
namespace Kratos
{
 
 
/* Within this class distinct information of integration can be
 * stored and processed.
 */
class KRATOS_API(KRATOS_CORE) IntegrationInfo : public Flags
{
public:
 
    KRATOS_CLASS_POINTER_DEFINITION(IntegrationInfo);
 
    typedef typename Point::IndexType SizeType;
    typedef typename Point::IndexType IndexType;
 
    typedef GeometryData::IntegrationMethod IntegrationMethod;
 
 
    KRATOS_DEFINE_LOCAL_FLAG(DO_NOT_CREATE_TESSELLATION_ON_SLAVE);
 
 
    enum class QuadratureMethod
    {
        Default,
        GAUSS,
        EXTENDED_GAUSS,
        GRID
    };
 
 
    IntegrationInfo(SizeType LocalSpaceDimension,
        IntegrationMethod ThisIntegrationMethod);
 
    IntegrationInfo(SizeType LocalSpaceDimension,
        SizeType NumberOfIntegrationPointsPerSpan,
        QuadratureMethod ThisQuadratureMethod = QuadratureMethod::GAUSS);
 
    IntegrationInfo(
        const std::vector<SizeType>& NumberOfIntegrationPointsPerSpanVector,
        const std::vector<QuadratureMethod>& ThisQuadratureMethodVector);
 
 
    SizeType LocalSpaceDimension()
    {
        return mNumberOfIntegrationPointsPerSpanVector.size();
    }
 
 
    void SetIntegrationMethod(
        IndexType DimensionIndex,
        IntegrationMethod ThisIntegrationMethod);
 
    SizeType GetNumberOfIntegrationPointsPerSpan(IndexType DimensionIndex) const;
 
    void SetNumberOfIntegrationPointsPerSpan(IndexType DimensionIndex,
        SizeType NumberOfIntegrationPointsPerSpan);
 
    QuadratureMethod GetQuadratureMethod(IndexType DimensionIndex) const
    {
        return mQuadratureMethodVector[DimensionIndex];
    }
 
    void SetQuadratureMethod(IndexType DimensionIndex,
        QuadratureMethod ThisQuadratureMethod);
 
    /* returns the IntegrationMethod to
     * corresponding to the direction index.
     */
    IntegrationMethod GetIntegrationMethod(
        IndexType DimensionIndex) const;
 
    /* Evaluates the corresponding IntegrationMethod to 
     * the number of points and the quadrature method.
     */
    static IntegrationMethod GetIntegrationMethod(
        SizeType NumberOfIntegrationPointsPerSpan,
        QuadratureMethod ThisQuadratureMethod)
    {
        switch (NumberOfIntegrationPointsPerSpan) {
        case 1:
            if (ThisQuadratureMethod == QuadratureMethod::GAUSS) {
                return IntegrationMethod::GI_GAUSS_1;
            }
            else {
                return IntegrationMethod::GI_EXTENDED_GAUSS_1;
            }
            break;
        case 2:
            if (ThisQuadratureMethod == QuadratureMethod::GAUSS) {
                return IntegrationMethod::GI_GAUSS_2;
            }
            else {
                return IntegrationMethod::GI_EXTENDED_GAUSS_2;
            }
            break;
        case 3:
            if (ThisQuadratureMethod == QuadratureMethod::GAUSS) {
                return IntegrationMethod::GI_GAUSS_3;
            }
            else {
                return IntegrationMethod::GI_EXTENDED_GAUSS_3;
            }
            break;
        case 4:
            if (ThisQuadratureMethod == QuadratureMethod::GAUSS) {
                return IntegrationMethod::GI_GAUSS_4;
            }
            else {
                return IntegrationMethod::GI_EXTENDED_GAUSS_4;
            }
            break;
        case 5:
            if (ThisQuadratureMethod == QuadratureMethod::GAUSS) {
                return IntegrationMethod::GI_GAUSS_5;
            }
            else {
                return IntegrationMethod::GI_EXTENDED_GAUSS_5;
            }
            break;
        case 0:
            return IntegrationMethod::NumberOfIntegrationMethods;
            break;
        }
        KRATOS_WARNING("Evaluation of Integration Method")
            << "Chosen combination of number of points per span and quadrature method does not has a corresponding IntegrationMethod in the KRATOS core."
            << "NumberOfIntegrationPointsPerSpan: " << NumberOfIntegrationPointsPerSpan << std::endl;
        return IntegrationMethod::NumberOfIntegrationMethods;
    }
 
 
    std::string Info() const override
    {
        std::stringstream buffer;
        buffer << " Integration info with local space dimension: " << mNumberOfIntegrationPointsPerSpanVector.size()
            << " and number of integration points per spans: " << mNumberOfIntegrationPointsPerSpanVector;
        return buffer.str();
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << " Integration info with local space dimension: " << mNumberOfIntegrationPointsPerSpanVector.size()
            << " and number of integration points per spans: " << mNumberOfIntegrationPointsPerSpanVector;
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
        rOStream << " Integration info with local space dimension: " << mNumberOfIntegrationPointsPerSpanVector.size()
            << " and number of integration points per spans: " << mNumberOfIntegrationPointsPerSpanVector;
    }
 
 
private:
 
    std::vector<SizeType> mNumberOfIntegrationPointsPerSpanVector;
 
    std::vector<QuadratureMethod> mQuadratureMethodVector;
 
 
}; // Class IntegrationPoint
 
 
 
template<std::size_t TDimension, class TDataType, class TWeightType>
inline std::istream& operator >> (std::istream& rIStream, IntegrationInfo& rThis);
 
template<std::size_t TDimension, class TDataType, class TWeightType>
inline std::ostream& operator << (std::ostream& rOStream, const IntegrationInfo& rThis)
{
    rThis.PrintInfo(rOStream);
    rThis.PrintData(rOStream);
 
    return rOStream;
}
 
}  // namespace Kratos.
 
#endif // KRATOS_INTEGRATION_INFO_H_INCLUDED  defined