fei_LinearSystem.hpp

/*--------------------------------------------------------------------*/
/*    Copyright 2005 Sandia Corporation.                              */
/*    Under the terms of Contract DE-AC04-94AL85000, there is a       */
/*    non-exclusive license for use of this work by or on behalf      */
/*    of the U.S. Government.  Export of this program may require     */
/*    a license from the United States Government.                    */
/*--------------------------------------------------------------------*/

#ifndef _fei_LinearSystem_hpp_
#define _fei_LinearSystem_hpp_

#include <fei_macros.hpp>
#include <fei_SharedPtr.hpp>
#include <fei_MatrixGraph.hpp>
#include <fei_Matrix.hpp>
#include <fei_Vector.hpp>
#include <fei_DirichletBCManager.hpp>

namespace fei {
  class Factory;
  class ParameterSet;

  class LinearSystem {
  public:
    class Factory {
    public:
      virtual ~Factory(){}

      virtual fei::SharedPtr<fei::LinearSystem>
  createLinearSystem(fei::SharedPtr<fei::MatrixGraph>& matrixGraph);
    };

    LinearSystem(fei::SharedPtr<fei::MatrixGraph>& matrixGraph);

    virtual ~LinearSystem();

    virtual int parameters(int numParams,
                           const char* const* paramStrings) = 0;

    virtual int parameters(const fei::ParameterSet& params) = 0;

    virtual void setMatrix(fei::SharedPtr<fei::Matrix>& matrix);

    virtual fei::SharedPtr<fei::Matrix> getMatrix()
      { return(matrix_); }

    virtual fei::SharedPtr<const fei::Matrix> getMatrix() const
      { fei::SharedPtr<const fei::Matrix> const_mat(matrix_);
        return(const_mat); }

    virtual void setRHS(fei::SharedPtr<fei::Vector>& rhs)
      { rhs_ = rhs; }

    virtual fei::SharedPtr<fei::Vector> getRHS()
      { return(rhs_); }

    virtual fei::SharedPtr<const fei::Vector> getRHS() const
      { fei::SharedPtr<const fei::Vector> const_rhs(rhs_);
        return(const_rhs); }

    virtual void setSolutionVector(fei::SharedPtr<fei::Vector>& soln)
      { soln_ = soln; }

    virtual fei::SharedPtr<fei::Vector> getSolutionVector()
      { return(soln_); }

    virtual fei::SharedPtr<const fei::Vector> getSolutionVector() const
      { fei::SharedPtr<const fei::Vector> const_soln(soln_);
      return(const_soln); }

    virtual int putAttribute(const char* name,
                             void* attribute);

    virtual int getAttribute(const char* name,
                             void*& attribute);

    virtual int loadEssentialBCs(int numIDs,
                                 const int* IDs,
                                 int idType,
                                 int fieldID,
                                 int offsetIntoField,
                                 const double* prescribedValues);

    virtual int loadEssentialBCs(int numIDs,
                                 const int* IDs,
                                 int idType,
                                 int fieldID,
                                 const int* offsetsIntoField,
                                 const double* prescribedValues);

    virtual int loadLagrangeConstraint(int constraintID,
               const double *weights,
               double rhsValue) = 0;

    virtual int loadPenaltyConstraint(int constraintID,
              const double *weights,
              double penaltyValue,
              double rhsValue) = 0;

    virtual int loadComplete(bool applyBCs=true,
                             bool globalAssemble=true) = 0;

    virtual int setBCValuesOnVector(fei::Vector* vector) = 0;

    virtual bool eqnIsEssentialBC(int globalEqnIndex) const = 0;

    virtual void getEssentialBCs(std::vector<int>& bcEqns,
                                 std::vector<double>& bcVals) const = 0;

    virtual void getConstrainedEqns(std::vector<int>& crEqns) const = 0;

   protected:
    fei::SharedPtr<fei::Matrix> matrix_;
    fei::SharedPtr<fei::Vector> soln_;
    fei::SharedPtr<fei::Vector> rhs_;

    fei::SharedPtr<fei::MatrixGraph> matrixGraph_;
    fei::DirichletBCManager* dbcManager_;

    std::vector<char*> attributeNames_;
    std::vector<void*> attributes_;
  };//class LinearSystem
}//namespace fei

#endif // _fei_LinearSystem_hpp_