StatisticsPoint.h

Go to the documentation of this file.

//Copyright (c) 2013-2014, 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.

enum CG {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.set_zero(); 
        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 set_CG_type(const char* CG_type) {this->gb->set_CG_type(CG_type);}
    CG get_CG_type() const {return this->gb->get_CG_type();}
    void set_w2(Mdouble new_) {this->gb->set_w2(new_);}
    Mdouble get_w2() const {return this->gb->get_w2();}
    Mdouble get_w() const {return this->gb->get_w();}
    Mdouble get_cutoff() {return this->gb->get_cutoff();}
    Mdouble get_cutoff2() {return this->gb->get_cutoff2();}
    Mdouble get_xmaxStat() {return this->gb->get_xmaxStat();}
    Mdouble get_ymaxStat() {return this->gb->get_ymaxStat();}
    Mdouble get_zmaxStat() {return this->gb->get_zmaxStat();}
    Mdouble get_xminStat() {return this->gb->get_xminStat();}
    Mdouble get_yminStat() {return this->gb->get_yminStat();}
    Mdouble get_zminStat() {return this->gb->get_zminStat();}
    void get_n(int& nx_, int& ny_, int& nz_) {this->gb->get_n(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 set_CG_invvolume();
    int nonaveragedDim();
    double averagingVolume();
    Mdouble get_CG_invvolume() {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 set_Position(Vec3D new_) {this->Position = new_;}
    Vec3D get_Position() 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 get_distance2(const Vec3D &P);

    Mdouble dot(const Vec3D &P, const Vec3D &Q);

    Vec3D clearAveragedDirections(Vec3D P);

    Vec3D cross(Vec3D P, Vec3D &Q);

    Matrix3D MatrixCross(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; 
    
};