StatisticsPoint.h

Go to the documentation of this file.

// This file is part of the MercuryDPM project (https://www.mercurydpm.org).
// Copyright (c), The MercuryDPM Developers Team. All rights reserved.
// License: BSD 3-Clause License; see the LICENSE file in the root directory.
 
#ifndef STATISTICSPOINT_H
#define STATISTICSPOINT_H
 
enum CG_TYPE
{
    HeavisideSphere, Gaussian, Polynomial
};
 
template<StatType T>
class StatisticsVector;
 
template<StatType T>
struct StatisticsPoint;
 
template<StatType T>
std::ostream& operator<<(std::ostream& os, const StatisticsPoint<T>& stat);
 
template<StatType T>
struct StatisticsPoint
{
public:
    
    //Constructors and Destructors  
    
    StatisticsPoint()
    {
        this->Position.setZero();
        mirrorParticle = -1;
        //~ this->set_zero(); 
    }
    
    StatisticsPoint(const StatisticsPoint& other)
    {
        *this = other;
        mirrorParticle = -1;
    }
    
    //set and get access functions
    static void set_gb(StatisticsVector<T>* new_gb)
    {
        gb = new_gb;
    }
    
    void setCGShape(const char* CG_type)
    {
        this->gb->setCGShape(CG_type);
    }
    
    CG_TYPE getCGShape() const
    {
        return this->gb->getCGShape();
    }
    
    void setCGWidth2(Mdouble new_)
    {
        this->gb->setCGWidth2(new_);
    }
    
    Mdouble getCGWidthSquared() const
    {
        return this->gb->getCGWidthSquared();
    }
    
    Mdouble getCGWidth() const
    {
        return this->gb->getCGWidth();
    }
    
    Mdouble getCutoff()
    {
        return this->gb->getCutoff();
    }
    
    Mdouble getCutoff2()
    {
        return this->gb->getCutoff2();
    }
    
    Mdouble getXMaxStat()
    {
        return this->gb->getXMaxStat();
    }
    
    Mdouble getYMaxStat()
    {
        return this->gb->getYMaxStat();
    }
    
    Mdouble getZMaxStat()
    {
        return this->gb->getZMaxStat();
    }
    
    Mdouble getXMinStat()
    {
        return this->gb->getXMinStat();
    }
    
    Mdouble getYMinStat()
    {
        return this->gb->getYMinStat();
    }
    
    Mdouble getZMinStat()
    {
        return this->gb->getZMinStat();
    }
    
    void getN(int& nx_, int& ny_, int& nz_)
    {
        this->gb->getN(nx_, ny_, nz_);
    }
    
    Mdouble evaluatePolynomial(Mdouble r)
    {
        return gb->evaluatePolynomial(r);
    }
    
    Mdouble evaluatePolynomialGradient(Mdouble r)
    {
        return gb->evaluatePolynomialGradient(r);
    }
    
    Mdouble evaluateIntegral(Mdouble n1, Mdouble n2, Mdouble t)
    {
        return gb->evaluateIntegral(n1, n2, t);
    }
    
    void setCGInverseVolume();
    
    int nonaveragedDim();
    
    double averagingVolume();
    
    Mdouble getCGInverseVolume()
    {
        return this->CG_invvolume;
    }
    
    void set_Gaussian_invvolume(int dim);
    
    double compute_Gaussian_invvolume(int dim);
    
    void set_Heaviside_invvolume();
    
    void set_Polynomial_invvolume(int dim);
    
    void setPosition(Vec3D new_)
    {
        this->Position = new_;
    }
    
    Vec3D getPosition() const
    {
        return this->Position;
    }
    
    friend std::ostream& operator<<<T>(std::ostream& os, const StatisticsPoint<T>& stat);
    
    void set_zero();
    
    StatisticsPoint<T> getSquared();
    
    inline StatisticsPoint<T>& operator=(const StatisticsPoint<T>& P);
    
    inline StatisticsPoint<T>& operator+=(const StatisticsPoint<T>& P);
    
    inline StatisticsPoint<T>& operator-=(const StatisticsPoint<T>& P);
    
    inline StatisticsPoint<T>& operator/=(const Mdouble a);
    
    inline void firstTimeAverage(const int n);
    
    Mdouble getDistanceSquaredNonAveraged(const Vec3D& P);
    
    Mdouble dotNonAveraged(const Vec3D& P, const Vec3D& Q);
    
    Vec3D clearAveragedDirections(Vec3D P);
    
    Vec3D crossNonAveraged(Vec3D P, Vec3D& Q);
    
    Matrix3D matrixCrossNonAveraged(Vec3D P, Matrix3D& Q);
    
    Mdouble CG_function(const Vec3D& PI);
    
    Mdouble CG_function_2D(const Vec3D& PI);
    
    Mdouble CG_function_1D(const Vec3D& PI);
    
    Vec3D CG_gradient(const Vec3D& P, const Mdouble phi);
    
    Vec3D CG_integral_gradient(Vec3D& P1, Vec3D& P2, Vec3D& P1_P2_normal, Mdouble P1_P2_distance);
    
    Mdouble CG_integral_gradient_1D(Vec3D& P1, Vec3D& P2, Vec3D& P1_P2_normal, Mdouble P1_P2_distance);
    
    Mdouble CG_integral(Vec3D& P1, Vec3D& P2, Vec3D& P1_P2_normal, Mdouble P1_P2_distance, Vec3D& rpsi);
    
    Mdouble CG_integral_2D(Vec3D& P1, Vec3D& P2, Vec3D& P1_P2_normal, Mdouble P1_P2_distance, Mdouble& rpsi_scalar);
    
    Mdouble CG_integral_1D(Vec3D& P1, Vec3D& P2, Vec3D& P1_P2_normal, Mdouble P1_P2_distance, Mdouble& rpsi_scalar);
    
    std::string print() const;
    
    std::string print_sqrt() const;
    
    std::string write_variable_names();
    
    std::string write() const;
 
public:
    //Values of macroscopical fields at Position
    Mdouble Nu;
    Mdouble Density;
    Vec3D Momentum;
    Vec3D DisplacementMomentum;
    MatrixSymmetric3D Displacement;
    MatrixSymmetric3D MomentumFlux;
    MatrixSymmetric3D DisplacementMomentumFlux;
    Vec3D EnergyFlux;
    Matrix3D NormalStress;
    Matrix3D TangentialStress;
    Vec3D NormalTraction;
    Vec3D TangentialTraction;
    MatrixSymmetric3D Fabric;
    Vec3D CollisionalHeatFlux;
    Mdouble Dissipation;
    Mdouble Potential;
    
    Vec3D LocalAngularMomentum;
    Matrix3D LocalAngularMomentumFlux;
    Matrix3D ContactCoupleStress;
    
    Mdouble CG_invvolume;
    
    int mirrorParticle;
 
private:
    static StatisticsVector<T>* gb;
    Vec3D Position;
    
};
 
#endif