Nektar::LibUtilities::Transposition Class Reference

#include <Transposition.h>

Public Member Functions
	Transposition (const LibUtilities::BasisKey &HomoBasis0, LibUtilities::CommSharedPtr hcomm)
	Transposition (const LibUtilities::BasisKey &HomoBasis0, const LibUtilities::BasisKey &HomoBasis1, LibUtilities::CommSharedPtr hcomm)
	Transposition (const LibUtilities::BasisKey &HomoBasis0, const LibUtilities::BasisKey &HomoBasis1, const LibUtilities::BasisKey &HomoBasis2, LibUtilities::CommSharedPtr hcomm)
	~Transposition ()
unsigned int	GetK (int i)
Array< OneD, unsigned int >	GetKs (void)
unsigned int	GetPlaneID (int i)
Array< OneD, unsigned int >	GetPlanesIDs (void)
void	Transpose (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool UseNumMode=false, TranspositionDir dir=eNoTrans)
void	SetSpecVanVisc (Array< OneD, NekDouble > visc)
NekDouble	GetSpecVanVisc (const int k)

Protected Attributes
CommSharedPtr	m_hcomm

Private Member Functions
void	TransposeXYtoZ (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool UseNumMode=false)
void	TransposeZtoXY (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool UseNumMode=false)
void	TransposeXtoYZ (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool UseNumMode=false)
void	TransposeYZtoX (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool UseNumMode=false)
void	TransposeYZtoZY (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool UseNumMode=false)
void	TransposeZYtoYZ (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool UseNumMode=false)

Private Attributes
int	m_num_homogeneous_directions
Array< OneD, int >	m_num_points_per_proc
	Number of homogeneous points on each processor per direction.
Array< OneD, int >	m_num_homogeneous_points
	Total homogeneous points per direction.
Array< OneD, int >	m_num_homogeneous_coeffs
	Total number of homogeneous coefficients.
Array< OneD, int >	m_num_processes
int	m_rank_id
	Rank of process.
Array< OneD, unsigned int >	m_planes_IDs
	IDs of the planes on the processes.
Array< OneD, unsigned int >	m_K
	Fourier wave numbers associated with the planes.
Array< OneD, int >	m_SizeMap
	MPI_Alltoallv map containing size of send/recv buffer.
Array< OneD, int >	m_OffsetMap
	MPI_Alltoallv offset map of send/recv buffer in global vector.

Detailed Description

Definition at line 63 of file Transposition.h.

Constructor & Destructor Documentation

Nektar::LibUtilities::Transposition::Transposition	(	const LibUtilities::BasisKey &	HomoBasis0,
		LibUtilities::CommSharedPtr	hcomm
	)

Constructor for 1D transform.

Definition at line 52 of file Transposition.cpp.

References Nektar::LibUtilities::eFourier, Nektar::LibUtilities::eFourierHalfModeIm, Nektar::LibUtilities::eFourierHalfModeRe, Nektar::LibUtilities::eFourierSingleMode, Nektar::LibUtilities::BasisKey::GetBasisType(), Nektar::LibUtilities::BasisKey::GetNumModes(), Nektar::LibUtilities::BasisKey::GetNumPoints(), m_hcomm, m_K, m_num_homogeneous_coeffs, m_num_homogeneous_directions, m_num_homogeneous_points, m_num_points_per_proc, m_num_processes, m_planes_IDs, and m_rank_id.

        {
            m_hcomm = hcomm;
            m_num_homogeneous_directions = 1;

            m_num_points_per_proc =
                        Array<OneD,int>(m_num_homogeneous_directions);
            m_num_homogeneous_points =
                        Array<OneD,int>(m_num_homogeneous_directions);
            m_num_homogeneous_coeffs =
                        Array<OneD,int>(m_num_homogeneous_directions);
            m_num_processes =
                        Array<OneD,int>(m_num_homogeneous_directions);

            m_num_homogeneous_points[0]  = HomoBasis0.GetNumPoints();
            m_num_homogeneous_coeffs[0]  = HomoBasis0.GetNumModes();
            m_num_processes[0]           = m_hcomm->GetSize();
            m_num_points_per_proc[0]     = m_num_homogeneous_points[0] /
                                           m_num_processes[0];
            m_rank_id                    = m_hcomm->GetRank();

            //================================================================
            // TODO: Need to be generalised for 1D, 2D and 3D
            m_planes_IDs = Array<OneD, unsigned int>(m_num_points_per_proc[0]);
            m_K          = Array<OneD, unsigned int>(m_num_points_per_proc[0]);

            for(int i = 0 ; i < m_num_points_per_proc[0] ; i++)
            {
                m_planes_IDs[i] = m_rank_id*m_num_points_per_proc[0] + i;
            }

            if(HomoBasis0.GetBasisType() == LibUtilities::eFourier)
            {
                for(int i = 0 ; i < m_num_points_per_proc[0] ; i++)
                {
                    m_K[i] = m_planes_IDs[i]/2;
                }
            }

            if(HomoBasis0.GetBasisType() == LibUtilities::eFourierSingleMode)
            {
                m_K[0] = 1;
                m_K[1] = 1;
            }

            if(HomoBasis0.GetBasisType() == LibUtilities::eFourierHalfModeRe ||
               HomoBasis0.GetBasisType() == LibUtilities::eFourierHalfModeIm)
            {
                m_K[0]=1;
            }
            //================================================================
        }

Nektar::LibUtilities::Transposition::Transposition	(	const LibUtilities::BasisKey &	HomoBasis0,
		const LibUtilities::BasisKey &	HomoBasis1,
		LibUtilities::CommSharedPtr	hcomm
	)

Constructor for 2D transform.

Definition at line 110 of file Transposition.cpp.

References Nektar::LibUtilities::BasisKey::GetNumModes(), Nektar::LibUtilities::BasisKey::GetNumPoints(), m_hcomm, m_num_homogeneous_coeffs, m_num_homogeneous_directions, m_num_homogeneous_points, m_num_points_per_proc, and m_num_processes.

        {
            m_hcomm = hcomm;
            m_num_homogeneous_directions = 2;

            m_num_points_per_proc =
                            Array<OneD,int>(m_num_homogeneous_directions);
            m_num_homogeneous_points =
                            Array<OneD,int>(m_num_homogeneous_directions);
            m_num_homogeneous_coeffs =
                            Array<OneD,int>(m_num_homogeneous_directions);
            m_num_processes =
                            Array<OneD,int>(m_num_homogeneous_directions);

            m_num_homogeneous_points[0]  = HomoBasis0.GetNumPoints();
            m_num_homogeneous_coeffs[0]  = HomoBasis0.GetNumModes();
            m_num_homogeneous_points[1]  = HomoBasis1.GetNumPoints();
            m_num_homogeneous_coeffs[1]  = HomoBasis1.GetNumModes();

            m_num_processes[0]           = m_hcomm->GetRowComm()->GetSize();
            m_num_processes[1]           = m_hcomm->GetColumnComm()->GetSize();

            m_num_points_per_proc[0]     = m_num_homogeneous_points[0] /
                                           m_num_processes[0];
            m_num_points_per_proc[1]     = m_num_homogeneous_points[1] /
                                           m_num_processes[1];

            //================================================================
            // TODO: Need set up for 2D lines IDs and Ks if Fourier
            //================================================================
        }

Nektar::LibUtilities::Transposition::Transposition	(	const LibUtilities::BasisKey &	HomoBasis0,
		const LibUtilities::BasisKey &	HomoBasis1,
		const LibUtilities::BasisKey &	HomoBasis2,
		LibUtilities::CommSharedPtr	hcomm
	)

Constructor for 3D transform.

Definition at line 148 of file Transposition.cpp.

References ASSERTL0, m_hcomm, m_num_homogeneous_coeffs, m_num_homogeneous_directions, m_num_homogeneous_points, m_num_points_per_proc, and m_num_processes.

        {
            m_hcomm = hcomm;
            m_num_homogeneous_directions = 3;

            m_num_points_per_proc =
                            Array<OneD,int>(m_num_homogeneous_directions);
            m_num_homogeneous_points =
                            Array<OneD,int>(m_num_homogeneous_directions);
            m_num_homogeneous_coeffs =
                            Array<OneD,int>(m_num_homogeneous_directions);
            m_num_processes =
                            Array<OneD,int>(m_num_homogeneous_directions);

            //================================================================
            // TODO: Need set up for 3D
            ASSERTL0(false, "Transposition is not set up for 3D.");
            //================================================================
        }

Nektar::LibUtilities::Transposition::~Transposition

(

)

Destructor

Definition at line 175 of file Transposition.cpp.

        {

        }

Member Function Documentation

unsigned int Nektar::LibUtilities::Transposition::GetK

(

int

i

)

Definition at line 182 of file Transposition.cpp.

References m_K.

        {
            return m_K[i];
        }

Array< OneD, unsigned int > Nektar::LibUtilities::Transposition::GetKs

(

void

)

Definition at line 187 of file Transposition.cpp.

References m_K.

        {
            return m_K;
        }

unsigned int Nektar::LibUtilities::Transposition::GetPlaneID

(

int

i

)

Definition at line 192 of file Transposition.cpp.

References m_planes_IDs.

        {
            return m_planes_IDs[i];
        }

Array< OneD, unsigned int > Nektar::LibUtilities::Transposition::GetPlanesIDs

(

void

)

Definition at line 197 of file Transposition.cpp.

References m_planes_IDs.

        {
            return m_planes_IDs;
        }

NekDouble Nektar::LibUtilities::Transposition::GetSpecVanVisc

(

const int

k

)

void Nektar::LibUtilities::Transposition::SetSpecVanVisc

(

Array< OneD, NekDouble >

visc

)

void Nektar::LibUtilities::Transposition::Transpose	(	const Array< OneD, const NekDouble > &	inarray,
		Array< OneD, NekDouble > &	outarray,
		bool	UseNumMode = false,
		TranspositionDir	dir = eNoTrans
	)

Main method: General transposition, the dir parameters define if 1D,2D,3D and which transposition is required at the same time

Definition at line 207 of file Transposition.cpp.

References ASSERTL0, Nektar::LibUtilities::eXtoY, Nektar::LibUtilities::eXtoYZ, Nektar::LibUtilities::eXYtoZ, Nektar::LibUtilities::eYtoZ, Nektar::LibUtilities::eYZtoX, Nektar::LibUtilities::eYZtoZY, Nektar::LibUtilities::eZtoX, Nektar::LibUtilities::eZtoXY, Nektar::LibUtilities::eZYtoYZ, TransposeXtoYZ(), TransposeXYtoZ(), TransposeYZtoX(), TransposeYZtoZY(), TransposeZtoXY(), and TransposeZYtoYZ().

        {
            switch(dir)
            {
            case eXYtoZ:
                {
                    TransposeXYtoZ(inarray,outarray,UseNumMode);
                }
                break;
            case eZtoXY:
                {
                    TransposeZtoXY(inarray,outarray,UseNumMode);
                }
                break;
            case eXtoYZ:
                {
                    TransposeXtoYZ(inarray,outarray,UseNumMode);
                }
                break;
            case eYZtoX:
                {
                    TransposeYZtoX(inarray,outarray,UseNumMode);
                }
                break;
            case eYZtoZY:
                {
                    TransposeYZtoZY(inarray,outarray,UseNumMode);
                }
                break;
            case eZYtoYZ:
                {
                    TransposeZYtoYZ(inarray,outarray,UseNumMode);
                }
                break;
            case eXtoY:
                {
                    ASSERTL0(false,"Transposition not implemented yet.");
                }
                break;
            case eYtoZ:
                {
                    ASSERTL0(false,"Transposition not implemented yet.");
                }
                break;
            case eZtoX:
                {
                    ASSERTL0(false,"Transposition not implemented yet.");
                }
                break;
            default:
                {
                    ASSERTL0(false,"Transposition type does not exist.");
                }
            }
        }

void Nektar::LibUtilities::Transposition::TransposeXtoYZ ( const Array< OneD, const NekDouble > &  inarray, Array< OneD, NekDouble > &  outarray, bool  UseNumMode = false  )

private

Homogeneous 2D transposition from SEM to Homogeneous(YZ) ordering.

Definition at line 494 of file Transposition.cpp.

References ASSERTL0, ASSERTL1, m_num_homogeneous_coeffs, m_num_homogeneous_points, m_num_processes, and Vmath::Vcopy().

Referenced by Transpose().

        {
            if(m_num_processes[0] > 1 || m_num_processes[1] > 1)
            {
                ASSERTL0(false,
                         "Parallel transposition not implemented yet for "
                         "3D-Homo-2D approach.");
            }
            else
            {
                int i, pts_per_line;
                int n = inarray.num_elements();
                int packed_len;

                pts_per_line = n / (m_num_homogeneous_points[0] *
                                    m_num_homogeneous_points[1]);

                if(UseNumMode)
                {
                    packed_len = (m_num_homogeneous_coeffs[0] *
                                  m_num_homogeneous_coeffs[1]);
                }
                else
                {
                    packed_len = (m_num_homogeneous_points[0] *
                                  m_num_homogeneous_points[1]);
                }

                ASSERTL1(&inarray[0] != &outarray[0],
                         "Inarray and outarray cannot be the same");

                for(i = 0; i < packed_len; ++i)
                {
                    Vmath::Vcopy(pts_per_line,
                            &(inarray[i * pts_per_line]), 1,
                            &(outarray[i]), packed_len);
                }
            }
        }

void Nektar::LibUtilities::Transposition::TransposeXYtoZ ( const Array< OneD, const NekDouble > &  inarray, Array< OneD, NekDouble > &  outarray, bool  UseNumMode = false  )

private

Homogeneous 1D transposition from SEM to Homogeneous ordering.

Definition at line 270 of file Transposition.cpp.

References ASSERTL1, m_hcomm, m_num_homogeneous_coeffs, m_num_homogeneous_points, m_num_points_per_proc, m_num_processes, m_OffsetMap, m_SizeMap, and Vmath::Vcopy().

Referenced by Transpose().

        {
            if(m_num_processes[0] > 1)
            {
                // Paramerers set up
                int i,packed_len;
                int copy_len = 0;
                int index = 0;
                int cnt = 0;

                int num_dofs             = inarray.num_elements();
                int num_points_per_plane = num_dofs/m_num_points_per_proc[0];
                int num_pencil_per_proc  =
                               (num_points_per_plane / m_num_processes[0]) +
                               (num_points_per_plane % m_num_processes[0] > 0);

                m_SizeMap = Array<OneD,int>   (m_num_processes[0],0);
                m_OffsetMap = Array<OneD,int> (m_num_processes[0],0);

                for(i = 0; i < m_num_processes[0]; i++)
                {
                    m_SizeMap[i]   = num_pencil_per_proc *
                                     m_num_points_per_proc[0];
                    m_OffsetMap[i] = i * num_pencil_per_proc *
                                     m_num_points_per_proc[0];
                }

                Array< OneD, NekDouble> tmp_outarray(
                            num_pencil_per_proc*m_num_homogeneous_points[0],
                            0.0);

                if(UseNumMode)
                {
                    packed_len = m_num_homogeneous_coeffs[0];
                }
                else
                {
                    packed_len = m_num_homogeneous_points[0];
                }

                // Start Transposition
                while(index < num_points_per_plane)
                {
                    copy_len =
                        num_pencil_per_proc < (num_points_per_plane - index)
                        ? num_pencil_per_proc
                        : (num_points_per_plane - index);

                    for(i = 0 ; i < m_num_points_per_proc[0]; i++)
                    {
                        Vmath::Vcopy(copy_len,
                            &(inarray[index + (i * num_points_per_plane)]), 1,
                            &(outarray[cnt]), 1);

                        cnt += num_pencil_per_proc;
                    }

                    index += copy_len;
                }

                m_hcomm->AlltoAllv(outarray,     m_SizeMap, m_OffsetMap,
                                   tmp_outarray, m_SizeMap, m_OffsetMap);

                for(i = 0; i < packed_len; ++i)
                {
                    Vmath::Vcopy(num_pencil_per_proc,
                            &(tmp_outarray[i * num_pencil_per_proc]), 1,
                            &(outarray[i]), packed_len);
                }
                // End Transposition
            }

            // Serial case implementation (more efficient then MPI 1 processor
            // implemenation)
            else
            {
                int i, pts_per_plane;
                int n = inarray.num_elements();
                int packed_len;

                pts_per_plane = n/m_num_points_per_proc[0];

                if(UseNumMode)
                {
                    packed_len = m_num_homogeneous_coeffs[0];
                }
                else
                {
                    packed_len = m_num_homogeneous_points[0];
                }

                ASSERTL1(&inarray[0] != &outarray[0],
                         "Inarray and outarray cannot be the same");

                for(i = 0; i < packed_len; ++i)
                {
                    Vmath::Vcopy(pts_per_plane,
                            &(inarray[i * pts_per_plane]), 1,
                            &(outarray[i]), packed_len);
                }
            }
        }

void Nektar::LibUtilities::Transposition::TransposeYZtoX ( const Array< OneD, const NekDouble > &  inarray, Array< OneD, NekDouble > &  outarray, bool  UseNumMode = false  )

private

Homogeneous 2D transposition from Homogeneous (YZ) ordering to SEM.

Definition at line 541 of file Transposition.cpp.

References ASSERTL0, ASSERTL1, m_num_homogeneous_coeffs, m_num_homogeneous_points, m_num_processes, and Vmath::Vcopy().

Referenced by Transpose().

        {
            if(m_num_processes[0] > 1 || m_num_processes[1] > 1)
            {
                ASSERTL0(false,
                         "Parallel transposition not implemented yet for "
                         "3D-Homo-2D approach.");
            }
            else
            {
                int i,pts_per_line;
                int n = inarray.num_elements();
                int packed_len;

                pts_per_line = n / (m_num_homogeneous_points[0] *
                                    m_num_homogeneous_points[1]);

                if(UseNumMode)
                {
                    packed_len = (m_num_homogeneous_coeffs[0] *
                                  m_num_homogeneous_coeffs[1]);
                }
                else
                {
                    packed_len = (m_num_homogeneous_points[0] *
                                  m_num_homogeneous_points[1]);
                }

                ASSERTL1(&inarray[0] != &outarray[0],
                         "Inarray and outarray cannot be the same");

                for(i = 0; i < packed_len; ++i)
                {
                    Vmath::Vcopy(pts_per_line,
                            &(inarray[i]), packed_len,
                            &(outarray[i * pts_per_line]), 1);
                }
            }
        }

void Nektar::LibUtilities::Transposition::TransposeYZtoZY ( const Array< OneD, const NekDouble > &  inarray, Array< OneD, NekDouble > &  outarray, bool  UseNumMode = false  )

private

Homogeneous 2D transposition from Y ordering to Z.

Definition at line 588 of file Transposition.cpp.

References ASSERTL0, m_num_homogeneous_points, m_num_processes, and Vmath::Vcopy().

Referenced by Transpose().

        {
            if(m_num_processes[0] > 1 || m_num_processes[1] > 1)
            {
                ASSERTL0(false,
                         "Parallel transposition not implemented yet for "
                         "3D-Homo-2D approach.");
            }
            else
            {
                int n = m_num_homogeneous_points[0] *
                        m_num_homogeneous_points[1];
                int s = inarray.num_elements();

                int pts_per_line  = s/n;

                int packed_len = pts_per_line * m_num_homogeneous_points[1];

                for(int i = 0; i < m_num_homogeneous_points[0] ; ++i)
                {
                    Vmath::Vcopy(packed_len,
                            &(inarray[i]), m_num_homogeneous_points[0],
                            &(outarray[i * packed_len]), 1);
                }
            }
        }

void Nektar::LibUtilities::Transposition::TransposeZtoXY ( const Array< OneD, const NekDouble > &  inarray, Array< OneD, NekDouble > &  outarray, bool  UseNumMode = false  )

private

Homogeneous 1D transposition from Homogeneous to SEM ordering.

Definition at line 380 of file Transposition.cpp.

References ASSERTL1, m_hcomm, m_num_homogeneous_coeffs, m_num_homogeneous_points, m_num_points_per_proc, m_num_processes, m_OffsetMap, m_SizeMap, and Vmath::Vcopy().

Referenced by Transpose().

        {
            if(m_num_processes[0] > 1)
            {
                // Paramerers set up
                int i,packed_len;
                int copy_len = 0;
                int index = 0;
                int cnt = 0;

                int num_dofs             = outarray.num_elements();
                int num_points_per_plane = num_dofs / m_num_points_per_proc[0];
                int num_pencil_per_proc  =
                                (num_points_per_plane / m_num_processes[0]) +
                                (num_points_per_plane % m_num_processes[0] > 0);

                m_SizeMap = Array<OneD,int> (m_num_processes[0],0);
                m_OffsetMap = Array<OneD,int> (m_num_processes[0],0);

                for(i = 0; i < m_num_processes[0]; i++)
                {
                    m_SizeMap[i]   = num_pencil_per_proc *
                                     m_num_points_per_proc[0];
                    m_OffsetMap[i] = i * num_pencil_per_proc *
                                     m_num_points_per_proc[0];
                }

                Array< OneD, NekDouble> tmp_inarray(
                            num_pencil_per_proc*m_num_homogeneous_points[0],
                            0.0);
                Array< OneD, NekDouble> tmp_outarray(
                            num_pencil_per_proc*m_num_homogeneous_points[0],
                            0.0);

                if(UseNumMode)
                {
                    packed_len = m_num_homogeneous_coeffs[0];
                }
                else
                {
                    packed_len = m_num_homogeneous_points[0];
                }

                // Start Transposition
                for(i = 0; i < packed_len; ++i)
                {
                    Vmath::Vcopy(num_pencil_per_proc,&(inarray[i]),packed_len,
                                 &(tmp_inarray[i*num_pencil_per_proc]),1);
                }

                m_hcomm->AlltoAllv(tmp_inarray,  m_SizeMap, m_OffsetMap,
                                   tmp_outarray, m_SizeMap, m_OffsetMap);

                while(index < num_points_per_plane)
                {
                    copy_len =
                        num_pencil_per_proc < (num_points_per_plane - index)
                        ? num_pencil_per_proc
                        : (num_points_per_plane - index);

                    for(i = 0 ; i < m_num_points_per_proc[0]; i++)
                    {
                        Vmath::Vcopy(copy_len,
                           &(tmp_outarray[cnt]), 1,
                           &(outarray[index + (i * num_points_per_plane)]), 1);

                        cnt += num_pencil_per_proc;
                    }

                    index += copy_len;
                }
                // End Transposition
            }

            // Serial case implementation (more efficient then MPI 1 processor
            // implemenation)
            else
            {
                int i,pts_per_plane;
                int n = inarray.num_elements();
                int packed_len;

                // use length of inarray to determine data storage type
                // (i.e.modal or physical).
                pts_per_plane = n/m_num_points_per_proc[0];

                if(UseNumMode)
                {
                    packed_len = m_num_homogeneous_coeffs[0];
                }
                else
                {
                    packed_len = m_num_homogeneous_points[0];
                }

                ASSERTL1(&inarray[0] != &outarray[0],
                         "Inarray and outarray cannot be the same");

                for(i = 0; i < packed_len; ++i)
                {
                    Vmath::Vcopy(pts_per_plane,
                                 &(inarray[i]), packed_len,
                                 &(outarray[i * pts_per_plane]), 1);
                }
            }
        }

void Nektar::LibUtilities::Transposition::TransposeZYtoYZ ( const Array< OneD, const NekDouble > &  inarray, Array< OneD, NekDouble > &  outarray, bool  UseNumMode = false  )

private

Homogeneous 2D transposition from Z ordering to Y.

Definition at line 622 of file Transposition.cpp.

References ASSERTL0, m_num_homogeneous_points, m_num_processes, and Vmath::Vcopy().

Referenced by Transpose().

        {
            if(m_num_processes[0] > 1 || m_num_processes[1] > 1)
            {
                ASSERTL0(false,
                         "Parallel transposition not implemented yet for "
                         "3D-Homo-2D approach.");
            }
            else
            {
                int n = m_num_homogeneous_points[0] *
                        m_num_homogeneous_points[1];
                int s = inarray.num_elements();

                int pts_per_line  = s/n;

                int packed_len = pts_per_line * m_num_homogeneous_points[1];

                for(int i = 0; i < packed_len ; ++i)
                {
                    Vmath::Vcopy(m_num_homogeneous_points[0],
                            &(inarray[i]), packed_len,
                            &(outarray[i * m_num_homogeneous_points[0]]), 1);
                }
            }
        }

Member Data Documentation

CommSharedPtr Nektar::LibUtilities::Transposition::m_hcomm

protected

Definition at line 102 of file Transposition.h.

Referenced by TransposeXYtoZ(), TransposeZtoXY(), and Transposition().

Array<OneD, unsigned int> Nektar::LibUtilities::Transposition::m_K

private

Fourier wave numbers associated with the planes.

Definition at line 156 of file Transposition.h.

Referenced by GetK(), GetKs(), and Transposition().

Array<OneD,int> Nektar::LibUtilities::Transposition::m_num_homogeneous_coeffs

private

Total number of homogeneous coefficients.

Definition at line 145 of file Transposition.h.

Referenced by TransposeXtoYZ(), TransposeXYtoZ(), TransposeYZtoX(), TransposeZtoXY(), and Transposition().

int Nektar::LibUtilities::Transposition::m_num_homogeneous_directions

private

Definition at line 136 of file Transposition.h.

Referenced by Transposition().

Array<OneD,int> Nektar::LibUtilities::Transposition::m_num_homogeneous_points

private

Total homogeneous points per direction.

Definition at line 142 of file Transposition.h.

Referenced by TransposeXtoYZ(), TransposeXYtoZ(), TransposeYZtoX(), TransposeYZtoZY(), TransposeZtoXY(), TransposeZYtoYZ(), and Transposition().

Array<OneD,int> Nektar::LibUtilities::Transposition::m_num_points_per_proc

private

Number of homogeneous points on each processor per direction.

Definition at line 139 of file Transposition.h.

Referenced by TransposeXYtoZ(), TransposeZtoXY(), and Transposition().

Array<OneD,int> Nektar::LibUtilities::Transposition::m_num_processes

private

Definition at line 147 of file Transposition.h.

Referenced by TransposeXtoYZ(), TransposeXYtoZ(), TransposeYZtoX(), TransposeYZtoZY(), TransposeZtoXY(), TransposeZYtoYZ(), and Transposition().

Array<OneD,int> Nektar::LibUtilities::Transposition::m_OffsetMap

private

MPI_Alltoallv offset map of send/recv buffer in global vector.

Definition at line 162 of file Transposition.h.

Referenced by TransposeXYtoZ(), and TransposeZtoXY().

Array<OneD, unsigned int> Nektar::LibUtilities::Transposition::m_planes_IDs

private

IDs of the planes on the processes.

Definition at line 153 of file Transposition.h.

Referenced by GetPlaneID(), GetPlanesIDs(), and Transposition().

int Nektar::LibUtilities::Transposition::m_rank_id

private

Rank of process.

Definition at line 150 of file Transposition.h.

Referenced by Transposition().

Array<OneD,int> Nektar::LibUtilities::Transposition::m_SizeMap

private

MPI_Alltoallv map containing size of send/recv buffer.

Definition at line 159 of file Transposition.h.

Referenced by TransposeXYtoZ(), and TransposeZtoXY().