CGCoordinates Namespace Reference

The class in this namespace contain the position of a CGPoint, in the non-averaged directions, and functions that only depend on which non-averaged directions are used. More...

Classes
class	Base_X_Y_Z
	Contains common member functions of the X, Y, and Z classes. More...
class	Base_XY_XZ_YZ
	Contains common member functions of the XY, XZ, and YZ classes. More...
class	BaseCoordinates
	Contains common member functions of the X, Y, and Z classes. More...
class	O
	Defines the non-averaged directions on which spatial coarse-graining is applied (none for O); all other directions (all for O) are averaged over homogeneously. More...
class	R
	Defines the non-averaged directions on which spatial coarse-graining is applied (the x-direction for R); all other directions are averaged over homogeneously. More...
class	RZ
	Defines the non-averaged directions on which spatial coarse-graining is applied (the x- and z-direction for RZ); all other directions are averaged over homogeneously. More...
class	X
	Defines the non-averaged directions on which spatial coarse-graining is applied (the x-direction for X); all other directions are averaged over homogeneously. More...
class	XY
	Defines the non-averaged directions on which spatial coarse-graining is applied (the x- and y-direction for XY); all other directions are averaged over homogeneously. More...
class	XYZ
	Defines the position of the CGPoint, in the non-averaged directions, i.e. all directions on which spatial coarse-graining is applied (all directions for XYZ); all other directions are averaged over homogeneously. More...
class	XZ
	Defines the non-averaged directions on which spatial coarse-graining is applied (the x- and z-direction for XZ); all other directions are averaged over homogeneously. More...
class	Y
	Defines the non-averaged directions on which spatial coarse-graining is applied (the y- direction for Y); all other directions are averaged over homogeneously. More...
class	YZ
	Defines the non-averaged directions on which spatial coarse-graining is applied (the y- and z-direction for YZ); all other directions are averaged over homogeneously. More...
class	Z
	Defines the non-averaged directions on which spatial coarse-graining is applied (the z-direction for Z); all other directions are averaged over homogeneously. More...

Functions
template<typename T >
std::enable_if< std::is_base_of< CGCoordinates::O, typename T::CoordinatesType >::value, void >::type	spaceEvenly (Vec3D min, Vec3D max, std::vector< std::size_t > nAll, std::vector< T > &points)
template<typename T >
std::enable_if< std::is_base_of< CGCoordinates::R, typename T::CoordinatesType >::value, void >::type	spaceEvenly (Vec3D min, Vec3D max, std::vector< std::size_t > nAll, std::vector< T > &points)
template<typename T >
std::enable_if< std::is_base_of< CGCoordinates::RZ, typename T::CoordinatesType >::value, void >::type	spaceEvenly (Vec3D min, Vec3D max, std::vector< std::size_t > nAll, std::vector< T > &points)
template<typename T >
std::enable_if< std::is_base_of< CGCoordinates::X, typename T::CoordinatesType >::value, void >::type	spaceEvenly (Vec3D min, Vec3D max, std::vector< std::size_t > nAll, std::vector< T > &points)
template<typename T >
std::enable_if< std::is_base_of< CGCoordinates::XY, typename T::CoordinatesType >::value, void >::type	spaceEvenly (Vec3D min, Vec3D max, std::vector< std::size_t > nAll, std::vector< T > &points)
template<typename T >
std::enable_if< std::is_base_of< CGCoordinates::XYZ, typename T::CoordinatesType >::value, void >::type	spaceEvenly (Vec3D min, Vec3D max, std::vector< std::size_t > n, std::vector< T > &points)
	Creates a spatial mesh of CGPoints, i.e. the spatial positions at which the cg-variables are evaluated. More...
template<typename T >
std::enable_if< std::is_base_of< CGCoordinates::XZ, typename T::CoordinatesType >::value, void >::type	spaceEvenly (Vec3D min, Vec3D max, std::vector< std::size_t > nAll, std::vector< T > &points)
template<typename T >
std::enable_if< std::is_base_of< CGCoordinates::Y, typename T::CoordinatesType >::value, void >::type	spaceEvenly (Vec3D min, Vec3D max, std::vector< std::size_t > nAll, std::vector< T > &points)
template<typename T >
std::enable_if< std::is_base_of< CGCoordinates::YZ, typename T::CoordinatesType >::value, void >::type	spaceEvenly (Vec3D min, Vec3D max, std::vector< std::size_t > nAll, std::vector< T > &points)
template<typename T >
std::enable_if< std::is_base_of< CGCoordinates::Z, typename T::CoordinatesType >::value, void >::type	spaceEvenly (Vec3D min, Vec3D max, std::vector< std::size_t > nAll, std::vector< T > &points)

Detailed Description

The class in this namespace contain the position of a CGPoint, in the non-averaged directions, and functions that only depend on which non-averaged directions are used.

Contains base classes of CGFunctions, which in turn contains the base classes of CGPoint; CGPoint's and CGFunctions are always templated with one of these classes. The classes currently are: O, X, Y, Z, YZ, XZ, XY, XYZ.

As the 1D classes X, Y, Z have some common functionality, they are derived from a common base class Base_X_Y_Z. Similarly, XY, XZ, YZ are derived from Base_XY_XZ_YZ.

See member CGCoordinates::XYZ for more details.

Function Documentation

spaceEvenly() [1/10]

template<typename T >

std::enable_if<std::is_base_of<CGCoordinates::XYZ, typename T::CoordinatesType>::value, void>::type CGCoordinates::spaceEvenly	(	Vec3D	min,
		Vec3D	max,
		std::vector< std::size_t >	n,
		std::vector< T > &	points
	)

Creates a spatial mesh of CGPoints, i.e. the spatial positions at which the cg-variables are evaluated.

The mesh is created over the domain [min.X,max.X].[min.Y,max.Y].[min.Z,max.Z]. The mesh is defined by splitting the domain into nx.ny.nz smaller cubical subdomains; the centers of these cubes are the mesh points. This is done to keep the results comparable to a binning method.

Parameters

[in]	min	the lower limit coordinate values of the meshed domain.
[in]	max	the upper limit coordinate values of the meshed domain.
[in]	n	the number of points in each spatial direction.
[out]	points	the vector of CGPoint's, which are now on a spatial mesh over the given domain.

{
    Vec3D delta = max - min;
    delta.X /= n[0];
    delta.Y /= n[1];
    delta.Z /= n[2];
    Vec3D start = min + 0.5 * delta;
    points.resize(n[0] * n[1] * n[2]);
    for (std::size_t i = 0; i < n[0]; i++)
    {
        for (std::size_t j = 0; j < n[1]; j++)
        {
            for (std::size_t k = 0; k < n[2]; k++)
            {
                points[(i * n[1] + j) * n[2] + k].coordinates.
                        setXYZ({start.X + delta.X * i,
                                start.Y + delta.Y * j,
                                start.Z + delta.Z * k});
            }
        }
    }
}

References constants::i, n, Vec3D::X, Vec3D::Y, and Vec3D::Z.

spaceEvenly() [2/10]

template<typename T >

std::enable_if<std::is_base_of<CGCoordinates::O, typename T::CoordinatesType>::value, void>::type CGCoordinates::spaceEvenly	(	Vec3D	min,
		Vec3D	max,
		std::vector< std::size_t >	nAll,
		std::vector< T > &	points
	)

See spaceEvenly for details.

{
    points.resize(1);
}

spaceEvenly() [3/10]

template<typename T >

std::enable_if<std::is_base_of<CGCoordinates::R, typename T::CoordinatesType>::value, void>::type CGCoordinates::spaceEvenly	(	Vec3D	min,
		Vec3D	max,
		std::vector< std::size_t >	nAll,
		std::vector< T > &	points
	)

See spaceEvenly for details.

Todo:

limit to r>0

{
    //note, the x-coordinate represents the r-coordinate here
    std::size_t n = nAll[0];
    Mdouble start = min.X;
    Mdouble delta = (max.X - start) / n;
//    Mdouble end = sqrt(mathsFunc::square(std::fmax(-min.X,max.X))+mathsFunc::square(std::fmax(-min.Y,max.Y)));
//    Mdouble start = 0;
//    Mdouble delta = (end - start) / n;
    if (start < 0.0)
    {
        if (max.X > 0.0)
        {
            start = 0.0;
        }
        else
        {
            start = -max.X;
            delta = (-min.X - start) / n;
        }
        logger(WARN, "r should be positive, but x-limits are not;"
                     "grid is set within % <r<%", start, start + delta * (n + 1));
    }
    start += 0.5 * delta;
    points.resize(n);
    for (std::size_t i = 0; i < n; i++)
    {
        points[i].coordinates.setR(start + delta * i);
    }
}

References constants::i, logger, n, WARN, and Vec3D::X.

spaceEvenly() [4/10]

template<typename T >

std::enable_if<std::is_base_of<CGCoordinates::RZ, typename T::CoordinatesType>::value, void>::type CGCoordinates::spaceEvenly	(	Vec3D	min,
		Vec3D	max,
		std::vector< std::size_t >	nAll,
		std::vector< T > &	points
	)

See spaceEvenly for details.

{
    std::size_t n0 = nAll[0];
    std::size_t n1 = nAll[2];
    Mdouble delta0 = (max.X - min.X) / n0;
    Mdouble delta1 = (max.Z - min.Z) / n1;
    Mdouble start0 = min.X + 0.5 * delta0;
    Mdouble start1 = min.Z + 0.5 * delta1;
    points.resize(n0 * n1);
    for (std::size_t i = 0; i < n0; i++)
    {
        for (std::size_t j = 0; j < n1; j++)
        {
            points[i * n1 + j].coordinates.setRZ(start0 + delta0 * i, start1 + delta1 * j);
        }
    }
}

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

spaceEvenly() [5/10]

template<typename T >

std::enable_if<std::is_base_of<CGCoordinates::X, typename T::CoordinatesType>::value, void>::type CGCoordinates::spaceEvenly	(	Vec3D	min,
		Vec3D	max,
		std::vector< std::size_t >	nAll,
		std::vector< T > &	points
	)

See spaceEvenly for details.

{
    std::size_t n = nAll[0];
    Mdouble delta = (max.X - min.X) / n;
    Mdouble start = min.X + 0.5 * delta;
    points.resize(n);
    for (std::size_t i = 0; i < n; i++)
    {
        points[i].coordinates.setX(start + delta * i);
    }
}

References constants::i, n, and Vec3D::X.

spaceEvenly() [6/10]

template<typename T >

std::enable_if<std::is_base_of<CGCoordinates::XY, typename T::CoordinatesType>::value, void>::type CGCoordinates::spaceEvenly	(	Vec3D	min,
		Vec3D	max,
		std::vector< std::size_t >	nAll,
		std::vector< T > &	points
	)

See spaceEvenly for details.

{
    std::size_t n0 = nAll[0];
    std::size_t n1 = nAll[1];
    Mdouble delta0 = (max.X - min.X) / n0;
    Mdouble delta1 = (max.Y - min.Y) / n1;
    Mdouble start0 = min.X + 0.5 * delta0;
    Mdouble start1 = min.Y + 0.5 * delta1;
    points.resize(n0 * n1);
    for (std::size_t i = 0; i < n0; i++)
    {
        for (std::size_t j = 0; j < n1; j++)
        {
            points[i * n1 + j].coordinates.setXY(start0 + delta0 * i, start1 + delta1 * j);
        }
    }
}

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

spaceEvenly() [7/10]

template<typename T >

std::enable_if<std::is_base_of<CGCoordinates::XZ, typename T::CoordinatesType>::value, void>::type CGCoordinates::spaceEvenly	(	Vec3D	min,
		Vec3D	max,
		std::vector< std::size_t >	nAll,
		std::vector< T > &	points
	)

See spaceEvenly for details.

{
    std::size_t n0 = nAll[0];
    std::size_t n1 = nAll[2];
    Mdouble delta0 = (max.X - min.X) / n0;
    Mdouble delta1 = (max.Z - min.Z) / n1;
    Mdouble start0 = min.X + 0.5 * delta0;
    Mdouble start1 = min.Z + 0.5 * delta1;
    points.resize(n0 * n1);
    for (std::size_t i = 0; i < n0; i++)
    {
        for (std::size_t j = 0; j < n1; j++)
        {
            points[i * n1 + j].coordinates.setXZ(start0 + delta0 * i, start1 + delta1 * j);
        }
    }
}

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

spaceEvenly() [8/10]

template<typename T >

std::enable_if<std::is_base_of<CGCoordinates::Y, typename T::CoordinatesType>::value, void>::type CGCoordinates::spaceEvenly	(	Vec3D	min,
		Vec3D	max,
		std::vector< std::size_t >	nAll,
		std::vector< T > &	points
	)

See spaceEvenly for details.

{
    std::size_t n = nAll[1];
    Mdouble delta = (max.Y - min.Y) / n;
    Mdouble start = min.Y + 0.5 * delta;
    points.resize(n);
    for (std::size_t i = 0; i < n; i++)
    {
        points[i].coordinates.setY(start + delta * i);
    }
}

References constants::i, n, and Vec3D::Y.

spaceEvenly() [9/10]

template<typename T >

std::enable_if<std::is_base_of<CGCoordinates::YZ, typename T::CoordinatesType>::value, void>::type CGCoordinates::spaceEvenly	(	Vec3D	min,
		Vec3D	max,
		std::vector< std::size_t >	nAll,
		std::vector< T > &	points
	)

See spaceEvenly for details.

{
    std::size_t n0 = nAll[1];
    std::size_t n1 = nAll[2];
    Mdouble delta0 = (max.Y - min.Y) / n0;
    Mdouble delta1 = (max.Z - min.Z) / n1;
    Mdouble start0 = min.Y + 0.5 * delta0;
    Mdouble start1 = min.Z + 0.5 * delta1;
    points.resize(n0 * n1);
    for (std::size_t i = 0; i < n0; i++)
    {
        for (std::size_t j = 0; j < n1; j++)
        {
            points[i * n1 + j].coordinates.setYZ(start0 + delta0 * i, start1 + delta1 * j);
        }
    }
}

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

spaceEvenly() [10/10]

template<typename T >

std::enable_if<std::is_base_of<CGCoordinates::Z, typename T::CoordinatesType>::value, void>::type CGCoordinates::spaceEvenly	(	Vec3D	min,
		Vec3D	max,
		std::vector< std::size_t >	nAll,
		std::vector< T > &	points
	)

See spaceEvenly for details.

{
    std::size_t n = nAll[2];
    Mdouble delta = (max.Z - min.Z) / n;
    Mdouble start = min.Z + 0.5 * delta;
    points.resize(n);
    for (std::size_t i = 0; i < n; i++)
    {
        points[i].coordinates.setZ(start + delta * i);
    }
}

References constants::i, n, and Vec3D::Z.