Teko_PreconditionerState.hpp

// @HEADER
// *****************************************************************************
//      Teko: A package for block and physics based preconditioning
//
// Copyright 2010 NTESS and the Teko contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER

#ifndef __Teko_PreconditionerState_hpp__
#define __Teko_PreconditionerState_hpp__

#include "Teuchos_ParameterListAcceptor.hpp"

// Thyra includes
// #include "Thyra_SolveSupportTypes.hpp"

// Teko includes
#include "Teko_Utilities.hpp"

namespace Teko {

class PreconditionerState : public Teuchos::ParameterListAcceptor {
 public:

  PreconditionerState() : isInitialized_(false) {}
  PreconditionerState(const PreconditionerState& src)
      : paramList_(Teuchos::rcp(new Teuchos::ParameterList(*src.paramList_))),
        srcVector_(src.srcVector_),
        inverses_(src.inverses_),
        isInitialized_(src.isInitialized_) {}



  void setParameterList(const Teuchos::RCP<Teuchos::ParameterList>& paramList);

  Teuchos::RCP<Teuchos::ParameterList> getNonconstParameterList();

  Teuchos::RCP<Teuchos::ParameterList> unsetParameterList();


  virtual bool isInitialized() const { return isInitialized_; }

  virtual void setInitialized(bool init = true) { isInitialized_ = init; }

  virtual void setSourceVector(const Teko::MultiVector& srcVec) { srcVector_ = srcVec; }

  virtual const Teko::MultiVector getSourceVector() const { return srcVector_; }

  virtual void addInverse(const std::string& name, const Teko::InverseLinearOp& ilo) {
    inverses_[name] = ilo;
  }

  virtual Teko::InverseLinearOp getInverse(const std::string& name) const {
    std::map<std::string, Teko::InverseLinearOp>::const_iterator itr;
    itr = inverses_.find(name);
    if (itr == inverses_.end()) return Teuchos::null;
    return itr->second;
  }

  virtual void addLinearOp(const std::string& name, const Teko::LinearOp& lo) {
    linearOps_[name] = lo;
  }

  virtual Teko::LinearOp getLinearOp(const std::string& name) { return linearOps_[name]; }

  virtual void addModifiableOp(const std::string& name, const Teko::ModifiableLinearOp& mlo) {
    modifiableOp_[name] = mlo;
  }

  virtual Teko::ModifiableLinearOp& getModifiableOp(const std::string& name) {
    std::map<std::string, Teko::ModifiableLinearOp>::iterator itr;
    itr = modifiableOp_.find(name);
    if (itr == modifiableOp_.end()) return modifiableOp_[name];
    return itr->second;
  }

  virtual void merge(const PreconditionerState& ps, int position = -1);

  unsigned int getTag() const;

  void setTag(unsigned int tag);

 protected:
  Teuchos::RCP<Teuchos::ParameterList> paramList_;

  Teko::MultiVector srcVector_;

  std::map<std::string, Teko::InverseLinearOp> inverses_;
  std::map<std::string, Teko::ModifiableLinearOp> modifiableOp_;
  std::map<std::string, Teko::LinearOp> linearOps_;

  bool isInitialized_;

  unsigned int tag_;
};

}  // end namespace Teko

#endif