Output_Data::p1x1_1D Class Reference

#include <export.h>

Public Member Functions
	p1x1_1D (const Grid_Info &_G)
	p1x1_1D (const p1x1_1D &other)
	~p1x1_1D ()
valarray< float >	operator() (DistFunc1D &df, size_t x0, size_t s)
size_t	Species () const
float	Pmin (size_t s) const
float	Pmax (size_t s) const
valarray< float >	p1_x1 (size_t s) const

Private Attributes
vector< valarray< float > >	p1x1
vector< float >	pmin
vector< float >	pmax

Detailed Description

Definition at line 290 of file export.h.

Constructor & Destructor Documentation

p1x1_1D() [1/2]

Output_Data::p1x1_1D::p1x1_1D

(

const Grid_Info &

_G

)

Definition at line 962 of file export.cpp.

References Grid_Info::axis, Algorithms::AxisBundle< T >::Npx(), Algorithms::AxisBundle< T >::pdim(), and Algorithms::AxisBundle< T >::pmax().

                                                {

//  Generate the required structures
    for (size_t s(0); s < _G.axis.pdim(); ++s) {
        pmax.push_back( static_cast<float>(_G.axis.pmax(s)) );
        pmin.push_back( static_cast<float>(-1.0*_G.axis.pmax(s)) );
//        Pl.push_back( PLegendre1D( _G.l0[s], _G.m0[s], _G.axis.Np(s), static_cast<float>(_G.axis.pmin(s)),
//                                   static_cast<float>(_G.axis.pmax(s)), _G.axis.Npx(s) ) );
//
//        polarR.push_back( Array2D<float>( _G.axis.Npx(s), _G.axis.Np(s) ) );

        p1x1.push_back( valarray<float>( _G.axis.Npx(s)) );

    }

/*//  Calculate a 2D array for the polar radius for each px and pr
    for (size_t s(0); s < _G.axis.pdim(); ++s) {
        valarray<float> p( Algorithms::MakeAxis( pmin[s], pmax[s], _G.axis.Np(s) )),
                px(Algorithms::MakeAxis( float(-1.0)* pmax[s], pmax[s], _G.axis.Npx(s) ));
//      --->
        for (size_t i(0); i < _G.axis.Npx(s); ++i){
            for (size_t j(0); j < _G.axis.Np(s); ++j){
                float polarR_sq  = p[j] * p[j] - px[i] * px[i];
                if (polarR_sq < 0.0) {
                    polarR[s](i,j) = -1.0;
                }
                else {
                    polarR[s](i,j)  = sqrt(abs(polarR_sq));
                }
                // std::cout << "\n polarR[s](" << px[i] << ',' << p[j] << ") = " << polarR[s](i,j) << "\n";
            }
        }
//      <---
    }*/
//    p1x1 = new valarray<float>(Npx);
}

Here is the call graph for this function:

p1x1_1D() [2/2]

Output_Data::p1x1_1D::p1x1_1D

(

const p1x1_1D &

other

)

Definition at line 1000 of file export.cpp.

References p1_x1(), Pmax(), Pmin(), and Species().

                                                 {

    for (size_t s(0); s < other.Species(); ++s) {
        pmin.push_back( other.Pmin(s) );
        pmax.push_back( other.Pmax(s) );
//        Pl.push_back( other.PL(s) );
//        polarR.push_back( other.PolarR(s) );
        p1x1.push_back( other.p1_x1(s) );
    }
}

Here is the call graph for this function:

~p1x1_1D()

Output_Data::p1x1_1D::~p1x1_1D

(

)

Definition at line 1012 of file export.cpp.

                            {
    // delete p1x1;
}

Member Function Documentation

operator()()

valarray< float > Output_Data::p1x1_1D::operator()	(	DistFunc1D &	df,
		size_t	x0,
		size_t	s
	)

Definition at line 1020 of file export.cpp.

References DistFunc1D::dim().

                                                                                   {

    p1x1[s] = 0.0; // this is a valarray<float>
    vector<complex<double> > dummyvec;

/*    float p_im1(0.0), p_ip1(0.0);
    float integrant_low(0.0),
            integrant_high(0.0);

//  Calculate the integral for each harmonic separately
//     for (size_t l(0); l < Nl(s); ++l) { 
    for (size_t i(0); i < (Pl[s]).dim(); ++i) {

        valarray<float> InPx( Npx(s) );
        for (size_t ipx(0); ipx < Npx(s)-1; ++ipx) { // at each location in px

// //          At each location in |p|
            size_t ip(0);
            while (polarR[s](ipx,ip) < 0 ) { ++ip; }

            p_ip1 = polarR[s](ipx,ip);
            integrant_high =(float( (df(i))(ip,x0).real() ))*Pl[s](i)(ipx, ip) ;



            InPx[ipx] += p_ip1 * (0.5*p_ip1) * integrant_high;
            ++ip;
            while ( (ip < Np(s) ) && (polarR[s](ipx,ip) > 0)  )   {
                p_im1 = p_ip1;
                integrant_low = integrant_high;

                p_ip1 = polarR[s](ipx,ip);
                integrant_high =(float( (df(i))(ip,x0).real() )) * Pl[s](i)(ipx, ip);

                InPx[ipx] += p_im1 * (0.5*(p_ip1-p_im1)) * integrant_low;
                InPx[ipx] += p_ip1 * (0.5*(p_ip1-p_im1)) * integrant_high;

                ++ip;
            }
            // if (i==3) std::cout << "\n p1x1[s](" << ipx << ',' << ip << ") = " << InPx[ipx] << "\n";
            (p1x1[s])[ipx] = integrant_high;
        }
    }*/

    int sgn(1);
    size_t midpoint,ipxp,ipxm;

    for (size_t i(0); i < df.dim(); ++i)
    {
        dummyvec = df(i).xVec(x0);

        midpoint = df(0,0).nump();
        p1x1[s][midpoint] = (float) ((dummyvec[0]).real());
        for (size_t ip(0); ip < df(0,0).nump(); ++ip)
        {
            ipxm = midpoint - 1 - ip;
            ipxp = midpoint + 1 + ip;

            (p1x1[s])[ipxm] += (float) (sgn*(dummyvec[ip]).real());
            (p1x1[s])[ipxp] += (float) ((dummyvec[ip]).real());
        }
        sgn *= -1;
    }

//    p1x1[s] *= 2.0 * M_PI;
    // exit(1);
    return p1x1[s];
}

Here is the call graph for this function:

p1_x1()

valarray<float> Output_Data::p1x1_1D::p1_x1 ( size_t  s ) const

inline

Definition at line 311 of file export.h.

Referenced by p1x1_1D().

{ return p1x1[s]; }

Here is the caller graph for this function:

Pmax()

float Output_Data::p1x1_1D::Pmax ( size_t  s ) const

inline

Definition at line 308 of file export.h.

Referenced by p1x1_1D().

{ return pmax[s]; }

Here is the caller graph for this function:

Pmin()

float Output_Data::p1x1_1D::Pmin ( size_t  s ) const

inline

Definition at line 307 of file export.h.

Referenced by p1x1_1D().

{ return pmin[s]; }

Here is the caller graph for this function:

Species()

size_t Output_Data::p1x1_1D::Species ( ) const

inline

Definition at line 303 of file export.h.

Referenced by p1x1_1D().

{ return p1x1.size(); }

Here is the caller graph for this function:

Field Documentation

p1x1

vector< valarray<float> > Output_Data::p1x1_1D::p1x1

private

Definition at line 318 of file export.h.

pmax

vector<float> Output_Data::p1x1_1D::pmax

private

Definition at line 319 of file export.h.

pmin

vector<float> Output_Data::p1x1_1D::pmin

private

Definition at line 319 of file export.h.

---

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

• /Users/archis/Dropbox/work/dev/oshun/oshun-OS/OSHUN/1d_cpp/source/export.h
• /Users/archis/Dropbox/work/dev/oshun/oshun-OS/OSHUN/1d_cpp/source/export.cpp