Nektar::LibUtilities::Transposition Class Reference

#include <Transposition.h>

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 int npts, 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 int npts, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool UseNumMode=false)
void	TransposeZtoXY (const int npts, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool UseNumMode=false)
void	TransposeXtoYZ (const int npts, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool UseNumMode=false)
void	TransposeYZtoX (const int npts, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool UseNumMode=false)
void	TransposeYZtoZY (const int npts, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool UseNumMode=false)
void	TransposeZYtoYZ (const int npts, 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 68 of file Transposition.h.

Constructor & Destructor Documentation

Transposition() [1/3]

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

Constructor for 1D transform.

Definition at line 50 of file Transposition.cpp.

{
    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;
    }
    //================================================================
}

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.

Transposition() [2/3]

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

Constructor for 2D transform.

Definition at line 114 of file Transposition.cpp.

{
    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
    //================================================================
}

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.

Transposition() [3/3]

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 145 of file Transposition.cpp.

{
    boost::ignore_unused(HomoBasis0, HomoBasis1, HomoBasis2);
 
    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.");
    //================================================================
}

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.

~Transposition()

Nektar::LibUtilities::Transposition::~Transposition

(

)

Destructor

Definition at line 169 of file Transposition.cpp.

{
}

Member Function Documentation

GetK()

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

(

int

i

)

Definition at line 175 of file Transposition.cpp.

{
    return m_K[i];
}

References m_K.

GetKs()

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

(

void

)

Definition at line 180 of file Transposition.cpp.

{
    return m_K;
}

References m_K.

GetPlaneID()

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

(

int

i

)

Definition at line 185 of file Transposition.cpp.

{
    return m_planes_IDs[i];
}

References m_planes_IDs.

GetPlanesIDs()

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

(

void

)

Definition at line 190 of file Transposition.cpp.

{
    return m_planes_IDs;
}

References m_planes_IDs.

GetSpecVanVisc()

NekDouble Nektar::LibUtilities::Transposition::GetSpecVanVisc

(

const int

k

)

GetStripID()

unsigned int Nektar::LibUtilities::Transposition::GetStripID

(

void

)

Definition at line 195 of file Transposition.cpp.

{
    return m_strip_ID;
}

References m_strip_ID.

SetSpecVanVisc()

void Nektar::LibUtilities::Transposition::SetSpecVanVisc

(

Array< OneD, NekDouble >

visc

)

Transpose()

void Nektar::LibUtilities::Transposition::Transpose	(	const int	npts,
		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 204 of file Transposition.cpp.

{
    switch (dir)
    {
        case eXYtoZ:
        {
            TransposeXYtoZ(npts, inarray, outarray, UseNumMode);
        }
        break;
        case eZtoXY:
        {
            TransposeZtoXY(npts, inarray, outarray, UseNumMode);
        }
        break;
        case eXtoYZ:
        {
            TransposeXtoYZ(npts, inarray, outarray, UseNumMode);
        }
        break;
        case eYZtoX:
        {
            TransposeYZtoX(npts, inarray, outarray, UseNumMode);
        }
        break;
        case eYZtoZY:
        {
            TransposeYZtoZY(npts, inarray, outarray, UseNumMode);
        }
        break;
        case eZYtoYZ:
        {
            TransposeZYtoYZ(npts, 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.");
        }
    }
}

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().

TransposeXtoYZ()

void Nektar::LibUtilities::Transposition::TransposeXtoYZ ( const int  npts, 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 477 of file Transposition.cpp.

{
    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 = npts;
        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);
        }
    }
}

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

Referenced by Transpose().

TransposeXYtoZ()

void Nektar::LibUtilities::Transposition::TransposeXYtoZ ( const int  npts, 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 266 of file Transposition.cpp.

{
    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             = npts;
        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 = npts;
        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);
        }
    }
}

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().

TransposeYZtoX()

void Nektar::LibUtilities::Transposition::TransposeYZtoX ( const int  npts, 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 521 of file Transposition.cpp.

{
    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 = npts;
        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);
        }
    }
}

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

Referenced by Transpose().

TransposeYZtoZY()

void Nektar::LibUtilities::Transposition::TransposeYZtoZY ( const int  npts, 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 565 of file Transposition.cpp.

{
    boost::ignore_unused(UseNumMode);
 
    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 = npts;
 
        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);
        }
    }
}

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

Referenced by Transpose().

TransposeZtoXY()

void Nektar::LibUtilities::Transposition::TransposeZtoXY ( const int  npts, 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 370 of file Transposition.cpp.

{
    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             = npts; // outarray.size();
        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 = npts;
        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);
        }
    }
}

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().

TransposeZYtoYZ()

void Nektar::LibUtilities::Transposition::TransposeZYtoYZ ( const int  npts, 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 597 of file Transposition.cpp.

{
    boost::ignore_unused(UseNumMode);
 
    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 = npts;
 
        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);
        }
    }
}

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

Referenced by Transpose().

Member Data Documentation

m_hcomm

CommSharedPtr Nektar::LibUtilities::Transposition::m_hcomm

protected

Definition at line 106 of file Transposition.h.

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

m_K

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().

m_num_homogeneous_coeffs

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

private

Total number of homogeneous coefficients.

Definition at line 142 of file Transposition.h.

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

m_num_homogeneous_directions

int Nektar::LibUtilities::Transposition::m_num_homogeneous_directions

private

Definition at line 133 of file Transposition.h.

Referenced by Transposition().

m_num_homogeneous_points

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

private

Total homogeneous points per direction.

Definition at line 139 of file Transposition.h.

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

m_num_points_per_proc

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

private

Number of homogeneous points on each processor per direction.

Definition at line 136 of file Transposition.h.

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

m_num_processes

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

private

Definition at line 144 of file Transposition.h.

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

m_OffsetMap

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().

m_planes_IDs

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

private

IDs of the planes on the processes.

Definition at line 150 of file Transposition.h.

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

m_rank_id

int Nektar::LibUtilities::Transposition::m_rank_id

private

Rank of process.

Definition at line 147 of file Transposition.h.

Referenced by Transposition().

m_SizeMap

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().

m_strip_ID

unsigned int Nektar::LibUtilities::Transposition::m_strip_ID

private

IDs of the strips on the processes.

Definition at line 153 of file Transposition.h.

Referenced by GetStripID(), and Transposition().