#include <Transposition.h>

Collaboration diagram for Nektar::LibUtilities::Transposition:

Public Member Functions
	Transposition (const LibUtilities::BasisKey &HomoBasis0, LibUtilities::CommSharedPtr hcomm0, LibUtilities::CommSharedPtr hcomm1)

	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)

unsigned int	GetStripID (void)

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. More...

Array< OneD, int >	m_num_homogeneous_points
	Total homogeneous points per direction. More...

Array< OneD, int >	m_num_homogeneous_coeffs
	Total number of homogeneous coefficients. More...

Array< OneD, int >	m_num_processes

int	m_rank_id
	Rank of process. More...

Array< OneD, unsigned int >	m_planes_IDs
	IDs of the planes on the processes. More...

unsigned int	m_strip_ID
	IDs of the strips on the processes. More...

Array< OneD, unsigned int >	m_K
	Fourier wave numbers associated with the planes. More...

Array< OneD, int >	m_SizeMap
	MPI_Alltoallv map containing size of send/recv buffer. More...

Array< OneD, int >	m_OffsetMap
	MPI_Alltoallv offset map of send/recv buffer in global vector. More...

Detailed Description

Definition at line 63 of file Transposition.h.

Constructor & Destructor Documentation

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

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, m_rank_id, and m_strip_ID.

         {
             m_hcomm = hcomm1;
             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;
             }
 
             int global_rank_id = hcomm0->GetColumnComm()->GetRank();
             int NumStrips = hcomm0->GetColumnComm()->GetSize() /
                             m_hcomm->GetSize();
             m_strip_ID = 0;
 
             if (NumStrips > 1)
             {
                 m_strip_ID = 
                     (NumStrips > global_rank_id) ? global_rank_id:(global_rank_id - NumStrips);
             }
             
             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 122 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 160 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 187 of file Transposition.cpp.

         {
 
         }

Member Function Documentation

unsigned int Nektar::LibUtilities::Transposition::GetK ( int i )

Definition at line 194 of file Transposition.cpp.

References m_K.

         {
             return m_K[i];
         }

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

Definition at line 199 of file Transposition.cpp.

References m_K.

         {
             return m_K;
         }

unsigned int Nektar::LibUtilities::Transposition::GetPlaneID ( int i )

Definition at line 204 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 209 of file Transposition.cpp.

References m_planes_IDs.

         {
             return m_planes_IDs;
         }

NekDouble Nektar::LibUtilities::Transposition::GetSpecVanVisc ( const int k )

unsigned int Nektar::LibUtilities::Transposition::GetStripID ( void )

Definition at line 214 of file Transposition.cpp.

References m_strip_ID.

         {
             return m_strip_ID;
         }

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 223 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 510 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 286 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 557 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 604 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 396 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 638 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);
                 }
             }
         }