Nektar::LibUtilities::Transposition Class Reference

#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 69 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 51 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 115 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 146 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 168 of file Transposition.cpp.

{
}

Member Function Documentation

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

(

int

i

)

Definition at line 174 of file Transposition.cpp.

References m_K.

{
    return m_K[i];
}

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

(

void

)

Definition at line 179 of file Transposition.cpp.

References m_K.

{
    return m_K;
}

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

(

int

i

)

Definition at line 184 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 189 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 194 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 203 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 473 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 264 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 516 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 559 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 367 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 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 < 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 107 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 157 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 143 of file Transposition.h.

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

int Nektar::LibUtilities::Transposition::m_num_homogeneous_directions

private

Definition at line 134 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 140 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 137 of file Transposition.h.

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

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

private

Definition at line 145 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 163 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 151 of file Transposition.h.

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

int Nektar::LibUtilities::Transposition::m_rank_id

private

Rank of process.

Definition at line 148 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 160 of file Transposition.h.

Referenced by TransposeXYtoZ(), and TransposeZtoXY().

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

private

IDs of the strips on the processes.

Definition at line 154 of file Transposition.h.

Referenced by GetStripID(), and Transposition().