DistributedFactory.cpp

Go to the documentation of this file.

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   This file is part of CEPS.
 
   CEPS is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
   CEPS is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with CEPS (see file LICENSE at root of project).
   If not, see <https://www.gnu.org/licenses/>.
 
 
   Copyright 2019-2024 Inria, Universite de Bordeaux
 
   Authors, in alphabetical order:
 
     Pierre-Elliott BECUE, Florian CARO, Yves COUDIERE(*), Andjela DAVIDOVIC, 
     Charlie DOUANLA-LONTSI, Marc FUENTES, Mehdi JUHOOR, Michael LEGUEBE(*), 
     Pauline MIGERDITICHAN, Valentin PANNETIER(*), Nejib ZEMZEMI.
     * : currently active authors
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#include "pde/common/DistributedFactory.hpp"
 
#include "common/core/CepsTypeTools.hpp"
 
DistributedFactory::DistributedFactory ()
{
  initialize ();
}
 
DistributedFactory::DistributedFactory (
  CepsUInt globalRows, CepsUInt globalCols,
  CepsUInt localRows, CepsUInt localCols,
  const CepsVector<CepsInt>& diagBlockNnz,
  const CepsVector<CepsInt>& offdiagBlockNnz
)
{
  initialize();
 
  setGlobalSizes(globalRows,globalCols);
  setLocalSizes ( localRows, localCols);
 
  CepsUInt dLength = diagBlockNnz   .size();
  CepsUInt oLength = offdiagBlockNnz.size();
  CEPS_ABORT_IF(dLength!=oLength or dLength==0,
    "provided non zero structure is ill-formed"
  );
 
  setNonZeroTemplate(diagBlockNnz.data(), offdiagBlockNnz.data(),dLength);
}
 
DistributedFactory::DistributedFactory (CepsUInt globalRows, CepsUInt globalCols,
                                        CepsUInt localRows, CepsUInt localCols,
                                        CepsUInt diagBlockNz,
                                        CepsUInt offdiagBlockNz)
{
  initialize();
 
  setGlobalSizes(globalRows,globalCols);
  setLocalSizes ( localRows, localCols);
 
  setNonZeroTemplate(diagBlockNz,offdiagBlockNz);
}
 
DistributedFactory::~DistributedFactory ()
{
  ceps::destroyTabular (m_haloRows);
  ceps::destroyTabular (m_haloCols);
  ceps::destroyTabular (m_d_nnz);
  ceps::destroyTabular (m_o_nnz);
}
 
void
DistributedFactory::setGlobalSizes (CepsUInt globalRows, CepsUInt globalCols)
{
  m_globalRows = globalRows;
  m_globalCols = globalCols;
  return;
}
 
void
DistributedFactory::setLocalSizes (CepsUInt localRows, CepsUInt localCols)
{
  m_localRows = localRows;
  m_localCols = localCols;
  return;
}
 
void
DistributedFactory::setHaloIndices (
  CepsIndex *haloRows,
  CepsUInt   nHaloRows,
  CepsIndex *haloCols,
  CepsUInt   nHaloCols
)
{
  ceps::destroyTabular (m_haloRows);
  m_nHaloRows = nHaloRows;
  m_haloRows  = new CepsIndex[m_nHaloRows];
  memcpy (m_haloRows, haloRows, m_nHaloRows * sizeof (CepsIndex));
 
  ceps::destroyTabular (m_haloCols);
  m_nHaloCols = nHaloCols;
  m_haloCols  = new CepsIndex[m_nHaloCols];
  memcpy (m_haloCols, haloCols, m_nHaloCols * sizeof (CepsIndex));
 
  return;
}
 
void
DistributedFactory::setNonZeroTemplate (
  const CepsIndex *d_nnz,
  const CepsIndex *o_nnz,
  CepsInt          nbLocalRows
)
{
  CEPS_ABORT_IF (nbLocalRows != m_localRows,
    "when setting non zero template, provided number of local rows (" << nbLocalRows << 
    ")\ndoes not match number of rows of the factory (" << m_localRows << ")"
  );
 
  ceps::destroyTabular (m_d_nnz);
  ceps::destroyTabular (m_o_nnz);
 
  m_d_nnz = ceps::newCopyArray (const_cast<CepsIndex *> (d_nnz), nbLocalRows);
  m_o_nnz = ceps::newCopyArray (const_cast<CepsIndex *> (o_nnz), nbLocalRows);
 
  return;
}
 
void
DistributedFactory::setNonZeroTemplate (CepsIndex d_nz, CepsIndex o_nz)
{
  m_d_nz = d_nz;
  m_o_nz = o_nz;
  return;
}
 
DVecPtr
DistributedFactory::getDistributedVector () const
{
  return DVecPtr (ceps::getNew<DistributedVector>(m_globalRows, m_localRows));
}
 
DHVecPtr
DistributedFactory::getDistributedHaloVector () const
{
  return DHVecPtr (ceps::getNew<DistributedHaloVector>(m_globalRows, m_localRows, m_nHaloRows, m_haloRows));
}
 
DMatPtr
DistributedFactory::getDistributedMatrix () const
{
  DistributedMatrix *mat = ceps::getNew<DistributedMatrix>(
    m_globalRows, m_globalCols, m_localRows, m_localRows
  );
 
  if (ceps::isValidPtr (m_d_nnz) and ceps::isValidPtr (m_o_nnz))
    mat->setNonZeroStructure (m_d_nnz, m_o_nnz);
  else
    mat->setNonZeroStructure (m_d_nz, m_o_nz);
  return DMatPtr (mat);
}
 
void
DistributedFactory::initialize ()
{
  m_globalRows = 0;
  m_globalCols = 0;
 
  m_localRows = 0;
  m_localCols = 0;
 
  m_haloRows  = nullptr;
  m_nHaloRows = 0;
  m_haloCols  = nullptr;
  m_nHaloCols = 0;
 
  m_d_nnz = nullptr;
  m_o_nnz = nullptr;
  m_d_nz  = 0;
  m_o_nz  = 0;
  return;
}