This class stores statistical values for a given spatial position; to be used in combination with StatisticsVector. More...

#include <StatisticsPoint.h>

Public Member Functions
	StatisticsPoint ()
	Constructor sets sensible values. More...

	StatisticsPoint (const StatisticsPoint &other)
	Copy constructor; simply copies everything. More...

void	setCGShape (const char *CG_type)
	see StatisticsVector::setCGShape More...

CG	getCGShape () const
	see StatisticsVector::getCGShape More...

void	setCGWidth2 (Mdouble new_)
	see StatisticsVector::setCGWidth2 More...

Mdouble	getCGWidthSquared () const
	see StatisticsVector::getCGWidthSquared More...

Mdouble	getCGWidth () const
	see StatisticsVector::getCGWidth More...

Mdouble	getCutoff ()
	see StatisticsVector::getCutoff More...

Mdouble	getCutoff2 ()
	see StatisticsVector::getCutoff2 More...

Mdouble	getXMaxStat ()
	see StatisticsVector::getXMaxStat More...

Mdouble	getYMaxStat ()
	see StatisticsVector::getYMaxStat More...

Mdouble	getZMaxStat ()
	see StatisticsVector::getZMaxStat More...

Mdouble	getXMinStat ()
	see StatisticsVector::getXMinStat More...

Mdouble	getYMinStat ()
	see StatisticsVector::getYMinStat More...

Mdouble	getZMinStat ()
	see StatisticsVector::getZMinStat More...

void	getN (int &nx_, int &ny_, int &nz_)
	see StatisticsVector::get_n More...

Mdouble	evaluatePolynomial (Mdouble r)
	see StatisticsVector::evaluatePolynomial More...

Mdouble	evaluatePolynomialGradient (Mdouble r)
	see StatisticsVector::evaluatePolynomialGradient More...

Mdouble	evaluateIntegral (Mdouble n1, Mdouble n2, Mdouble t)
	see StatisticsVector::evaluateIntegral More...

void	setCGInverseVolume ()
	sets CG_invvolume More...

int	nonaveragedDim ()

double	averagingVolume ()

Mdouble	getCGInverseVolume ()
	returns CG_invvolume More...

void	set_Gaussian_invvolume (int dim)
	sets CG_invvolume if CG_type=Gaussian More...

double	compute_Gaussian_invvolume (int dim)
	computes CG_invvolume if CG_type=Gaussian More...

void	set_Heaviside_invvolume ()
	sets CG_invvolume if CG_type=HeaviSideSphere More...

void	set_Polynomial_invvolume (int dim)
	sets CG_invvolume if CG_type=Polynomial More...

void	setPosition (Vec3D new_)
	sets Position More...

Vec3D	getPosition () const
	returns Position More...

void	set_zero ()
	Sets all statistical variables to zero. More...

StatisticsPoint< T >	getSquared ()
	Squares all statistical variables; needed for variance. More...

StatisticsPoint< T > &	operator= (const StatisticsPoint< T > &P)
	Defines a equal operator needed for copy constructor. More...

StatisticsPoint< T > &	operator+= (const StatisticsPoint< T > &P)
	Defines a plus operator needed to average values ( $\bar{v} = (\sum_{i=1}^n v_i)/n$ ) More...

StatisticsPoint< T > &	operator-= (const StatisticsPoint< T > &P)
	Defines a plus operator needed to calculate variance. More...

StatisticsPoint< T > &	operator/= (const Mdouble a)
	Defines a division operator needed to average values ( $\bar{v} = (\sum_{i=1}^n v_i)/n$ ) More...

void	firstTimeAverage (const int n)
	Defines a division operator needed to time-average values (because the displacement does not have a value at the first timestep, this is slightly different than /=) More...

Mdouble	getDistanceSquaredNonAveraged (const Vec3D &P)
	returns the coarse graining distance in the coordinates that are not averaged about More...

Mdouble	dotNonAveraged (const Vec3D &P, const Vec3D &Q)
	Returns the dot product of two vectors in the coordinates that are not averaged about. More...

Vec3D	clearAveragedDirections (Vec3D P)
	Returns a vector where the averaged directions are zero. More...

Vec3D	crossNonAveraged (Vec3D P, Vec3D &Q)
	Returns the cross product of two vectors in the coordinates that are not averaged about. More...

Matrix3D	matrixCrossNonAveraged (Vec3D P, Matrix3D &Q)
	Returns the cross product of two vectors in the coordinates that are not averaged about. More...

Mdouble	CG_function (const Vec3D &PI)
	Returns the value of the course graining function phi(P,PI) More...

Mdouble	CG_function_2D (const Vec3D &PI)
	returns the value of the course graining function phi(P,PI) averaged along a line More...

Mdouble	CG_function_1D (const Vec3D &PI)
	Returns the value of the course graining function phi(P,PI) averaged along a plane. More...

Vec3D	CG_gradient (const Vec3D &P, const Mdouble phi)
	gradient of phi More...

Vec3D	CG_integral_gradient (Vec3D &P1, Vec3D &P2, Vec3D &P1_P2_normal, Mdouble P1_P2_distance)
	gradient of phi More...

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)
	Returns the value of the coarse graining integral $\psi(P,PI,PJ) = \int_0^1 \phi(P - PI + s PJ) ds$ . More...

Mdouble	CG_integral_2D (Vec3D &P1, Vec3D &P2, Vec3D &P1_P2_normal, Mdouble P1_P2_distance, Mdouble &rpsi_scalar)
	Returns the value of the coarse graining integral $\psi(P,PI,PJ) = \int_0^1 \phi(P - PI + s PJ) ds$ averaged along a line. More...

Mdouble	CG_integral_1D (Vec3D &P1, Vec3D &P2, Vec3D &P1_P2_normal, Mdouble P1_P2_distance, Mdouble &rpsi_scalar)
	Returns the value of the coarse graining integral $\psi(P,PI,PJ) = \int_0^1 \phi(P - PI + s PJ) ds$ averaged along a plane. More...

std::string	print () const
	Outputs statistical variables in human-readable format. More...

std::string	print_sqrt () const
	Outputs root of statistical variables in human-readable format. More...

std::string	write_variable_names ()
	Outputs names of statistical variables in computer-readable format. More...

std::string	write () const
	Outputs statistical variables in computer-readable format. More...

template<>
int	nonaveragedDim ()

template<>
int	nonaveragedDim ()

template<>
int	nonaveragedDim ()

template<>
int	nonaveragedDim ()

template<>
int	nonaveragedDim ()

template<>
int	nonaveragedDim ()

template<>
int	nonaveragedDim ()

template<>
int	nonaveragedDim ()

template<>
int	nonaveragedDim ()

template<>
int	nonaveragedDim ()

template<>
int	nonaveragedDim ()

template<>
int	nonaveragedDim ()

template<>
int	nonaveragedDim ()

template<>
int	nonaveragedDim ()

template<>
double	averagingVolume ()

template<>
double	averagingVolume ()

template<>
double	averagingVolume ()

template<>
double	averagingVolume ()

template<>
double	averagingVolume ()

template<>
double	averagingVolume ()

template<>
double	averagingVolume ()

template<>
double	averagingVolume ()

template<>
double	averagingVolume ()

template<>
double	averagingVolume ()

template<>
double	averagingVolume ()

template<>
double	averagingVolume ()

template<>
double	averagingVolume ()

template<>
double	averagingVolume ()

template<>
Mdouble	CG_function (const Vec3D &PI)

template<>
Mdouble	CG_function (const Vec3D &PI)

template<>
Mdouble	CG_function (const Vec3D &)

template<>
Mdouble	CG_function (const Vec3D &PI)

template<>
Mdouble	CG_function (const Vec3D &)

template<>
Mdouble	CG_function (const Vec3D &PI)

template<>
Mdouble	CG_function (const Vec3D &PI)

template<>
Mdouble	CG_function (const Vec3D &PI)

template<>
Mdouble	CG_function (const Vec3D &PI)

template<>
Mdouble	CG_function (const Vec3D &PI)

template<>
Mdouble	CG_function (const Vec3D &PI)

template<>
Mdouble	CG_function (const Vec3D &)

template<>
Vec3D	CG_gradient (const Vec3D &P, const Mdouble phi)

template<>
Vec3D	CG_gradient (const Vec3D &P, const Mdouble phi)

template<>
Vec3D	CG_gradient (const Vec3D &P, const Mdouble phi)

template<>
Vec3D	CG_gradient (const Vec3D &P, const Mdouble phi)

template<>
Vec3D	CG_gradient (const Vec3D &P, const Mdouble phi)

template<>
Vec3D	CG_gradient (const Vec3D &P, const Mdouble phi)

template<>
Vec3D	CG_gradient (const Vec3D &, const Mdouble)

template<>
Mdouble	CG_integral (Vec3D &P1, Vec3D &P2, Vec3D &P1_P2_normal, Mdouble P1_P2_distance, Vec3D &rpsi)

template<>
Mdouble	CG_integral (Vec3D &P1, Vec3D &P2, Vec3D &, Mdouble, Vec3D &rpsi UNUSED)

template<>
Mdouble	CG_integral (Vec3D &, Vec3D &, Vec3D &, Mdouble, Vec3D &rpsi UNUSED)

template<>
Mdouble	CG_integral (Vec3D &P1, Vec3D &P2, Vec3D &, Mdouble, Vec3D &rpsi UNUSED)

template<>
Mdouble	CG_integral (Vec3D &, Vec3D &, Vec3D &, Mdouble, Vec3D &rpsi UNUSED)

template<>
Mdouble	CG_integral (Vec3D &P1, Vec3D &P2, Vec3D &P1_P2_normal, Mdouble P1_P2_distance, Vec3D &rpsi)

template<>
Mdouble	CG_integral (Vec3D &P1, Vec3D &P2, Vec3D &P1_P2_normal, Mdouble P1_P2_distance, Vec3D &rpsi)

template<>
Mdouble	CG_integral (Vec3D &P1, Vec3D &P2, Vec3D &P1_P2_normal, Mdouble P1_P2_distance, Vec3D &rpsi)

template<>
Mdouble	CG_integral (Vec3D &P1, Vec3D &P2, Vec3D &P1_P2_normal, Mdouble P1_P2_distance, Vec3D &rpsi)

template<>
Mdouble	CG_integral (Vec3D &P1, Vec3D &P2, Vec3D &P1_P2_normal, Mdouble P1_P2_distance, Vec3D &rpsi)

template<>
Mdouble	CG_integral (Vec3D &P1, Vec3D &P2, Vec3D &P1_P2_normal, Mdouble P1_P2_distance, Vec3D &rpsi)

template<>
Mdouble	CG_integral (Vec3D &P1, Vec3D &P2 UNUSED, Vec3D &P1_P2_normal UNUSED, Mdouble P1_P2_distance UNUSED, Vec3D &rpsi)

template<>
Vec3D	CG_integral_gradient (Vec3D &P1, Vec3D &P2, Vec3D &P1_P2_normal, Mdouble P1_P2_distance)

template<>
Mdouble	getDistanceSquaredNonAveraged (const Vec3D &P)

template<>
Mdouble	getDistanceSquaredNonAveraged (const Vec3D &P)

template<>
Mdouble	getDistanceSquaredNonAveraged (const Vec3D &P)

template<>
Mdouble	getDistanceSquaredNonAveraged (const Vec3D &P)

template<>
Mdouble	getDistanceSquaredNonAveraged (const Vec3D &P)

template<>
Mdouble	getDistanceSquaredNonAveraged (const Vec3D &P)

template<>
Mdouble	getDistanceSquaredNonAveraged (const Vec3D &)

template<>
Mdouble	dotNonAveraged (const Vec3D &P, const Vec3D &Q)

template<>
Mdouble	dotNonAveraged (const Vec3D &P, const Vec3D &Q)

template<>
Mdouble	dotNonAveraged (const Vec3D &P, const Vec3D &Q)

template<>
Mdouble	dotNonAveraged (const Vec3D &P, const Vec3D &Q)

template<>
Mdouble	dotNonAveraged (const Vec3D &P, const Vec3D &Q)

template<>
Mdouble	dotNonAveraged (const Vec3D &P, const Vec3D &Q)

template<>
Mdouble	dotNonAveraged (const Vec3D &, const Vec3D &)

template<>
Vec3D	clearAveragedDirections (Vec3D P)

template<>
Vec3D	clearAveragedDirections (Vec3D P)

template<>
Vec3D	clearAveragedDirections (Vec3D P)

template<>
Vec3D	clearAveragedDirections (Vec3D P)

template<>
Vec3D	clearAveragedDirections (Vec3D P)

template<>
Vec3D	clearAveragedDirections (Vec3D P)

template<>
Vec3D	clearAveragedDirections (Vec3D P UNUSED)

template<>
Vec3D	crossNonAveraged (Vec3D P, Vec3D &Q)

template<>
Vec3D	crossNonAveraged (Vec3D P, Vec3D &Q)

template<>
Vec3D	crossNonAveraged (Vec3D P, Vec3D &Q)

template<>
Vec3D	crossNonAveraged (Vec3D P UNUSED, Vec3D &Q UNUSED)

template<>
Vec3D	crossNonAveraged (Vec3D P UNUSED, Vec3D &Q UNUSED)

template<>
Vec3D	crossNonAveraged (Vec3D P UNUSED, Vec3D &Q UNUSED)

template<>
Vec3D	crossNonAveraged (Vec3D P UNUSED, Vec3D &Q UNUSED)

template<>
Matrix3D	matrixCrossNonAveraged (Vec3D P, Matrix3D &Q)

template<>
Matrix3D	matrixCrossNonAveraged (Vec3D P, Matrix3D &Q)

template<>
Matrix3D	matrixCrossNonAveraged (Vec3D P, Matrix3D &Q)

template<>
Matrix3D	matrixCrossNonAveraged (Vec3D P UNUSED, Matrix3D &Q UNUSED)

template<>
Matrix3D	matrixCrossNonAveraged (Vec3D P UNUSED, Matrix3D &Q UNUSED)

template<>
Matrix3D	matrixCrossNonAveraged (Vec3D P UNUSED, Matrix3D &Q UNUSED)

template<>
Matrix3D	matrixCrossNonAveraged (Vec3D P UNUSED, Matrix3D &Q UNUSED)

Static Public Member Functions
static void	set_gb (StatisticsVector< T > *new_gb)
	see StatisticsVector::setCGShape More...

Public Attributes
Mdouble	Nu
	Particle volume fraction, $\sum_i m_i/\rho_i \phi_i$ . More...

Mdouble	Density
	Density, $\sum_i m_i \phi_i$ . More...

Vec3D	Momentum
	Momentum, $\sum_i m_i v_{ia} \phi_i$ . More...

Vec3D	DisplacementMomentum
	Momentum from linear displacement, $\sum_i m_i u_{ia} \phi_i$ , where $\vec{u}_i=(\vec{r}_i(t)-\vec{r}_i(t-\tau))/\tau$ , with $\tau=savecount \Delta t$ the time intervall between outputs. More...

MatrixSymmetric3D	Displacement
	Linear displacement, $2/(2 \rho_i^2) \sum_{ij} m_i m_j \phi_j (v_{ija} \partial_b \phi_i + v_{ijb} \partial_a \phi_i)$ . More...

MatrixSymmetric3D	MomentumFlux
	Momentum flux, $\sum_i m_i v_{ia} v_{ib} \phi_i$ . More...

MatrixSymmetric3D	DisplacementMomentumFlux
	Momentum flux from linear displacement, $\sum_i m_i u_{ia} u_{ib} \phi_i$ . More...

Vec3D	EnergyFlux
	Energy flux, $2/2 \sum_i m_i v_{ia} v_{ia} v_{ib} \phi_i$ . More...

Matrix3D	NormalStress
	Stress from normal forces, $\sum_{ij} f^n_{ija} l_{ijb} \psi_{ij}$ . More...

Matrix3D	TangentialStress
	Stress from tangential forces, $\sum_{ij} f^t_{ija} l_{ijb} \psi_{ij}$ . More...

Vec3D	NormalTraction
	Traction from normal forces, $\sum_{ij} f^n_{ija} l_{ijb} \phi_i$ . More...

Vec3D	TangentialTraction
	Traction from tangential forces, $\sum_{ij} f^t_{ija} l_{ijb} \phi_i$ . More...

MatrixSymmetric3D	Fabric
	Fabric tensor, $\sum_{ij} m_i/\rho_i n_{ija} n_{ijb} \psi_{ij}$ . More...

Vec3D	CollisionalHeatFlux
	Heat flux from collisions, $\sum_{ij} (v_{ia}+v_ja)/2 f_{ija} l_{ijb} \psi_i$ . More...

Mdouble	Dissipation
	Dissipation form collisions, $\sum_{ij} (v_{ia}+v_ja)/2 f_{ija} \psi_i$ . More...

Mdouble	Potential
	Elastic energy $2/4 \sum_{ij} (k \delta_{ij}^2 +k^t {\delta^t_{ij}}^2) \phi_i$ . More...

Vec3D	LocalAngularMomentum

Matrix3D	LocalAngularMomentumFlux

Matrix3D	ContactCoupleStress

Mdouble	CG_invvolume
	Prefactor of CG function which depends on $w. More...

int	mirrorParticle
	indicates that a position is a (fake) particles used for periodic walls More...

Private Attributes
Vec3D	Position
	Position at which evaluation occurs. More...

Static Private Attributes
static StatisticsVector< T > *	gb
	Pointer to StatisticsVector (to obtain global parameters) More...

Friends
std::ostream &	operator (std::ostream &os, const StatisticsPoint< T > &stat)
	Outputs statistical variables to ostream. More...

Detailed Description

template<StatType T>
struct StatisticsPoint< T >

This class stores statistical values for a given spatial position; to be used in combination with StatisticsVector.

Definition at line 39 of file StatisticsPoint.h.

Constructor & Destructor Documentation

template<StatType T>

StatisticsPoint< T >::StatisticsPoint ( )

inline

Constructor sets sensible values.

Definition at line 53 of file StatisticsPoint.h.

References StatisticsPoint< T >::mirrorParticle, StatisticsPoint< T >::Position, and Vec3D::setZero().

     {
         this->Position.setZero();
         mirrorParticle = -1;
         //~ this->set_zero(); 
     }

template<StatType T>

StatisticsPoint< T >::StatisticsPoint ( const StatisticsPoint< T > & other )

inline

Copy constructor; simply copies everything.

Definition at line 61 of file StatisticsPoint.h.

References StatisticsPoint< T >::mirrorParticle.

     {
         *this = other;
         mirrorParticle = -1;
     }

Member Function Documentation

template<StatType T>

double StatisticsPoint< T >::averagingVolume ( )

Referenced by StatisticsPoint< T >::CG_integral_1D(), StatisticsPoint< T >::CG_integral_2D(), and StatisticsPoint< T >::setCGInverseVolume().

template<>

double StatisticsPoint< XYZ >::averagingVolume ( )

Definition at line 1036 of file StatisticsPoint.hcc.

 {
     return 1.0;
 }

template<>

double StatisticsPoint< XY >::averagingVolume ( )

Definition at line 1040 of file StatisticsPoint.hcc.

 {
     return ((gb->getSystemDimensions() != 3) ? (1.0) : (getZMaxStat() - getZMinStat()));
 }

template<>

double StatisticsPoint< XZ >::averagingVolume ( )

Definition at line 1044 of file StatisticsPoint.hcc.

 {
     return (getYMaxStat() - getYMinStat());
 }

template<>

double StatisticsPoint< YZ >::averagingVolume ( )

Definition at line 1048 of file StatisticsPoint.hcc.

 {
     return (getXMaxStat() - getXMinStat());
 }

template<>

double StatisticsPoint< X >::averagingVolume ( )

Definition at line 1052 of file StatisticsPoint.hcc.

 {
     return (getYMaxStat() - getYMinStat())
             * ((gb->getSystemDimensions() != 3) ? (1.0) : (getZMaxStat() - getZMinStat()));
 }

template<>

double StatisticsPoint< Y >::averagingVolume ( )

Definition at line 1057 of file StatisticsPoint.hcc.

 {
     return (getXMaxStat() - getXMinStat())
             * ((gb->getSystemDimensions() != 3) ? (1.0) : (getZMaxStat() - getZMinStat()));
 }

template<>

double StatisticsPoint< Z >::averagingVolume ( )

Definition at line 1062 of file StatisticsPoint.hcc.

 {
     return (getXMaxStat() - getXMinStat())
             * (getYMaxStat() - getYMinStat());
 }

template<>

double StatisticsPoint< O >::averagingVolume ( )

Definition at line 1067 of file StatisticsPoint.hcc.

 {
     return (getXMaxStat() - getXMinStat())
             * (getYMaxStat() - getYMinStat())
             * ((gb->getSystemDimensions() != 3) ? (1.0) : (getZMaxStat() - getZMinStat()));
 }

template<>

double StatisticsPoint< RAZ >::averagingVolume ( )

Definition at line 1073 of file StatisticsPoint.hcc.

 {
     exit(-1);
 }

template<>

double StatisticsPoint< AZ >::averagingVolume ( )

Definition at line 1077 of file StatisticsPoint.hcc.

 {
     exit(-1);
 }

template<>

double StatisticsPoint< RZ >::averagingVolume ( )

Definition at line 1081 of file StatisticsPoint.hcc.

 {
     exit(-1);
 }

template<>

double StatisticsPoint< RA >::averagingVolume ( )

Definition at line 1085 of file StatisticsPoint.hcc.

 {
     exit(-1);
 }

template<>

double StatisticsPoint< R >::averagingVolume ( )

Definition at line 1089 of file StatisticsPoint.hcc.

 {
     exit(-1);
 }

template<>

double StatisticsPoint< A >::averagingVolume ( )

Definition at line 1093 of file StatisticsPoint.hcc.

 {
     exit(-1);
 }

template<StatType T>

Mdouble StatisticsPoint< T >::CG_function ( const Vec3D & PI )

Returns the value of the course graining function phi(P,PI)

Definition at line 252 of file StatisticsPoint.hcc.

References StatisticsPoint< T >::evaluatePolynomial(), Gaussian, StatisticsPoint< T >::getCGInverseVolume(), StatisticsPoint< T >::getCGShape(), StatisticsPoint< T >::getCGWidthSquared(), StatisticsPoint< T >::getCutoff(), StatisticsPoint< T >::getCutoff2(), StatisticsPoint< T >::getDistanceSquaredNonAveraged(), HeavisideSphere, and Polynomial.

 {
     Mdouble dist2 = getDistanceSquaredNonAveraged(PI);
     if (getCGShape() == HeavisideSphere)
     {
         return (getCGWidthSquared() < dist2) ? 0.0 : getCGInverseVolume();
     }
     else if (getCGShape() == Gaussian)
     {
         return (getCutoff2() < dist2) ? 0.0 : getCGInverseVolume() * exp(-dist2 / (2.0 * getCGWidthSquared()));
     }
     else if (getCGShape() == Polynomial)
     {
         return (getCutoff2() < dist2) ? 0.0 : getCGInverseVolume() * evaluatePolynomial(sqrt(dist2) / getCutoff());
     }
     else
     {
         std::cerr << "error in CG_function" << std::endl;
         exit(-1);
     }
 }

template<>

Mdouble StatisticsPoint< RA >::CG_function ( const Vec3D & PI )

Definition at line 1098 of file StatisticsPoint.hcc.

 {
     return CG_function_2D(PI);
 }

template<>

Mdouble StatisticsPoint< RZ >::CG_function ( const Vec3D & PI )

Definition at line 1102 of file StatisticsPoint.hcc.

References Gaussian, besselFunc::I0(), mathsFunc::square(), Vec3D::X, Vec3D::Y, and Vec3D::Z.

 {
     Mdouble dist2 = getDistanceSquaredNonAveraged(PI);
     Mdouble R2 = mathsFunc::square(PI.X) + mathsFunc::square(PI.Y);
     Mdouble RI2 = mathsFunc::square(Position.X) + mathsFunc::square(Position.Y);
     Mdouble Z2 = mathsFunc::square(PI.Z - Position.Z);
     if (getCGShape() == Gaussian)
     {
         return (getCutoff2() < dist2) ? 0.0 : getCGInverseVolume()
                                                  * exp(-(R2 + RI2 + Z2) / (2.0 * getCGWidthSquared())) * besselFunc::I0(sqrt(R2 * RI2) / getCGWidthSquared());
     }
     else
     {
         std::cerr << "error in CG_function<RZ>" << std::endl;
         exit(-1);
     }
 }

template<>

Mdouble StatisticsPoint< AZ >::CG_function ( const Vec3D & )

Definition at line 1119 of file StatisticsPoint.hcc.

 {
     std::cerr << "error in CG_function<AZ>" << std::endl;
     exit(-1);
 }

template<>

Mdouble StatisticsPoint< R >::CG_function ( const Vec3D & PI )

Definition at line 1124 of file StatisticsPoint.hcc.

References Gaussian, besselFunc::I0(), mathsFunc::square(), Vec3D::X, and Vec3D::Y.

 {
     Mdouble dist2 = getDistanceSquaredNonAveraged(PI);
     Mdouble R2 = mathsFunc::square(PI.X) + mathsFunc::square(PI.Y);
     Mdouble RI2 = mathsFunc::square(Position.X) + mathsFunc::square(Position.Y);
     if (getCGShape() == Gaussian)
     {
         return (getCutoff2() < dist2) ? 0.0 : getCGInverseVolume()
                                                  * exp(-(R2 + RI2) / (2.0 * getCGWidthSquared())) * besselFunc::I0(sqrt(R2 * RI2) / getCGWidthSquared());
     }
     else
     {
         std::cerr << "error in CG_function<R>" << std::endl;
         exit(-1);
     }
 }

template<>

Mdouble StatisticsPoint< A >::CG_function ( const Vec3D & )

Definition at line 1140 of file StatisticsPoint.hcc.

 {
     std::cerr << "error in CG_function<A>" << std::endl;
     exit(-1);
 }

template<>

Mdouble StatisticsPoint< XY >::CG_function ( const Vec3D & PI )

Definition at line 1146 of file StatisticsPoint.hcc.

 {
     return CG_function_2D(PI);
 }

template<>

Mdouble StatisticsPoint< XZ >::CG_function ( const Vec3D & PI )

Definition at line 1150 of file StatisticsPoint.hcc.

 {
     return CG_function_2D(PI);
 }

template<>

Mdouble StatisticsPoint< YZ >::CG_function ( const Vec3D & PI )

Definition at line 1154 of file StatisticsPoint.hcc.

 {
     return CG_function_2D(PI);
 }

template<>

Mdouble StatisticsPoint< X >::CG_function ( const Vec3D & PI )

Definition at line 1158 of file StatisticsPoint.hcc.

 {
     return CG_function_1D(PI);
 }

template<>

Mdouble StatisticsPoint< Y >::CG_function ( const Vec3D & PI )

Definition at line 1162 of file StatisticsPoint.hcc.

 {
     return CG_function_1D(PI);
 }

template<>

Mdouble StatisticsPoint< Z >::CG_function ( const Vec3D & PI )

Definition at line 1166 of file StatisticsPoint.hcc.

 {
     return CG_function_1D(PI);
 }

template<>

Mdouble StatisticsPoint< O >::CG_function ( const Vec3D & )

Definition at line 1170 of file StatisticsPoint.hcc.

 {
     return getCGInverseVolume();
 }

template<StatType T>

Mdouble StatisticsPoint< T >::CG_function_1D ( const Vec3D & PI )

Returns the value of the course graining function phi(P,PI) averaged along a plane.

Definition at line 306 of file StatisticsPoint.hcc.

References StatisticsPoint< T >::evaluatePolynomial(), Gaussian, StatisticsPoint< T >::getCGInverseVolume(), StatisticsPoint< T >::getCGShape(), StatisticsPoint< T >::getCGWidthSquared(), StatisticsPoint< T >::getCutoff(), StatisticsPoint< T >::getCutoff2(), StatisticsPoint< T >::getDistanceSquaredNonAveraged(), HeavisideSphere, constants::pi, and Polynomial.

Referenced by StatisticsPoint< T >::CG_integral_1D(), and StatisticsPoint< T >::CG_integral_2D().

 {
     Mdouble dist2 = getDistanceSquaredNonAveraged(PI);
     if (getCGShape() == HeavisideSphere)
     {
         return (getCGWidthSquared() < dist2) ? 0.0 : (getCGInverseVolume() * constants::pi * (getCGWidthSquared() - dist2));
     }
     else if (getCGShape() == Gaussian)
     {
         return (getCutoff2() < dist2) ? 0.0 : getCGInverseVolume() * exp(-dist2 / (2.0 * getCGWidthSquared()));
     }
     else if (getCGShape() == Polynomial)
     {
         return (getCutoff2() < dist2) ? 0.0 : getCGInverseVolume() * evaluatePolynomial(sqrt(dist2) / getCutoff());
     }
     else
     {
         std::cerr << "error in CG_function_1D" << std::endl;
         exit(-1);
     }
 }

template<StatType T>

Mdouble StatisticsPoint< T >::CG_function_2D ( const Vec3D & PI )

returns the value of the course graining function phi(P,PI) averaged along a line

Todo:: the volume should be calculated in setCGInverseVolume

Definition at line 275 of file StatisticsPoint.hcc.

References StatisticsPoint< T >::evaluatePolynomial(), Gaussian, StatisticsPoint< T >::getCGInverseVolume(), StatisticsPoint< T >::getCGShape(), StatisticsPoint< T >::getCGWidthSquared(), StatisticsPoint< T >::getCutoff(), StatisticsPoint< T >::getCutoff2(), StatisticsPoint< T >::getDistanceSquaredNonAveraged(), HeavisideSphere, and Polynomial.

 {
     Mdouble dist2 = getDistanceSquaredNonAveraged(PI);
     if (getCGShape() == HeavisideSphere)
     {
         if (getCGWidthSquared() < dist2)
             return 0.0;
         else
         {
             Mdouble wn = sqrt(getCGWidthSquared() - dist2);
             return getCGInverseVolume() * 2.0 * wn;
             //return getCGInverseVolume()*(std::min(wn,gb->getObjectDistanceLeft()) +std::min(wn,gb->getObjectDistanceRight()));    
         }
     }
     else if (getCGShape() == Gaussian)
     {
         return (getCutoff2() < dist2) ? 0.0 : getCGInverseVolume() * exp(-dist2 / (2.0 * getCGWidthSquared()));
     }
     else if (getCGShape() == Polynomial)
     {
         return (getCutoff2() < dist2) ? 0.0 : getCGInverseVolume() * evaluatePolynomial(sqrt(dist2) / getCutoff());
     }
     else
     {
         std::cerr << "error in CG_function_2D" << std::endl;
         exit(-1);
     }
 }

template<StatType T>

Vec3D StatisticsPoint< T >::CG_gradient	(	const Vec3D &	P,
		const Mdouble	phi
	)

gradient of phi

Todo:: {Only implemented for Gaussian}

Definition at line 329 of file StatisticsPoint.hcc.

References StatisticsPoint< T >::evaluatePolynomialGradient(), Gaussian, StatisticsPoint< T >::getCGInverseVolume(), StatisticsPoint< T >::getCGShape(), StatisticsPoint< T >::getCGWidth(), StatisticsPoint< T >::getCGWidthSquared(), Vec3D::getLength(), Polynomial, and StatisticsPoint< T >::Position.

 {
     //CG_type_todo
     if (getCGShape() == Gaussian)
     {
         return (P - Position) * (phi / getCGWidthSquared());
     }
     else if (getCGShape() == Polynomial)
     {
         Mdouble r = Vec3D::getLength(Position - P) / getCGWidth();
         return getCGInverseVolume() * evaluatePolynomialGradient(r) / r / getCGWidthSquared() * (Position - P);
     }
     else
     {
         std::cerr << "error in CG_gradient" << std::endl;
         exit(-1);
     }
 }

template<>

Vec3D StatisticsPoint< YZ >::CG_gradient	(	const Vec3D &	P,
		const Mdouble	phi
	)

Definition at line 1175 of file StatisticsPoint.hcc.

References Gaussian, Vec3D::Y, and Vec3D::Z.

 {
     //CG_type_todo
     if (getCGShape() == Gaussian)
     {
         return Vec3D(0.0, P.Y - Position.Y, P.Z - Position.Z) * (phi / getCGWidthSquared());
     }
     else
     {
         std::cerr << "error in CG_gradient<YZ>" << std::endl;
         exit(-1);
     }
 }

template<>

Vec3D StatisticsPoint< XZ >::CG_gradient	(	const Vec3D &	P,
		const Mdouble	phi
	)

Definition at line 1188 of file StatisticsPoint.hcc.

References Gaussian, Vec3D::X, and Vec3D::Z.

 {
     //CG_type_todo
     if (getCGShape() == Gaussian)
     {
         return Vec3D(P.X - Position.X, 0.0, P.Z - Position.Z) * (phi / getCGWidthSquared());
     }
     else
     {
         std::cerr << "error in CG_gradient<XZ>" << std::endl;
         exit(-1);
     }
 }

template<>

Vec3D StatisticsPoint< XY >::CG_gradient	(	const Vec3D &	P,
		const Mdouble	phi
	)

Definition at line 1201 of file StatisticsPoint.hcc.

References Gaussian, Vec3D::X, and Vec3D::Y.

 {
     //CG_type_todo
     if (getCGShape() == Gaussian)
     {
         return Vec3D(P.X - Position.X, P.Y - Position.Y, 0.0) * (phi / getCGWidthSquared());
     }
     else
     {
         std::cerr << "error in CG_gradient<XY>" << std::endl;
         exit(-1);
     }
 }

template<>

Vec3D StatisticsPoint< X >::CG_gradient	(	const Vec3D &	P,
		const Mdouble	phi
	)

Definition at line 1215 of file StatisticsPoint.hcc.

References Gaussian, Polynomial, and Vec3D::X.

 {
     //CG_type_todo
     if (getCGShape() == Gaussian)
     {
         return Vec3D((P.X - Position.X) * (phi / getCGWidthSquared()), 0.0, 0.0);
     }
     else if (getCGShape() == Polynomial)
     {
         Mdouble r = fabs(Position.X - P.X) / getCGWidth();
         return Vec3D(getCGInverseVolume() * evaluatePolynomialGradient(r) / r / getCGWidthSquared() * (Position.X - P.X), 0, 0);
     }
     else
     {
         std::cerr << "error in CG_gradient<X>" << std::endl;
         exit(-1);
     }
 }

template<>

Vec3D StatisticsPoint< Y >::CG_gradient	(	const Vec3D &	P,
		const Mdouble	phi
	)

Definition at line 1233 of file StatisticsPoint.hcc.

References Gaussian, Polynomial, and Vec3D::Y.

 {
     //CG_type_todo
     if (getCGShape() == Gaussian)
     {
         return Vec3D(0.0, (P.Y - Position.Y) * (phi / getCGWidthSquared()), 0.0);
     }
     else if (getCGShape() == Polynomial)
     {
         Mdouble r = fabs(Position.Y - P.Y) / getCGWidth();
         return Vec3D(0, getCGInverseVolume() * evaluatePolynomialGradient(r) / r / getCGWidthSquared() * (Position.Y - P.Y), 0);
     }
     else
     {
         std::cerr << "error in CG_gradient<Y>" << std::endl;
         exit(-1);
     }
 }

template<>

Vec3D StatisticsPoint< Z >::CG_gradient	(	const Vec3D &	P,
		const Mdouble	phi
	)

Definition at line 1251 of file StatisticsPoint.hcc.

References Gaussian, Polynomial, and Vec3D::Z.

 {
     //CG_type_todo
     if (getCGShape() == Gaussian)
     {
         return Vec3D(0.0, 0.0, (P.Z - Position.Z) * (phi / getCGWidthSquared()));
     }
     else if (getCGShape() == Polynomial)
     {
         Mdouble r = fabs(Position.Z - P.Z) / getCGWidth();
         return Vec3D(0, 0, getCGInverseVolume() * evaluatePolynomialGradient(r) / r / getCGWidthSquared() * (Position.Z - P.Z));
     }
     else
     {
         std::cerr << "error in CG_gradient<Z>" << std::endl;
         exit(-1);
     }
 }

template<>

Vec3D StatisticsPoint< O >::CG_gradient	(	const Vec3D &	,
		const Mdouble
	)

Definition at line 1270 of file StatisticsPoint.hcc.

 {
     return Vec3D(0.0, 0.0, 0.0);
 }

template<StatType T>

Mdouble StatisticsPoint< T >::CG_integral	(	Vec3D &	P1,
		Vec3D &	P2,
		Vec3D &	P1_P2_normal,
		Mdouble	P1_P2_distance,
		Vec3D &	rpsi
	)

Returns the value of the coarse graining integral $\psi(P,PI,PJ) = \int_0^1 \phi(P - PI + s PJ) ds$ .

/todo{Thomas: rpsi_scalar is not always set}

Todo:: .fstat/.restart/.data/.stat should be by default in binary, with text output as option.

we need a converter tool binary->text / text->binary text version of .fstat and the particle data in .restart should have a header should .fstat report every p-p collision twice?

Definition at line 479 of file StatisticsPoint.hcc.

 {   
     //apply the cutoff in normal direction:
     Vec3D P_P1 = Position - P1;
     Mdouble a = dotNonAveraged(P_P1,P1_P2_normal);
     if ( a > getCutoff() ) return 0.0;
     Vec3D P_P2 = Position - P2;
     Mdouble b = dotNonAveraged(P_P2,P1_P2_normal);
     if ( -b > getCutoff() ) return 0.0;
     //apply the cutoff in tangential direction:
     Vec3D tangential = P_P1 - a * P1_P2_normal;
     if (dotNonAveraged(tangential,tangential)>getCutoff2()) return 0.0;
     //evaluate:
     if (getCGShape()==HeavisideSphere)
     {   
         Mdouble wn2 = getCGWidthSquared() - dotNonAveraged(tangential,tangential);
         if ((wn2<=0) | (a*fabs(a)>=wn2) | (b*fabs(b)<=-wn2))
         {   
             return 0;
         }
         else
         {   
             Mdouble wn = sqrt(wn2);
             return getCGInverseVolume()*( std::min(b,wn)-std::max(a,-wn) ) / P1_P2_distance;
         }
     }
     else if (getCGShape()==Gaussian)
     { //Gaussian
         static Mdouble InvVolumeExp = compute_Gaussian_invvolume(gb->getSystemDimensions()-1);
         static Mdouble w_sqrt_2 = constants::sqrt_2*getCGWidth();
         static Mdouble P1_P2_distance_for_cutoff=-1, InvVolumeErf=-1;
         if (P1_P2_distance_for_cutoff!=P1_P2_distance)
         {   
             P1_P2_distance_for_cutoff = P1_P2_distance;
             Mdouble amax = -getCutoff();
             Mdouble bmax = getCutoff()+P1_P2_distance;
             InvVolumeErf = P1_P2_distance/(
                     erf(bmax/w_sqrt_2)*bmax+w_sqrt_2/constants::sqrt_pi*exp(-bmax*bmax/(w_sqrt_2*w_sqrt_2))
                     -erf(amax/w_sqrt_2)*amax-w_sqrt_2/constants::sqrt_pi*exp(-amax*amax/(w_sqrt_2*w_sqrt_2)));
             // std::cout << "InvVolumeErf" << InvVolumeErf << " InvVolumeExp" << InvVolumeExp << " f" << getCGInverseVolume() * sqrt(2*constants::pi*getCGWidthSquared()) << std::endl;
         }
         Mdouble psi=exp(-dotNonAveraged(tangential,tangential)/(2.0*getCGWidthSquared())) * InvVolumeExp
         * ( erf(b/w_sqrt_2) - erf(a/w_sqrt_2) ) * InvVolumeErf /2./P1_P2_distance;
         rpsi=Position*psi;
         return psi;
     }
     else if (getCGShape()==Polynomial)
     {   
         double wn2 = getCGWidthSquared() - dotNonAveraged(tangential,tangential);
         if ((wn2<=0) | (a*fabs(a)>=wn2) | (b*fabs(b)<=-wn2))
         {   
             return 0;
         }
         else
         {   
             double wn = sqrt(wn2);
             double w = getCGWidth();
             return getCGInverseVolume()*evaluateIntegral(std::max(a,-wn)/w,std::min(b,wn)/w,tangential.getLength()/w)*w / P1_P2_distance;
         }
         //CG_type_todo
     }
     else
     {   std::cerr << "error in CG_integral" << std::endl; exit(-1);}
 }

template<>

Mdouble StatisticsPoint< RA >::CG_integral	(	Vec3D &	P1,
		Vec3D &	P2,
		Vec3D &	P1_P2_normal,
		Mdouble	P1_P2_distance,
		Vec3D &	rpsi
	)

Definition at line 1288 of file StatisticsPoint.hcc.

 {
     Mdouble rpsi_scalar;
     Mdouble psi = CG_integral_2D(P1, P2, P1_P2_normal, P1_P2_distance, rpsi_scalar);
     rpsi = Position * psi;
     return psi;
 }

template<>

Mdouble StatisticsPoint< RZ >::CG_integral	(	Vec3D &	P1,
		Vec3D &	P2,
		Vec3D &	,
		Mdouble	,
		Vec3D &rpsi	UNUSED
	)

Definition at line 1295 of file StatisticsPoint.hcc.

 {   
     Vec3D P=(P1+P2)/2; return CG_function(P);
 }

template<>

Mdouble StatisticsPoint< AZ >::CG_integral	(	Vec3D &	,
		Vec3D &	,
		Vec3D &	,
		Mdouble	,
		Vec3D &rpsi	UNUSED
	)

Definition at line 1299 of file StatisticsPoint.hcc.

 {   
     std::cerr << "error in CG_function<AZ>" << std::endl; exit(-1);
 }

template<>

Mdouble StatisticsPoint< R >::CG_integral	(	Vec3D &	P1,
		Vec3D &	P2,
		Vec3D &	,
		Mdouble	,
		Vec3D &rpsi	UNUSED
	)

Definition at line 1303 of file StatisticsPoint.hcc.

 {   
     Vec3D P=(P1+P2)/2; return CG_function(P);
 }

template<>

Mdouble StatisticsPoint< A >::CG_integral	(	Vec3D &	,
		Vec3D &	,
		Vec3D &	,
		Mdouble	,
		Vec3D &rpsi	UNUSED
	)

Definition at line 1307 of file StatisticsPoint.hcc.

 {   
     std::cerr << "error in CG_function<A>" << std::endl; exit(-1);
 }

template<>

Mdouble StatisticsPoint< XY >::CG_integral	(	Vec3D &	P1,
		Vec3D &	P2,
		Vec3D &	P1_P2_normal,
		Mdouble	P1_P2_distance,
		Vec3D &	rpsi
	)

Definition at line 1312 of file StatisticsPoint.hcc.

References Vec3D::Z.

 {
     Mdouble rpsi_scalar = 0;
     Mdouble psi = CG_integral_2D(P1, P2, P1_P2_normal, P1_P2_distance, rpsi_scalar);
     rpsi = Vec3D(Position.X * psi, Position.Y * psi, P1.Z * psi - (P1.Z - P2.Z) * rpsi_scalar);
     return psi;
 }

template<>

Mdouble StatisticsPoint< XZ >::CG_integral	(	Vec3D &	P1,
		Vec3D &	P2,
		Vec3D &	P1_P2_normal,
		Mdouble	P1_P2_distance,
		Vec3D &	rpsi
	)

Definition at line 1319 of file StatisticsPoint.hcc.

References Vec3D::Y.

 {
     Mdouble rpsi_scalar = 0;
     Mdouble psi = CG_integral_2D(P1, P2, P1_P2_normal, P1_P2_distance, rpsi_scalar);
     rpsi = Vec3D(Position.X * psi, P1.Y * psi - (P1.Y - P2.Y) * rpsi_scalar, Position.Z * psi);
     return psi;
 }

template<>

Mdouble StatisticsPoint< YZ >::CG_integral	(	Vec3D &	P1,
		Vec3D &	P2,
		Vec3D &	P1_P2_normal,
		Mdouble	P1_P2_distance,
		Vec3D &	rpsi
	)

Definition at line 1326 of file StatisticsPoint.hcc.

References Vec3D::X.

 {
     Mdouble rpsi_scalar = 0;
     Mdouble psi = CG_integral_2D(P1, P2, P1_P2_normal, P1_P2_distance, rpsi_scalar);
     rpsi = Vec3D(P1.X * psi - (P1.X - P2.X) * rpsi_scalar, Position.Y * psi, Position.Z * psi);
     return psi;
 }

template<>

Mdouble StatisticsPoint< X >::CG_integral	(	Vec3D &	P1,
		Vec3D &	P2,
		Vec3D &	P1_P2_normal,
		Mdouble	P1_P2_distance,
		Vec3D &	rpsi
	)

Definition at line 1333 of file StatisticsPoint.hcc.

References Vec3D::Y, and Vec3D::Z.

 {
     Mdouble rpsi_scalar = 0;
     Mdouble psi = CG_integral_1D(P1, P2, P1_P2_normal, P1_P2_distance, rpsi_scalar);
     rpsi = Vec3D(Position.X * psi, P1.Y * psi - (P1.Y - P2.Y) * rpsi_scalar, P1.Z * psi - (P1.Z - P2.Z) * rpsi_scalar);
     return psi;
 }

template<>

Mdouble StatisticsPoint< Y >::CG_integral	(	Vec3D &	P1,
		Vec3D &	P2,
		Vec3D &	P1_P2_normal,
		Mdouble	P1_P2_distance,
		Vec3D &	rpsi
	)

Definition at line 1340 of file StatisticsPoint.hcc.

References Vec3D::X, and Vec3D::Z.

 {
     Mdouble rpsi_scalar = 0;
     Mdouble psi = CG_integral_1D(P1, P2, P1_P2_normal, P1_P2_distance, rpsi_scalar);
     rpsi = Vec3D(P1.X * psi - (P1.X - P2.X) * rpsi_scalar, Position.Y * psi, P1.Z * psi - (P1.Z - P2.Z) * rpsi_scalar);
     return psi;
 }

template<>

Mdouble StatisticsPoint< Z >::CG_integral	(	Vec3D &	P1,
		Vec3D &	P2,
		Vec3D &	P1_P2_normal,
		Mdouble	P1_P2_distance,
		Vec3D &	rpsi
	)

Definition at line 1347 of file StatisticsPoint.hcc.

References Vec3D::X, and Vec3D::Y.

 {
     Mdouble rpsi_scalar = 0;
     Mdouble psi = CG_integral_1D(P1, P2, P1_P2_normal, P1_P2_distance, rpsi_scalar);
     rpsi = Vec3D(P1.X * psi - (P1.X - P2.X) * rpsi_scalar, P1.Y * psi - (P1.Y - P2.Y) * rpsi_scalar, Position.Z * psi);
     return psi;
 }

template<>

Mdouble StatisticsPoint< O >::CG_integral	(	Vec3D &	P1,
		Vec3D &P2	UNUSED,
		Vec3D &P1_P2_normal	UNUSED,
		Mdouble P1_P2_distance	UNUSED,
		Vec3D &	rpsi
	)

Todo:: Is that right?

Definition at line 1354 of file StatisticsPoint.hcc.

 {   
     Mdouble psi = getCGInverseVolume();
     rpsi=P1*psi; 
     return psi;
 }

template<StatType T>

Mdouble StatisticsPoint< T >::CG_integral_1D	(	Vec3D &	P1,
		Vec3D &	P2,
		Vec3D &	P1_P2_normal,
		Mdouble	P1_P2_distance,
		Mdouble &	rpsi_scalar
	)

Returns the value of the coarse graining integral $\psi(P,PI,PJ) = \int_0^1 \phi(P - PI + s PJ) ds$ averaged along a plane.

/todo{Thomas: rpsi_scalar is not always set}

Definition at line 641 of file StatisticsPoint.hcc.

 {
     //apply the cutoff in normal direction:
     Vec3D P_P1 = Position - P1;
     Mdouble a = dotNonAveraged(P_P1, P1_P2_normal);
     if (a > getCutoff())
         return 0.0;
     Vec3D P_P2 = Position - P2;
     Mdouble b = dotNonAveraged(P_P2, P1_P2_normal);
     if (-b > getCutoff())
         return 0.0;
     //apply the cutoff in tangential direction:
     Vec3D tangential = P_P1 - a * P1_P2_normal;
     if (dotNonAveraged(tangential, tangential) > getCutoff2())
         return 0.0;
     if (getCGShape() == HeavisideSphere)
     {
         Mdouble wn2 = getCGWidthSquared() - dotNonAveraged(tangential, tangential);
         if ((wn2 <= 0) | (a * fabs(a) >= wn2) | (b * fabs(b) <= -wn2))
         {
             return 0;
         }
         else
         {
             //if the normal is parallel to the averaging direction
             if (std::max(fabs(a), fabs(b)) < 1e-20)
             {
                 return getCGInverseVolume() * constants::pi * wn2;
             }
             Mdouble wn = sqrt(wn2);
             return getCGInverseVolume() / P1_P2_distance
                     * (((b >= wn) ? (2.0 / 3.0 * constants::pi * wn2 * wn) : (b * constants::pi * (wn2 - mathsFunc::square(b) / 3.0)))
                             - ((a <= -wn) ? (-2.0 / 3.0 * constants::pi * wn2 * wn) : (a * constants::pi * (wn2 - mathsFunc::square(a) / 3.0))));
         }
     }
     else if (getCGShape() == Gaussian)
     { //Gaussian
         if (fabs(b - a) < 1e-20)
         {
             return getCGInverseVolume() * exp(-dotNonAveraged(P_P1, P_P1) / (2.0 * getCGWidthSquared()));
         }
         static Mdouble w_sqrt_2 = constants::sqrt_2 * getCGWidth();
         static Mdouble P1_P2_distance_for_cutoff = -1, InvVolumeErf = -1;
         if (P1_P2_distance_for_cutoff != P1_P2_distance)
         {
             P1_P2_distance_for_cutoff = P1_P2_distance;
             Mdouble amax = -getCutoff();
             Mdouble bmax = getCutoff() + P1_P2_distance;
             InvVolumeErf = P1_P2_distance / (
                     erf(bmax / w_sqrt_2) * bmax + w_sqrt_2 / constants::sqrt_pi * exp(-bmax * bmax / (w_sqrt_2 * w_sqrt_2))
                             - erf(amax / w_sqrt_2) * amax - w_sqrt_2 / constants::sqrt_pi * exp(-amax * amax / (w_sqrt_2 * w_sqrt_2))
                     ) / averagingVolume();
             //std::cout << "InvVolumeErf" << InvVolumeErf << " InvVolumeExp" << InvVolumeExp << " f" << getCGInverseVolume() * sqrt(2*constants::pi*getCGWidthSquared()) << std::endl;
         }
         //Note: use dot(t,t),  GetLength2(t), as dot only works on non-averaged directions
         Mdouble psi = (erf(b / w_sqrt_2) - erf(a / w_sqrt_2)) * InvVolumeErf / 2. / P1_P2_distance;
         Mdouble phi1 = getCGInverseVolume() * exp(-dotNonAveraged(P_P1, P_P1) / (2.0 * getCGWidthSquared()));
         Mdouble phi2 = getCGInverseVolume() * exp(-dotNonAveraged(P_P2, P_P2) / (2.0 * getCGWidthSquared()));
         rpsi_scalar = -a / P1_P2_distance * psi + getCGWidthSquared() / P1_P2_distance / P1_P2_distance * (phi1 - phi2);
         return psi;
     }
     else if (getCGShape() == Polynomial)
     {
         //~ std::cout << setprecision(12) << P1_P2_normal << std::endl;
         double wn2 = getCGWidthSquared() - dotNonAveraged(tangential, tangential);
         if ((wn2 <= 0) | (a * fabs(a) >= wn2) | (b * fabs(b) <= -wn2))
         {
             return 0;
         }
         else if ((P1_P2_distance < 1e-12) | (Vec3D::getLengthSquared(tangential) < 1e-24))
         {
             //~ } else if (fabs(b-a)<1e-12) { 
             //if the normal is parallel to the averaging direction
             //~ std::cout << "normal is parallel to the averaging direction: "
             //~ << " P_P1 " << P1_P2_distance
             //~ << " psi= " << CG_function_1D(P1) << std::endl;
             return CG_function_1D(P1);
         }
         else
         {
             double wn = sqrt(wn2);
             double w = getCGWidth();
             return getCGInverseVolume() * evaluateIntegral(std::max(a, -wn) / w, std::min(b, wn) / w, dotNonAveraged(tangential, tangential) / w) * w / P1_P2_distance;
         }
     }
     else
     {
         std::cerr << "error in CG_integral_1D" << std::endl;
         exit(-1);
     }
     std::cout << "eind testje" << rpsi_scalar << std::endl;
 }

template<StatType T>

Mdouble StatisticsPoint< T >::CG_integral_2D	(	Vec3D &	P1,
		Vec3D &	P2,
		Vec3D &	P1_P2_normal,
		Mdouble	P1_P2_distance,
		Mdouble &	rpsi_scalar
	)

Returns the value of the coarse graining integral $\psi(P,PI,PJ) = \int_0^1 \phi(P - PI + s PJ) ds$ averaged along a line.

/todo{Thomas: rpsi_scalar is not always set}

Todo:: add rpsi

Definition at line 546 of file StatisticsPoint.hcc.

 {
     //apply the cutoff in normal direction:
     Vec3D P_P1 = Position - P1;
     Mdouble a = dotNonAveraged(P_P1, P1_P2_normal);
     if (a > getCutoff())
         return 0.0;
     Vec3D P_P2 = Position - P2;
     Mdouble b = dotNonAveraged(P_P2, P1_P2_normal);
     if (-b > getCutoff())
         return 0.0;
     //apply the cutoff in tangential direction:
     Vec3D tangential = P_P1 - a * P1_P2_normal;
     if (dotNonAveraged(tangential, tangential) > getCutoff2())
         return 0.0;
     if (getCGShape() == HeavisideSphere)
     {
         Mdouble wn2 = getCGWidthSquared() - dotNonAveraged(tangential, tangential);
         if ((wn2 <= 0) || (a * fabs(a) >= wn2) || (b * fabs(b) <= -wn2))
         {
             return 0;
         }
         else
         {
             Mdouble wn = sqrt(wn2);
             //if the normal is parallel to the averaging direction
             if (std::max(fabs(a), fabs(b)) < 1e-20)
             {
                 return getCGInverseVolume() * 2 * wn;
             }
             return getCGInverseVolume() / P1_P2_distance
                     * (((b >= wn) ? (constants::pi * wn2 / 2.0) : (b * sqrt(wn2 - mathsFunc::square(b)) + wn2 * asin(b / wn)))
                             + ((a <= -wn) ? (constants::pi * wn2 / 2.0) : (-a * sqrt(wn2 - mathsFunc::square(a)) - wn2 * asin(a / wn))));
         }
     }
     else if (getCGShape() == Gaussian)
     { //Gaussian
         if (dotNonAveraged(P1_P2_normal, P1_P2_normal) < 1e-20)
         {
             //since we average parallel to the force line, the CG integral is shaped like the CG function
             return getCGInverseVolume() * exp(-dotNonAveraged(P_P1, P_P1) / (2.0 * getCGWidthSquared()));
         }
         static Mdouble InvVolumeExp = compute_Gaussian_invvolume(gb->getSystemDimensions() - 2);
         static Mdouble w_sqrt_2 = constants::sqrt_2 * getCGWidth();
         static Mdouble P1_P2_distance_for_cutoff = -1, InvVolumeErf = -1;
         if (P1_P2_distance_for_cutoff != P1_P2_distance)
         {
             P1_P2_distance_for_cutoff = P1_P2_distance;
             Mdouble amax = -getCutoff();
             Mdouble bmax = getCutoff() + P1_P2_distance;
             InvVolumeErf = P1_P2_distance / (
                     erf(bmax / w_sqrt_2) * bmax + w_sqrt_2 / constants::sqrt_pi * exp(-bmax * bmax / (w_sqrt_2 * w_sqrt_2))
                             - erf(amax / w_sqrt_2) * amax - w_sqrt_2 / constants::sqrt_pi * exp(-amax * amax / (w_sqrt_2 * w_sqrt_2))
                     ) / averagingVolume();
             //std::cout << "InvVolumeErf" << InvVolumeErf << " InvVolumeExp" << InvVolumeExp << " f" << getCGInverseVolume() * sqrt(2*constants::pi*getCGWidthSquared()) << std::endl;
         }
         //Note: use dot(t,t),  GetLength2(t), as dot only works on non-averaged directions
         //we also define rpsi
         Mdouble psi = exp(-dotNonAveraged(tangential, tangential) / (2.0 * getCGWidthSquared())) * InvVolumeExp
                 * (erf(b / w_sqrt_2) - erf(a / w_sqrt_2)) * InvVolumeErf / 2. / P1_P2_distance;
         Mdouble phi1 = getCGInverseVolume() * exp(-dotNonAveraged(P_P1, P_P1) / (2.0 * getCGWidthSquared()));
         Mdouble phi2 = getCGInverseVolume() * exp(-dotNonAveraged(P_P2, P_P2) / (2.0 * getCGWidthSquared()));
         rpsi_scalar = -a / P1_P2_distance * psi + getCGWidthSquared() / P1_P2_distance / P1_P2_distance * (phi1 - phi2);
         return psi;
     }
     else if (getCGShape() == Polynomial)
     {
         double wn2 = getCGWidthSquared() - dotNonAveraged(tangential, tangential);
         if ((wn2 <= 0) | (a * fabs(a) >= wn2) | (b * fabs(b) <= -wn2))
         {
             return 0;
         }
         else if (P1_P2_distance < 1e-20)
         {
             //if the normal is parallel to the averaging direction
             return CG_function_1D(P_P1);
         }
         else
         {
             double wn = sqrt(wn2);
             double w = getCGWidth();
             return getCGInverseVolume() * evaluateIntegral(std::max(a, -wn) / w, std::min(b, wn) / w, tangential.getLength() / w) * w / P1_P2_distance;
         }
         //CG_type_todo
     }
     else
     {
         std::cerr << "error in CG_integral_2D" << std::endl;
         exit(-1);
     }
 }

template<StatType T>

Vec3D StatisticsPoint< T >::CG_integral_gradient	(	Vec3D &	P1,
		Vec3D &	P2,
		Vec3D &	P1_P2_normal,
		Mdouble	P1_P2_distance
	)

gradient of phi

Todo:: {Only implemented for Gaussian and statavg Z}

Todo:: {some gradients are not computed}

Todo:: The gradient is not centered; thus there is a bias; follow the corrections in CG_integral_gradient_1D

Definition at line 350 of file StatisticsPoint.hcc.

References StatisticsPoint< T >::dotNonAveraged(), StatisticsPoint< T >::evaluateIntegral(), Gaussian, StatisticsPoint< T >::getCGInverseVolume(), StatisticsPoint< T >::getCGShape(), StatisticsPoint< T >::getCGWidth(), StatisticsPoint< T >::getCGWidthSquared(), Vec3D::getLength(), constants::pi, Polynomial, StatisticsPoint< T >::Position, and mathsFunc::square().

 {
     Vec3D P_P1 = Position - P1;
     Vec3D P_P2 = Position - P2;
     Mdouble a = dotNonAveraged(P_P1, P1_P2_normal);
     Mdouble b = dotNonAveraged(P_P2, P1_P2_normal);
     Vec3D tangential = P_P1 - a * P1_P2_normal;
     //CG_type_todo
     if (getCGShape() == Gaussian)
     {
         Mdouble wsq2 = sqrt(2 * getCGWidthSquared());
         Mdouble f = sqrt(2 * constants::pi * getCGWidthSquared());
         return Vec3D(0.0, 0.0, (exp(-mathsFunc::square(a / wsq2)) - exp(-mathsFunc::square(b / wsq2))) / f / (P2.Z - P1.Z));
     }
     else if (getCGShape() == Polynomial)
     {
         double wn2 = getCGWidthSquared() - dotNonAveraged(tangential, tangential);
         if ((wn2 <= 0) | (a * fabs(a) >= wn2) | (b * fabs(b) <= -wn2))
         {
             return Vec3D(0, 0, 0);
         }
         else
         {
             double wn = std::sqrt(wn2);
             double w = getCGWidth();
             double delta = w * 1e-3;
             double I = getCGInverseVolume() * evaluateIntegral(std::max(a, -wn) / w, std::min(b, wn) / w, tangential.getLength() / w) * w / P1_P2_distance;
             Vec3D delta_P_P1 = P_P1 + Vec3D(delta, 0, 0);
             Vec3D delta_P_P2 = P_P2 + Vec3D(delta, 0, 0);
             a = dotNonAveraged(delta_P_P1, P1_P2_normal);
             b = dotNonAveraged(delta_P_P2, P1_P2_normal);
             tangential = delta_P_P1 - a * P1_P2_normal;
             wn = std::sqrt(getCGWidthSquared() - dotNonAveraged(tangential, tangential));
             double Ix = getCGInverseVolume() * evaluateIntegral(std::max(a, -wn) / w, std::min(b, wn) / w, tangential.getLength() / w) * w / P1_P2_distance;
             delta_P_P1 = P_P1 + Vec3D(0, delta, 0);
             delta_P_P2 = P_P2 + Vec3D(0, delta, 0);
             a = dotNonAveraged(delta_P_P1, P1_P2_normal);
             b = dotNonAveraged(delta_P_P2, P1_P2_normal);
             tangential = delta_P_P1 - a * P1_P2_normal;
             wn = std::sqrt(getCGWidthSquared() - dotNonAveraged(tangential, tangential));
             double Iy = getCGInverseVolume() * evaluateIntegral(std::max(a, -wn) / w, std::min(b, wn) / w, tangential.getLength() / w) * w / P1_P2_distance;
             delta_P_P1 = P_P1 + Vec3D(0, 0, delta);
             delta_P_P2 = P_P2 + Vec3D(0, 0, delta);
             a = dotNonAveraged(delta_P_P1, P1_P2_normal);
             b = dotNonAveraged(delta_P_P2, P1_P2_normal);
             tangential = delta_P_P1 - a * P1_P2_normal;
             wn = std::sqrt(getCGWidthSquared() - dotNonAveraged(tangential, tangential));
             double Iz = getCGInverseVolume() * evaluateIntegral(std::max(a, -wn) / w, std::min(b, wn) / w, tangential.getLength() / w) * w / P1_P2_distance;
             return Vec3D(Ix - I, Iy - I, Iz - I) / delta;
         }
     }
     else
     {
         return Vec3D(0, 0, 0);
     }
     //~ if (getCGShape()==Gaussian) return Vec3D(0.0,0.0,0.0);
     //~ else { std::cerr << "error in CG_function" << std::endl; exit(-1); }
 }

template<>

Vec3D StatisticsPoint< Z >::CG_integral_gradient	(	Vec3D &	P1,
		Vec3D &	P2,
		Vec3D &	P1_P2_normal,
		Mdouble	P1_P2_distance
	)

Definition at line 1361 of file StatisticsPoint.hcc.

 {
     return Vec3D(0, 0, CG_integral_gradient_1D(P1, P2, P1_P2_normal, P1_P2_distance));
 }

template<StatType T>

Mdouble StatisticsPoint< T >::CG_integral_gradient_1D	(	Vec3D &	P1,
		Vec3D &	P2,
		Vec3D &	P1_P2_normal,
		Mdouble	P1_P2_distance
	)

Todo:: {debug this code}

Todo:: Thomas: whats the best delta? Somewhere between 1e-7 and 1e-4

Definition at line 411 of file StatisticsPoint.hcc.

References StatisticsPoint< T >::dotNonAveraged(), StatisticsPoint< T >::evaluateIntegral(), Gaussian, StatisticsPoint< T >::getCGInverseVolume(), StatisticsPoint< T >::getCGShape(), StatisticsPoint< T >::getCGWidth(), StatisticsPoint< T >::getCGWidthSquared(), Vec3D::getLengthSquared(), constants::pi, Polynomial, StatisticsPoint< T >::Position, and mathsFunc::square().

 {
     Vec3D P_P1 = Position - P1;
     Vec3D P_P2 = Position - P2;
     Mdouble a = dotNonAveraged(P_P1, P1_P2_normal);
     Mdouble b = dotNonAveraged(P_P2, P1_P2_normal);
     Vec3D tangential = P_P1 - a * P1_P2_normal;
     //CG_type_todo
     if (getCGShape() == Gaussian)
     {
         Mdouble wsq2 = sqrt(2 * getCGWidthSquared());
         Mdouble f = sqrt(2 * constants::pi * getCGWidthSquared());
         return (exp(-mathsFunc::square(a / wsq2)) - exp(-mathsFunc::square(b / wsq2))) / f / (P2.Z - P1.Z);
     }
     else if (getCGShape() == Polynomial)
     {
         double wn2 = getCGWidthSquared() - dotNonAveraged(tangential, tangential);
         if ((wn2 <= 0) | (a * fabs(a) >= wn2) | (b * fabs(b) <= -wn2))
         {
             return 0;
         }
         else if ((P1_P2_distance < 1e-12) | (Vec3D::getLengthSquared(tangential) < 1e-24))
         {
             //if the normal is parallel to the averaging direction
             std::cout << "normal is parallel to the averaging direction: "
                     << " P1_P2_distance " << P1_P2_distance
                     << " tangential " << tangential << std::endl;
             return 0; //CG_gradient_1D(P1,CG_function(P1));
         }
         else
         {
             double wn = sqrt(wn2);
             double w = getCGWidth();
             double delta = w * 3e-6;
             //double I =  getCGInverseVolume()*evaluateIntegral(std::max(a,-wn)/w,std::min(b,wn)/w,dot(tangential,tangential)/w)*w / P1_P2_distance;
             Vec3D delta_P_P1 = P_P1 + Vec3D(delta, delta, delta);
             Vec3D delta_P_P2 = P_P2 + Vec3D(delta, delta, delta);
             a = dotNonAveraged(delta_P_P1, P1_P2_normal);
             b = dotNonAveraged(delta_P_P2, P1_P2_normal);
             tangential = delta_P_P1 - a * P1_P2_normal;
             wn = sqrt(getCGWidthSquared() - dotNonAveraged(tangential, tangential));
             double I2 = getCGInverseVolume() * evaluateIntegral(std::max(a, -wn) / w, std::min(b, wn) / w, dotNonAveraged(tangential, tangential) / w) * w / P1_P2_distance;
             
             delta_P_P1 = P_P1 - Vec3D(delta, delta, delta);
             delta_P_P2 = P_P2 - Vec3D(delta, delta, delta);
             a = dotNonAveraged(delta_P_P1, P1_P2_normal);
             b = dotNonAveraged(delta_P_P2, P1_P2_normal);
             tangential = delta_P_P1 - a * P1_P2_normal;
             wn = sqrt(getCGWidthSquared() - dotNonAveraged(tangential, tangential));
             double I1 = getCGInverseVolume() * evaluateIntegral(std::max(a, -wn) / w, std::min(b, wn) / w, dotNonAveraged(tangential, tangential) / w) * w / P1_P2_distance;
             
             return (I2 - I1) / (2. * delta);
         }
     }
     else
         return 0;
 }

template<StatType T>

Vec3D StatisticsPoint< T >::clearAveragedDirections ( Vec3D P )

Returns a vector where the averaged directions are zero.

Definition at line 1479 of file StatisticsPoint.hcc.

 {
     return P;
 }

template<>

Vec3D StatisticsPoint< XY >::clearAveragedDirections ( Vec3D P )

Definition at line 1483 of file StatisticsPoint.hcc.

References Vec3D::X, and Vec3D::Y.

 {
     return Vec3D(P.X, P.Y, 0);
 }

template<>

Vec3D StatisticsPoint< XZ >::clearAveragedDirections ( Vec3D P )

Definition at line 1487 of file StatisticsPoint.hcc.

References Vec3D::X, and Vec3D::Z.

 {
     return Vec3D(P.X, 0, P.Z);
 }

template<>

Vec3D StatisticsPoint< YZ >::clearAveragedDirections ( Vec3D P )

Definition at line 1491 of file StatisticsPoint.hcc.

References Vec3D::Y, and Vec3D::Z.

 {
     return Vec3D(0, P.Y, P.Z);
 }

template<>

Vec3D StatisticsPoint< X >::clearAveragedDirections ( Vec3D P )

Definition at line 1495 of file StatisticsPoint.hcc.

References Vec3D::X.

 {
     return Vec3D(P.X, 0, 0);
 }

template<>

Vec3D StatisticsPoint< Y >::clearAveragedDirections ( Vec3D P )

Definition at line 1499 of file StatisticsPoint.hcc.

References Vec3D::Y.

 {
     return Vec3D(0, P.Y, 0);
 }

template<>

Vec3D StatisticsPoint< Z >::clearAveragedDirections ( Vec3D P )

Definition at line 1503 of file StatisticsPoint.hcc.

References Vec3D::Z.

 {
     return Vec3D(0, 0, P.Z);
 }

template<>

Vec3D StatisticsPoint< O >::clearAveragedDirections ( Vec3D P UNUSED )

Definition at line 1507 of file StatisticsPoint.hcc.

 {   
     return Vec3D(0, 0, 0);
 }

template<StatType T>

double StatisticsPoint< T >::compute_Gaussian_invvolume ( int dim )

computes CG_invvolume if CG_type=Gaussian

Definition at line 913 of file StatisticsPoint.hcc.

References mathsFunc::cubic(), StatisticsPoint< T >::getCGWidth(), StatisticsPoint< T >::getCGWidthSquared(), StatisticsPoint< T >::getCutoff(), StatisticsPoint< T >::getCutoff2(), constants::sqrt_2, constants::sqrt_pi, and mathsFunc::square().

Referenced by StatisticsPoint< T >::CG_integral(), StatisticsPoint< T >::CG_integral_2D(), and StatisticsPoint< T >::set_Gaussian_invvolume().

 {
     if (dim == 0)
     {
         return 1.;
     }
     
     //this is the prefactor 1/V of phi(r)=1/V*exp(-|r|^2/w^2) for dim=1
     double CG_invvolume_computed = 1. / (constants::sqrt_2 * constants::sqrt_pi * getCGWidth());
     //take into account the cutoff radius and the dimension of the problem
     if (dim == 3)
     {
         CG_invvolume_computed = mathsFunc::cubic(CG_invvolume_computed);
         //Wolfram alpha: erf(c/(sqrt(2) w))-(sqrt(2/pi) c e^(-c^2/(2 w^2)))/w
         CG_invvolume_computed /= erf(getCutoff() / (constants::sqrt_2 * getCGWidth()))
                 - constants::sqrt_2 / constants::sqrt_pi * getCutoff() / getCGWidth() * exp(-getCutoff2() / (2 * getCGWidthSquared()));
     }
     else if (dim == 2)
     {
         CG_invvolume_computed = mathsFunc::square(CG_invvolume_computed);
         //Wolfram alpha: integrate(x*exp(-x^2/(2w^2)),{x,0,c})/integrate(x*exp(-x^2/(2w^2)),{x,0,inf})=1-e^(-c^2/(2 w^2))
         CG_invvolume_computed /= 1 - exp(-getCutoff2() / (2 * getCGWidthSquared()));
     }
     else
     {
         CG_invvolume_computed /= erf(getCutoff() / (constants::sqrt_2 * getCGWidth()));
     }
     return CG_invvolume_computed;
 }

template<StatType T>

Vec3D StatisticsPoint< T >::crossNonAveraged	(	Vec3D	P,
		Vec3D &	Q
	)

Returns the cross product of two vectors in the coordinates that are not averaged about.

Definition at line 232 of file StatisticsPoint.hcc.

References Vec3D::X, Vec3D::Y, and Vec3D::Z.

 {
     return Vec3D(P.Y * Q.Z - P.Z * Q.Y, P.Z * Q.X - P.X * Q.Z, P.X * Q.Y - P.Y * Q.X);
 }

template<>

Vec3D StatisticsPoint< XY >::crossNonAveraged	(	Vec3D	P,
		Vec3D &	Q
	)

Definition at line 1512 of file StatisticsPoint.hcc.

References Vec3D::X, and Vec3D::Y.

 {
     return Vec3D(0, 0, P.X * Q.Y - P.Y * Q.X);
 }

template<>

Vec3D StatisticsPoint< XZ >::crossNonAveraged	(	Vec3D	P,
		Vec3D &	Q
	)

Definition at line 1516 of file StatisticsPoint.hcc.

References Vec3D::X, and Vec3D::Z.

 {
     return Vec3D(0, P.Z * Q.X - P.X * Q.Z, 0);
 }

template<>

Vec3D StatisticsPoint< YZ >::crossNonAveraged	(	Vec3D	P,
		Vec3D &	Q
	)

Definition at line 1520 of file StatisticsPoint.hcc.

References Vec3D::Y, and Vec3D::Z.

 {
     return Vec3D(P.Y * Q.Z - P.Z * Q.Y, 0, 0);
 }

template<>

Vec3D StatisticsPoint< X >::crossNonAveraged	(	Vec3D P	UNUSED,
		Vec3D &Q	UNUSED
	)

Definition at line 1524 of file StatisticsPoint.hcc.

1525 { return Vec3D(0,0,0);}

Vec3D

Implementation of a 3D vector (by Vitaliy).

Definition: Vector.h:45

template<>

Vec3D StatisticsPoint< Y >::crossNonAveraged	(	Vec3D P	UNUSED,
		Vec3D &Q	UNUSED
	)

Definition at line 1526 of file StatisticsPoint.hcc.

1527 { return Vec3D(0,0,0);}

Vec3D

Implementation of a 3D vector (by Vitaliy).

Definition: Vector.h:45

template<>

Vec3D StatisticsPoint< Z >::crossNonAveraged	(	Vec3D P	UNUSED,
		Vec3D &Q	UNUSED
	)

Definition at line 1528 of file StatisticsPoint.hcc.

1529 { return Vec3D(0,0,0);}

Vec3D

Implementation of a 3D vector (by Vitaliy).

Definition: Vector.h:45

template<>

Vec3D StatisticsPoint< O >::crossNonAveraged	(	Vec3D P	UNUSED,
		Vec3D &Q	UNUSED
	)

Definition at line 1530 of file StatisticsPoint.hcc.

1531 { return Vec3D(0,0,0);}

Vec3D

Implementation of a 3D vector (by Vitaliy).

Definition: Vector.h:45

template<StatType T>

Mdouble StatisticsPoint< T >::dotNonAveraged	(	const Vec3D &	P,
		const Vec3D &	Q
	)

Returns the dot product of two vectors in the coordinates that are not averaged about.

Definition at line 246 of file StatisticsPoint.hcc.

References Vec3D::X, Vec3D::Y, and Vec3D::Z.

Referenced by StatisticsPoint< T >::CG_integral(), StatisticsPoint< T >::CG_integral_1D(), StatisticsPoint< T >::CG_integral_2D(), StatisticsPoint< T >::CG_integral_gradient(), and StatisticsPoint< T >::CG_integral_gradient_1D().

 {
     return P.X * Q.X + P.Y * Q.Y + P.Z * Q.Z;
 }

template<>

Mdouble StatisticsPoint< XY >::dotNonAveraged	(	const Vec3D &	P,
		const Vec3D &	Q
	)

Definition at line 1450 of file StatisticsPoint.hcc.

References Vec3D::X, and Vec3D::Y.

 {
     return P.X * Q.X + P.Y * Q.Y;
 }

template<>

Mdouble StatisticsPoint< XZ >::dotNonAveraged	(	const Vec3D &	P,
		const Vec3D &	Q
	)

Definition at line 1454 of file StatisticsPoint.hcc.

References Vec3D::X, and Vec3D::Z.

 {
     return P.X * Q.X + P.Z * Q.Z;
 }

template<>

Mdouble StatisticsPoint< YZ >::dotNonAveraged	(	const Vec3D &	P,
		const Vec3D &	Q
	)

Definition at line 1458 of file StatisticsPoint.hcc.

References Vec3D::Y, and Vec3D::Z.

 {
     return P.Y * Q.Y + P.Z * Q.Z;
 }

template<>

Mdouble StatisticsPoint< X >::dotNonAveraged	(	const Vec3D &	P,
		const Vec3D &	Q
	)

Definition at line 1462 of file StatisticsPoint.hcc.

References Vec3D::X.

 {
     return P.X * Q.X;
 }

template<>

Mdouble StatisticsPoint< Y >::dotNonAveraged	(	const Vec3D &	P,
		const Vec3D &	Q
	)

Definition at line 1466 of file StatisticsPoint.hcc.

References Vec3D::Y.

 {
     return P.Y * Q.Y;
 }

template<>

Mdouble StatisticsPoint< Z >::dotNonAveraged	(	const Vec3D &	P,
		const Vec3D &	Q
	)

Definition at line 1470 of file StatisticsPoint.hcc.

References Vec3D::Z.

 {
     return P.Z * Q.Z;
 }

template<>

Mdouble StatisticsPoint< O >::dotNonAveraged	(	const Vec3D &	,
		const Vec3D &
	)

Definition at line 1474 of file StatisticsPoint.hcc.

 {
     return 0;
 }

template<StatType T>

Mdouble StatisticsPoint< T >::evaluateIntegral	(	Mdouble	n1,
		Mdouble	n2,
		Mdouble	t
	)

inline

see StatisticsVector::evaluateIntegral

Definition at line 154 of file StatisticsPoint.h.

References StatisticsPoint< T >::gb.

Referenced by StatisticsPoint< T >::CG_integral(), StatisticsPoint< T >::CG_integral_1D(), StatisticsPoint< T >::CG_integral_2D(), StatisticsPoint< T >::CG_integral_gradient(), and StatisticsPoint< T >::CG_integral_gradient_1D().

     {
         return gb->evaluateIntegral(n1, n2, t);
     }

template<StatType T>

Mdouble StatisticsPoint< T >::evaluatePolynomial ( Mdouble r )

inline

see StatisticsVector::evaluatePolynomial

Definition at line 144 of file StatisticsPoint.h.

References StatisticsPoint< T >::gb.

Referenced by StatisticsPoint< T >::CG_function(), StatisticsPoint< T >::CG_function_1D(), and StatisticsPoint< T >::CG_function_2D().

     {
         return gb->evaluatePolynomial(r);
     }

template<StatType T>

Mdouble StatisticsPoint< T >::evaluatePolynomialGradient ( Mdouble r )

inline

see StatisticsVector::evaluatePolynomialGradient

Definition at line 149 of file StatisticsPoint.h.

References StatisticsPoint< T >::gb.

Referenced by StatisticsPoint< T >::CG_gradient().

     {
         return gb->evaluatePolynomialGradient(r);
     }

template<StatType T>

void StatisticsPoint< T >::firstTimeAverage ( const int n )

inline

Defines a division operator needed to time-average values (because the displacement does not have a value at the first timestep, this is slightly different than /=)

Definition at line 193 of file StatisticsPoint.hcc.

 {
     Nu /= n;
     Density /= n;
     Momentum /= n;
     if (n == 1)
     {
         DisplacementMomentum.setZero();
         Displacement.setZero();
         DisplacementMomentumFlux.setZero();
     }
     else
     {
         DisplacementMomentum /= n - 1;
         Displacement /= n - 1;
         DisplacementMomentumFlux /= n - 1;
     }
     MomentumFlux /= n;
     EnergyFlux /= n;
     NormalStress /= n;
     TangentialStress /= n;
     NormalTraction /= n;
     TangentialTraction /= n;
     Fabric /= n;
     CollisionalHeatFlux /= n;
     Dissipation /= n;
     Potential /= n;
     LocalAngularMomentum /= n;
     LocalAngularMomentumFlux /= n;
     ContactCoupleStress /= n;
 }

template<StatType T>

Mdouble StatisticsPoint< T >::getCGInverseVolume ( )

inline

returns CG_invvolume

Definition at line 164 of file StatisticsPoint.h.

References StatisticsPoint< T >::CG_invvolume.

Referenced by StatisticsPoint< T >::CG_function(), StatisticsPoint< T >::CG_function_1D(), StatisticsPoint< T >::CG_function_2D(), StatisticsPoint< T >::CG_gradient(), StatisticsPoint< T >::CG_integral(), StatisticsPoint< T >::CG_integral_1D(), StatisticsPoint< T >::CG_integral_2D(), StatisticsPoint< T >::CG_integral_gradient(), and StatisticsPoint< T >::CG_integral_gradient_1D().

     {
         return this->CG_invvolume;
     }

template<StatType T>

CG StatisticsPoint< T >::getCGShape ( ) const

inline

see StatisticsVector::getCGShape

Definition at line 79 of file StatisticsPoint.h.

References StatisticsPoint< T >::gb.

Referenced by StatisticsPoint< T >::CG_function(), StatisticsPoint< T >::CG_function_1D(), StatisticsPoint< T >::CG_function_2D(), StatisticsPoint< T >::CG_gradient(), StatisticsPoint< T >::CG_integral(), StatisticsPoint< T >::CG_integral_1D(), StatisticsPoint< T >::CG_integral_2D(), StatisticsPoint< T >::CG_integral_gradient(), StatisticsPoint< T >::CG_integral_gradient_1D(), and StatisticsPoint< T >::setCGInverseVolume().

     {
         return this->gb->getCGShape();
     }

template<StatType T>

Mdouble StatisticsPoint< T >::getCGWidth ( ) const

inline

see StatisticsVector::getCGWidth

Definition at line 94 of file StatisticsPoint.h.

References StatisticsPoint< T >::gb.

Referenced by StatisticsPoint< T >::CG_gradient(), StatisticsPoint< T >::CG_integral(), StatisticsPoint< T >::CG_integral_1D(), StatisticsPoint< T >::CG_integral_2D(), StatisticsPoint< T >::CG_integral_gradient(), StatisticsPoint< T >::CG_integral_gradient_1D(), and StatisticsPoint< T >::compute_Gaussian_invvolume().

     {
         return this->gb->getCGWidth();
     }

template<StatType T>

Mdouble StatisticsPoint< T >::getCGWidthSquared ( ) const

inline

see StatisticsVector::getCGWidthSquared

Definition at line 89 of file StatisticsPoint.h.

References StatisticsPoint< T >::gb.

     {
         return this->gb->getCGWidthSquared();
     }

template<StatType T>

Mdouble StatisticsPoint< T >::getCutoff ( )

inline

see StatisticsVector::getCutoff

Definition at line 99 of file StatisticsPoint.h.

References StatisticsPoint< T >::gb.

Referenced by StatisticsPoint< T >::CG_function(), StatisticsPoint< T >::CG_function_1D(), StatisticsPoint< T >::CG_function_2D(), StatisticsPoint< T >::CG_integral(), StatisticsPoint< T >::CG_integral_1D(), StatisticsPoint< T >::CG_integral_2D(), and StatisticsPoint< T >::compute_Gaussian_invvolume().

     {
         return this->gb->getCutoff();
     }

template<StatType T>

Mdouble StatisticsPoint< T >::getCutoff2 ( )

inline

see StatisticsVector::getCutoff2

Definition at line 104 of file StatisticsPoint.h.

References StatisticsPoint< T >::gb.

Referenced by StatisticsPoint< T >::CG_function(), StatisticsPoint< T >::CG_function_1D(), StatisticsPoint< T >::CG_function_2D(), StatisticsPoint< T >::CG_integral(), StatisticsPoint< T >::CG_integral_1D(), StatisticsPoint< T >::CG_integral_2D(), and StatisticsPoint< T >::compute_Gaussian_invvolume().

     {
         return this->gb->getCutoff2();
     }

template<StatType T>

Mdouble StatisticsPoint< T >::getDistanceSquaredNonAveraged ( const Vec3D & P )

returns the coarse graining distance in the coordinates that are not averaged about

Definition at line 226 of file StatisticsPoint.hcc.

References StatisticsPoint< T >::Position, mathsFunc::square(), Vec3D::X, Vec3D::Y, and Vec3D::Z.

Referenced by StatisticsPoint< T >::CG_function(), StatisticsPoint< T >::CG_function_1D(), and StatisticsPoint< T >::CG_function_2D().

 {
     return mathsFunc::square(P.X - Position.X) + mathsFunc::square(P.Y - Position.Y) + mathsFunc::square(P.Z - Position.Z);
 }

template<>

Mdouble StatisticsPoint< XY >::getDistanceSquaredNonAveraged ( const Vec3D & P )

Definition at line 1421 of file StatisticsPoint.hcc.

References mathsFunc::square(), Vec3D::X, and Vec3D::Y.

 {
     return mathsFunc::square(P.X - Position.X) + mathsFunc::square(P.Y - Position.Y);
 }

template<>

Mdouble StatisticsPoint< XZ >::getDistanceSquaredNonAveraged ( const Vec3D & P )

Definition at line 1425 of file StatisticsPoint.hcc.

References mathsFunc::square(), Vec3D::X, and Vec3D::Z.

 {
     return mathsFunc::square(P.X - Position.X) + mathsFunc::square(P.Z - Position.Z);
 }

template<>

Mdouble StatisticsPoint< YZ >::getDistanceSquaredNonAveraged ( const Vec3D & P )

Definition at line 1429 of file StatisticsPoint.hcc.

References mathsFunc::square(), Vec3D::Y, and Vec3D::Z.

 {
     return mathsFunc::square(P.Y - Position.Y) + mathsFunc::square(P.Z - Position.Z);
 }

template<>

Mdouble StatisticsPoint< X >::getDistanceSquaredNonAveraged ( const Vec3D & P )

Definition at line 1433 of file StatisticsPoint.hcc.

References mathsFunc::square(), and Vec3D::X.

 {
     return mathsFunc::square(P.X - Position.X);
 }

template<>

Mdouble StatisticsPoint< Y >::getDistanceSquaredNonAveraged ( const Vec3D & P )

Definition at line 1437 of file StatisticsPoint.hcc.

References mathsFunc::square(), and Vec3D::Y.

 {
     return mathsFunc::square(P.Y - Position.Y);
 }

template<>

Mdouble StatisticsPoint< Z >::getDistanceSquaredNonAveraged ( const Vec3D & P )

Definition at line 1441 of file StatisticsPoint.hcc.

References mathsFunc::square(), and Vec3D::Z.

 {
     return mathsFunc::square(P.Z - Position.Z);
 }

template<>

Mdouble StatisticsPoint< O >::getDistanceSquaredNonAveraged ( const Vec3D & )

Definition at line 1445 of file StatisticsPoint.hcc.

 {
     return 0;
 }

template<StatType T>

void StatisticsPoint< T >::getN	(	int &	nx_,
		int &	ny_,
		int &	nz_
	)

inline

see StatisticsVector::get_n

Definition at line 139 of file StatisticsPoint.h.

References StatisticsPoint< T >::gb.

     {
         this->gb->getN(nx_, ny_, nz_);
     }

template<StatType T>

Vec3D StatisticsPoint< T >::getPosition ( ) const

inline

returns Position

Definition at line 184 of file StatisticsPoint.h.

References StatisticsPoint< T >::Position.

     {
         return this->Position;
     }

template<StatType T>

StatisticsPoint< T > StatisticsPoint< T >::getSquared ( )

Squares all statistical variables; needed for variance.

Definition at line 66 of file StatisticsPoint.hcc.

 {
     StatisticsPoint < T > P;
     P.Nu = mathsFunc::square(Nu);
     P.Density = mathsFunc::square(Density);
     P.Momentum = Vec3D::square(Momentum);
     P.DisplacementMomentum = Vec3D::square(DisplacementMomentum);
     P.Displacement = MatrixSymmetric3D::square(Displacement);
     P.MomentumFlux = MatrixSymmetric3D::square(MomentumFlux);
     P.DisplacementMomentumFlux = MatrixSymmetric3D::square(DisplacementMomentumFlux);
     P.EnergyFlux = Vec3D::square(EnergyFlux);
     P.NormalStress = Matrix3D::square(NormalStress);
     P.TangentialStress = Matrix3D::square(TangentialStress);
     P.NormalTraction = Vec3D::square(NormalTraction);
     P.TangentialTraction = Vec3D::square(TangentialTraction);
     P.Fabric = MatrixSymmetric3D::square(Fabric);
     P.CollisionalHeatFlux = Vec3D::square(CollisionalHeatFlux);
     P.Dissipation = mathsFunc::square(Dissipation);
     P.Potential = mathsFunc::square(Potential);
     P.LocalAngularMomentum = Vec3D::square(LocalAngularMomentum);
     P.LocalAngularMomentumFlux = Matrix3D::square(LocalAngularMomentumFlux);
     P.ContactCoupleStress = Matrix3D::square(ContactCoupleStress);
     return P;
 }

template<StatType T>

Mdouble StatisticsPoint< T >::getXMaxStat ( )

inline

see StatisticsVector::getXMaxStat

Definition at line 109 of file StatisticsPoint.h.

References StatisticsPoint< T >::gb.

     {
         return this->gb->getXMaxStat();
     }

template<StatType T>

Mdouble StatisticsPoint< T >::getXMinStat ( )

inline

see StatisticsVector::getXMinStat

Definition at line 124 of file StatisticsPoint.h.

References StatisticsPoint< T >::gb.

     {
         return this->gb->getXMinStat();
     }

template<StatType T>

Mdouble StatisticsPoint< T >::getYMaxStat ( )

inline

see StatisticsVector::getYMaxStat

Definition at line 114 of file StatisticsPoint.h.

References StatisticsPoint< T >::gb.

     {
         return this->gb->getYMaxStat();
     }

template<StatType T>

Mdouble StatisticsPoint< T >::getYMinStat ( )

inline

see StatisticsVector::getYMinStat

Definition at line 129 of file StatisticsPoint.h.

References StatisticsPoint< T >::gb.

     {
         return this->gb->getYMinStat();
     }

template<StatType T>

Mdouble StatisticsPoint< T >::getZMaxStat ( )

inline

see StatisticsVector::getZMaxStat

Definition at line 119 of file StatisticsPoint.h.

References StatisticsPoint< T >::gb.

     {
         return this->gb->getZMaxStat();
     }

template<StatType T>

Mdouble StatisticsPoint< T >::getZMinStat ( )

inline

see StatisticsVector::getZMinStat

Definition at line 134 of file StatisticsPoint.h.

References StatisticsPoint< T >::gb.

     {
         return this->gb->getZMinStat();
     }

template<StatType T>

Matrix3D StatisticsPoint< T >::matrixCrossNonAveraged	(	Vec3D	P,
		Matrix3D &	Q
	)

Returns the cross product of two vectors in the coordinates that are not averaged about.

Definition at line 237 of file StatisticsPoint.hcc.

References Vec3D::X, Matrix3D::XX, Matrix3D::XY, Matrix3D::XZ, Vec3D::Y, Matrix3D::YX, Matrix3D::YY, Matrix3D::YZ, Vec3D::Z, Matrix3D::ZX, Matrix3D::ZY, and Matrix3D::ZZ.

 {
     return Matrix3D(
             P.Y * Q.ZX - P.Z * Q.YX, P.Z * Q.XX - P.X * Q.ZX, P.X * Q.YX - P.Y * Q.XX,
             P.Y * Q.ZY - P.Z * Q.YY, P.Z * Q.XY - P.X * Q.ZY, P.X * Q.YY - P.Y * Q.XY,
             P.Y * Q.ZZ - P.Z * Q.YZ, P.Z * Q.XZ - P.X * Q.ZZ, P.X * Q.YZ - P.Y * Q.XZ);
 }

template<>

Matrix3D StatisticsPoint< XY >::matrixCrossNonAveraged	(	Vec3D	P,
		Matrix3D &	Q
	)

Definition at line 1533 of file StatisticsPoint.hcc.

References Vec3D::X, Matrix3D::XX, Matrix3D::XY, Matrix3D::XZ, Vec3D::Y, Matrix3D::YX, Matrix3D::YY, and Matrix3D::YZ.

 {
     return Matrix3D(
             0, 0, P.X * Q.YX - P.Y * Q.XX,
             0, 0, P.X * Q.YY - P.Y * Q.XY,
             0, 0, P.X * Q.YZ - P.Y * Q.XZ);
 }

template<>

Matrix3D StatisticsPoint< XZ >::matrixCrossNonAveraged	(	Vec3D	P,
		Matrix3D &	Q
	)

Definition at line 1540 of file StatisticsPoint.hcc.

References Vec3D::X, Matrix3D::XX, Matrix3D::XY, Matrix3D::XZ, Vec3D::Z, Matrix3D::ZX, Matrix3D::ZY, and Matrix3D::ZZ.

 {
     return Matrix3D(
             0, P.Z * Q.XX - P.X * Q.ZX, 0,
             0, P.Z * Q.XY - P.X * Q.ZY, 0,
             0, P.Z * Q.XZ - P.X * Q.ZZ, 0);
 }

template<>

Matrix3D StatisticsPoint< YZ >::matrixCrossNonAveraged	(	Vec3D	P,
		Matrix3D &	Q
	)

Definition at line 1547 of file StatisticsPoint.hcc.

References Vec3D::Y, Matrix3D::YX, Matrix3D::YY, Matrix3D::YZ, Vec3D::Z, Matrix3D::ZX, Matrix3D::ZY, and Matrix3D::ZZ.

 {
     return Matrix3D(
             P.Y * Q.ZX - P.Z * Q.YX, 0, 0,
             P.Y * Q.ZY - P.Z * Q.YY, 0, 0,
             P.Y * Q.ZZ - P.Z * Q.YZ, 0, 0);
 }

template<>

Matrix3D StatisticsPoint< X >::matrixCrossNonAveraged	(	Vec3D P	UNUSED,
		Matrix3D &Q	UNUSED
	)

Definition at line 1554 of file StatisticsPoint.hcc.

 {
     return Matrix3D(0,0,0,0,0,0,0,0,0);
 }

template<>

Matrix3D StatisticsPoint< Y >::matrixCrossNonAveraged	(	Vec3D P	UNUSED,
		Matrix3D &Q	UNUSED
	)

Definition at line 1558 of file StatisticsPoint.hcc.

 {
     return Matrix3D(0,0,0,0,0,0,0,0,0);
 }

template<>

Matrix3D StatisticsPoint< Z >::matrixCrossNonAveraged	(	Vec3D P	UNUSED,
		Matrix3D &Q	UNUSED
	)

Definition at line 1562 of file StatisticsPoint.hcc.

 {
     return Matrix3D(0,0,0,0,0,0,0,0,0);
 }

template<>

Matrix3D StatisticsPoint< O >::matrixCrossNonAveraged	(	Vec3D P	UNUSED,
		Matrix3D &Q	UNUSED
	)

Definition at line 1566 of file StatisticsPoint.hcc.

 {
     return Matrix3D(0,0,0,0,0,0,0,0,0);
 }

template<StatType T>

int StatisticsPoint< T >::nonaveragedDim ( )

Referenced by StatisticsPoint< T >::setCGInverseVolume().

template<>

int StatisticsPoint< XYZ >::nonaveragedDim ( )

Definition at line 979 of file StatisticsPoint.hcc.

 {
     return gb->getSystemDimensions();
 }

template<>

int StatisticsPoint< YZ >::nonaveragedDim ( )

Definition at line 983 of file StatisticsPoint.hcc.

 {
     return gb->getSystemDimensions() - 1;
 }

template<>

int StatisticsPoint< XZ >::nonaveragedDim ( )

Definition at line 987 of file StatisticsPoint.hcc.

 {
     return gb->getSystemDimensions() - 1;
 }

template<>

int StatisticsPoint< XY >::nonaveragedDim ( )

Definition at line 991 of file StatisticsPoint.hcc.

 {
     return 2;
 }

template<>

int StatisticsPoint< X >::nonaveragedDim ( )

Definition at line 995 of file StatisticsPoint.hcc.

 {
     return 1;
 }

template<>

int StatisticsPoint< Y >::nonaveragedDim ( )

Definition at line 999 of file StatisticsPoint.hcc.

 {
     return 1;
 }

template<>

int StatisticsPoint< Z >::nonaveragedDim ( )

Definition at line 1003 of file StatisticsPoint.hcc.

 {
     return gb->getSystemDimensions() - 2;
 }

template<>

int StatisticsPoint< O >::nonaveragedDim ( )

Definition at line 1007 of file StatisticsPoint.hcc.

 {
     return 0;
 }

template<>

int StatisticsPoint< RAZ >::nonaveragedDim ( )

Definition at line 1011 of file StatisticsPoint.hcc.

 {
     exit(-1);
 }

template<>

int StatisticsPoint< AZ >::nonaveragedDim ( )

Definition at line 1015 of file StatisticsPoint.hcc.

 {
     exit(-1);
 }

template<>

int StatisticsPoint< RZ >::nonaveragedDim ( )

Definition at line 1019 of file StatisticsPoint.hcc.

 {
     exit(-1);
 }

template<>

int StatisticsPoint< RA >::nonaveragedDim ( )

Definition at line 1023 of file StatisticsPoint.hcc.

 {
     exit(-1);
 }

template<>

int StatisticsPoint< R >::nonaveragedDim ( )

Definition at line 1027 of file StatisticsPoint.hcc.

 {
     exit(-1);
 }

template<>

int StatisticsPoint< A >::nonaveragedDim ( )

Definition at line 1031 of file StatisticsPoint.hcc.

 {
     exit(-1);
 }

template<StatType T>

StatisticsPoint< T > & StatisticsPoint< T >::operator+= ( const StatisticsPoint< T > & P )

inline

Defines a plus operator needed to average values ( $\bar{v} = (\sum_{i=1}^n v_i)/n$ )

Definition at line 117 of file StatisticsPoint.hcc.

 {
     Nu += P.Nu;
     Density += P.Density;
     Momentum += P.Momentum;
     DisplacementMomentum += P.DisplacementMomentum;
     Displacement += P.Displacement;
     MomentumFlux += P.MomentumFlux;
     DisplacementMomentumFlux += P.DisplacementMomentumFlux;
     EnergyFlux += P.EnergyFlux;
     NormalStress += P.NormalStress;
     TangentialStress += P.TangentialStress;
     NormalTraction += P.NormalTraction;
     TangentialTraction += P.TangentialTraction;
     Fabric += P.Fabric;
     CollisionalHeatFlux += P.CollisionalHeatFlux;
     Dissipation += P.Dissipation;
     Potential += P.Potential;
     LocalAngularMomentum += P.LocalAngularMomentum;
     LocalAngularMomentumFlux += P.LocalAngularMomentumFlux;
     ContactCoupleStress += P.ContactCoupleStress;
     return *this;
 }

template<StatType T>

StatisticsPoint< T > & StatisticsPoint< T >::operator-= ( const StatisticsPoint< T > & P )

inline

Defines a plus operator needed to calculate variance.

Definition at line 142 of file StatisticsPoint.hcc.

 {
     Nu -= P.Nu;
     Density -= P.Density;
     Momentum -= P.Momentum;
     DisplacementMomentum -= P.DisplacementMomentum;
     Displacement -= P.Displacement;
     MomentumFlux -= P.MomentumFlux;
     DisplacementMomentumFlux -= P.DisplacementMomentumFlux;
     EnergyFlux -= P.EnergyFlux;
     NormalStress -= P.NormalStress;
     TangentialStress -= P.TangentialStress;
     NormalTraction -= P.NormalTraction;
     TangentialTraction -= P.TangentialTraction;
     Fabric -= P.Fabric;
     CollisionalHeatFlux -= P.CollisionalHeatFlux;
     Dissipation -= P.Dissipation;
     Potential -= P.Potential;
     LocalAngularMomentum -= P.LocalAngularMomentum;
     LocalAngularMomentumFlux -= P.LocalAngularMomentumFlux;
     ContactCoupleStress -= P.ContactCoupleStress;
     return *this;
 }

template<StatType T>

StatisticsPoint< T > & StatisticsPoint< T >::operator/= ( const Mdouble a )

inline

Defines a division operator needed to average values ( $\bar{v} = (\sum_{i=1}^n v_i)/n$ )

Definition at line 167 of file StatisticsPoint.hcc.

 {
     Nu /= a;
     Density /= a;
     Momentum /= a;
     DisplacementMomentum /= a;
     Displacement /= a;
     MomentumFlux /= a;
     DisplacementMomentumFlux /= a;
     EnergyFlux /= a;
     NormalStress /= a;
     TangentialStress /= a;
     NormalTraction /= a;
     TangentialTraction /= a;
     Fabric /= a;
     CollisionalHeatFlux /= a;
     Dissipation /= a;
     Potential /= a;
     LocalAngularMomentum /= a;
     LocalAngularMomentumFlux /= a;
     ContactCoupleStress /= a;
     return *this;
 }

template<StatType T>

StatisticsPoint< T > & StatisticsPoint< T >::operator= ( const StatisticsPoint< T > & P )

inline

Defines a equal operator needed for copy constructor.

Definition at line 92 of file StatisticsPoint.hcc.

 {
     Nu = P.Nu;
     Density = P.Density;
     Momentum = P.Momentum;
     DisplacementMomentum = P.DisplacementMomentum;
     Displacement = P.Displacement;
     MomentumFlux = P.MomentumFlux;
     DisplacementMomentumFlux = P.DisplacementMomentumFlux;
     EnergyFlux = P.EnergyFlux;
     NormalStress = P.NormalStress;
     TangentialStress = P.TangentialStress;
     NormalTraction = P.NormalTraction;
     TangentialTraction = P.TangentialTraction;
     Fabric = P.Fabric;
     CollisionalHeatFlux = P.CollisionalHeatFlux;
     Dissipation = P.Dissipation;
     Potential = P.Potential;
     LocalAngularMomentum = P.LocalAngularMomentum;
     LocalAngularMomentumFlux = P.LocalAngularMomentumFlux;
     ContactCoupleStress = P.ContactCoupleStress;
     return *this;
 }

template<StatType T>

std::string StatisticsPoint< T >::print ( ) const

Outputs statistical variables in human-readable format.

Definition at line 827 of file StatisticsPoint.hcc.

 {
     std::stringstream ss;
     ss << "Nu " << Nu
             << ", Density " << Density
             << ",\n Momentum " << Momentum
             << ",\n DisplacementMomentum " << DisplacementMomentum
             << ",\n Displacement " << Displacement
             << ",\n MomentumFlux " << MomentumFlux
             << ",\n DisplacementMomentumFlux " << DisplacementMomentumFlux
             << ",\n EnergyFlux " << EnergyFlux
             << ",\n NormalStress " << NormalStress
             << ",\n TangentialStress " << TangentialStress
             << ",\n NormalTraction " << NormalTraction
             << ",\n TangentialTraction " << TangentialTraction
             << ",\n Fabric " << Fabric
             << ",\n CollisionalHeatFlux " << CollisionalHeatFlux
             << ",\n Dissipation " << Dissipation
             << ",\n Potential " << Potential
             << ",\n LocalAngularMomentum " << LocalAngularMomentum
             << ",\n LocalAngularMomentumFlux " << LocalAngularMomentumFlux
             << ",\n ContactCoupleStress " << ContactCoupleStress;
     return ss.str();
 }

template<StatType T>

std::string StatisticsPoint< T >::print_sqrt ( ) const

Outputs root of statistical variables in human-readable format.

Definition at line 853 of file StatisticsPoint.hcc.

 {
     std::stringstream ss;
     ss << "Nu " << std::sqrt(Nu)
             << ", Density " << std::sqrt(Density)
             << ", Momentum " << Vec3D::sqrt(Momentum)
             << ", DisplacementMomentum " << Vec3D::sqrt(DisplacementMomentum)
             << ", Displacement " << MatrixSymmetric3D::sqrt(Displacement)
             << ", MomentumFlux " << MatrixSymmetric3D::sqrt(MomentumFlux)
             << ", DisplacementMomentumFlux " << MatrixSymmetric3D::sqrt(DisplacementMomentumFlux)
             << ", EnergyFlux " << Vec3D::sqrt(EnergyFlux)
             << ", NormalStress " << Matrix3D::sqrt(NormalStress)
             << ", TangentialStress " << Matrix3D::sqrt(TangentialStress)
             << ", NormalTraction " << Vec3D::sqrt(NormalTraction)
             << ", TangentialTraction " << Vec3D::sqrt(TangentialTraction)
             << ", Fabric " << MatrixSymmetric3D::sqrt(Fabric)
             << ", CollisionalHeatFlux " << Vec3D::sqrt(CollisionalHeatFlux)
             << ", Dissipation " << std::sqrt(Dissipation)
             << ", Potential " << std::sqrt(Potential)
             << ", LocalAngularMomentum " << Vec3D::sqrt(LocalAngularMomentum)
             << ", LocalAngularMomentumFlux " << Matrix3D::sqrt(LocalAngularMomentumFlux)
             << ", ContactCoupleStress " << Matrix3D::sqrt(ContactCoupleStress);
     
     return ss.str();
 }

template<StatType T>

void StatisticsPoint< T >::set_Gaussian_invvolume ( int dim )

sets CG_invvolume if CG_type=Gaussian

Definition at line 907 of file StatisticsPoint.hcc.

References StatisticsPoint< T >::CG_invvolume, and StatisticsPoint< T >::compute_Gaussian_invvolume().

Referenced by StatisticsPoint< T >::setCGInverseVolume().

 {
     CG_invvolume = compute_Gaussian_invvolume(dim);
 }

template<StatType T>

static void StatisticsPoint< T >::set_gb ( StatisticsVector< T > * new_gb )

inlinestatic

see StatisticsVector::setCGShape

Definition at line 69 of file StatisticsPoint.h.

References StatisticsPoint< T >::gb.

Referenced by StatisticsVector< T >::constructor().

     {
         gb = new_gb;
     }

template<StatType T>

void StatisticsPoint< T >::set_Heaviside_invvolume ( )

sets CG_invvolume if CG_type=HeaviSideSphere

Todo:: {Thomas: check 2d case}

Definition at line 944 of file StatisticsPoint.hcc.

References StatisticsPoint< T >::CG_invvolume, StatisticsPoint< T >::getCGWidthSquared(), and constants::pi.

Referenced by StatisticsPoint< T >::setCGInverseVolume().

 {
     CG_invvolume = 1.0 / (4.0 / 3.0 * constants::pi * sqrt(getCGWidthSquared()) * getCGWidthSquared());
 }

template<StatType T>

void StatisticsPoint< T >::set_Polynomial_invvolume ( int dim )

sets CG_invvolume if CG_type=Polynomial

Definition at line 951 of file StatisticsPoint.hcc.

References StatisticsPoint< T >::CG_invvolume, and StatisticsPoint< T >::getCGWidthSquared().

Referenced by StatisticsPoint< T >::setCGInverseVolume().

 {
     if (dim == 3)
         CG_invvolume = 1.0 / (sqrt(getCGWidthSquared()) * getCGWidthSquared());
     else if (dim == 2)
         CG_invvolume = 1.0 / getCGWidthSquared();
     else
         CG_invvolume = 1.0 / sqrt(getCGWidthSquared());
 }

template<StatType T>

void StatisticsPoint< T >::set_zero ( )

Sets all statistical variables to zero.

Definition at line 41 of file StatisticsPoint.hcc.

 {
     Nu = 0.0;
     Density = 0.0;
     Momentum.setZero();
     DisplacementMomentum.setZero();
     Displacement.setZero();
     MomentumFlux.setZero();
     DisplacementMomentumFlux.setZero();
     EnergyFlux.setZero();
     TangentialStress.setZero();
     NormalStress.setZero();
     TangentialStress.setZero();
     NormalTraction.setZero();
     TangentialTraction.setZero();
     Fabric.setZero();
     CollisionalHeatFlux.setZero();
     Dissipation = 0.0;
     Potential = 0.0;
     LocalAngularMomentum.setZero();
     LocalAngularMomentumFlux.setZero();
     ContactCoupleStress.setZero();
 }

template<StatType T>

void StatisticsPoint< T >::setCGInverseVolume ( )

sets CG_invvolume

Definition at line 961 of file StatisticsPoint.hcc.

References StatisticsPoint< T >::averagingVolume(), StatisticsPoint< T >::CG_invvolume, Gaussian, StatisticsPoint< T >::getCGShape(), HeavisideSphere, StatisticsPoint< T >::nonaveragedDim(), Polynomial, StatisticsPoint< T >::set_Gaussian_invvolume(), StatisticsPoint< T >::set_Heaviside_invvolume(), and StatisticsPoint< T >::set_Polynomial_invvolume().

 {
     if (getCGShape() == HeavisideSphere)
     {
         set_Heaviside_invvolume();
     }
     else if (getCGShape() == Gaussian)
     {
         set_Gaussian_invvolume (nonaveragedDim());
         } else if (getCGShape()==Polynomial)
         {   
             set_Polynomial_invvolume(nonaveragedDim());
         }
         else
         {   std::cerr << "error in CG_function" << std::endl; exit(-1);}
         CG_invvolume /= averagingVolume();
     }

template<StatType T>

void StatisticsPoint< T >::setCGShape ( const char * CG_type )

inline

see StatisticsVector::setCGShape

Definition at line 74 of file StatisticsPoint.h.

References StatisticsPoint< T >::gb.

     {
         this->gb->setCGShape(CG_type);
     }

template<StatType T>

void StatisticsPoint< T >::setCGWidth2 ( Mdouble new_ )

inline

see StatisticsVector::setCGWidth2

Definition at line 84 of file StatisticsPoint.h.

References StatisticsPoint< T >::gb.

     {
         this->gb->setCGWidth2(new_);
     }

template<StatType T>

void StatisticsPoint< T >::setPosition ( Vec3D new_ )

inline

sets Position

Definition at line 179 of file StatisticsPoint.h.

References StatisticsPoint< T >::Position.

     {
         this->Position = new_;
     }

template<StatType T>

std::string StatisticsPoint< T >::write ( ) const

Outputs statistical variables in computer-readable format.

Definition at line 880 of file StatisticsPoint.hcc.

 {
     std::stringstream ss;
     ss.precision(16);
     ss << Nu
             << " " << Density
             << " " << Momentum
             << " " << DisplacementMomentum
             << " " << Displacement
             << " " << MomentumFlux
             << " " << DisplacementMomentumFlux
             << " " << EnergyFlux
             << " " << NormalStress
             << " " << TangentialStress
             << " " << NormalTraction
             << " " << TangentialTraction
             << " " << Fabric
             << " " << CollisionalHeatFlux
             << " " << Dissipation
             << " " << Potential
             << " " << LocalAngularMomentum
             << " " << LocalAngularMomentumFlux
             << " " << ContactCoupleStress;
     return ss.str();
 }

template<StatType T>

std::string StatisticsPoint< T >::write_variable_names ( )

Outputs names of statistical variables in computer-readable format.

Definition at line 735 of file StatisticsPoint.hcc.

 {
     std::stringstream ss;
     ss << "Nu "
             << "Density "
             << "MomentumX "
             << "MomentumY "
             << "MomentumZ "
             << "DisplacementMomentumX "
             << "DisplacementMomentumY "
             << "DisplacementMomentumZ "
             << "DisplacementXX "
             << "DisplacementXY "
             << "DisplacementXZ "
             << "DisplacementYY "
             << "DisplacementYZ "
             << "DisplacementZZ "
             << "MomentumFluxXX "
             << "MomentumFluxXY "
             << "MomentumFluxXZ "
             << "MomentumFluxYY "
             << "MomentumFluxYZ "
             << "MomentumFluxZZ "
             << "DisplacementMomentumFluxXX "
             << "DisplacementMomentumFluxXY "
             << "DisplacementMomentumFluxXZ "
             << "DisplacementMomentumFluxYY "
             << "DisplacementMomentumFluxYZ "
             << "DisplacementMomentumFluxZZ "
             << "EnergyFluxX "
             << "EnergyFluxY "
             << "EnergyFluxZ "
             << "NormalStressXX "
             << "NormalStressXY "
             << "NormalStressXZ "
             << "NormalStressYX "
             << "NormalStressYY "
             << "NormalStressYZ "
             << "NormalStressZX "
             << "NormalStressZY "
             << "NormalStressZZ "
             << "TangentialStressXX "
             << "TangentialStressXY "
             << "TangentialStressXZ "
             << "TangentialStressYX "
             << "TangentialStressYY "
             << "TangentialStressYZ "
             << "TangentialStressZX "
             << "TangentialStressZY "
             << "TangentialStressZZ "
             << "NormalTractionX "
             << "NormalTractionY "
             << "NormalTractionZ "
             << "TangentialTractionX "
             << "TangentialTractionY "
             << "TangentialTractionZ "
             << "FabricXX "
             << "FabricXY "
             << "FabricXZ "
             << "FabricYY "
             << "FabricYZ "
             << "FabricZZ "
             << "CollisionalHeatFluxX "
             << "CollisionalHeatFluxY "
             << "CollisionalHeatFluxZ "
             << "Dissipation "
             << "Potential "
             << "LocalAngularMomentumX "
             << "LocalAngularMomentumY "
             << "LocalAngularMomentumZ "
             << "LocalAngularMomentumFluxXX "
             << "LocalAngularMomentumFluxXY "
             << "LocalAngularMomentumFluxXZ "
             << "LocalAngularMomentumFluxYX "
             << "LocalAngularMomentumFluxYY "
             << "LocalAngularMomentumFluxYZ "
             << "LocalAngularMomentumFluxZX "
             << "LocalAngularMomentumFluxZY "
             << "LocalAngularMomentumFluxZZ "
             << "ContactCoupleStressXX "
             << "ContactCoupleStressXY "
             << "ContactCoupleStressXZ "
             << "ContactCoupleStressYX "
             << "ContactCoupleStressYY "
             << "ContactCoupleStressYZ "
             << "ContactCoupleStressZX "
             << "ContactCoupleStressZY "
             << "ContactCoupleStressZZ ";
     return ss.str();
 }

Friends And Related Function Documentation

template<StatType T>

std::ostream& operator	(	std::ostream &	os,
		const StatisticsPoint< T > &	stat
	)

friend

Outputs statistical variables to ostream.

Member Data Documentation

template<StatType T>

Mdouble StatisticsPoint< T >::CG_invvolume

Prefactor of CG function which depends on $w.

Definition at line 311 of file StatisticsPoint.h.

Referenced by StatisticsPoint< T >::getCGInverseVolume(), StatisticsPoint< T >::set_Gaussian_invvolume(), StatisticsPoint< T >::set_Heaviside_invvolume(), StatisticsPoint< T >::set_Polynomial_invvolume(), and StatisticsPoint< T >::setCGInverseVolume().

template<StatType T>

Vec3D StatisticsPoint< T >::CollisionalHeatFlux

Heat flux from collisions, $\sum_{ij} (v_{ia}+v_ja)/2 f_{ija} l_{ijb} \psi_i$ .

Todo:: {Heat flux calculations have not been checked, only implemented}

Definition at line 298 of file StatisticsPoint.h.

Referenced by StatisticsPoint< T >::firstTimeAverage(), StatisticsPoint< T >::getSquared(), StatisticsPoint< T >::operator+=(), StatisticsPoint< T >::operator-=(), StatisticsPoint< T >::operator/=(), StatisticsPoint< T >::operator=(), StatisticsPoint< T >::print(), StatisticsPoint< T >::print_sqrt(), StatisticsPoint< T >::set_zero(), and StatisticsPoint< T >::write().

template<StatType T>

Matrix3D StatisticsPoint< T >::ContactCoupleStress

Definition at line 308 of file StatisticsPoint.h.

Referenced by StatisticsPoint< T >::firstTimeAverage(), StatisticsPoint< T >::getSquared(), StatisticsPoint< T >::operator+=(), StatisticsPoint< T >::operator-=(), StatisticsPoint< T >::operator/=(), StatisticsPoint< T >::operator=(), StatisticsPoint< T >::print(), StatisticsPoint< T >::print_sqrt(), StatisticsPoint< T >::set_zero(), and StatisticsPoint< T >::write().

template<StatType T>

Mdouble StatisticsPoint< T >::Density

Density, $\sum_i m_i \phi_i$ .

Definition at line 273 of file StatisticsPoint.h.

Referenced by StatisticsPoint< T >::firstTimeAverage(), StatisticsPoint< T >::getSquared(), StatisticsPoint< T >::operator+=(), StatisticsPoint< T >::operator-=(), StatisticsPoint< T >::operator/=(), StatisticsPoint< T >::operator=(), StatisticsPoint< T >::print(), StatisticsPoint< T >::print_sqrt(), StatisticsPoint< T >::set_zero(), and StatisticsPoint< T >::write().

template<StatType T>

MatrixSymmetric3D StatisticsPoint< T >::Displacement

Linear displacement, $2/(2 \rho_i^2) \sum_{ij} m_i m_j \phi_j (v_{ija} \partial_b \phi_i + v_{ijb} \partial_a \phi_i)$ .

Definition at line 279 of file StatisticsPoint.h.

Referenced by StatisticsPoint< T >::firstTimeAverage(), StatisticsPoint< T >::getSquared(), StatisticsPoint< T >::operator+=(), StatisticsPoint< T >::operator-=(), StatisticsPoint< T >::operator/=(), StatisticsPoint< T >::operator=(), StatisticsPoint< T >::print(), StatisticsPoint< T >::print_sqrt(), StatisticsPoint< T >::set_zero(), and StatisticsPoint< T >::write().

template<StatType T>

Vec3D StatisticsPoint< T >::DisplacementMomentum

Momentum from linear displacement, $\sum_i m_i u_{ia} \phi_i$ , where $\vec{u}_i=(\vec{r}_i(t)-\vec{r}_i(t-\tau))/\tau$ , with $\tau=savecount \Delta t$ the time intervall between outputs.

Definition at line 277 of file StatisticsPoint.h.

Referenced by StatisticsPoint< T >::firstTimeAverage(), StatisticsPoint< T >::getSquared(), StatisticsPoint< T >::operator+=(), StatisticsPoint< T >::operator-=(), StatisticsPoint< T >::operator/=(), StatisticsPoint< T >::operator=(), StatisticsPoint< T >::print(), StatisticsPoint< T >::print_sqrt(), StatisticsPoint< T >::set_zero(), and StatisticsPoint< T >::write().

template<StatType T>

MatrixSymmetric3D StatisticsPoint< T >::DisplacementMomentumFlux

Momentum flux from linear displacement, $\sum_i m_i u_{ia} u_{ib} \phi_i$ .

Definition at line 283 of file StatisticsPoint.h.

Referenced by StatisticsPoint< T >::firstTimeAverage(), StatisticsPoint< T >::getSquared(), StatisticsPoint< T >::operator+=(), StatisticsPoint< T >::operator-=(), StatisticsPoint< T >::operator/=(), StatisticsPoint< T >::operator=(), StatisticsPoint< T >::print(), StatisticsPoint< T >::print_sqrt(), StatisticsPoint< T >::set_zero(), and StatisticsPoint< T >::write().

template<StatType T>

Mdouble StatisticsPoint< T >::Dissipation

Dissipation form collisions, $\sum_{ij} (v_{ia}+v_ja)/2 f_{ija} \psi_i$ .

Todo:: {Dissipation calculations have not been checked, only implemented}

Definition at line 301 of file StatisticsPoint.h.

Referenced by StatisticsPoint< T >::firstTimeAverage(), StatisticsPoint< T >::getSquared(), StatisticsPoint< T >::operator+=(), StatisticsPoint< T >::operator-=(), StatisticsPoint< T >::operator/=(), StatisticsPoint< T >::operator=(), StatisticsPoint< T >::print(), StatisticsPoint< T >::print_sqrt(), StatisticsPoint< T >::set_zero(), and StatisticsPoint< T >::write().

template<StatType T>

Vec3D StatisticsPoint< T >::EnergyFlux

Energy flux, $2/2 \sum_i m_i v_{ia} v_{ia} v_{ib} \phi_i$ .

Definition at line 285 of file StatisticsPoint.h.

Referenced by StatisticsPoint< T >::firstTimeAverage(), StatisticsPoint< T >::getSquared(), StatisticsPoint< T >::operator+=(), StatisticsPoint< T >::operator-=(), StatisticsPoint< T >::operator/=(), StatisticsPoint< T >::operator=(), StatisticsPoint< T >::print(), StatisticsPoint< T >::print_sqrt(), StatisticsPoint< T >::set_zero(), and StatisticsPoint< T >::write().

template<StatType T>

MatrixSymmetric3D StatisticsPoint< T >::Fabric

Fabric tensor, $\sum_{ij} m_i/\rho_i n_{ija} n_{ijb} \psi_{ij}$ .

Definition at line 295 of file StatisticsPoint.h.

Referenced by StatisticsPoint< T >::firstTimeAverage(), StatisticsPoint< T >::getSquared(), StatisticsPoint< T >::operator+=(), StatisticsPoint< T >::operator-=(), StatisticsPoint< T >::operator/=(), StatisticsPoint< T >::operator=(), StatisticsPoint< T >::print(), StatisticsPoint< T >::print_sqrt(), StatisticsPoint< T >::set_zero(), and StatisticsPoint< T >::write().

template<StatType T>

StatisticsVector< T > * StatisticsPoint< T >::gb

staticprivate

Pointer to StatisticsVector (to obtain global parameters)

Definition at line 318 of file StatisticsPoint.h.

template<StatType T>

Vec3D StatisticsPoint< T >::LocalAngularMomentum

Definition at line 306 of file StatisticsPoint.h.

Referenced by StatisticsPoint< T >::firstTimeAverage(), StatisticsPoint< T >::getSquared(), StatisticsPoint< T >::operator+=(), StatisticsPoint< T >::operator-=(), StatisticsPoint< T >::operator/=(), StatisticsPoint< T >::operator=(), StatisticsPoint< T >::print(), StatisticsPoint< T >::print_sqrt(), StatisticsPoint< T >::set_zero(), and StatisticsPoint< T >::write().

template<StatType T>

Matrix3D StatisticsPoint< T >::LocalAngularMomentumFlux

Definition at line 307 of file StatisticsPoint.h.

Referenced by StatisticsPoint< T >::firstTimeAverage(), StatisticsPoint< T >::getSquared(), StatisticsPoint< T >::operator+=(), StatisticsPoint< T >::operator-=(), StatisticsPoint< T >::operator/=(), StatisticsPoint< T >::operator=(), StatisticsPoint< T >::print(), StatisticsPoint< T >::print_sqrt(), StatisticsPoint< T >::set_zero(), and StatisticsPoint< T >::write().

template<StatType T>

int StatisticsPoint< T >::mirrorParticle

indicates that a position is a (fake) particles used for periodic walls

Definition at line 314 of file StatisticsPoint.h.

Referenced by StatisticsPoint< T >::StatisticsPoint().

template<StatType T>

Vec3D StatisticsPoint< T >::Momentum

Momentum, $\sum_i m_i v_{ia} \phi_i$ .

Definition at line 275 of file StatisticsPoint.h.

Referenced by StatisticsPoint< T >::firstTimeAverage(), StatisticsPoint< T >::getSquared(), StatisticsPoint< T >::operator+=(), StatisticsPoint< T >::operator-=(), StatisticsPoint< T >::operator/=(), StatisticsPoint< T >::operator=(), StatisticsPoint< T >::print(), StatisticsPoint< T >::print_sqrt(), StatisticsPoint< T >::set_zero(), and StatisticsPoint< T >::write().

template<StatType T>

MatrixSymmetric3D StatisticsPoint< T >::MomentumFlux

Momentum flux, $\sum_i m_i v_{ia} v_{ib} \phi_i$ .

Definition at line 281 of file StatisticsPoint.h.

Referenced by StatisticsPoint< T >::firstTimeAverage(), StatisticsPoint< T >::getSquared(), StatisticsPoint< T >::operator+=(), StatisticsPoint< T >::operator-=(), StatisticsPoint< T >::operator/=(), StatisticsPoint< T >::operator=(), StatisticsPoint< T >::print(), StatisticsPoint< T >::print_sqrt(), StatisticsPoint< T >::set_zero(), and StatisticsPoint< T >::write().

template<StatType T>

Matrix3D StatisticsPoint< T >::NormalStress

Stress from normal forces, $\sum_{ij} f^n_{ija} l_{ijb} \psi_{ij}$ .

Definition at line 287 of file StatisticsPoint.h.

Referenced by StatisticsPoint< T >::firstTimeAverage(), StatisticsPoint< T >::getSquared(), StatisticsPoint< T >::operator+=(), StatisticsPoint< T >::operator-=(), StatisticsPoint< T >::operator/=(), StatisticsPoint< T >::operator=(), StatisticsPoint< T >::print(), StatisticsPoint< T >::print_sqrt(), StatisticsPoint< T >::set_zero(), and StatisticsPoint< T >::write().

template<StatType T>

Vec3D StatisticsPoint< T >::NormalTraction

Traction from normal forces, $\sum_{ij} f^n_{ija} l_{ijb} \phi_i$ .

Definition at line 291 of file StatisticsPoint.h.

Referenced by StatisticsPoint< T >::firstTimeAverage(), StatisticsPoint< T >::getSquared(), StatisticsPoint< T >::operator+=(), StatisticsPoint< T >::operator-=(), StatisticsPoint< T >::operator/=(), StatisticsPoint< T >::operator=(), StatisticsPoint< T >::print(), StatisticsPoint< T >::print_sqrt(), StatisticsPoint< T >::set_zero(), and StatisticsPoint< T >::write().

template<StatType T>

Mdouble StatisticsPoint< T >::Nu

Particle volume fraction, $\sum_i m_i/\rho_i \phi_i$ .

Definition at line 271 of file StatisticsPoint.h.

Referenced by StatisticsPoint< T >::firstTimeAverage(), StatisticsPoint< T >::getSquared(), StatisticsPoint< T >::operator+=(), StatisticsPoint< T >::operator-=(), StatisticsPoint< T >::operator/=(), StatisticsPoint< T >::operator=(), StatisticsPoint< T >::print(), StatisticsPoint< T >::print_sqrt(), StatisticsPoint< T >::set_zero(), and StatisticsPoint< T >::write().

template<StatType T>

Vec3D StatisticsPoint< T >::Position

private

Position at which evaluation occurs.

Definition at line 320 of file StatisticsPoint.h.

Referenced by StatisticsPoint< T >::CG_gradient(), StatisticsPoint< T >::CG_integral(), StatisticsPoint< T >::CG_integral_1D(), StatisticsPoint< T >::CG_integral_2D(), StatisticsPoint< T >::CG_integral_gradient(), StatisticsPoint< T >::CG_integral_gradient_1D(), StatisticsPoint< T >::getDistanceSquaredNonAveraged(), StatisticsPoint< T >::getPosition(), StatisticsPoint< T >::setPosition(), and StatisticsPoint< T >::StatisticsPoint().

template<StatType T>

Mdouble StatisticsPoint< T >::Potential

Elastic energy $2/4 \sum_{ij} (k \delta_{ij}^2 +k^t {\delta^t_{ij}}^2) \phi_i$ .

Todo:: {Potential calculations have not been checked, only implemented; fstat file does not include the torsional and rolling spring and hence cannot account for their potential}

Definition at line 304 of file StatisticsPoint.h.

Referenced by StatisticsPoint< T >::firstTimeAverage(), StatisticsPoint< T >::getSquared(), StatisticsPoint< T >::operator+=(), StatisticsPoint< T >::operator-=(), StatisticsPoint< T >::operator/=(), StatisticsPoint< T >::operator=(), StatisticsPoint< T >::print(), StatisticsPoint< T >::print_sqrt(), StatisticsPoint< T >::set_zero(), and StatisticsPoint< T >::write().

template<StatType T>

Matrix3D StatisticsPoint< T >::TangentialStress

Stress from tangential forces, $\sum_{ij} f^t_{ija} l_{ijb} \psi_{ij}$ .

Definition at line 289 of file StatisticsPoint.h.

Referenced by StatisticsPoint< T >::firstTimeAverage(), StatisticsPoint< T >::getSquared(), StatisticsPoint< T >::operator+=(), StatisticsPoint< T >::operator-=(), StatisticsPoint< T >::operator/=(), StatisticsPoint< T >::operator=(), StatisticsPoint< T >::print(), StatisticsPoint< T >::print_sqrt(), StatisticsPoint< T >::set_zero(), and StatisticsPoint< T >::write().

template<StatType T>

Vec3D StatisticsPoint< T >::TangentialTraction

Traction from tangential forces, $\sum_{ij} f^t_{ija} l_{ijb} \phi_i$ .

Definition at line 293 of file StatisticsPoint.h.

Referenced by StatisticsPoint< T >::firstTimeAverage(), StatisticsPoint< T >::getSquared(), StatisticsPoint< T >::operator+=(), StatisticsPoint< T >::operator-=(), StatisticsPoint< T >::operator/=(), StatisticsPoint< T >::operator=(), StatisticsPoint< T >::print(), StatisticsPoint< T >::print_sqrt(), StatisticsPoint< T >::set_zero(), and StatisticsPoint< T >::write().

The documentation for this struct was generated from the following files:

/usr/local/www/mercury/repo/Release/0.11/Kernel/StatisticsPoint.h
/usr/local/www/mercury/repo/Release/0.11/Kernel/StatisticsPoint.hcc

Public Member Functions

Static Public Member Functions

Public Attributes

Private Attributes

Static Private Attributes

Friends

Detailed Description

template<StatType T> struct StatisticsPoint< T >

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation

template<StatType T>
struct StatisticsPoint< T >