dg::geo::FluxGenerator Struct Reference

A symmetry flux generator. More...

Inheritance diagram for dg::geo::FluxGenerator:

Public Member Functions
	FluxGenerator (const CylindricalFunctorsLvl2 &psi, const CylindricalFunctorsLvl1 &ipol, double psi_0, double psi_1, double x0, double y0, int mode=0, bool verbose=false)
	Construct a symmetry flux grid generator.
virtual FluxGenerator *	clone () const override final
	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

A symmetry flux generator.

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

The poloidal coordinate lines are obtained by integrating

\begin{align} \frac{d R}{d \eta} &= \frac{B^R}{B^\eta} = \frac{q R}{I} \frac{\partial \psi_p}{\partial Z} \\ \frac{d Z}{d \eta} &= \frac{B^Z}{B^\eta} = -\frac{q R}{I} \frac{\partial \psi_p}{\partial R} \end{align}

, i.e. is obtained from a magnetic field where the \( B^\varphi\) component is scaled by the safety factor \( q(\psi_p)\), which can here be understood as the normalisation constant that makes the poloidal \( \eta\) coordinate go from 0 to \(2\pi\). Symmetry flux coordinates fulfill the condition \(\sqrt{g} = \frac{R}{I}\).

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}

, where \( f(\psi_p)\) is the normalization constant now.

The symmetry refers to the symmetry in the toroidal angle while flux coordinates allow the representation of the magnetic field in Clebsch form

    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

FluxGenerator()

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

inline

Construct a symmetry flux grid generator.

Parameters

psi	\( \psi(x,y)\) the flux function and its derivatives in Cartesian coordinates (x,y)
ipol	\( I(x,y)\) the current 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

Note

If mode==1 then this class does the same as the RibeiroFluxGenerator

Member Function Documentation

clone()

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

inlinefinaloverridevirtual

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