itkFEMItpackSparseMatrix.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/

#ifndef itkFEMItpackSparseMatrix_h
#define itkFEMItpackSparseMatrix_h

#include "itkFEMException.h"
#include "ITKFEMExport.h"

namespace itk
{
namespace fem
{
// Forward declaration of friend class
class ItpackLinearSystemWrapper;

class ITKFEM_EXPORT ItpackSparseMatrix
{
public:

  typedef long   integer;
  typedef double doublereal;

  ItpackSparseMatrix();

  ItpackSparseMatrix(integer order);

  ItpackSparseMatrix(integer order, integer maxNonZeroValues);

  ~ItpackSparseMatrix();

  void SetOrder(integer order)
  {
    m_N = order;
  }

  void SetMaxNonZeroValues(integer maxNonZeroValues)
  {
    m_NZ = maxNonZeroValues;
  }

  void Set(integer i, integer j, doublereal value);

  void Add(integer i, integer j, doublereal value);

  doublereal Get(integer i, integer j);

  integer *    GetN()
  {
    return &m_N;
  }

  integer *     GetIA();

  void  SetCompressedRow(integer *ia, integer *ja, doublereal *a);

  integer *     GetJA();

  doublereal *  GetA();

  doublereal * GetValueArray()
  {
    return GetA();
  }

  integer *    GetColumnArray()
  {
    return GetJA();
  }

  integer *    GetRowArray()
  {
    return GetIA();
  }

  integer     GetOrder()       const
  {
    return m_N;
  }

  integer     GetMaxNonZeroValues() const
  {
    return m_NZ;
  }

  void Clear();

  void mult(doublereal *vector, doublereal *result);

  void mult(ItpackSparseMatrix *rightMatrix, ItpackSparseMatrix *resultMatrix);

  void PrintCompressedRow();

private:

  friend class LinearSystemWrapperItpack;

  void Initialize();

  void UnFinalize();

  void Finalize();

  integer m_MatrixFinalized;

  integer m_MatrixInitialized;

  integer m_N;

  integer m_NZ;

  integer *m_IA;

  integer *m_JA;

  doublereal *m_A;

  integer *m_IWORK;

  integer m_MODE;

  integer m_NOUT;

  integer m_LEVEL;

  // integer m_IER;
};

class ITK_ABI_EXPORT FEMExceptionItpackSparseMatrixSbagn : public FEMException
{
public:

  typedef long   integer;
  typedef double doublereal;

  FEMExceptionItpackSparseMatrixSbagn(const char *file, unsigned int lineNumber, std::string location,
                                      integer errorCode);

  virtual ~FEMExceptionItpackSparseMatrixSbagn()
  ITK_NOEXCEPT ITK_OVERRIDE;

  itkTypeMacro(FEMExceptionItpackSparseMatrixSbagn, FEMException);
};

class ITK_ABI_EXPORT FEMExceptionItpackSparseMatrixSbsij : public FEMException
{
public:

  typedef long   integer;
  typedef double doublereal;

  FEMExceptionItpackSparseMatrixSbsij(const char *file, unsigned int lineNumber, std::string location,
                                      integer errorCode);

  virtual ~FEMExceptionItpackSparseMatrixSbsij()
  ITK_NOEXCEPT ITK_OVERRIDE;

  itkTypeMacro(FEMExceptionItpackSparseMatrixSbsij, FEMException);
};
}
}  // end namespace itk::fem

#endif