src/FieldLayout/CenteredFieldLayout.cpp

Go to the documentation of this file.

// -*- C++ -*-
/***************************************************************************
 *
 * The IPPL Framework
 * 
 * This program was prepared by PSI. 
 * All rights in the program are reserved by PSI.
 * Neither PSI nor the author(s)
 * makes any warranty, express or implied, or assumes any liability or
 * responsibility for the use of this software
 *
 * Visit http://www.acl.lanl.gov/POOMS for more details
 *
 ***************************************************************************/

// -*- C++ -*-
/***************************************************************************
 *
 * The IPPL Framework
 * 
 *
 * Visit http://people.web.psi.ch/adelmann/ for more details
 *
 ***************************************************************************/


// include files
#include "FieldLayout/CenteredFieldLayout.h"
#include "Meshes/Centering.h"
#include "Meshes/CartesianCentering.h"
#include "Utility/PAssert.h"
#include "Profile/Profiler.h"

//=============================================================================
// Helper global functions:
// The constructors call these specialized global functions as a workaround for
// lack of partial specialization:
//=============================================================================

//===========================Arbitrary mesh type=============================

//-----------------------------------------------------------------------------
// These specify only a total number of vnodes, allowing the constructor
// complete control on how to do the vnode partitioning of the index space:
// Constructor for arbitrary dimension with parallel/serial specifier array:

//------------------Cell centering---------------------------------------------
template<unsigned Dim, class Mesh>
inline void
centeredInitialize(CenteredFieldLayout<Dim,Mesh,Cell> & cfl,
                   const Mesh& mesh, 
                   e_dim_tag* edt, 
                   int vnodes)
{
  NDIndex<Dim> ndi;
  for (int d=0; d<Dim; d++) 
    ndi[d] = Index(mesh.gridSizes[d] - 1);
  cfl.initialize(ndi, edt, vnodes);
}

//------------------Vert centering---------------------------------------------
template<unsigned Dim, class Mesh>
inline void
centeredInitialize(CenteredFieldLayout<Dim,Mesh,Vert> & cfl,
                   const Mesh& mesh, 
                   e_dim_tag* edt, 
                   int vnodes)
{
  NDIndex<Dim> ndi;
  for (int d=0; d<Dim; d++) 
    ndi[d] = Index(mesh.gridSizes[d]);
  cfl.initialize(ndi, edt, vnodes);
}

//------------------CartesianCentering centering-------------------------------
template<const CenteringEnum* CE, unsigned Dim, class Mesh,
         unsigned NComponents>
inline void
centeredInitialize(CenteredFieldLayout<Dim,Mesh,
                   CartesianCentering<CE,Dim,NComponents> > & cfl,
                   const Mesh& mesh, 
                   e_dim_tag* edt, 
                   int vnodes)
{
  NDIndex<Dim> ndi;
  // For componentwise layout of Field of multicomponent object, like 
  // Field<Vektor...>, allow for maximal number of objects needed per
  // dimension (the number for the object component requiring the maximal
  // number):
  unsigned npts[Dim], nGridPts;
  int d, c;
  for (d=0; d<Dim; d++) {
    nGridPts = mesh.gridSizes[d];
    npts[d] = 0;
    for (c=0; c<NComponents; c++) {
      if (CE[c + d*NComponents] == CELL) {
        npts[d] = max(npts[d], (nGridPts - 1));
      } else {
        npts[d] = max(npts[d], nGridPts);
      }
    }
  }
  for (d=0; d<Dim; d++) ndi[d] = Index(npts[d]);
  cfl.initialize(ndi, edt, vnodes);
}

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// These specify both the total number of vnodes and the numbers of vnodes
// along each dimension for the partitioning of the index space. Obviously this
// restricts the number of vnodes to be a product of the numbers along each
// dimension (the constructor implementation checks this):

//------------------Cell centering---------------------------------------------
template<unsigned Dim, class Mesh>
inline void
centeredInitialize(CenteredFieldLayout<Dim,Mesh,Cell> & cfl,
                   const Mesh& mesh, 
                   e_dim_tag* edt, 
                   unsigned* vnodesAlongDirection, 
                   bool recurse,
                   int vnodes)
{
  NDIndex<Dim> ndi;
  for (int d=0; d<Dim; d++) ndi[d] = Index(mesh.gridSizes[d] - 1);
  cfl.initialize(ndi, edt, vnodesAlongDirection, recurse, vnodes);
}

//------------------Vert centering---------------------------------------------
template<unsigned Dim, class Mesh>
inline void
centeredInitialize(CenteredFieldLayout<Dim,Mesh,Vert> & cfl,
                   const Mesh& mesh, 
                   e_dim_tag* edt, 
                   unsigned* vnodesAlongDirection, 
                   bool recurse,
                   int vnodes)
{
  NDIndex<Dim> ndi;
  for (int d=0; d<Dim; d++) ndi[d] = Index(mesh.gridSizes[d]);
  cfl.initialize(ndi, edt, vnodesAlongDirection, recurse, vnodes);
}

//------------------CartesianCentering centering-------------------------------
template<const CenteringEnum* CE, unsigned Dim, class Mesh,
         unsigned NComponents>
inline void
centeredInitialize(CenteredFieldLayout<Dim,Mesh,
                   CartesianCentering<CE,Dim,NComponents> > & cfl,
                   const Mesh& mesh, 
                   e_dim_tag* edt, 
                   unsigned* vnodesAlongDirection, 
                   bool recurse,
                   int vnodes)
{
  NDIndex<Dim> ndi;
  // For componentwise layout of Field of multicomponent object, like 
  // Field<Vektor...>, allow for maximal number of objects needed per
  // dimension (the number for the object component requiring the maximal
  // number):
  unsigned npts[Dim], nGridPts;
  int d, c;
  for (d=0; d<Dim; d++) {
    nGridPts = mesh.gridSizes[d];
    npts[d] = 0;
    for (c=0; c<NComponents; c++) {
      if (CE[c + d*NComponents] == CELL) {
        npts[d] = max(npts[d], (nGridPts - 1));
      } else {
        npts[d] = max(npts[d], nGridPts);
      }
    }
  }
  for (d=0; d<Dim; d++) ndi[d] = Index(npts[d]);
  cfl.initialize(ndi, edt, vnodesAlongDirection, recurse, vnodes);
}

//-----------------------------------------------------------------------------
// This initializer just specifies a completely user-provided partitioning.

//------------------Cell centering---------------------------------------------
template<unsigned Dim, class Mesh>
inline void
centeredInitialize(CenteredFieldLayout<Dim,Mesh,Cell> & cfl,
                   const Mesh& mesh, 
                   const NDIndex<Dim> *dombegin,
                   const NDIndex<Dim> *domend,
                   const int *nbegin,
                   const int *nend)
{
  NDIndex<Dim> ndi;
  for (int d=0; d<Dim; d++) ndi[d] = Index(mesh.gridSizes[d] - 1);
  cfl.initialize(ndi, dombegin, domend, nbegin, nend);
}

//------------------Vert centering---------------------------------------------
template<unsigned Dim, class Mesh>
inline void
centeredInitialize(CenteredFieldLayout<Dim,Mesh,Vert> & cfl,
                   const Mesh& mesh, 
                   const NDIndex<Dim> *dombegin,
                   const NDIndex<Dim> *domend,
                   const int *nbegin,
                   const int *nend)
{
  NDIndex<Dim> ndi;
  for (int d=0; d<Dim; d++) ndi[d] = Index(mesh.gridSizes[d]);
  cfl.initialize(ndi, dombegin, domend, nbegin, nend);
}

//------------------CartesianCentering centering-------------------------------
template<const CenteringEnum* CE, unsigned Dim, class Mesh,
         unsigned NComponents>
inline void
centeredInitialize(CenteredFieldLayout<Dim,Mesh,
                   CartesianCentering<CE,Dim,NComponents> > & cfl,
                   const Mesh& mesh, 
                   const NDIndex<Dim> *dombegin,
                   const NDIndex<Dim> *domend,
                   const int *nbegin,
                   const int *nend)
{
  // For componentwise layout of Field of multicomponent object, like 
  // Field<Vektor...>, allow for maximal number of objects needed per
  // dimension (the number for the object component requiring the maximal
  // number):
  unsigned npts[Dim], nGridPts;
  int d, c;
  for (d=0; d<Dim; d++) {
    nGridPts = mesh.gridSizes[d];
    npts[d] = 0;
    for (c=0; c<NComponents; c++) {
      if (CE[c + d*NComponents] == CELL) {
        npts[d] = max(npts[d], (nGridPts - 1));
      } else {
        npts[d] = max(npts[d], nGridPts);
      }
    }
  }

  NDIndex<Dim> ndi;
  for (d=0; d<Dim; d++) ndi[d] = Index(npts[d]);
  cfl.initialize(ndi, dombegin, domend, nbegin, nend);
}


//=============================================================================
// General ctor calls specializations of global function (workaround for lack
// of partial specialization:
//=============================================================================

//-----------------------------------------------------------------------------
// These specify only a total number of vnodes, allowing the constructor
// complete control on how to do the vnode partitioning of the index space:
// Constructor for arbitrary dimension with parallel/serial specifier array:

// Constructor for arbitrary dimension with parallel/serial specifier array:
// This one also works if nothing except mesh is specified:
template<unsigned Dim, class Mesh, class Centering>
CenteredFieldLayout<Dim,Mesh,Centering>::
CenteredFieldLayout(Mesh& mesh, 
                    e_dim_tag *p, 
                    int vnodes)
{
  TAU_TYPE_STRING(taustr, CT(*this) +  "void (" 
                  + CT(mesh) + ", e_dim_tag *, int)");
  TAU_PROFILE("CenteredFieldLayout::CenteredFieldLayout()", taustr
              , TAU_LAYOUT);

  PInsist(Dim<=Mesh::Dimension,
    "CenteredFieldLayout dimension cannot be greater than Mesh dimension!!");
  centeredInitialize(*this, mesh, p, vnodes);
}


// Constructors for 1 ... 6 dimensions with parallel/serial specifiers:
template<unsigned Dim, class Mesh, class Centering>
CenteredFieldLayout<Dim,Mesh,Centering>::
CenteredFieldLayout(Mesh& mesh, 
                    e_dim_tag p1, 
                    int vnodes)
{
  TAU_TYPE_STRING(taustr, CT(*this) + " void (" 
                  + CT(mesh) + ", e_dim_tag, int)");
  TAU_PROFILE("CenteredFieldLayout::CenteredFieldLayout()", taustr
              , TAU_LAYOUT);

  PInsist(Dim==1,
    "Number of arguments does not match dimension of CenteredFieldLayout!!");
  PInsist(Dim<=Mesh::Dimension,
    "CenteredFieldLayout dimension cannot be greater than Mesh dimension!!");
  centeredInitialize(*this, mesh, &p1, vnodes);
}
template<unsigned Dim, class Mesh, class Centering>
CenteredFieldLayout<Dim,Mesh,Centering>::
CenteredFieldLayout(Mesh& mesh, 
                    e_dim_tag p1, e_dim_tag p2, 
                    int vnodes)
{
  TAU_TYPE_STRING(taustr, CT(*this) +  "void (" 
                  + CT(mesh) + ", e_dim_tag, e_dim_tag, int)");
  TAU_PROFILE("CenteredFieldLayout::CenteredFieldLayout()", taustr
              , TAU_LAYOUT);

  PInsist(Dim==2,
    "Number of arguments does not match dimension of CenteredFieldLayout!!");
  PInsist(Dim<=Mesh::Dimension,
    "CenteredFieldLayout dimension cannot be greater than Mesh dimension!!");
  e_dim_tag edt[2];
  edt[0] = p1; edt[1] = p2;
  centeredInitialize(*this, mesh, edt, vnodes);
}
template<unsigned Dim, class Mesh, class Centering>
CenteredFieldLayout<Dim,Mesh,Centering>::
CenteredFieldLayout(Mesh& mesh, 
                    e_dim_tag p1, e_dim_tag p2, e_dim_tag p3, 
                    int vnodes)
{
  TAU_TYPE_STRING(taustr, CT(*this) +  "void (" 
                  + CT(mesh) + ", e_dim_tag, e_dim_tag, e_dim_tag, int)");
  TAU_PROFILE("CenteredFieldLayout::CenteredFieldLayout()", taustr
              , TAU_LAYOUT);

  PInsist(Dim==3,
    "Number of arguments does not match dimension of CenteredFieldLayout!!");
  PInsist(Dim<=Mesh::Dimension,
    "CenteredFieldLayout dimension cannot be greater than Mesh dimension!!");
  e_dim_tag edt[3];
  edt[0] = p1; edt[1] = p2; edt[2] = p3;
  centeredInitialize(*this, mesh, edt, vnodes);
}
template<unsigned Dim, class Mesh, class Centering>
CenteredFieldLayout<Dim,Mesh,Centering>::
CenteredFieldLayout(Mesh& mesh, 
                    e_dim_tag p1, e_dim_tag p2, e_dim_tag p3, e_dim_tag p4,
                    int vnodes)
{
  TAU_TYPE_STRING(taustr, CT(*this) +  "void (" 
                  + CT(mesh) + ", e_dim_tag, e_dim_tag, e_dim_tag, e_dim_tag, "
                  + "int)");
  TAU_PROFILE("CenteredFieldLayout::CenteredFieldLayout()", taustr
              , TAU_LAYOUT);

  PInsist(Dim==4,
    "Number of arguments does not match dimension of CenteredFieldLayout!!");
  PInsist(Dim<=Mesh::Dimension,
    "CenteredFieldLayout dimension cannot be greater than Mesh dimension!!");
  e_dim_tag edt[4];
  edt[0] = p1; edt[1] = p2; edt[2] = p3; edt[3] = p4;
  centeredInitialize(*this, mesh, edt, vnodes);
}
template<unsigned Dim, class Mesh, class Centering>
CenteredFieldLayout<Dim,Mesh,Centering>::
CenteredFieldLayout(Mesh& mesh, 
                    e_dim_tag p1, e_dim_tag p2, e_dim_tag p3, e_dim_tag p4,
                    e_dim_tag p5,
                    int vnodes)
{
  TAU_TYPE_STRING(taustr, CT(*this) +  "void (" + CT(mesh) 
                  + ", e_dim_tag, e_dim_tag, e_dim_tag, e_dim_tag, e_dim_tag, "
                  + "int)");
  TAU_PROFILE("CenteredFieldLayout::CenteredFieldLayout()", taustr
              , TAU_LAYOUT);

  PInsist(Dim==5,
    "Number of arguments does not match dimension of CenteredFieldLayout!!");
  PInsist(Dim<=Mesh::Dimension,
    "CenteredFieldLayout dimension cannot be greater than Mesh dimension!!");
  e_dim_tag edt[5];
  edt[0] = p1; edt[1] = p2; edt[2] = p3; edt[3] = p4; edt[4] = p5;
  centeredInitialize(*this, mesh, edt, vnodes);
}
template<unsigned Dim, class Mesh, class Centering>
CenteredFieldLayout<Dim,Mesh,Centering>::
CenteredFieldLayout(Mesh& mesh, 
                    e_dim_tag p1, e_dim_tag p2, e_dim_tag p3, e_dim_tag p4,
                    e_dim_tag p5, e_dim_tag p6,
                    int vnodes)
{
  TAU_TYPE_STRING(taustr, CT(*this) +  "void (" 
                  + CT(mesh) 
                  + ", e_dim_tag, e_dim_tag, e_dim_tag, e_dim_tag, e_dim_tag, "
                  + "e_dim_tag, int)");
  TAU_PROFILE("CenteredFieldLayout::CenteredFieldLayout()", taustr, 
              TAU_LAYOUT);

  PInsist(Dim==6,
    "Number of arguments does not match dimension of CenteredFieldLayout!!");
  PInsist(Dim<=Mesh::Dimension,
    "CenteredFieldLayout dimension cannot be greater than Mesh dimension!!");
  e_dim_tag edt[6];
  edt[0] = p1; edt[1] = p2; edt[2] = p3; edt[3] = p4; edt[4] = p5; edt[5] = p6;
  centeredInitialize(*this, mesh, edt, vnodes);
}
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// These specify both the total number of vnodes and the numbers of vnodes
// along each dimension for the partitioning of the index space. Obviously this
// restricts the number of vnodes to be a product of the numbers along each
// dimension (the constructor implementation checks this):

// Constructor for arbitrary dimension with parallel/serial specifier array:
template<unsigned Dim, class Mesh, class Centering>
CenteredFieldLayout<Dim,Mesh,Centering>::
CenteredFieldLayout(Mesh& mesh, 
                    e_dim_tag *p, 
                    unsigned* vnodesAlongDirection, 
                    bool recurse,
                    int vnodes)
{
  TAU_TYPE_STRING(taustr, CT(*this) +  "void (" 
                  + CT(mesh) + ", e_dim_tag *, unsigned *, int)");
  TAU_PROFILE("CenteredFieldLayout::CenteredFieldLayout()", taustr
              , TAU_LAYOUT);

  PInsist(Dim<=Mesh::Dimension,
    "CenteredFieldLayout dimension cannot be greater than Mesh dimension!!");
  centeredInitialize(*this, mesh, p, vnodesAlongDirection, recurse, vnodes);
}
// Constructors for 1 ... 6 dimensions with parallel/serial specifiers:
template<unsigned Dim, class Mesh, class Centering>
CenteredFieldLayout<Dim,Mesh,Centering>::
CenteredFieldLayout(Mesh& mesh, 
                    e_dim_tag p1, 
                    unsigned vnodes1,
                    bool recurse,
                    int vnodes)
{
  TAU_TYPE_STRING(taustr, CT(*this) + " void (" 
                  + CT(mesh) + ", e_dim_tag, unsigned, int)");
  TAU_PROFILE("CenteredFieldLayout::CenteredFieldLayout()", taustr
              , TAU_LAYOUT);

  PInsist(Dim==1,
    "Number of arguments does not match dimension of CenteredFieldLayout!!");
  PInsist(Dim<=Mesh::Dimension,
    "CenteredFieldLayout dimension cannot be greater than Mesh dimension!!");
  centeredInitialize(*this, mesh, &p1, &vnodes1, recurse, vnodes);
}
template<unsigned Dim, class Mesh, class Centering>
CenteredFieldLayout<Dim,Mesh,Centering>::
CenteredFieldLayout(Mesh& mesh, 
                    e_dim_tag p1, e_dim_tag p2, 
                    unsigned vnodes1, unsigned vnodes2,
                    bool recurse,
                    int vnodes)
{
  TAU_TYPE_STRING(taustr, CT(*this) +  "void (" 
                  + CT(mesh) + ", e_dim_tag, e_dim_tag, unsigned, unsigned, "
                  + "int)");
  TAU_PROFILE("CenteredFieldLayout::CenteredFieldLayout()", taustr
              , TAU_LAYOUT);

  PInsist(Dim==2,
    "Number of arguments does not match dimension of CenteredFieldLayout!!");
  PInsist(Dim<=Mesh::Dimension,
    "CenteredFieldLayout dimension cannot be greater than Mesh dimension!!");
  e_dim_tag edt[2];
  edt[0] = p1; edt[1] = p2;
  unsigned vad[2];
  vad[0] = vnodes1; vad[1] = vnodes2;
  centeredInitialize(*this, mesh, edt, vad, recurse, vnodes);
}
template<unsigned Dim, class Mesh, class Centering>
CenteredFieldLayout<Dim,Mesh,Centering>::
CenteredFieldLayout(Mesh& mesh, 
                    e_dim_tag p1, e_dim_tag p2, e_dim_tag p3, 
                    unsigned vnodes1, unsigned vnodes2, unsigned vnodes3,
                    bool recurse,
                    int vnodes)
{
  TAU_TYPE_STRING(taustr, CT(*this) +  "void (" 
                  + CT(mesh) 
                  + ", e_dim_tag, e_dim_tag, e_dim_tag, "
                  + "unsigned, unsigned, int)");
  TAU_PROFILE("CenteredFieldLayout::CenteredFieldLayout()", taustr
              , TAU_LAYOUT);

  PInsist(Dim==3,
    "Number of arguments does not match dimension of CenteredFieldLayout!!");
  PInsist(Dim<=Mesh::Dimension,
    "CenteredFieldLayout dimension cannot be greater than Mesh dimension!!");
  e_dim_tag edt[3];
  edt[0] = p1; edt[1] = p2; edt[2] = p3;
  unsigned vad[3];
  vad[0] = vnodes1; vad[1] = vnodes2; vad[2] = vnodes3; 
  centeredInitialize(*this, mesh, edt, vad, recurse, vnodes);
}
template<unsigned Dim, class Mesh, class Centering>
CenteredFieldLayout<Dim,Mesh,Centering>::
CenteredFieldLayout(Mesh& mesh, 
                    e_dim_tag p1, e_dim_tag p2, e_dim_tag p3, e_dim_tag p4,
                    unsigned vnodes1, unsigned vnodes2, unsigned vnodes3,
                    unsigned vnodes4,
                    bool recurse,
                    int vnodes)
{
  TAU_TYPE_STRING(taustr, CT(*this) +  "void (" 
                  + CT(mesh) + ", e_dim_tag, e_dim_tag, e_dim_tag, e_dim_tag, "
                  + "unsigned, unsigned, unsigned, unsigned, int)");
  TAU_PROFILE("CenteredFieldLayout::CenteredFieldLayout()", taustr
              , TAU_LAYOUT);

  PInsist(Dim==4,
    "Number of arguments does not match dimension of CenteredFieldLayout!!");
  PInsist(Dim<=Mesh::Dimension,
    "CenteredFieldLayout dimension cannot be greater than Mesh dimension!!");
  e_dim_tag edt[4];
  edt[0] = p1; edt[1] = p2; edt[2] = p3; edt[3] = p4;
  unsigned vad[4];
  vad[0] = vnodes1; vad[1] = vnodes2; vad[2] = vnodes3; 
  vad[3] = vnodes4;
  centeredInitialize(*this, mesh, edt, vad, recurse, vnodes);
}
template<unsigned Dim, class Mesh, class Centering>
CenteredFieldLayout<Dim,Mesh,Centering>::
CenteredFieldLayout(Mesh& mesh, 
                    e_dim_tag p1, e_dim_tag p2, e_dim_tag p3, e_dim_tag p4,
                    e_dim_tag p5,
                    unsigned vnodes1, unsigned vnodes2, unsigned vnodes3,
                    unsigned vnodes4, unsigned vnodes5,
                    bool recurse,
                    int vnodes)
{
  TAU_TYPE_STRING(taustr, CT(*this) +  "void (" 
                  + CT(mesh) 
                  + ", e_dim_tag, e_dim_tag, e_dim_tag, e_dim_tag, e_dim_tag, "
                  + "unsigned, unsigned, unsigned, unsigned, unsigned, int)");
  TAU_PROFILE("CenteredFieldLayout::CenteredFieldLayout()", taustr
              , TAU_LAYOUT);

  PInsist(Dim==5,
    "Number of arguments does not match dimension of CenteredFieldLayout!!");
  PInsist(Dim<=Mesh::Dimension,
    "CenteredFieldLayout dimension cannot be greater than Mesh dimension!!");
  e_dim_tag edt[5];
  edt[0] = p1; edt[1] = p2; edt[2] = p3; edt[3] = p4; edt[4] = p5;
  unsigned vad[5];
  vad[0] = vnodes1; vad[1] = vnodes2; vad[2] = vnodes3; 
  vad[3] = vnodes4; vad[4] = vnodes5;
  centeredInitialize(*this, mesh, edt, vad, recurse, vnodes);
}
template<unsigned Dim, class Mesh, class Centering>
CenteredFieldLayout<Dim,Mesh,Centering>::
CenteredFieldLayout(Mesh& mesh, 
                    e_dim_tag p1, e_dim_tag p2, e_dim_tag p3, e_dim_tag p4,
                    e_dim_tag p5, e_dim_tag p6,
                    unsigned vnodes1, unsigned vnodes2, unsigned vnodes3,
                    unsigned vnodes4, unsigned vnodes5, unsigned vnodes6,
                    bool recurse,
                    int vnodes)
{
  TAU_TYPE_STRING(taustr, CT(*this) +  "void (" 
                  + CT(mesh) 
                  + ", e_dim_tag, e_dim_tag, e_dim_tag, e_dim_tag, e_dim_tag, "
                  + "e_dim_tag, "
                  + "unsigned, unsigned, unsigned, unsigned, unsigned, "
                  + "unsigned, int)");
  TAU_PROFILE("CenteredFieldLayout::CenteredFieldLayout()", taustr, 
              TAU_LAYOUT);

  PInsist(Dim==6,
    "Number of arguments does not match dimension of CenteredFieldLayout!!");
  PInsist(Dim<=Mesh::Dimension,
    "CenteredFieldLayout dimension cannot be greater than Mesh dimension!!");
  e_dim_tag edt[6];
  edt[0] = p1; edt[1] = p2; edt[2] = p3; edt[3] = p4; edt[4] = p5; edt[5] = p6;
  unsigned vad[6];
  vad[0] = vnodes1; vad[1] = vnodes2; vad[2] = vnodes3; 
  vad[3] = vnodes4; vad[4] = vnodes5; vad[5] = vnodes6;
  centeredInitialize(*this, mesh, edt, vad, recurse, vnodes);
}

//-----------------------------------------------------------------------------
// A constructor for a completely user-specified partitioning of the
// mesh space.

template<unsigned Dim, class Mesh, class Centering>
CenteredFieldLayout<Dim,Mesh,Centering>::
CenteredFieldLayout(Mesh& mesh,
                    const NDIndex<Dim> *dombegin,
                    const NDIndex<Dim> *domend,
                    const int *nbegin,
                    const int *nend)
{
  TAU_TYPE_STRING(taustr, CT(*this) +  "void (" 
                  + CT(mesh) + ", NDIndex *, NDIndex *, int *, int *)");
  TAU_PROFILE("CenteredFieldLayout::CenteredFieldLayout()", taustr, 
              TAU_LAYOUT);

  centeredInitialize(*this, mesh, dombegin, domend, nbegin, nend);
}


/***************************************************************************
 * $RCSfile: CenteredFieldLayout.cpp,v $   $Author: adelmann $
 * $Revision: 1.1.1.1 $   $Date: 2003/01/23 07:40:27 $
 * IPPL_VERSION_ID: $Id: CenteredFieldLayout.cpp,v 1.1.1.1 2003/01/23 07:40:27 adelmann Exp $ 
 ***************************************************************************/

---