NOX_Playa_Group.hpp

// $Id$ 
// $Source$ 

//@HEADER
//   
//@HEADER

#ifndef NOX_Playa_GROUP_H
#define NOX_Playa_GROUP_H

#include "NOX_Abstract_Group.H" // base class
#include "Teuchos_ParameterList.hpp"  // base class

#include "NOX_Common.H"             // class data element (string)
#include "NOX_Playa_Vector.hpp"     // class data element
#include "Teuchos_RCP.hpp"
#include "PlayaVectorType.hpp"
#include "PlayaVectorSpaceDecl.hpp"
#include "PlayaLinearSolverDecl.hpp"
#include "PlayaLinearOperatorDecl.hpp"
#include "PlayaNonlinearOperator.hpp" // nonlinear operator

// Forward declares
namespace Teuchos 
{
namespace Parameter 
{
class List;
}
}

namespace NOX {
namespace NOXPlaya {

using Teuchos::rcp;
using Teuchos::rcp_dynamic_cast;

class Group : public virtual NOX::Abstract::Group
{

public:

  Group(const Playa::Vector<double>& initcond, 
    const Playa::NonlinearOperator<double>& nonlinOp,
    const Playa::LinearSolver<double>& solver);

  Group(const Playa::NonlinearOperator<double>& nonlinOp,
    const Playa::LinearSolver<double>& solver);

  Group(const Playa::Vector<double>& initcond, 
    const Playa::NonlinearOperator<double>& nonlinOp,
    const Playa::LinearSolver<double>& solver,
    int numdigits);

  Group(const Playa::NonlinearOperator<double>& nonlinOp,
    const Playa::LinearSolver<double>& solver,
    int numdigits);




  Group(const NOX::NOXPlaya::Group& source, NOX::CopyType type = DeepCopy);

  ~Group();


  NOX::Abstract::Group& operator=(const NOX::Abstract::Group& source);
  NOX::Abstract::Group& operator=(const NOX::NOXPlaya::Group& source);


  void setX(const NOX::Abstract::Vector& y);
  void setX(const NOX::NOXPlaya::Vector& y);

  void computeX(const NOX::Abstract::Group& grp, 
    const NOX::Abstract::Vector& d, 
    double step);
  void computeX(const NOX::NOXPlaya::Group& grp, 
    const NOX::NOXPlaya::Vector& d, 
    double step);

  NOX::Abstract::Group::ReturnType computeF();

  NOX::Abstract::Group::ReturnType computeJacobian();

  NOX::Abstract::Group::ReturnType computeGradient();

  NOX::Abstract::Group::ReturnType computeNewton(Teuchos::ParameterList& params);


  
  NOX::Abstract::Group::ReturnType 
  applyJacobian(const NOX::NOXPlaya::Vector& input, 
    NOX::NOXPlaya::Vector& result) const;

  NOX::Abstract::Group::ReturnType 
  applyJacobian(const NOX::Abstract::Vector& input, 
    NOX::Abstract::Vector& result) const;

  NOX::Abstract::Group::ReturnType 
  applyJacobianTranspose(const NOX::NOXPlaya::Vector& input, 
    NOX::NOXPlaya::Vector& result) const;

  NOX::Abstract::Group::ReturnType 
  applyJacobianTranspose(const NOX::Abstract::Vector& input, 
    NOX::Abstract::Vector& result) const;

  NOX::Abstract::Group::ReturnType 
  applyJacobianInverse(Teuchos::ParameterList& params, 
    const NOX::NOXPlaya::Vector& input, 
    NOX::NOXPlaya::Vector& result) const;

  NOX::Abstract::Group::ReturnType 
  applyJacobianInverse(Teuchos::ParameterList& params, 
    const NOX::Abstract::Vector& input, 
    NOX::Abstract::Vector& result) const;
  


  bool isF() const;
  bool isJacobian() const;
  bool isGradient() const;
  bool isNewton() const;



  const NOX::Abstract::Vector& getX() const;

  const NOX::Abstract::Vector& getF() const;
  
  double getNormF() const;

  const NOX::Abstract::Vector& getGradient() const;

  const NOX::Abstract::Vector& getNewton() const;

  virtual Teuchos::RCP< const NOX::Abstract::Vector > getXPtr() const 
    {return rcp_dynamic_cast<const NOX::Abstract::Vector>(xVector);}

  virtual Teuchos::RCP< const NOX::Abstract::Vector > getFPtr() const 
    {return rcp_dynamic_cast<const NOX::Abstract::Vector>(fVector);}



  virtual Teuchos::RCP< const NOX::Abstract::Vector > getGradientPtr() const
    {return rcp_dynamic_cast<const NOX::Abstract::Vector>(gradientVector);}

  virtual Teuchos::RCP< const NOX::Abstract::Vector > getNewtonPtr() const 
    {return rcp_dynamic_cast<const NOX::Abstract::Vector>(newtonVector);}

#ifdef TRILINOS_6
  virtual NOX::Abstract::Group* clone(NOX::CopyType type = NOX::DeepCopy) const;
#else
  virtual RCP<NOX::Abstract::Group> clone(NOX::CopyType type = NOX::DeepCopy) const;
#endif

  void print() const;

protected:

  void resetIsValid();

protected:

  int precision; 
      

  RCP<NOX::NOXPlaya::Vector> xVector;
  RCP<NOX::NOXPlaya::Vector> fVector;
  RCP<NOX::NOXPlaya::Vector> newtonVector;
  RCP<NOX::NOXPlaya::Vector> gradientVector;

  mutable Playa::LinearSolver<double> solver;

  Playa::LinearOperator<double> jacobian;


  Playa::NonlinearOperator<double> nonlinearOp;

  bool isValidF;
  bool isValidJacobian;
  bool isValidGradient;
  bool isValidNewton;
  
  double normF;

};

} // namespace Playa
} // namespace NOX


#endif