dg::geo::aRealGenerator2d< real_type > Struct Template Reference

The abstract generator base class. More...

Inheritance diagram for dg::geo::aRealGenerator2d< real_type >:

Public Member Functions
real_type	width () const
	length in $\zeta$ of the computational space
real_type	height () const
	length in $\eta$ of the computational space
bool	isOrthogonal () const
	sparsity pattern for metric
void	generate (const thrust::host_vector< real_type > &zeta1d, const thrust::host_vector< real_type > &eta1d, thrust::host_vector< real_type > &x, thrust::host_vector< real_type > &y, thrust::host_vector< real_type > &zetaX, thrust::host_vector< real_type > &zetaY, thrust::host_vector< real_type > &etaX, thrust::host_vector< real_type > &etaY) const
	Generate grid points and elements of the Jacobian.
virtual aRealGenerator2d *	clone () const =0
	Abstract clone method that returns a copy on the heap.
virtual	~aRealGenerator2d ()

Protected Member Functions
	aRealGenerator2d ()
	empty
	aRealGenerator2d (const aRealGenerator2d &)
	empty
aRealGenerator2d &	operator= (const aRealGenerator2d &)
	return *this

Detailed Description

template<class real_type>
struct dg::geo::aRealGenerator2d< real_type >

The abstract generator base class.

A generator is there to construct coordinate transformations from physical coordinates $x,y$ to the computational domain $\zeta ,\eta$, which is a product space. It can be used to construct curvilinear grids like the following code snippet demonstrates:

    std::unique_ptr<dg::geo::aGenerator2d> generator;
    //create the magnetic field
    dg::geo::TokamakMagneticField mag = dg::geo::createMagneticField(
            js["magnetic_field"]["params"]);
    //create a grid generator
    std::string type = js["grid"]["generator"]["type"].asString();
    int mode = 0;
    if( type != "dsp")
        mode = js["grid"]["generator"]["mode"].asInt();
    std::cout << "Constructing "<<type<<" grid ... \n";
    if( type == "flux")
        generator = std::make_unique<dg::geo::FluxGenerator>( mag.get_psip(),
                mag.get_ipol(), psi_0, psi_1, mag.R0(), 0., mode, false);
    else if( type == "orthogonal")
    {
        double psi_init = js["grid"]["generator"]["firstline"].asDouble();
        if( mode == 0 || mode == 1)
            generator = std::make_unique<dg::geo::SimpleOrthogonal>(
                mag.get_psip(), psi_0, psi_1, mag.R0(), 0., psi_init, mode);
        if( mode > 1)
        {
            dg::geo::CylindricalSymmTensorLvl1 lc =
                dg::geo::make_LiseikinCollective( mag.get_psip(), 0.1, 0.001);
            generator = std::make_unique<dg::geo::SimpleOrthogonal>(
                mag.get_psip(), lc, psi_0, psi_1, mag.R0(), 0., psi_init,
                mode%2);
        }
    }
    else if( type == "separatrix-orthogonal")
    {
        double RX = mag.R0()-1.1*mag.params().triangularity()*mag.params().a();
        double ZX = -1.1*mag.params().elongation()*mag.params().a();
        dg::geo::findXpoint( mag.get_psip(), RX, ZX);
        //dg::geo::CylindricalSymmTensorLvl1 monitor_chi;
        dg::geo::CylindricalSymmTensorLvl1 monitor_chi = dg::geo::make_Xconst_monitor( mag.get_psip(), RX, ZX) ;
        double fx = js["grid"]["generator"]["fx"].asDouble();
        generator = std::make_unique<dg::geo::SeparatrixOrthogonalAdaptor>(
            mag.get_psip(), monitor_chi, psi_0, RX, ZX, mag.R0(), 0., mode, false, fx);
        //psi_1 = -fx/(1.-fx)*psi_0;
    }
    else if ( type == "dsp")
    {
        double boxscaleRm  = js["grid"][ "scaleR"].get( 0u, 1.05).asDouble();
        double boxscaleRp  = js["grid"][ "scaleR"].get( 1u, 1.05).asDouble();
        double boxscaleZm  = js["grid"][ "scaleZ"].get( 0u, 1.05).asDouble();
        double boxscaleZp  = js["grid"][ "scaleZ"].get( 1u, 1.05).asDouble();
        const double Rmin=mag.R0()-boxscaleRm*mag.params().a();
        const double Zmin=-boxscaleZm*mag.params().a();
        const double Rmax=mag.R0()+boxscaleRp*mag.params().a();
        const double Zmax=boxscaleZp*mag.params().a();
        generator = std::make_unique<dg::geo::DSPGenerator>( mag,
            Rmin, Rmax, Zmin, Zmax, 2.*M_PI/(double)Nz);
    }
    else if( type == "ribeiro-flux")
        generator = std::make_unique<dg::geo::RibeiroFluxGenerator>( mag.get_psip(),
                psi_0, psi_1, mag.R0(), 0., mode, false);
    else if( type == "ribeiro")
        generator = std::make_unique<dg::geo::Ribeiro>( mag.get_psip(),
                psi_0, psi_1, mag.R0(), 0., mode, false);

Note

the origin of the computational space is assumed to be (0,0)

Constructor & Destructor Documentation

~aRealGenerator2d()

template<class real_type >

virtual dg::geo::aRealGenerator2d< real_type >::~aRealGenerator2d ( )

inlinevirtual

aRealGenerator2d() [1/2]

template<class real_type >

dg::geo::aRealGenerator2d< real_type >::aRealGenerator2d ( )

inlineprotected

empty

aRealGenerator2d() [2/2]

template<class real_type >

dg::geo::aRealGenerator2d< real_type >::aRealGenerator2d ( const aRealGenerator2d< real_type > & )

inlineprotected

empty

Member Function Documentation

clone()

template<class real_type >

virtual aRealGenerator2d * dg::geo::aRealGenerator2d< real_type >::clone ( ) const

pure virtual

Abstract clone method that returns a copy on the heap.

Returns

a copy of *this on the heap

Implemented in dg::geo::DSPGenerator, dg::geo::FluxGenerator, dg::geo::Hector< IMatrix, Matrix, container >, dg::geo::LogPolarGenerator, dg::geo::PolarGenerator, dg::geo::Ribeiro, dg::geo::RibeiroFluxGenerator, dg::geo::SeparatrixOrthogonalAdaptor, and dg::geo::SimpleOrthogonal.

generate()

template<class real_type >

void dg::geo::aRealGenerator2d< real_type >::generate ( const thrust::host_vector< real_type > & zeta1d, const thrust::host_vector< real_type > & eta1d, thrust::host_vector< real_type > & x, thrust::host_vector< real_type > & y, thrust::host_vector< real_type > & zetaX, thrust::host_vector< real_type > & zetaY, thrust::host_vector< real_type > & etaX, thrust::host_vector< real_type > & etaY ) const

inline

Generate grid points and elements of the Jacobian.

Parameters

zeta1d	(input) a list of $N_{\zeta }$ points $0<{\zeta }_i<$width()
eta1d	(input) a list of $N_{\eta }$ points $0<{\eta }_j<$height()
x	(output) the list of $N_{\eta }{N}_{\zeta }$ coordinates $x({\zeta }_i,{\eta }_j)$
y	(output) the list of $N_{\eta }{N}_{\zeta }$ coordinates $y({\zeta }_i,{\eta }_j)$
zetaX	(output) the list of $N_{\eta }{N}_{\zeta }$ elements $\partial \zeta /\partial x({\zeta }_i,{\eta }_j)$
zetaY	(output) the list of $N_{\eta }{N}_{\zeta }$ elements $\partial \zeta /\partial y({\zeta }_i,{\eta }_j)$
etaX	(output) the list of $N_{\eta }{N}_{\zeta }$ elements $\partial \eta /\partial x({\zeta }_i,{\eta }_j)$
etaY	(output) the list of $N_{\eta }{N}_{\zeta }$ elements $\partial \eta /\partial y({\zeta }_i,{\eta }_j)$

Note

the first ( $\zeta$) coordinate shall be constructed contiguously in memory, i.e. the resuling lists are $x_0=x({\zeta }_0,{\eta }_0),x_1=x({\zeta }_1,{\eta }_0)x_2=x({\zeta }_2,{\eta }_0)\dots x_{NM-1}=x({\zeta }_{N-1}{\eta }_{M-1})$

All the resulting vectors are write-only and get properly resized

height()

template<class real_type >

real_type dg::geo::aRealGenerator2d< real_type >::height ( ) const

inline

length in $\eta$ of the computational space

isOrthogonal()

template<class real_type >

bool dg::geo::aRealGenerator2d< real_type >::isOrthogonal ( ) const

inline

sparsity pattern for metric

operator=()

template<class real_type >

aRealGenerator2d & dg::geo::aRealGenerator2d< real_type >::operator= ( const aRealGenerator2d< real_type > & )

inlineprotected

return *this

width()

template<class real_type >

real_type dg::geo::aRealGenerator2d< real_type >::width ( ) const

inline

length in $\zeta$ of the computational space

---

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

• generator.h