dg::geo::RibeiroFluxGenerator Struct Reference

Same as the Ribeiro class but uses \( \zeta = f_0 (\psi_p - \psi_0)\) as a flux label directly. More...

Inheritance diagram for dg::geo::RibeiroFluxGenerator:

Public Member Functions
	RibeiroFluxGenerator (const CylindricalFunctorsLvl2 &psi, double psi_0, double psi_1, double x0, double y0, int mode=0, bool verbose=false)
	Construct a flux aligned grid generator.
virtual RibeiroFluxGenerator *	clone () const
	Abstract clone method that returns a copy on the heap.
Public Member Functions inherited from dg::geo::aRealGenerator2d< real_type >
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 ()

Additional Inherited Members
Protected Member Functions inherited from dg::geo::aRealGenerator2d< real_type >
	aRealGenerator2d ()
	empty
	aRealGenerator2d (const aRealGenerator2d &)
	empty
aRealGenerator2d &	operator= (const aRealGenerator2d &)
	return *this

Detailed Description

Same as the Ribeiro class but uses \( \zeta = f_0 (\psi_p - \psi_0)\) as a flux label directly.

The radial coordinate is given by \( \zeta = f_0 (\psi_p - \psi_0)\).

The poloidal coordinate lines are given by

\begin{align} \frac{d R}{d \eta} &= \frac{ 1}{f(\psi_p)(\nabla\psi_p)^2} \frac{\partial \psi_p}{\partial Z} \\ \frac{d Z}{d \eta} &= -\frac{ 1}{f(\psi_p)(\nabla\psi_p)^2} \frac{\partial \psi_p}{\partial R} \end{align}

, where \( f(\psi_p)\) is the normalisation constant that makes the poloidal \( \eta\) coordinate go from 0 to \(2\pi\).

When an "equalarc" adaption is chosen then the integration is changed to

\begin{align} \frac{d R}{d \eta} &= \frac{ 1}{f(\psi_p)|\nabla\psi_p|} \frac{\partial \psi_p}{\partial Z} \\ \frac{d Z}{d \eta} &= -\frac{ 1}{f(\psi_p)|\nabla\psi_p|} \frac{\partial \psi_p}{\partial R} \end{align}

,

    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);

Constructor & Destructor Documentation

RibeiroFluxGenerator()

dg::geo::RibeiroFluxGenerator::RibeiroFluxGenerator ( const CylindricalFunctorsLvl2 & psi, double psi_0, double psi_1, double x0, double y0, int mode = 0, bool verbose = false )

inline

Construct a flux aligned grid generator.

Parameters

psi	\( \psi(x,y)\) the flux function and its derivatives in Cartesian coordinates (x,y)
psi_0	first boundary
psi_1	second boundary
x0	a point in the inside of the domain bounded by psi_0 (shouldn't be the O-point)
y0	a point in the inside of the domain bounded by psi_0 (shouldn't be the O-point)
mode	This parameter indicates the adaption type used to create the grid: 0 is no adaption, 1 is an equalarc adaption
verbose	if true the integrators will write additional information to std::cout

Member Function Documentation

clone()

virtual RibeiroFluxGenerator * dg::geo::RibeiroFluxGenerator::clone ( ) const

inlinevirtual

Abstract clone method that returns a copy on the heap.

Returns

a copy of *this on the heap

Implements dg::geo::aRealGenerator2d< real_type >.

---

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

• flux.h