StatisticsPoint.h

Go to the documentation of this file.

//Copyright (c) 2013-2023, The MercuryDPM Developers Team. All rights reserved.
//For the list of developers, see <http://www.MercuryDPM.org/Team>.
//
//Redistribution and use in source and binary forms, with or without
//modification, are permitted provided that the following conditions are met:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name MercuryDPM nor the
//    names of its contributors may be used to endorse or promote products
//    derived from this software without specific prior written permission.
//
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
//ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
//WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
//DISCLAIMED. IN NO EVENT SHALL THE MERCURYDPM DEVELOPERS TEAM BE LIABLE FOR ANY
//DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
//(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
//ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
//(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
#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