DianaBorderedSolver.hpp

/* -----------------------------------------------------------------------------
 *  Diana process modelling, simulation and analysis software
 *  Copyright (c) 2005, Michael Krasnyk
 *  All rights reserved.

 *  This file is a part of Diana process modelling, simulation and analysis software
 *
 *  Diana 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 (see accompanying file LICENSE)
 * -----------------------------------------------------------------------------
 *  $Id: DianaBorderedSolver.hpp 8160 2009-03-16 18:36:30Z miha $
 * -----------------------------------------------------------------------------
 *  Description:
 */

#ifndef DIANA_BORDERED_SOLVER_HPP
#define DIANA_BORDERED_SOLVER_HPP

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <vector>
#include <Basic/DianaSparseArray.hpp>
#include "IDianaLinearAlgebraSolver.hpp"
#ifdef HAVE_HSL
#include "DianaHslSolver.hpp"
#else
#include "DianaSparseSolver.hpp"
#endif

namespace Diana {

  class DianaBorderedSolver : virtual public IDianaLinearAlgebraSolver {

  public:
    DianaBorderedSolver();
    virtual ~DianaBorderedSolver();

    void setA(const DianaSparseArray& spar)
      throw (Common::Error::ECapeUnknown, Common::Error::ECapeBadArgument,
             Common::Error::ECapeOutOfBounds, Common::Error::ECapeSolvingError,
             Common::Error::ECapeNoMemory);

    void setB(const Common::Types::CapeArrayDouble& _vecB)
      throw (Common::Error::ECapeUnknown, Common::Error::ECapeBadArgument,
             Common::Error::ECapeOutOfBounds, Common::Error::ECapeSolvingError,
             Common::Error::ECapeNoMemory);
    
    void setC(const Common::Types::CapeArrayDouble& _vecC)
      throw (Common::Error::ECapeUnknown, Common::Error::ECapeBadArgument,
             Common::Error::ECapeOutOfBounds, Common::Error::ECapeSolvingError,
             Common::Error::ECapeNoMemory);
    
    void setD(Common::Types::CapeDouble _dblD)
      throw (Common::Error::ECapeUnknown, Common::Error::ECapeBadArgument,
             Common::Error::ECapeOutOfBounds, Common::Error::ECapeSolvingError,
             Common::Error::ECapeNoMemory);
    
    void decompose()
      throw (Common::Error::ECapeUnknown, Common::Error::ECapeBadArgument,
             Common::Error::ECapeOutOfBounds, Common::Error::ECapeSolvingError,
             Common::Error::ECapeNoMemory);

    void solve(const Common::Types::CapeArrayDouble& rhs,
               Common::Types::CapeArrayDouble& sol,
               Common::Types::CapeBoolean transpose=false)
      throw (Common::Error::ECapeUnknown, Common::Error::ECapeBadArgument,
             Common::Error::ECapeOutOfBounds, Common::Error::ECapeSolvingError,
             Common::Error::ECapeNoMemory);

    void solve(int n, const double* rhs, double* sol,
               Common::Types::CapeBoolean transpose=false)
      throw (Common::Error::ECapeUnknown, Common::Error::ECapeBadArgument,
             Common::Error::ECapeOutOfBounds, Common::Error::ECapeSolvingError,
             Common::Error::ECapeNoMemory);

    void mulvec(const Common::Types::CapeArrayDouble& vec,
                Common::Types::CapeArrayDouble& res,
                Common::Types::CapeBoolean transpose=false)
      throw (Common::Error::ECapeUnknown, Common::Error::ECapeBadArgument,
             Common::Error::ECapeOutOfBounds, Common::Error::ECapeSolvingError,
             Common::Error::ECapeNoMemory);

    void mulvec(int nvec, const double* vec, int nres, double* res,
                Common::Types::CapeBoolean transpose=false)
      throw (Common::Error::ECapeUnknown, Common::Error::ECapeBadArgument,
             Common::Error::ECapeOutOfBounds, Common::Error::ECapeSolvingError,
             Common::Error::ECapeNoMemory);

  private:
    int                            nSize;
#ifdef HAVE_HSL
    DianaHslSolver                 dsmA;
#else
    DianaSparseSolver              dsmA;
#endif
    Common::Types::CapeArrayDouble vecB;
    Common::Types::CapeArrayDouble vecC;
    Common::Types::CapeDouble      dblD;
    Common::Types::CapeArrayDouble vecAmB;
    Common::Types::CapeArrayDouble vecAmF;
  };
};

#endif // DIANA_BORDERED_SOLVER_HPP