Output_Data::Output_Preprocessor_1D Class Reference

#include <export.h>

Collaboration diagram for Output_Data::Output_Preprocessor_1D:

Public Member Functions
	Output_Preprocessor_1D (const Grid_Info &_grid, const vector< string > _oTags, string homedir="")
void	operator() (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	distdump (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)

Private Member Functions
void	Ex (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	Ey (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	Ez (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	Bx (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	By (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	Bz (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	px (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	f0 (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	f10 (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	f11 (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	f20 (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	fl0 (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	n (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	T (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	Jx (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	Jy (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	Jz (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	Qx (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	Qy (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	Qz (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	vNx (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	vNy (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	vNz (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	Ux (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	Uy (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	Uz (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	Z (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	ni (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)
void	Ti (const State1D &Y, const Grid_Info &grid, const size_t tout, const Parallel_Environment_1D &PE)

Private Attributes
size_t	Nbc
Export_Files::Xport	expo
p1x1_1D	px_x
fx1_1D	f_x
vector< string >	oTags

Detailed Description

Definition at line 406 of file export.h.

Constructor & Destructor Documentation

Output_Preprocessor_1D()

Output_Data::Output_Preprocessor_1D::Output_Preprocessor_1D ( const Grid_Info &  _grid, const vector< string >  _oTags, string  homedir = ""  )

inline

Definition at line 410 of file export.h.

        : expo( _grid.axis, _oTags, homedir),
          px_x( _grid ), //pxpy_x( _grid),
          f_x( _grid),
          oTags(_oTags) { }

Member Function Documentation

Bx()

void Output_Data::Output_Preprocessor_1D::Bx ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 1571 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, EMF1D::Bx(), State1D::EMF(), Input::List(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), and Parallel_Environment_1D::RANK().

                                                                                {

    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;
    size_t st(0), bi(0);
    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    int msg_sz(outNxLocal); //*szy);
    float* Bxbuf = new float[msg_sz];
    valarray<float> BxGlobal(outNxGlobal); //, yglob_axis.dim());

    for(size_t i(0); i < msg_sz; ++i) {
        Bxbuf[i] = static_cast<float>( Y.EMF().Bx()(Nbc+i).real() );
    }

    if (PE.NODES() > 1) {
        if (PE.RANK()!=0) {
            MPI_Send(Bxbuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
        }
        else {
            // Fill data for rank = 0
            for(size_t i(0); i < outNxLocal; i++) {
                BxGlobal[i] = Bxbuf[i];
            }
            // Fill data for rank > 0
            for (int rr = 1; rr < PE.NODES(); ++rr){
                MPI_Recv(Bxbuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);
                for(size_t i(0); i < outNxLocal; i++) {
                    BxGlobal[i + outNxLocal*rr] = Bxbuf[i];
                }
            }
        }
    }
        // Fill data for Nodes = 0
    else {
        for(size_t i(0); i < outNxGlobal; i++) {
            BxGlobal[i] = Bxbuf[i];
        }
    }

    if (PE.RANK() == 0) expo.Export_h5("Bx", BxGlobal, tout);

    delete[] Bxbuf;

}

Here is the call graph for this function:

By()

void Output_Data::Output_Preprocessor_1D::By ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 1621 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, EMF1D::By(), State1D::EMF(), Input::List(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), and Parallel_Environment_1D::RANK().

                                                                                {

    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;
    size_t st(0), bi(0);
    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    int msg_sz(outNxLocal); //*szy);
    float* Bybuf = new float[msg_sz];
    valarray<float> ByGlobal(outNxGlobal); //, yglob_axis.dim());

    for(size_t i(0); i < msg_sz; ++i) {
        Bybuf[i] = static_cast<float>( Y.EMF().By()(Nbc+i).real() );
    }

    if (PE.NODES() > 1) {
        if (PE.RANK()!=0) {
            MPI_Send(Bybuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
        }
        else {
            // Fill data for rank = 0
            for(size_t i(0); i < outNxLocal; i++) {
                ByGlobal[i] = Bybuf[i];
            }
            // Fill data for rank > 0
            for (int rr = 1; rr < PE.NODES(); ++rr){
                MPI_Recv(Bybuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);
                for(size_t i(0); i < outNxLocal; i++) {
                    ByGlobal[i + outNxLocal*rr] = Bybuf[i];
                }
            }
        }
    }
        // Fill data for Nodes = 0
    else {
        for(size_t i(0); i < outNxGlobal; i++) {
            ByGlobal[i] = Bybuf[i];
        }
    }

    if (PE.RANK() == 0) expo.Export_h5("By", ByGlobal, tout);

    delete[] Bybuf;

}

Here is the call graph for this function:

Bz()

void Output_Data::Output_Preprocessor_1D::Bz ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 1671 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, EMF1D::Bz(), State1D::EMF(), Input::List(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), and Parallel_Environment_1D::RANK().

                                                                                {

    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;
    size_t st(0), bi(0);
    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    int msg_sz(outNxLocal); //*szy);
    float* Bzbuf = new float[msg_sz];
    valarray<float> BzGlobal(outNxGlobal); //, yglob_axis.dim());

    for(size_t i(0); i < msg_sz; ++i) {
        Bzbuf[i] = static_cast<float>( Y.EMF().Bz()(Nbc+i).real() );
    }

    if (PE.NODES() > 1) {
        if (PE.RANK()!=0) {
            MPI_Send(Bzbuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
        }
        else {
            // Fill data for rank = 0
            for(size_t i(0); i < outNxLocal; i++) {
                BzGlobal[i] = Bzbuf[i];
            }
            // Fill data for rank > 0
            for (int rr = 1; rr < PE.NODES(); ++rr){
                MPI_Recv(Bzbuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);
                for(size_t i(0); i < outNxLocal; i++) {
                    BzGlobal[i + outNxLocal*rr] = Bzbuf[i];
                }
            }
        }
    }
        // Fill data for Nodes = 0
    else {
        for(size_t i(0); i < outNxGlobal; i++) {
            BzGlobal[i] = Bzbuf[i];
        }
    }

    if (PE.RANK() == 0) expo.Export_h5("Bz", BzGlobal, tout);

    delete[] Bzbuf;

}

Here is the call graph for this function:

distdump()

void Output_Data::Output_Preprocessor_1D::distdump	(	const State1D &	Y,
		const Grid_Info &	grid,
		const size_t	tout,
		const Parallel_Environment_1D &	PE
	)

Definition at line 1389 of file export.cpp.

References Input::List().

Referenced by main().

                                                                                      {

    if (Input::List().o_p1x1){
        px( Y, grid, tout, PE );
    }
    if (Input::List().o_f0x1){
        f0( Y, grid, tout, PE );
    }
    if (Input::List().o_f10x1){
        f10( Y, grid, tout, PE );
    }
    if (Input::List().o_f11x1){
        f11( Y, grid, tout, PE );
    }
    if (Input::List().o_f20x1){
        f20( Y, grid, tout, PE );
    }
    if (Input::List().o_fl0x1){
        fl0( Y, grid, tout, PE );
    }
//    if (Input::List().o_p2p1x1){
//        pxpy( Y, grid, tout, PE );
//    }

}

Here is the call graph for this function:

Here is the caller graph for this function:

Ex()

void Output_Data::Output_Preprocessor_1D::Ex ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 1421 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, State1D::EMF(), EMF1D::Ex(), Input::List(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), and Parallel_Environment_1D::RANK().

                                                                                {

    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;
    size_t st(0), bi(0);
    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    int msg_sz(outNxLocal); //*szy);
    float* Exbuf = new float[msg_sz];
    valarray<float> ExGlobal(outNxGlobal); //, yglob_axis.dim());

    for(size_t i(0); i < msg_sz; ++i) {
        Exbuf[i] = static_cast<float>( Y.EMF().Ex()(Nbc+i).real() );
    }

    if (PE.NODES() > 1) {
        if (PE.RANK()!=0) {
            MPI_Send(Exbuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
        }
        else {
            // Fill data for rank = 0
            for(size_t i(0); i < outNxLocal; i++) {
                ExGlobal[i] = Exbuf[i];
            }
            // Fill data for rank > 0
            for (int rr = 1; rr < PE.NODES(); ++rr){
                MPI_Recv(Exbuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);
                for(size_t i(0); i < outNxLocal; i++) {
                    ExGlobal[i + outNxLocal*rr] = Exbuf[i];
                }
            }
        }
    }
        // Fill data for Nodes = 0
    else {
        for(size_t i(0); i < outNxGlobal; i++) {
            ExGlobal[i] = Exbuf[i];
        }
    }

    if (PE.RANK() == 0) expo.Export_h5("Ex", ExGlobal, tout);

    delete[] Exbuf;

}

Here is the call graph for this function:

Ey()

void Output_Data::Output_Preprocessor_1D::Ey ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 1471 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, State1D::EMF(), EMF1D::Ey(), Input::List(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), and Parallel_Environment_1D::RANK().

                                                                                {

    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;
    size_t st(0), bi(0);
    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    int msg_sz(outNxLocal); //*szy);
    float* Eybuf = new float[msg_sz];
    valarray<float> EyGlobal(outNxGlobal); //, yglob_axis.dim());

    for(size_t i(0); i < msg_sz; ++i) {
        Eybuf[i] = static_cast<float>( Y.EMF().Ey()(Nbc+i).real() );
    }

    if (PE.NODES() > 1) {
        if (PE.RANK()!=0) {
            MPI_Send(Eybuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
        }
        else {
            // Fill data for rank = 0
            for(size_t i(0); i < outNxLocal; i++) {
                EyGlobal[i] = Eybuf[i];
            }
            // Fill data for rank > 0
            for (int rr = 1; rr < PE.NODES(); ++rr){
                MPI_Recv(Eybuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);
                for(size_t i(0); i < outNxLocal; i++) {
                    EyGlobal[i + outNxLocal*rr] = Eybuf[i];
                }
            }
        }
    }
        // Fill data for Nodes = 0
    else {
        for(size_t i(0); i < outNxGlobal; i++) {
            EyGlobal[i] = Eybuf[i];
        }
    }

    if (PE.RANK() == 0) expo.Export_h5("Ey", EyGlobal, tout);

    delete[] Eybuf;

}

Here is the call graph for this function:

Ez()

void Output_Data::Output_Preprocessor_1D::Ez ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 1521 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, State1D::EMF(), EMF1D::Ez(), Input::List(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), and Parallel_Environment_1D::RANK().

                                                                                {

    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;
    size_t st(0), bi(0);
    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    int msg_sz(outNxLocal); //*szy);
    float* Ezbuf = new float[msg_sz];
    valarray<float> EzGlobal(outNxGlobal); //, yglob_axis.dim());

    for(size_t i(0); i < msg_sz; ++i) {
        Ezbuf[i] = static_cast<float>( Y.EMF().Ez()(Nbc+i).real() );
    }

    if (PE.NODES() > 1) {
        if (PE.RANK()!=0) {
            MPI_Send(Ezbuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
        }
        else {
            // Fill data for rank = 0
            for(size_t i(0); i < outNxLocal; i++) {
                EzGlobal[i] = Ezbuf[i];
            }
            // Fill data for rank > 0
            for (int rr = 1; rr < PE.NODES(); ++rr){
                MPI_Recv(Ezbuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);
                for(size_t i(0); i < outNxLocal; i++) {
                    EzGlobal[i + outNxLocal*rr] = Ezbuf[i];
                }
            }
        }
    }
        // Fill data for Nodes = 0
    else {
        for(size_t i(0); i < outNxGlobal; i++) {
            EzGlobal[i] = Ezbuf[i];
        }
    }

    if (PE.RANK() == 0) expo.Export_h5("Ez", EzGlobal, tout);

    delete[] Ezbuf;

}

Here is the call graph for this function:

f0()

void Output_Data::Output_Preprocessor_1D::f0 ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 1862 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, State1D::DF(), Input::List(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), Parallel_Environment_1D::RANK(), and State1D::Species().

                                                                                {

    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;

    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    for(int s(0); s < Y.Species(); ++s) {

        int msg_sz(2*outNxLocal*f_x.Np(s));
        Array3D<float> f0x1Global(f_x.Np(s),outNxGlobal,2); //, yglob_axis.dim());
        float* f0xbuf = new float[msg_sz];

        for (size_t i(0); i < outNxLocal; ++i) {

            Array2D<float> data2D = f_x( Y.DF(s),0,0, i+Nbc, s);

            for (size_t j(0); j < f_x.Np(s); ++j) {
                // std::cout << "\n f0(" << i << "," << j << ") = (" << data2D(j,1) << "," << data2D(j,2) <<")";
                f0xbuf[2*j+   2*i*f_x.Np(s)]=data2D(j,0);

                f0xbuf[2*j+1+ 2*i*f_x.Np(s)]=data2D(j,1);
            }
        }

        if (PE.NODES() > 1) {
            if (PE.RANK()!=0) {
                MPI_Send(f0xbuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
            }
            else {
                // Fill data for rank = 0
                for(size_t i(0); i < outNxLocal; i++) {

                    for (size_t j(0); j < f_x.Np(s); ++j) {
                        f0x1Global(j,i,0) = f0xbuf[2*j+   2*i*f_x.Np(s)];
                        f0x1Global(j,i,1) = f0xbuf[2*j+1+ 2*i*f_x.Np(s)];
                    }
                }
                // Fill data for rank > 0
                for (int rr = 1; rr < PE.NODES(); ++rr){
                    MPI_Recv(f0xbuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);

                    for(size_t i(0); i < outNxLocal; i++) {
                        for (size_t j(0); j < f_x.Np(s); ++j) {
                            f0x1Global(j,i + outNxLocal*rr,0) = f0xbuf[2*j+   2*i*f_x.Np(s)];
                            f0x1Global(j,i + outNxLocal*rr,1) = f0xbuf[2*j+1+ 2*i*f_x.Np(s)];
                        }
                    }
                }
            }
        }
        else {
            for(size_t i(0); i < outNxGlobal; i++) {

                for (size_t j(0); j < f_x.Np(s); ++j) {
                    f0x1Global(j,i,0) = f0xbuf[2*j+   2*i*f_x.Np(s)];
                    f0x1Global(j,i,1) = f0xbuf[2*j+1+ 2*i*f_x.Np(s)];
                }
            }
        }

        if (PE.RANK() == 0) expo.Export_h5("f0-x", f0x1Global, tout, s);

        delete[] f0xbuf;
    }

}

Here is the call graph for this function:

f10()

void Output_Data::Output_Preprocessor_1D::f10 ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 1997 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, State1D::DF(), Input::List(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), Parallel_Environment_1D::RANK(), and State1D::Species().

                                                                                 {

    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;

    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    for(int s(0); s < Y.Species(); ++s) {

        int msg_sz(2*outNxLocal*f_x.Np(s));
        Array3D<float> f0x1Global(f_x.Np(s),outNxGlobal,2); //, yglob_axis.dim());
        float* f0xbuf = new float[msg_sz];

        for (size_t i(0); i < outNxLocal; ++i) {

            Array2D<float> data2D = f_x( Y.DF(s), 1, 0, i+Nbc, s);

            for (size_t j(0); j < f_x.Np(s); ++j) {
                // std::cout << "\n f0(" << i << "," << j << ") = (" << data2D(j,1) << "," << data2D(j,2) <<")";
                f0xbuf[2*j+   2*i*f_x.Np(s)]=data2D(j,0);

                f0xbuf[2*j+1+ 2*i*f_x.Np(s)]=data2D(j,1);
            }
        }

        if (PE.NODES() > 1) {
            if (PE.RANK()!=0) {
                MPI_Send(f0xbuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
            }
            else {
                // Fill data for rank = 0
                for(size_t i(0); i < outNxLocal; i++) {

                    for (size_t j(0); j < f_x.Np(s); ++j) {
                        f0x1Global(j,i,0) = f0xbuf[2*j+   2*i*f_x.Np(s)];
                        f0x1Global(j,i,1) = f0xbuf[2*j+1+ 2*i*f_x.Np(s)];
                    }
                }
                // Fill data for rank > 0
                for (int rr = 1; rr < PE.NODES(); ++rr){
                    MPI_Recv(f0xbuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);

                    for(size_t i(0); i < outNxLocal; i++) {
                        for (size_t j(0); j < f_x.Np(s); ++j) {
                            f0x1Global(j,i + outNxLocal*rr,0) = f0xbuf[2*j+   2*i*f_x.Np(s)];
                            f0x1Global(j,i + outNxLocal*rr,1) = f0xbuf[2*j+1+ 2*i*f_x.Np(s)];
                        }
                    }
                }
            }
        }
        else {
            for(size_t i(0); i < outNxGlobal; i++) {

                for (size_t j(0); j < f_x.Np(s); ++j) {
                    f0x1Global(j,i,0) = f0xbuf[2*j+   2*i*f_x.Np(s)];
                    f0x1Global(j,i,1) = f0xbuf[2*j+1+ 2*i*f_x.Np(s)];
                }
            }
        }

        if (PE.RANK() == 0) expo.Export_h5("f10-x", f0x1Global, tout, s);

        delete[] f0xbuf;
    }

}

Here is the call graph for this function:

f11()

void Output_Data::Output_Preprocessor_1D::f11 ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 2068 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, State1D::DF(), Input::List(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), Parallel_Environment_1D::RANK(), and State1D::Species().

                                                                                 {

    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;

    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    for(int s(0); s < Y.Species(); ++s) {

        int msg_sz(2*outNxLocal*f_x.Np(s));
        Array3D<float> f0x1Global(f_x.Np(s),outNxGlobal,2); //, yglob_axis.dim());
        float* f0xbuf = new float[msg_sz];

        for (size_t i(0); i < outNxLocal; ++i) {

            Array2D<float> data2D = f_x( Y.DF(s),1,1, i+Nbc, s);

            for (size_t j(0); j < f_x.Np(s); ++j) {
                // std::cout << "\n f0(" << i << "," << j << ") = (" << data2D(j,1) << "," << data2D(j,2) <<")";
                f0xbuf[2*j+   2*i*f_x.Np(s)]=data2D(j,0);

                f0xbuf[2*j+1+ 2*i*f_x.Np(s)]=data2D(j,1);
            }
        }

        if (PE.NODES() > 1) {
            if (PE.RANK()!=0) {
                MPI_Send(f0xbuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
            }
            else {
                // Fill data for rank = 0
                for(size_t i(0); i < outNxLocal; i++) {

                    for (size_t j(0); j < f_x.Np(s); ++j) {
                        f0x1Global(j,i,0) = f0xbuf[2*j+   2*i*f_x.Np(s)];
                        f0x1Global(j,i,1) = f0xbuf[2*j+1+ 2*i*f_x.Np(s)];
                    }
                }
                // Fill data for rank > 0
                for (int rr = 1; rr < PE.NODES(); ++rr){
                    MPI_Recv(f0xbuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);

                    for(size_t i(0); i < outNxLocal; i++) {
                        for (size_t j(0); j < f_x.Np(s); ++j) {
                            f0x1Global(j,i + outNxLocal*rr,0) = f0xbuf[2*j+   2*i*f_x.Np(s)];
                            f0x1Global(j,i + outNxLocal*rr,1) = f0xbuf[2*j+1+ 2*i*f_x.Np(s)];
                        }
                    }
                }
            }
        }
        else {
            for(size_t i(0); i < outNxGlobal; i++) {

                for (size_t j(0); j < f_x.Np(s); ++j) {
                    f0x1Global(j,i,0) = f0xbuf[2*j+   2*i*f_x.Np(s)];
                    f0x1Global(j,i,1) = f0xbuf[2*j+1+ 2*i*f_x.Np(s)];
                }
            }
        }

        if (PE.RANK() == 0) expo.Export_h5("f11-x", f0x1Global, tout, s);

        delete[] f0xbuf;
    }


}

Here is the call graph for this function:

f20()

void Output_Data::Output_Preprocessor_1D::f20 ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 2140 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, State1D::DF(), Input::List(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), Parallel_Environment_1D::RANK(), and State1D::Species().

                                                                                 {

    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;

    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    for(int s(0); s < Y.Species(); ++s) {

        int msg_sz(2*outNxLocal*f_x.Np(s));
        Array3D<float> f0x1Global(f_x.Np(s),outNxGlobal,2); //, yglob_axis.dim());
        float* f0xbuf = new float[msg_sz];

        for (size_t i(0); i < outNxLocal; ++i) {

            Array2D<float> data2D = f_x( Y.DF(s), 2, 0, i+Nbc, s);

            for (size_t j(0); j < f_x.Np(s); ++j) {
                // std::cout << "\n f0(" << i << "," << j << ") = (" << data2D(j,1) << "," << data2D(j,2) <<")";
                f0xbuf[2*j+   2*i*f_x.Np(s)]=data2D(j,0);

                f0xbuf[2*j+1+ 2*i*f_x.Np(s)]=data2D(j,1);
            }
        }

        if (PE.NODES() > 1) {
            if (PE.RANK()!=0) {
                MPI_Send(f0xbuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
            }
            else {
                // Fill data for rank = 0
                for(size_t i(0); i < outNxLocal; i++) {

                    for (size_t j(0); j < f_x.Np(s); ++j) {
                        f0x1Global(j,i,0) = f0xbuf[2*j+   2*i*f_x.Np(s)];
                        f0x1Global(j,i,1) = f0xbuf[2*j+1+ 2*i*f_x.Np(s)];
                    }
                }
                // Fill data for rank > 0
                for (int rr = 1; rr < PE.NODES(); ++rr){
                    MPI_Recv(f0xbuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);

                    for(size_t i(0); i < outNxLocal; i++) {
                        for (size_t j(0); j < f_x.Np(s); ++j) {
                            f0x1Global(j,i + outNxLocal*rr,0) = f0xbuf[2*j+   2*i*f_x.Np(s)];
                            f0x1Global(j,i + outNxLocal*rr,1) = f0xbuf[2*j+1+ 2*i*f_x.Np(s)];
                        }
                    }
                }
            }
        }
        else {
            for(size_t i(0); i < outNxGlobal; i++) {

                for (size_t j(0); j < f_x.Np(s); ++j) {
                    f0x1Global(j,i,0) = f0xbuf[2*j+   2*i*f_x.Np(s)];
                    f0x1Global(j,i,1) = f0xbuf[2*j+1+ 2*i*f_x.Np(s)];
                }
            }
        }

        if (PE.RANK() == 0) expo.Export_h5("f20-x", f0x1Global, tout, s);

        delete[] f0xbuf;
    }

}

Here is the call graph for this function:

fl0()

void Output_Data::Output_Preprocessor_1D::fl0 ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 2212 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, State1D::DF(), DistFunc1D::l0(), Input::List(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), Parallel_Environment_1D::RANK(), and State1D::Species().

                                                                                 {

    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;

    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    for(int s(0); s < Y.Species(); ++s) {

        int msg_sz(2*outNxLocal*f_x.Np(s));
        Array3D<float> f0x1Global(f_x.Np(s),outNxGlobal,2); //, yglob_axis.dim());
        float* f0xbuf = new float[msg_sz];

        for (size_t i(0); i < outNxLocal; ++i) {

            Array2D<float> data2D = f_x( Y.DF(s), Y.DF(s).l0()-1,0, i+Nbc, s);

            for (size_t j(0); j < f_x.Np(s); ++j) {
                // std::cout << "\n f0(" << i << "," << j << ") = (" << data2D(j,1) << "," << data2D(j,2) <<")";
                f0xbuf[2*j+   2*i*f_x.Np(s)]=data2D(j,0);

                f0xbuf[2*j+1+ 2*i*f_x.Np(s)]=data2D(j,1);
            }
        }

        if (PE.NODES() > 1) {
            if (PE.RANK()!=0) {
                MPI_Send(f0xbuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
            }
            else {
                // Fill data for rank = 0
                for(size_t i(0); i < outNxLocal; i++) {

                    for (size_t j(0); j < f_x.Np(s); ++j) {
                        f0x1Global(j,i,0) = f0xbuf[2*j+   2*i*f_x.Np(s)];
                        f0x1Global(j,i,1) = f0xbuf[2*j+1+ 2*i*f_x.Np(s)];
                    }
                }
                // Fill data for rank > 0
                for (int rr = 1; rr < PE.NODES(); ++rr){
                    MPI_Recv(f0xbuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);

                    for(size_t i(0); i < outNxLocal; i++) {
                        for (size_t j(0); j < f_x.Np(s); ++j) {
                            f0x1Global(j,i + outNxLocal*rr,0) = f0xbuf[2*j+   2*i*f_x.Np(s)];
                            f0x1Global(j,i + outNxLocal*rr,1) = f0xbuf[2*j+1+ 2*i*f_x.Np(s)];
                        }
                    }
                }
            }
        }
        else {
            for(size_t i(0); i < outNxGlobal; i++) {

                for (size_t j(0); j < f_x.Np(s); ++j) {
                    f0x1Global(j,i,0) = f0xbuf[2*j+   2*i*f_x.Np(s)];
                    f0x1Global(j,i,1) = f0xbuf[2*j+1+ 2*i*f_x.Np(s)];
                }
            }
        }

        if (PE.RANK() == 0) expo.Export_h5("fl0-x", f0x1Global, tout, s);

        delete[] f0xbuf;
    }

}

Here is the call graph for this function:

Jx()

void Output_Data::Output_Preprocessor_1D::Jx ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 2434 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, State1D::DF(), Input::List(), Algorithms::MakeCAxis(), DistFunc1D::mass(), Algorithms::moment(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), DistFunc1D::q(), Parallel_Environment_1D::RANK(), State1D::SH(), State1D::Species(), and vfloat().

                                                                                {


    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;
    // size_t st(0), bi(0);
    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    int msg_sz(outNxLocal); //*szy);
    float* Jxbuf = new float[msg_sz];
    valarray<float> JxGlobal(outNxGlobal); //, yglob_axis.dim());

    for(int s(0); s < Y.Species(); ++s) {

//        valarray<float> pra( Algorithms::MakeAxis( f_x.Pmin(s), f_x.Pmax(s), f_x.Np(s) ) );
        valarray<float> pra( Algorithms::MakeCAxis(float(0.0), f_x.Pmax(s), f_x.Np(s) ) );

        for(size_t i(0); i < msg_sz; ++i) {
            Jxbuf[i] = Y.DF(s).q()/Y.DF(s).mass()*4.0/3.0*M_PI*Algorithms::moment(  vfloat( (Y.SH(s,1,0)).xVec(i+Nbc) ), pra, 3);
        }

        if (PE.NODES() > 1) {
            if (PE.RANK()!=0) {
                MPI_Send(Jxbuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
            }
            else {
                // Fill data for rank = 0
                for(size_t i(0); i < outNxLocal; i++) {
                    JxGlobal[i] = Jxbuf[i];
                }
                // Fill data for rank > 0
                for (int rr = 1; rr < PE.NODES(); ++rr){
                    MPI_Recv(Jxbuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);
                    for(size_t i(0); i < outNxLocal; i++) {
                        JxGlobal[i + outNxLocal*rr] = Jxbuf[i];
                    }
                }
            }
        }
            // Fill data for Nodes = 0
        else {
            for(size_t i(0); i < outNxGlobal; i++) {
                JxGlobal[i] = Jxbuf[i];
            }
        }

        if (PE.RANK() == 0) expo.Export_h5("Jx", JxGlobal, tout, s);

    }

    delete[] Jxbuf;

}

Here is the call graph for this function:

Jy()

void Output_Data::Output_Preprocessor_1D::Jy ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 2493 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, State1D::DF(), Input::List(), Algorithms::MakeCAxis(), DistFunc1D::mass(), Algorithms::moment(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), DistFunc1D::q(), Parallel_Environment_1D::RANK(), State1D::SH(), State1D::Species(), and vfloat().

                                                                                {


    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;
    // size_t st(0), bi(0);
    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    int msg_sz(outNxLocal); //*szy);
    float* Jybuf = new float[msg_sz];
    valarray<float> JyGlobal(outNxGlobal); //, yglob_axis.dim());

    for(int s(0); s < Y.Species(); ++s) {

//        valarray<float> pra( Algorithms::MakeAxis( f_x.Pmin(s), f_x.Pmax(s), f_x.Np(s) ) );
        valarray<float> pra( Algorithms::MakeCAxis(float(0.0), f_x.Pmax(s), f_x.Np(s) ) );

        for(size_t i(0); i < msg_sz; ++i) {
            Jybuf[i] = Y.DF(s).q()/Y.DF(s).mass()*8.0/3.0*M_PI*Algorithms::moment(  vfloat( (Y.SH(s,1,1)).xVec(i+Nbc) ), pra, 3);
        }

        if (PE.NODES() > 1) {
            if (PE.RANK()!=0) {
                MPI_Send(Jybuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
            }
            else {
                // Fill data for rank = 0
                for(size_t i(0); i < outNxLocal; i++) {
                    JyGlobal[i] = Jybuf[i];
                }
                // Fill data for rank > 0
                for (int rr = 1; rr < PE.NODES(); ++rr){
                    MPI_Recv(Jybuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);
                    for(size_t i(0); i < outNxLocal; i++) {
                        JyGlobal[i + outNxLocal*rr] = Jybuf[i];
                    }
                }
            }
        }
            // Fill data for Nodes = 0
        else {
            for(size_t i(0); i < outNxGlobal; i++) {
                JyGlobal[i] = Jybuf[i];
            }
        }

        if (PE.RANK() == 0) expo.Export_h5("Jy", JyGlobal, tout, s);

    }

    delete[] Jybuf;

}

Here is the call graph for this function:

Jz()

void Output_Data::Output_Preprocessor_1D::Jz ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 2551 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, State1D::DF(), Input::List(), Algorithms::MakeCAxis(), DistFunc1D::mass(), Algorithms::moment(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), DistFunc1D::q(), Parallel_Environment_1D::RANK(), State1D::SH(), State1D::Species(), and vfloat_complex().

                                                                                {


    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;
    // size_t st(0), bi(0);
    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    int msg_sz(outNxLocal); //*szy);
    float* Jzbuf = new float[msg_sz];
    valarray<float> JzGlobal(outNxGlobal); //, yglob_axis.dim());

    for(int s(0); s < Y.Species(); ++s) {

//        valarray<float> pra( Algorithms::MakeAxis( f_x.Pmin(s), f_x.Pmax(s), f_x.Np(s) ) );
        valarray<float> pra( Algorithms::MakeCAxis(float(0.0), f_x.Pmax(s), f_x.Np(s) ) );
        for(size_t i(0); i < msg_sz; ++i) {
            Jzbuf[i] = Y.DF(s).q()/Y.DF(s).mass()*-8.0/3.0*M_PI*Algorithms::moment(  vfloat_complex( (Y.SH(s,1,1)).xVec(i+Nbc) ), pra, 3);
        }

        if (PE.NODES() > 1) {
            if (PE.RANK()!=0) {
                MPI_Send(Jzbuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
            }
            else {
                // Fill data for rank = 0
                for(size_t i(0); i < outNxLocal; i++) {
                    JzGlobal[i] = Jzbuf[i];
                }
                // Fill data for rank > 0
                for (int rr = 1; rr < PE.NODES(); ++rr){
                    MPI_Recv(Jzbuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);
                    for(size_t i(0); i < outNxLocal; i++) {
                        JzGlobal[i + outNxLocal*rr] = Jzbuf[i];
                    }
                }
            }
        }
            // Fill data for Nodes = 0
        else {
            for(size_t i(0); i < outNxGlobal; i++) {
                JzGlobal[i] = Jzbuf[i];
            }
        }

        if (PE.RANK() == 0) expo.Export_h5("Jz", JzGlobal, tout, s);

    }

    delete[] Jzbuf;

}

Here is the call graph for this function:

n()

void Output_Data::Output_Preprocessor_1D::n ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 2285 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, Input::List(), Algorithms::MakeCAxis(), Algorithms::moment(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), Parallel_Environment_1D::RANK(), State1D::SH(), State1D::Species(), and vfloat().

                                                                               {


    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;
    size_t st(0), bi(0);
    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    int msg_sz(outNxLocal); //*szy);
    float* nbuf = new float[msg_sz];
    valarray<float> nGlobal(outNxGlobal); //, yglob_axis.dim());

    for(int s(0); s < Y.Species(); ++s) {

//        valarray<float> pra( Algorithms::MakeAxis( f_x.Pmin(s), f_x.Pmax(s), f_x.Np(s) ) );

        valarray<float> pra( Algorithms::MakeCAxis(float(0.0), f_x.Pmax(s), f_x.Np(s) ) );
        for(size_t i(0); i < msg_sz; ++i) {

            // std::cout << "f00n[" << i << "]=" << (Y.SH(s,0,0)).xVec(i+Nbc)[0] << "\n";

            nbuf[i] = 4.0*M_PI*Algorithms::moment(  vfloat( (Y.SH(s,0,0)).xVec(i+Nbc) ), pra, 2);
        }

        if (PE.NODES() > 1) {
            if (PE.RANK()!=0) {
                MPI_Send(nbuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
            }
            else {
                // Fill data for rank = 0
                for(size_t i(0); i < outNxLocal; i++) {
                    nGlobal[i] = nbuf[i];
                }
                // Fill data for rank > 0
                for (int rr = 1; rr < PE.NODES(); ++rr){
                    MPI_Recv(nbuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);
                    for(size_t i(0); i < outNxLocal; i++) {
                        nGlobal[i + outNxLocal*rr] = nbuf[i];
                    }
                }
            }
        }
            // Fill data for Nodes = 0
        else {
            for(size_t i(0); i < outNxGlobal; i++) {
                nGlobal[i] = nbuf[i];
            }
        }

        if (PE.RANK() == 0) expo.Export_h5("n", nGlobal, tout, s);

    }

    delete[] nbuf;

}

Here is the call graph for this function:

ni()

void Output_Data::Output_Preprocessor_1D::ni ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 3305 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, Hydro1D::density(), State1D::HYDRO(), Input::List(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), and Parallel_Environment_1D::RANK().

                                                                                {


    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;
    // size_t st(0), bi(0);
    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    int msg_sz(outNxLocal); //*szy);
    float* nibuf = new float[msg_sz];
    valarray<float> niGlobal(outNxGlobal); //, yglob_axis.dim());

    for(size_t i(0); i < msg_sz; ++i) {
        nibuf[i] = static_cast<float>(Y.HYDRO().density(i+Nbc));
    }

    if (PE.NODES() > 1) {
        if (PE.RANK()!=0) {
            MPI_Send(nibuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
        }
        else {
            // Fill data for rank = 0
            for(size_t i(0); i < outNxLocal; i++) {
                niGlobal[i] = nibuf[i];
            }
            // Fill data for rank > 0
            for (int rr = 1; rr < PE.NODES(); ++rr){
                MPI_Recv(nibuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);
                for(size_t i(0); i < outNxLocal; i++) {
                    niGlobal[i + outNxLocal*rr] = nibuf[i];
                }
            }
        }
    }
        // Fill data for Nodes = 0
    else {
        for(size_t i(0); i < outNxGlobal; i++) {
            niGlobal[i] = nibuf[i];
        }
    }

    if (PE.RANK() == 0) expo.Export_h5("ni", niGlobal, tout, 0);



    delete[] nibuf;

}

Here is the call graph for this function:

operator()()

void Output_Data::Output_Preprocessor_1D::operator()	(	const State1D &	Y,
		const Grid_Info &	grid,
		const size_t	tout,
		const Parallel_Environment_1D &	PE
	)

Definition at line 1277 of file export.cpp.

References Input::List().

                                                                                        {

    if (Input::List().o_Ex) {
        Ex( Y, grid, tout, PE );
    }

    if (Input::List().o_Ey) {
        Ey( Y, grid, tout, PE );
    }

    if (Input::List().o_Ez) {
        Ez( Y, grid, tout, PE );
    }

    if (Input::List().o_Bx) {
        Bx( Y, grid, tout, PE );
    }

    if (Input::List().o_By) {
        By( Y, grid, tout, PE );
    }

    if (Input::List().o_Bz) {
        Bz( Y, grid, tout, PE );
    }

    if (Input::List().o_x1x2) {
        n( Y, grid, tout, PE );
    }

    if (Input::List().o_Temperature) {
        T( Y, grid, tout, PE );
    }

    if (Input::List().o_Jx) {
        Jx( Y, grid, tout, PE );
    }

    if (Input::List().o_Jy) {
        Jy( Y, grid, tout, PE );
    }

    if (Input::List().o_Jz) {
        Jz( Y, grid, tout, PE );
    }

    if (Input::List().o_Qx) {
        Qx( Y, grid, tout, PE );
    }

    if (Input::List().o_Qy) {
        Qy( Y, grid, tout, PE );
    }

    if (Input::List().o_Qz) {
        Qz( Y, grid, tout, PE );
    }
    if (Input::List().o_vNx) {
        vNx( Y, grid, tout, PE );
    }
    if (Input::List().o_vNy) {
        vNy( Y, grid, tout, PE );
    }
    if (Input::List().o_vNz) {
        vNz( Y, grid, tout, PE );
    }

//    if (Input::List().o_p1x1){
//        px( Y, grid, tout, PE );
//    }
//    if (Input::List().o_f0x1){
//        f0( Y, grid, tout, PE );
//    }
//    if (Input::List().o_f10x1){
//        f10( Y, grid, tout, PE );
//    }
//    if (Input::List().o_f11x1){
//        f11( Y, grid, tout, PE );
//    }
//    if (Input::List().o_p2p1x1){
//        pxpy( Y, grid, tout, PE );
//    }

    if (Input::List().o_Ux) {
        Ux( Y, grid, tout, PE );
    }

    if (Input::List().o_Uy) {
        Uy( Y, grid, tout, PE );
    }

    if (Input::List().o_Uz) {
        Uz( Y, grid, tout, PE );
    }

    if (Input::List().o_Z) {
        Z( Y, grid, tout, PE );
    }

    if (Input::List().o_ni) {
        ni( Y, grid, tout, PE );
    }

    if (Input::List().o_Ux) {
        Ti( Y, grid, tout, PE );
    }

}

Here is the call graph for this function:

px()

void Output_Data::Output_Preprocessor_1D::px ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 1720 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, State1D::DF(), Input::List(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), Parallel_Environment_1D::RANK(), and State1D::Species().

                                                                                {
    // std::cout << "0 \n";
    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;
    size_t st(0), bi(0);
    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));



    for(int s(0); s < Y.Species(); ++s) {
        size_t Npx(2*f_x.Np(s)+1);
        int msg_sz(outNxLocal*Npx);
        Array2D<float> p1x1Global(Npx,outNxGlobal); //, yglob_axis.dim());
        float* pxbuf = new float[Npx*outNxLocal];

        for (size_t i(0); i < outNxLocal; ++i) {

            valarray<float> data1D = px_x( Y.DF(s), i+Nbc, s);

            for (size_t j(0); j < Npx; ++j) {
                pxbuf[j+i*Npx]=data1D[j];
            }
        }

        if (PE.NODES() > 1) {
            if (PE.RANK()!=0) {
                MPI_Send(pxbuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
            }
            else {
                // Fill data for rank = 0
                for(size_t i(0); i < outNxLocal; i++) {
                    for (size_t j(0); j < Npx; ++j) {
                        p1x1Global(j,i) = pxbuf[j+i*Npx];
                    }
                }
                // Fill data for rank > 0
                for (int rr = 1; rr < PE.NODES(); ++rr){
                    MPI_Recv(pxbuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);
                    for(size_t i(0); i < outNxLocal; i++) {
                        for (size_t j(0); j < Npx; ++j) {
                            p1x1Global(j,i + outNxLocal*rr) = pxbuf[j+i*Npx];
                        }
                    }
                }
            }
        }
        else {
            for(size_t i(0); i < outNxGlobal; i++) {
                for (size_t j(0); j < Npx; ++j) {
                    p1x1Global(j,i) = pxbuf[j+i*Npx];
                }
            }
        }

        if (PE.RANK() == 0) expo.Export_h5("px-x", p1x1Global, tout, s);

        delete[] pxbuf;
    }

}

Here is the call graph for this function:

Qx()

void Output_Data::Output_Preprocessor_1D::Qx ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 2607 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, Input::List(), Algorithms::MakeCAxis(), Algorithms::moment(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), Parallel_Environment_1D::RANK(), State1D::SH(), State1D::Species(), and vfloat().

                                                                                {


    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;

    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    int msg_sz(outNxLocal); //*szy);

    double Vxbuf;
    double Vybuf;
    double Vzbuf;
    double VxVxbuf;
    double VyVybuf;
    double VzVzbuf;
    double VxVybuf;
    double VxVzbuf;
    double VyVzbuf;
    double nbuf;
    double Ubuf;

    float* Qxbuf = new float[msg_sz];
    valarray<float> QxGlobal(outNxGlobal); //, yglob_axis.dim());

    for(int s(0); s < Y.Species(); ++s) {

//        valarray<float> pra( Algorithms::MakeAxis( f_x.Pmin(s), f_x.Pmax(s), f_x.Np(s) ) );
        valarray<float> pra( Algorithms::MakeCAxis(float(0.0), f_x.Pmax(s), f_x.Np(s) ) );
        for(size_t i(0); i < msg_sz; ++i) {
//                nbuf = 4.0*M_PI*Algorithms::moment(  vfloat( (Y.SH(s,0,0)).xVec(i+Nbc) ), pra, 2);
//                Ubuf = 4.0*M_PI*Algorithms::moment(  vfloat( (Y.SH(s,0,0)).xVec(i+Nbc) ), pra, 4);
//
//                Vxbuf  = 4.0/3.0*M_PI*Algorithms::moment(  vfloat( (Y.SH(s,1,0)).xVec(i+Nbc) ), pra, 3);
//                Vybuf  = 4.0/3.0*M_PI*Algorithms::moment(  vfloat( (Y.SH(s,1,1)).xVec(i+Nbc) ), pra, 3);
//                Vzbuf  = 4.0/3.0*M_PI*Algorithms::moment(  vfloat_complex( (Y.SH(s,1,1)).xVec(i+Nbc) ), pra, 3);
//                Vxbuf /= nbuf;
//                Vybuf /= nbuf;
//                Vzbuf /= nbuf;
//
//                VxVxbuf = 4.0/3.0*2.0/5.0*M_PI*Algorithms::moment(  vfloat( (Y.SH(s,2,0)).xVec(i+Nbc) ), pra, 4);
//                VyVybuf = 4.0*4.0/5.0*M_PI*Algorithms::moment(  vfloat( (Y.SH(s,2,2)).xVec(i+Nbc) ), pra, 4);
//                VzVzbuf = -1.0*VyVybuf;
//
//                VyVybuf -= VxVxbuf/2.0;
//                VzVzbuf -= VxVxbuf/2.0;
//
//                VxVxbuf += Ubuf/2.0;
//                VyVybuf += Ubuf/2.0;
//                VzVzbuf += Ubuf/2.0;
//
//                VxVybuf = 4.0*2.0/5.0*M_PI*Algorithms::moment(  vfloat( (Y.SH(s,2,1)).xVec(i+Nbc) ), pra, 4);
//                VxVzbuf = -4.0*2.0/5.0*M_PI*Algorithms::moment(  vfloat_complex( (Y.SH(s,2,1)).xVec(i+Nbc) ), pra, 4);
//                VyVzbuf = -4.0*4.0/5.0*M_PI*Algorithms::moment(  vfloat_complex( (Y.SH(s,2,2)).xVec(i+Nbc) ), pra, 4);
//
//                VxVxbuf /= nbuf;
//                VyVybuf /= nbuf;
//                VzVzbuf /= nbuf;
//                VxVybuf /= nbuf;
//                VxVzbuf /= nbuf;
//                VyVzbuf /= nbuf;

            Qxbuf[i] = 4.0*M_PI/3.0*Algorithms::moment(  vfloat( (Y.SH(s,1,0)).xVec(i+Nbc) ), pra, 5);
//                Qxbuf[i] -= Vxbuf *(VxVxbuf +VyVybuf +VzVzbuf )*nbuf ;
//                Qxbuf[i] -= 2.0 *( VxVxbuf *Vxbuf  + VxVybuf *Vybuf + VxVzbuf*Vzbuf)*nbuf ;
//                Qxbuf[i] += 2.0 *( Vxbuf *Vxbuf  + Vybuf *Vybuf +Vzbuf*Vzbuf ) * Vxbuf  * nbuf ;
            Qxbuf[i] *= 0.5;
        }

        if (PE.NODES() > 1) {
            if (PE.RANK()!=0) {
                MPI_Send(Qxbuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
            }
            else {
                // Fill data for rank = 0
                for(size_t i(0); i < outNxLocal; i++) {
                    QxGlobal[i] = Qxbuf[i];
                }
                // Fill data for rank > 0
                for (int rr = 1; rr < PE.NODES(); ++rr){
                    MPI_Recv(Qxbuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);
                    for(size_t i(0); i < outNxLocal; i++) {
                        QxGlobal[i + outNxLocal*rr] = Qxbuf[i];
                    }
                }
            }
        }
            // Fill data for Nodes = 0
        else {
            for(size_t i(0); i < outNxGlobal; i++) {
                QxGlobal[i] = Qxbuf[i];
            }
        }

        if (PE.RANK() == 0) expo.Export_h5("Qx", QxGlobal, tout, s);

    }

    delete[] Qxbuf;

}

Here is the call graph for this function:

Qy()

void Output_Data::Output_Preprocessor_1D::Qy ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 2713 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, Input::List(), Algorithms::MakeCAxis(), Algorithms::moment(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), Parallel_Environment_1D::RANK(), State1D::SH(), State1D::Species(), and vfloat().

                                                                                {


    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;

    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    int msg_sz(outNxLocal); //*szy);

    double Vxbuf;
    double Vybuf;
    double Vzbuf;
    double VxVxbuf;
    double VyVybuf;
    double VzVzbuf;
    double VxVybuf;
    double VxVzbuf;
    double VyVzbuf;
    double nbuf;
    double Ubuf;

    float* Qxbuf = new float[msg_sz];
    valarray<float> QxGlobal(outNxGlobal); //, yglob_axis.dim());

    for(int s(0); s < Y.Species(); ++s) {

//        valarray<float> pra( Algorithms::MakeAxis( f_x.Pmin(s), f_x.Pmax(s), f_x.Np(s) ) );
        valarray<float> pra( Algorithms::MakeCAxis(float(0.0), f_x.Pmax(s), f_x.Np(s) ) );
        for(size_t i(0); i < msg_sz; ++i) {
//                nbuf = 4.0*M_PI*Algorithms::moment(  vfloat( (Y.SH(s,0,0)).xVec(i+Nbc) ), pra, 2);
//                Ubuf = 4.0*M_PI*Algorithms::moment(  vfloat( (Y.SH(s,0,0)).xVec(i+Nbc) ), pra, 4);
//
//                Vxbuf  = 4.0/3.0*M_PI*Algorithms::moment(  vfloat( (Y.SH(s,1,0)).xVec(i+Nbc) ), pra, 3);
//                Vybuf  = 4.0/3.0*M_PI*Algorithms::moment(  vfloat( (Y.SH(s,1,1)).xVec(i+Nbc) ), pra, 3);
//                Vzbuf  = 4.0/3.0*M_PI*Algorithms::moment(  vfloat_complex( (Y.SH(s,1,1)).xVec(i+Nbc) ), pra, 3);
//                Vxbuf /= nbuf;
//                Vybuf /= nbuf;
//                Vzbuf /= nbuf;
//
//                VxVxbuf = 4.0/3.0*2.0/5.0*M_PI*Algorithms::moment(  vfloat( (Y.SH(s,2,0)).xVec(i+Nbc) ), pra, 4);
//                VyVybuf = 4.0*4.0/5.0*M_PI*Algorithms::moment(  vfloat( (Y.SH(s,2,2)).xVec(i+Nbc) ), pra, 4);
//                VzVzbuf = -1.0*VyVybuf;
//
//                VyVybuf -= VxVxbuf/2.0;
//                VzVzbuf -= VxVxbuf/2.0;
//
//                VxVxbuf += Ubuf/2.0;
//                VyVybuf += Ubuf/2.0;
//                VzVzbuf += Ubuf/2.0;
//
//                VxVybuf = 4.0*2.0/5.0*M_PI*Algorithms::moment(  vfloat( (Y.SH(s,2,1)).xVec(i+Nbc) ), pra, 4);
//                VxVzbuf = -4.0*2.0/5.0*M_PI*Algorithms::moment(  vfloat_complex( (Y.SH(s,2,1)).xVec(i+Nbc) ), pra, 4);
//                VyVzbuf = -4.0*4.0/5.0*M_PI*Algorithms::moment(  vfloat_complex( (Y.SH(s,2,2)).xVec(i+Nbc) ), pra, 4);
//
//                VxVxbuf /= nbuf;
//                VyVybuf /= nbuf;
//                VzVzbuf /= nbuf;
//                VxVybuf /= nbuf;
//                VxVzbuf /= nbuf;
//                VyVzbuf /= nbuf;

            Qxbuf[i] = 8.0*M_PI/3.0*Algorithms::moment(  vfloat( (Y.SH(s,1,1)).xVec(i+Nbc) ), pra, 5);
//                Qxbuf[i] -= Vxbuf *(VxVxbuf +VyVybuf +VzVzbuf )*nbuf ;
//                Qxbuf[i] -= 2.0 *( VxVxbuf *Vxbuf  + VxVybuf *Vybuf + VxVzbuf*Vzbuf)*nbuf ;
//                Qxbuf[i] += 2.0 *( Vxbuf *Vxbuf  + Vybuf *Vybuf +Vzbuf*Vzbuf ) * Vxbuf  * nbuf ;
            Qxbuf[i] *= 0.5;
        }

        if (PE.NODES() > 1) {
            if (PE.RANK()!=0) {
                MPI_Send(Qxbuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
            }
            else {
                // Fill data for rank = 0
                for(size_t i(0); i < outNxLocal; i++) {
                    QxGlobal[i] = Qxbuf[i];
                }
                // Fill data for rank > 0
                for (int rr = 1; rr < PE.NODES(); ++rr){
                    MPI_Recv(Qxbuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);
                    for(size_t i(0); i < outNxLocal; i++) {
                        QxGlobal[i + outNxLocal*rr] = Qxbuf[i];
                    }
                }
            }
        }
            // Fill data for Nodes = 0
        else {
            for(size_t i(0); i < outNxGlobal; i++) {
                QxGlobal[i] = Qxbuf[i];
            }
        }

        if (PE.RANK() == 0) expo.Export_h5("Qy", QxGlobal, tout, s);

    }

    delete[] Qxbuf;

}

Here is the call graph for this function:

Qz()

void Output_Data::Output_Preprocessor_1D::Qz ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 2819 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, Input::List(), Algorithms::MakeCAxis(), Algorithms::moment(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), Parallel_Environment_1D::RANK(), State1D::SH(), State1D::Species(), and vfloat_complex().

                                                                                {


    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;

    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    int msg_sz(outNxLocal); //*szy);

    double Vxbuf;
    double Vybuf;
    double Vzbuf;
    double VxVxbuf;
    double VyVybuf;
    double VzVzbuf;
    double VxVybuf;
    double VxVzbuf;
    double VyVzbuf;
    double nbuf;
    double Ubuf;

    float* Qxbuf = new float[msg_sz];
    valarray<float> QxGlobal(outNxGlobal); //, yglob_axis.dim());

    for(int s(0); s < Y.Species(); ++s) {

//        valarray<float> pra( Algorithms::MakeAxis( f_x.Pmin(s), f_x.Pmax(s), f_x.Np(s) ) );
        valarray<float> pra( Algorithms::MakeCAxis( float(0.0),f_x.Pmax(s), f_x.Np(s) ) );
        for(size_t i(0); i < msg_sz; ++i) {
//                nbuf = 4.0*M_PI*Algorithms::moment(  vfloat( (Y.SH(s,0,0)).xVec(i+Nbc) ), pra, 2);
//                Ubuf = 4.0*M_PI*Algorithms::moment(  vfloat( (Y.SH(s,0,0)).xVec(i+Nbc) ), pra, 4);
//
//                Vxbuf  = 4.0/3.0*M_PI*Algorithms::moment(  vfloat( (Y.SH(s,1,0)).xVec(i+Nbc) ), pra, 3);
//                Vybuf  = 4.0/3.0*M_PI*Algorithms::moment(  vfloat( (Y.SH(s,1,1)).xVec(i+Nbc) ), pra, 3);
//                Vzbuf  = 4.0/3.0*M_PI*Algorithms::moment(  vfloat_complex( (Y.SH(s,1,1)).xVec(i+Nbc) ), pra, 3);
//                Vxbuf /= nbuf;
//                Vybuf /= nbuf;
//                Vzbuf /= nbuf;
//
//                VxVxbuf = 4.0/3.0*2.0/5.0*M_PI*Algorithms::moment(  vfloat( (Y.SH(s,2,0)).xVec(i+Nbc) ), pra, 4);
//                VyVybuf = 4.0*4.0/5.0*M_PI*Algorithms::moment(  vfloat( (Y.SH(s,2,2)).xVec(i+Nbc) ), pra, 4);
//                VzVzbuf = -1.0*VyVybuf;
//
//                VyVybuf -= VxVxbuf/2.0;
//                VzVzbuf -= VxVxbuf/2.0;
//
//                VxVxbuf += Ubuf/2.0;
//                VyVybuf += Ubuf/2.0;
//                VzVzbuf += Ubuf/2.0;
//
//                VxVybuf = 4.0*2.0/5.0*M_PI*Algorithms::moment(  vfloat( (Y.SH(s,2,1)).xVec(i+Nbc) ), pra, 4);
//                VxVzbuf = -4.0*2.0/5.0*M_PI*Algorithms::moment(  vfloat_complex( (Y.SH(s,2,1)).xVec(i+Nbc) ), pra, 4);
//                VyVzbuf = -4.0*4.0/5.0*M_PI*Algorithms::moment(  vfloat_complex( (Y.SH(s,2,2)).xVec(i+Nbc) ), pra, 4);
//
//                VxVxbuf /= nbuf;
//                VyVybuf /= nbuf;
//                VzVzbuf /= nbuf;
//                VxVybuf /= nbuf;
//                VxVzbuf /= nbuf;
//                VyVzbuf /= nbuf;

            Qxbuf[i] = -8.0*M_PI/3.0*Algorithms::moment(  vfloat_complex( (Y.SH(s,1,1)).xVec(i+Nbc) ), pra, 5);
//                Qxbuf[i] -= Vxbuf *(VxVxbuf +VyVybuf +VzVzbuf )*nbuf ;
//                Qxbuf[i] -= 2.0 *( VxVxbuf *Vxbuf  + VxVybuf *Vybuf + VxVzbuf*Vzbuf)*nbuf ;
//                Qxbuf[i] += 2.0 *( Vxbuf *Vxbuf  + Vybuf *Vybuf +Vzbuf*Vzbuf ) * Vxbuf  * nbuf ;
            Qxbuf[i] *= 0.5;
        }

        if (PE.NODES() > 1) {
            if (PE.RANK()!=0) {
                MPI_Send(Qxbuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
            }
            else {
                // Fill data for rank = 0
                for(size_t i(0); i < outNxLocal; i++) {
                    QxGlobal[i] = Qxbuf[i];
                }
                // Fill data for rank > 0
                for (int rr = 1; rr < PE.NODES(); ++rr){
                    MPI_Recv(Qxbuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);
                    for(size_t i(0); i < outNxLocal; i++) {
                        QxGlobal[i + outNxLocal*rr] = Qxbuf[i];
                    }
                }
            }
        }
            // Fill data for Nodes = 0
        else {
            for(size_t i(0); i < outNxGlobal; i++) {
                QxGlobal[i] = Qxbuf[i];
            }
        }

        if (PE.RANK() == 0) expo.Export_h5("Qz", QxGlobal, tout, s);

    }

    delete[] Qxbuf;

}

Here is the call graph for this function:

T()

void Output_Data::Output_Preprocessor_1D::T ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 2345 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, State1D::DF(), Input::List(), Algorithms::MakeCAxis(), DistFunc1D::mass(), Algorithms::moment(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), Parallel_Environment_1D::RANK(), State1D::SH(), State1D::Species(), and vfloat().

                                                                               {


    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;
    // size_t st(0), bi(0);
    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    int msg_sz(outNxLocal); //*szy);
    // float* nbuf = new float[msg_sz];
    float* tbuf = new float[msg_sz];
    valarray<float> tGlobal(outNxGlobal); //, yglob_axis.dim());

    double convert_factor = (2.99792458e8)*(2.99792458e8)*(9.1093829e-31)/(1.602176565e-19);

    for(int s(0); s < Y.Species(); ++s) {

//        valarray<float> pra( Algorithms::MakeAxis( f_x.Pmin(s), f_x.Pmax(s), f_x.Np(s) ) );
        valarray<float> pra( Algorithms::MakeCAxis(float(0.0), f_x.Pmax(s), f_x.Np(s) ) );
        // float deltapra = pra[1] - pra[0];

        // need nbuf for density normalization
        for(size_t i(0); i < msg_sz; ++i) {
            tbuf[i] = 4.0*M_PI*Algorithms::moment(  vfloat( (Y.SH(s,0,0)).xVec(i+Nbc) ), pra, 4);
            tbuf[i] /= 3.0*4.0*M_PI*Algorithms::moment(  vfloat( (Y.SH(s,0,0)).xVec(i+Nbc) ), pra, 2);

            // tbuf[i] *= convert_factor/Y.DF(s).mass();

            tbuf[i] *= 1.0/Y.DF(s).mass();

        }

//          for (int ix(0); ix < outNxLocal; ++ix){
//              double accumulator = 0.0;
//              for(int ip(0); ip < pra.size(); ++ip) {
//                  double p_squared = pra[ip]*pra[ip];
//                  double val = Y.SH(s,0,0)(ip,ix+Nbc).real();
//                  // pr/dx() can be moved outside loop if anyone cares.
//                  val *= (deltapra) *p_squared*p_squared;
//                  accumulator += val;
//              }
//              tbuf[ix] = accumulator; 
//              // do the normalization
//              tbuf[ix] *= ( 4.0*M_PI*2.0/3.0 );
//              // do the density part of the normalization...
//              tbuf[ix] /= nbuf[ix]; 

// //               double pth2 = ( TemperatureFromPthSq[ix] );
//              tbuf[ix] *= convert_factor;//pth2 / (1.0 + pth2) * convert_factor;
//          }

        if (PE.NODES() > 1) {
            if (PE.RANK()!=0) {
                MPI_Send(tbuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
            }
            else {
                // Fill data for rank = 0
                for(size_t i(0); i < outNxLocal; i++) {
                    tGlobal[i] = tbuf[i];
                }
                // Fill data for rank > 0
                for (int rr = 1; rr < PE.NODES(); ++rr){
                    MPI_Recv(tbuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);
                    for(size_t i(0); i < outNxLocal; i++) {
                        tGlobal[i + outNxLocal*rr] = tbuf[i];
                    }
                }
            }
        }
            // Fill data for Nodes = 0
        else {
            for(size_t i(0); i < outNxGlobal; i++) {
                tGlobal[i] = tbuf[i];
            }
        }

        if (PE.RANK() == 0) expo.Export_h5("T", tGlobal, tout, s);

    }

    // delete[] nbuf;
    delete[] tbuf;

}

Here is the call graph for this function:

Ti()

void Output_Data::Output_Preprocessor_1D::Ti ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 3360 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, State1D::HYDRO(), Input::List(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), Parallel_Environment_1D::RANK(), and Hydro1D::temperature().

                                                                                {


    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;
    // size_t st(0), bi(0);
    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    int msg_sz(outNxLocal); //*szy);
    float* Thydrobuf = new float[msg_sz];
    valarray<float> ThydroGlobal(outNxGlobal); //, yglob_axis.dim());

    for(size_t i(0); i < msg_sz; ++i) {
        Thydrobuf[i] = static_cast<float>(511000.0/3.0*Y.HYDRO().temperature(i+Nbc));
    }

    if (PE.NODES() > 1) {
        if (PE.RANK()!=0) {
            MPI_Send(Thydrobuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
        }
        else {
            // Fill data for rank = 0
            for(size_t i(0); i < outNxLocal; i++) {
                ThydroGlobal[i] = Thydrobuf[i];
            }
            // Fill data for rank > 0
            for (int rr = 1; rr < PE.NODES(); ++rr){
                MPI_Recv(Thydrobuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);
                for(size_t i(0); i < outNxLocal; i++) {
                    ThydroGlobal[i + outNxLocal*rr] = Thydrobuf[i];
                }
            }
        }
    }
        // Fill data for Nodes = 0
    else {
        for(size_t i(0); i < outNxGlobal; i++) {
            ThydroGlobal[i] = Thydrobuf[i];
        }
    }

    if (PE.RANK() == 0) expo.Export_h5("Ti", ThydroGlobal, tout, 0);



    delete[] Thydrobuf;

}

Here is the call graph for this function:

Ux()

void Output_Data::Output_Preprocessor_1D::Ux ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 3092 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, State1D::HYDRO(), Input::List(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), Parallel_Environment_1D::RANK(), and Hydro1D::vx().

                                                                                {


    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;
    // size_t st(0), bi(0);
    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    int msg_sz(outNxLocal); //*szy);
    float* Uxbuf = new float[msg_sz];
    valarray<float> UxGlobal(outNxGlobal); //, yglob_axis.dim());

    for(size_t i(0); i < msg_sz; ++i) {
        Uxbuf[i] = static_cast<float>(Y.HYDRO().vx(i+Nbc));
    }

    if (PE.NODES() > 1) {
        if (PE.RANK()!=0) {
            MPI_Send(Uxbuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
        }
        else {
            // Fill data for rank = 0
            for(size_t i(0); i < outNxLocal; i++) {
                UxGlobal[i] = Uxbuf[i];
            }
            // Fill data for rank > 0
            for (int rr = 1; rr < PE.NODES(); ++rr){
                MPI_Recv(Uxbuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);
                for(size_t i(0); i < outNxLocal; i++) {
                    UxGlobal[i + outNxLocal*rr] = Uxbuf[i];
                }
            }
        }
    }
        // Fill data for Nodes = 0
    else {
        for(size_t i(0); i < outNxGlobal; i++) {
            UxGlobal[i] = Uxbuf[i];
        }
    }

    if (PE.RANK() == 0) expo.Export_h5("Ux", UxGlobal, tout, 0);



    delete[] Uxbuf;

}

Here is the call graph for this function:

Uy()

void Output_Data::Output_Preprocessor_1D::Uy ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 3144 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, State1D::HYDRO(), Input::List(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), Parallel_Environment_1D::RANK(), and Hydro1D::vy().

                                                                                {


    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;
    // size_t st(0), bi(0);
    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    int msg_sz(outNxLocal); //*szy);
    float* Uxbuf = new float[msg_sz];
    valarray<float> UxGlobal(outNxGlobal); //, yglob_axis.dim());

    for(size_t i(0); i < msg_sz; ++i) {
        Uxbuf[i] = static_cast<float>(Y.HYDRO().vy(i+Nbc));
    }

    if (PE.NODES() > 1) {
        if (PE.RANK()!=0) {
            MPI_Send(Uxbuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
        }
        else {
            // Fill data for rank = 0
            for(size_t i(0); i < outNxLocal; i++) {
                UxGlobal[i] = Uxbuf[i];
            }
            // Fill data for rank > 0
            for (int rr = 1; rr < PE.NODES(); ++rr){
                MPI_Recv(Uxbuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);
                for(size_t i(0); i < outNxLocal; i++) {
                    UxGlobal[i + outNxLocal*rr] = Uxbuf[i];
                }
            }
        }
    }
        // Fill data for Nodes = 0
    else {
        for(size_t i(0); i < outNxGlobal; i++) {
            UxGlobal[i] = Uxbuf[i];
        }
    }

    if (PE.RANK() == 0) expo.Export_h5("Uy", UxGlobal, tout, 0);



    delete[] Uxbuf;

}

Here is the call graph for this function:

Uz()

void Output_Data::Output_Preprocessor_1D::Uz ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 3196 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, State1D::HYDRO(), Input::List(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), Parallel_Environment_1D::RANK(), and Hydro1D::vz().

                                                                                {


    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;
    // size_t st(0), bi(0);
    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    int msg_sz(outNxLocal); //*szy);
    float* Uxbuf = new float[msg_sz];
    valarray<float> UxGlobal(outNxGlobal); //, yglob_axis.dim());


    for(size_t i(0); i < msg_sz; ++i) {
        Uxbuf[i] = static_cast<float>(Y.HYDRO().vz(i+Nbc));
    }

    if (PE.NODES() > 1) {
        if (PE.RANK()!=0) {
            MPI_Send(Uxbuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
        }
        else {
            // Fill data for rank = 0
            for(size_t i(0); i < outNxLocal; i++) {
                UxGlobal[i] = Uxbuf[i];
            }
            // Fill data for rank > 0
            for (int rr = 1; rr < PE.NODES(); ++rr){
                MPI_Recv(Uxbuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);
                for(size_t i(0); i < outNxLocal; i++) {
                    UxGlobal[i + outNxLocal*rr] = Uxbuf[i];
                }
            }
        }
    }
        // Fill data for Nodes = 0
    else {
        for(size_t i(0); i < outNxGlobal; i++) {
            UxGlobal[i] = Uxbuf[i];
        }
    }

    if (PE.RANK() == 0) expo.Export_h5("Uz", UxGlobal, tout, 0);



    delete[] Uxbuf;

}

Here is the call graph for this function:

vNx()

void Output_Data::Output_Preprocessor_1D::vNx ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 2926 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, Input::List(), Algorithms::MakeCAxis(), Algorithms::moment(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), Parallel_Environment_1D::RANK(), State1D::SH(), State1D::Species(), and vfloat().

                                                                                 {


    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;
    // size_t st(0), bi(0);
    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    int msg_sz(outNxLocal); //*szy);
    float* vNxbuf = new float[msg_sz];
    valarray<float> vNxGlobal(outNxGlobal); //, yglob_axis.dim());

    for(int s(0); s < Y.Species(); ++s) {

//        valarray<float> pra( Algorithms::MakeAxis( f_x.Pmin(s), f_x.Pmax(s), f_x.Np(s) ) );

        valarray<float> pra( Algorithms::MakeCAxis( float(0.0),f_x.Pmax(s), f_x.Np(s) ) );

        for(size_t i(0); i < msg_sz; ++i) {
            vNxbuf[i] = (float) (1.0 / 6.0 * (Algorithms::moment(vfloat((Y.SH(s, 1, 0)).xVec(i + Nbc) ), pra, 6)
                                              / Algorithms::moment(  vfloat( (Y.SH(s,0,0)).xVec(i+Nbc) ), pra, 5)));
        }

        if (PE.NODES() > 1) {
            if (PE.RANK()!=0) {
                MPI_Send(vNxbuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
            }
            else {
                // Fill data for rank = 0
                for(size_t i(0); i < outNxLocal; i++) {
                    vNxGlobal[i] = vNxbuf[i];
                }
                // Fill data for rank > 0
                for (int rr = 1; rr < PE.NODES(); ++rr){
                    MPI_Recv(vNxbuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);
                    for(size_t i(0); i < outNxLocal; i++) {
                        vNxGlobal[i + outNxLocal*rr] = vNxbuf[i];
                    }
                }
            }
        }
            // Fill data for Nodes = 0
        else {
            for(size_t i(0); i < outNxGlobal; i++) {
                vNxGlobal[i] = vNxbuf[i];
            }
        }

        if (PE.RANK() == 0) expo.Export_h5("vNx", vNxGlobal, tout, 0);

    }

    delete[] vNxbuf;

}

Here is the call graph for this function:

vNy()

void Output_Data::Output_Preprocessor_1D::vNy ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 2985 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, Input::List(), Algorithms::MakeCAxis(), Algorithms::moment(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), Parallel_Environment_1D::RANK(), State1D::SH(), State1D::Species(), and vfloat().

                                                                                 {


    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;
    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    int msg_sz(outNxLocal); //*szy);
    float* vNxbuf = new float[msg_sz];
    valarray<float> vNxGlobal(outNxGlobal);

    for(int s(0); s < Y.Species(); ++s) {
//        valarray<float> pra( Algorithms::MakeAxis( f_x.Pmin(s), f_x.Pmax(s), f_x.Np(s) ) );
        valarray<float> pra( Algorithms::MakeCAxis( float(0.0), f_x.Pmax(s), f_x.Np(s) ) );

        for(size_t i(0); i < msg_sz; ++i) {
            vNxbuf[i] = (float) (2.0 / 6.0 * (Algorithms::moment(vfloat((Y.SH(s, 1, 1)).xVec(i + Nbc) ), pra, 6)
                                              / Algorithms::moment(  vfloat( (Y.SH(s,0,0)).xVec(i+Nbc) ), pra, 5)));
        }
        if (PE.NODES() > 1) {
            if (PE.RANK()!=0) {
                MPI_Send(vNxbuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
            }
            else {
                // Fill data for rank = 0
                for(size_t i(0); i < outNxLocal; i++) {
                    vNxGlobal[i] = vNxbuf[i];
                }
                // Fill data for rank > 0
                for (int rr = 1; rr < PE.NODES(); ++rr){
                    MPI_Recv(vNxbuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);
                    for(size_t i(0); i < outNxLocal; i++) {
                        vNxGlobal[i + outNxLocal*rr] = vNxbuf[i];
                    }
                }
            }
        }
            // Fill data for Nodes = 0
        else {
            for(size_t i(0); i < outNxGlobal; i++) {
                vNxGlobal[i] = vNxbuf[i];
            }
        }
        if (PE.RANK() == 0) expo.Export_h5("vNy", vNxGlobal, tout, 0);
    }
    delete[] vNxbuf;
}

Here is the call graph for this function:

vNz()

void Output_Data::Output_Preprocessor_1D::vNz ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 3037 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, Input::List(), Algorithms::MakeCAxis(), Algorithms::moment(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), Parallel_Environment_1D::RANK(), State1D::SH(), State1D::Species(), vfloat(), and vfloat_complex().

                                                                                 {


    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;
    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    int msg_sz(outNxLocal);
    float* vNxbuf = new float[msg_sz];
    valarray<float> vNxGlobal(outNxGlobal);

    for(int s(0); s < Y.Species(); ++s) {
//        valarray<float> pra( Algorithms::MakeAxis( f_x.Pmin(s), f_x.Pmax(s), f_x.Np(s) ) );

        valarray<float> pra( Algorithms::MakeCAxis( float(0.0), f_x.Pmax(s), f_x.Np(s) ) );

        for(size_t i(0); i < msg_sz; ++i) {
            vNxbuf[i] = (float) (-2.0 / 6.0 * (Algorithms::moment(vfloat_complex((Y.SH(s, 1, 1)).xVec(i + Nbc) ), pra, 6)
                                               / Algorithms::moment(  vfloat( (Y.SH(s,0,0)).xVec(i+Nbc) ), pra, 5)));
        }
        if (PE.NODES() > 1) {
            if (PE.RANK()!=0) {
                MPI_Send(vNxbuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
            }
            else {
                // Fill data for rank = 0
                for(size_t i(0); i < outNxLocal; i++) {
                    vNxGlobal[i] = vNxbuf[i];
                }
                // Fill data for rank > 0
                for (int rr = 1; rr < PE.NODES(); ++rr){
                    MPI_Recv(vNxbuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);
                    for(size_t i(0); i < outNxLocal; i++) {
                        vNxGlobal[i + outNxLocal*rr] = vNxbuf[i];
                    }
                }
            }
        }
            // Fill data for Nodes = 0
        else {
            for(size_t i(0); i < outNxGlobal; i++) {
                vNxGlobal[i] = vNxbuf[i];
            }
        }
        if (PE.RANK() == 0) expo.Export_h5("vNz", vNxGlobal, tout, 0);
    }
    delete[] vNxbuf;
}

Here is the call graph for this function:

Z()

void Output_Data::Output_Preprocessor_1D::Z ( const State1D &  Y, const Grid_Info &  grid, const size_t  tout, const Parallel_Environment_1D &  PE  )

private

Definition at line 3249 of file export.cpp.

References Grid_Info::axis, Input::Input_List::BoundaryCells, State1D::HYDRO(), Input::List(), Parallel_Environment_1D::NODES(), Algorithms::AxisBundle< T >::Nx(), Algorithms::AxisBundle< T >::Nxg(), Parallel_Environment_1D::RANK(), and Hydro1D::Z().

                                                                               {


    size_t Nbc = Input::List().BoundaryCells;
    MPI_Status status;
    // size_t st(0), bi(0);
    size_t outNxLocal(grid.axis.Nx(0) - 2*Nbc);
    size_t outNxGlobal(grid.axis.Nxg(0));

    int msg_sz(outNxLocal); //*szy);
    float* Uxbuf = new float[msg_sz];
    valarray<float> UxGlobal(outNxGlobal); //, yglob_axis.dim());


    for(size_t i(0); i < msg_sz; ++i) {
        Uxbuf[i] = static_cast<float>(Y.HYDRO().Z(i+Nbc));
    }

    if (PE.NODES() > 1) {
        if (PE.RANK()!=0) {
            MPI_Send(Uxbuf, msg_sz, MPI_FLOAT, 0, PE.RANK(), MPI_COMM_WORLD);
        }
        else {
            // Fill data for rank = 0
            for(size_t i(0); i < outNxLocal; i++) {
                UxGlobal[i] = Uxbuf[i];
            }
            // Fill data for rank > 0
            for (int rr = 1; rr < PE.NODES(); ++rr){
                MPI_Recv(Uxbuf, msg_sz, MPI_FLOAT, rr, rr, MPI_COMM_WORLD, &status);
                for(size_t i(0); i < outNxLocal; i++) {
                    UxGlobal[i + outNxLocal*rr] = Uxbuf[i];
                }
            }
        }
    }
        // Fill data for Nodes = 0
    else {
        for(size_t i(0); i < outNxGlobal; i++) {
            UxGlobal[i] = Uxbuf[i];
        }
    }

    if (PE.RANK() == 0) expo.Export_h5("Z", UxGlobal, tout, 0);



    delete[] Uxbuf;

}

Here is the call graph for this function:

Field Documentation

expo

Export_Files::Xport Output_Data::Output_Preprocessor_1D::expo

private

Definition at line 429 of file export.h.

f_x

fx1_1D Output_Data::Output_Preprocessor_1D::f_x

private

Definition at line 431 of file export.h.

Nbc

size_t Output_Data::Output_Preprocessor_1D::Nbc

private

Definition at line 428 of file export.h.

oTags

vector< string > Output_Data::Output_Preprocessor_1D::oTags

private

Definition at line 433 of file export.h.

px_x

p1x1_1D Output_Data::Output_Preprocessor_1D::px_x

private

Definition at line 430 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