EpetraExt_ModelEvaluator.h

Go to the documentation of this file.

// @HEADER
// ***********************************************************************
// 
//     EpetraExt: Epetra Extended - Linear Algebra Services Package
//                 Copyright (2001) Sandia Corporation
// 
// Under 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.
// 
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//  
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//  
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
// Questions? Contact Michael A. Heroux (maherou@sandia.gov) 
// 
// ***********************************************************************
// @HEADER

#ifndef EPETRA_EXT_MODEL_EVALUATOR_HPP
#define EPETRA_EXT_MODEL_EVALUATOR_HPP

#include "EpetraExt_ConfigDefs.h"
#include "EpetraExt_PolynomialVectorTraits.h"
#include "Teuchos_RefCountPtr.hpp"
#include "Teuchos_Describable.hpp"
#include "Teuchos_Polynomial.hpp"
#include "Teuchos_Array.hpp"

#ifdef HAVE_PYTRILINOS
#undef HAVE_INTTYPES_H
#undef HAVE_STDINT_H
#undef HAVE_SYS_TIME_H
#include "Python.h"
#endif

class Epetra_Map;
class Epetra_Vector;
class Epetra_Operator;

// Forward declaration of Stochastic Galerkin (SG) argument types
namespace Stokhos {
  template <typename coeff_type> class VectorOrthogPoly;
}

namespace EpetraExt {

class ModelEvaluator : virtual public Teuchos::Describable {
public:


  enum EInArgsMembers {
    IN_ARG_x_dot
    ,IN_ARG_x
    ,IN_ARG_x_dot_poly 
    ,IN_ARG_x_poly    
    ,IN_ARG_x_dot_sg  
    ,IN_ARG_x_sg      
    ,IN_ARG_t
    ,IN_ARG_alpha
    ,IN_ARG_beta
  };
  static const int NUM_E_IN_ARGS_MEMBERS=9;

  class InArgs {
  public:

    typedef Teuchos::RefCountPtr<const Stokhos::VectorOrthogPoly<Epetra_Vector> > sg_const_vector_t;
    
    InArgs();
    std::string modelEvalDescription() const;
    int Np() const;
    int Np_sg() const;
    void set_x_dot( const Teuchos::RefCountPtr<const Epetra_Vector> &x_dot );
    Teuchos::RefCountPtr<const Epetra_Vector> get_x_dot() const;
    void set_x( const Teuchos::RefCountPtr<const Epetra_Vector> &x );
    Teuchos::RefCountPtr<const Epetra_Vector> get_x() const;
    void set_x_poly(
      const Teuchos::RefCountPtr<const Teuchos::Polynomial<Epetra_Vector> > &x_poly
      );
    Teuchos::RefCountPtr<const Teuchos::Polynomial<Epetra_Vector> > get_x_poly() const;
    void set_x_dot_poly(
      const Teuchos::RefCountPtr<const Teuchos::Polynomial<Epetra_Vector> > &x_dot_poly
      );
    Teuchos::RefCountPtr<const Teuchos::Polynomial<Epetra_Vector> > get_x_dot_poly() const;
    void set_x_sg(const sg_const_vector_t &x_sg);
    sg_const_vector_t get_x_sg() const;
    void set_x_dot_sg(const sg_const_vector_t &x_dot_sg);
    sg_const_vector_t get_x_dot_sg() const;
    void set_p( int l, const Teuchos::RefCountPtr<const Epetra_Vector> &p_l );
    Teuchos::RefCountPtr<const Epetra_Vector> get_p(int l) const;
    void set_p_sg( int l, const sg_const_vector_t &p_sg_l );
    sg_const_vector_t get_p_sg(int l) const;
    void set_t( double t );
    double get_alpha() const;
    void set_alpha( double alpha );
    double get_beta() const;
    void set_beta( double beta );
    double get_t() const;
    bool supports(EInArgsMembers arg) const;
  protected:
    void _setModelEvalDescription( const std::string &modelEvalDescription );
    void _set_Np(int Np);
    void _set_Np_sg(int Np);
    void _setSupports( EInArgsMembers arg, bool supports );
  private:
    // types
    typedef Teuchos::Array<Teuchos::RefCountPtr<const Epetra_Vector> > p_t;
    typedef Teuchos::Array<sg_const_vector_t > p_sg_t;
    // data
    std::string modelEvalDescription_;
    Teuchos::RefCountPtr<const Epetra_Vector>  x_dot_;
    Teuchos::RefCountPtr<const Epetra_Vector>  x_;
    Teuchos::RefCountPtr<const Teuchos::Polynomial<Epetra_Vector> > x_dot_poly_;
    Teuchos::RefCountPtr<const Teuchos::Polynomial<Epetra_Vector> > x_poly_;
    sg_const_vector_t                          x_dot_sg_;
    sg_const_vector_t                          x_sg_;
    p_t                                        p_;
    p_sg_t                                     p_sg_;
    double                                     t_;
    double                                     alpha_;
    double                                     beta_;
    bool supports_[NUM_E_IN_ARGS_MEMBERS];
    // functions
    void assert_supports(EInArgsMembers arg) const;
    void assert_l(int l) const;
  };

  enum EEvalType {
    EVAL_TYPE_EXACT                
    ,EVAL_TYPE_APPROX_DERIV        
    ,EVAL_TYPE_VERY_APPROX_DERIV   
  };

  template<class ObjType>
  class Evaluation : public Teuchos::RefCountPtr<ObjType> {
  public:
    Evaluation() : evalType_(EVAL_TYPE_EXACT) {}
    Evaluation( const Teuchos::RefCountPtr<ObjType> &obj )
      : Teuchos::RefCountPtr<ObjType>(obj), evalType_(EVAL_TYPE_EXACT) {}
    Evaluation( const Teuchos::RefCountPtr<ObjType> &obj, EEvalType evalType )
      : Teuchos::RefCountPtr<ObjType>(obj), evalType_(evalType) {}
    EEvalType getType() const { return evalType_; }
    void reset( const Teuchos::RefCountPtr<ObjType> &obj, EEvalType evalType ) 
    { this->operator=(obj); evalType_ = evalType; }
  private:
    EEvalType                      evalType_;
  };
  
  enum EDerivativeMultiVectorOrientation {
    DERIV_MV_BY_COL           
    ,DERIV_TRANS_MV_BY_ROW    
  };

  enum EDerivativeLinearOp { DERIV_LINEAR_OP };

  class DerivativeSupport {
  public:
    DerivativeSupport()
      :supportsLinearOp_(false), supportsMVByCol_(false), supportsTransMVByRow_(false)
      {}
    DerivativeSupport( EDerivativeLinearOp )
      :supportsLinearOp_(true), supportsMVByCol_(false), supportsTransMVByRow_(false)
      {}
    DerivativeSupport( EDerivativeMultiVectorOrientation mvOrientation )
      :supportsLinearOp_(false), supportsMVByCol_(mvOrientation==DERIV_MV_BY_COL)
      ,supportsTransMVByRow_(mvOrientation==DERIV_TRANS_MV_BY_ROW)
      {}
    DerivativeSupport(
      EDerivativeLinearOp, EDerivativeMultiVectorOrientation mvOrientation )
      :supportsLinearOp_(true), supportsMVByCol_(mvOrientation==DERIV_MV_BY_COL)
      ,supportsTransMVByRow_(mvOrientation==DERIV_TRANS_MV_BY_ROW)
      {}
    DerivativeSupport(
      EDerivativeMultiVectorOrientation mvOrientation1,
      EDerivativeMultiVectorOrientation mvOrientation2
      )
      :supportsLinearOp_(false)
      ,supportsMVByCol_(
        mvOrientation1==DERIV_MV_BY_COL||mvOrientation2==DERIV_MV_BY_COL )
      ,supportsTransMVByRow_(
        mvOrientation1==DERIV_TRANS_MV_BY_ROW||mvOrientation2==DERIV_TRANS_MV_BY_ROW )
      {}
    DerivativeSupport& plus(EDerivativeLinearOp)
      { supportsLinearOp_ = true; return *this; }
    DerivativeSupport& plus(EDerivativeMultiVectorOrientation mvOrientation)
      {
        switch(mvOrientation) {
          case DERIV_MV_BY_COL: supportsMVByCol_ = true; break;
          case DERIV_TRANS_MV_BY_ROW: supportsTransMVByRow_ = true; break;
          default: TEST_FOR_EXCEPT(true);
        }
        return *this;
      }
    bool none() const
      { return ( !supportsLinearOp_ && !supportsMVByCol_ && !supportsTransMVByRow_ ); }
    bool supports(EDerivativeLinearOp) const
      { return supportsLinearOp_; }
    bool supports(EDerivativeMultiVectorOrientation mvOrientation) const
      {
        switch(mvOrientation) {
          case DERIV_MV_BY_COL: return supportsMVByCol_;
          case DERIV_TRANS_MV_BY_ROW: return supportsTransMVByRow_;
          default: TEST_FOR_EXCEPT(true);
        }
        return false; // Will never be called!
      }
  private:
    bool supportsLinearOp_;
    bool supportsMVByCol_;
    bool supportsTransMVByRow_;
  public:
  };

  enum EDerivativeLinearity {
    DERIV_LINEARITY_UNKNOWN      
    ,DERIV_LINEARITY_CONST       
    ,DERIV_LINEARITY_NONCONST    
  };
  enum ERankStatus {
    DERIV_RANK_UNKNOWN       
    ,DERIV_RANK_FULL         
    ,DERIV_RANK_DEFICIENT    
  };

  struct DerivativeProperties {
    EDerivativeLinearity linearity;
    ERankStatus rank;
    bool supportsAdjoint;
    DerivativeProperties()
      :linearity(DERIV_LINEARITY_UNKNOWN),rank(DERIV_RANK_UNKNOWN),supportsAdjoint(false) {}
    DerivativeProperties(
      EDerivativeLinearity in_linearity, ERankStatus in_rank, bool in_supportsAdjoint
      ):linearity(in_linearity),rank(in_rank),supportsAdjoint(in_supportsAdjoint) {}
  };

  class DerivativeMultiVector {
  public:
    DerivativeMultiVector() {}
    DerivativeMultiVector(
      const Teuchos::RefCountPtr<Epetra_MultiVector> &mv
      ,const EDerivativeMultiVectorOrientation orientation = DERIV_MV_BY_COL
      ,const Teuchos::Array<int> &paramIndexes = Teuchos::Array<int>()
      ) : mv_(mv), orientation_(orientation), paramIndexes_(paramIndexes) {}
    void changeOrientation( const EDerivativeMultiVectorOrientation orientation )
      { orientation_ = orientation; };
    Teuchos::RefCountPtr<Epetra_MultiVector> getMultiVector() const
      { return mv_; }
    EDerivativeMultiVectorOrientation getOrientation() const
      { return orientation_; }
    const Teuchos::Array<int>& getParamIndexes() const
      { return paramIndexes_; }
  private:
    Teuchos::RefCountPtr<Epetra_MultiVector> mv_;
    EDerivativeMultiVectorOrientation orientation_;
    Teuchos::Array<int> paramIndexes_;
  };

  class Derivative {
  public:
    Derivative() {}
    Derivative( const Teuchos::RefCountPtr<Epetra_Operator> &lo )
      : lo_(lo) {}
    Derivative(
      const Teuchos::RefCountPtr<Epetra_MultiVector> &mv
      ,const EDerivativeMultiVectorOrientation orientation = DERIV_MV_BY_COL
      ) : dmv_(mv,orientation) {}
    Derivative( const DerivativeMultiVector &dmv )
      : dmv_(dmv) {}
    Teuchos::RefCountPtr<Epetra_Operator> getLinearOp() const
      { return lo_; }
    Teuchos::RefCountPtr<Epetra_MultiVector> getMultiVector() const
      { return dmv_.getMultiVector(); }
    EDerivativeMultiVectorOrientation getMultiVectorOrientation() const
      { return dmv_.getOrientation(); }
    DerivativeMultiVector getDerivativeMultiVector() const
      { return dmv_; }
    bool isEmpty() const
        { return !lo_.get() && !dmv_.getMultiVector().get(); }
  private:
    Teuchos::RefCountPtr<Epetra_Operator> lo_;
    DerivativeMultiVector dmv_;
  };

  enum EOutArgsMembers {
    OUT_ARG_f
    ,OUT_ARG_W
    ,OUT_ARG_f_poly   
    ,OUT_ARG_f_sg     
    ,OUT_ARG_W_sg     
  };
  static const int NUM_E_OUT_ARGS_MEMBERS=5;

  enum EOutArgsDfDp {
    OUT_ARG_DfDp   
  };

  enum EOutArgsDgDx_dot {
    OUT_ARG_DgDx_dot   
  };

  enum EOutArgsDgDx {
    OUT_ARG_DgDx   
  };

  enum EOutArgsDgDp {
    OUT_ARG_DgDp   
  };

  enum EOutArgsDgDp_sg {
    OUT_ARG_DgDp_sg   
  };

  class OutArgs {
  public:

    typedef Teuchos::RefCountPtr<Stokhos::VectorOrthogPoly<Epetra_Vector> > sg_vector_t;

    typedef Teuchos::RefCountPtr<Stokhos::VectorOrthogPoly<Epetra_Operator> > sg_operator_t;

    typedef Teuchos::RefCountPtr<Stokhos::VectorOrthogPoly<Derivative> > sg_deriv_t;

    OutArgs();
    std::string modelEvalDescription() const;
    int Np() const;
    int Ng() const;
    int Np_sg() const;
    int Ng_sg() const;
    bool supports(EOutArgsMembers arg) const;
    const DerivativeSupport& supports(EOutArgsDfDp arg, int l) const;
    const DerivativeSupport& supports(EOutArgsDgDx_dot arg, int j) const;
    const DerivativeSupport& supports(EOutArgsDgDx arg, int j) const;
    const DerivativeSupport& supports(EOutArgsDgDp arg, int j, int l) const;
    const DerivativeSupport& supports(EOutArgsDgDp_sg arg, int j, int l) const;
    void set_f( const Evaluation<Epetra_Vector> &f );
    Evaluation<Epetra_Vector> get_f() const;
    void set_f_sg( const sg_vector_t& f_sg );
    sg_vector_t get_f_sg() const;
    void set_g( int j, const Evaluation<Epetra_Vector> &g_j );
    Evaluation<Epetra_Vector> get_g(int j) const;
    void set_g_sg( int j, const sg_vector_t &g_sg_j );
    sg_vector_t get_g_sg(int j) const;
    void set_W( const Teuchos::RefCountPtr<Epetra_Operator> &W );
    Teuchos::RefCountPtr<Epetra_Operator> get_W() const;
    DerivativeProperties get_W_properties() const;
    void set_W_sg( const sg_operator_t& W_sg );
    sg_operator_t get_W_sg() const;
    void set_DfDp(int l,  const Derivative &DfDp_l);
    Derivative get_DfDp(int l) const;
    DerivativeProperties get_DfDp_properties(int l) const;
    void set_DgDx_dot(int j, const Derivative &DgDx_dot_j);
    Derivative get_DgDx_dot(int j) const;
    DerivativeProperties get_DgDx_dot_properties(int j) const;
    void set_DgDx(int j, const Derivative &DgDx_j);
    Derivative get_DgDx(int j) const;
    DerivativeProperties get_DgDx_properties(int j) const;
    void set_DgDp( int j, int l, const Derivative &DgDp_j_l );
    Derivative get_DgDp(int j, int l) const;
    DerivativeProperties get_DgDp_properties(int j, int l) const;
    void set_DgDp_sg( int j, int l, const sg_deriv_t &DgDp_sg_j_l );
    sg_deriv_t get_DgDp_sg(int j, int l) const;
    DerivativeProperties get_DgDp_sg_properties(int j, int l) const;

    void set_f_poly( const Teuchos::RefCountPtr<Teuchos::Polynomial<Epetra_Vector> > &f_poly );
    Teuchos::RefCountPtr<Teuchos::Polynomial<Epetra_Vector> > get_f_poly() const;
    
    
    bool funcOrDerivesAreSet(EOutArgsMembers arg) const;
  protected:
    void _setModelEvalDescription( const std::string &modelEvalDescription );
    void _set_Np_Ng(int Np, int Ng);
    void _set_Np_Ng_sg(int Np_sg, int Ng_sg);
    void _setSupports( EOutArgsMembers arg, bool supports );
    void _setSupports( EOutArgsDfDp arg, int l, const DerivativeSupport& );
    void _setSupports( EOutArgsDgDx_dot arg, int j, const DerivativeSupport& );
    void _setSupports( EOutArgsDgDx arg, int j, const DerivativeSupport& );
    void _setSupports( EOutArgsDgDp arg, int j, int l, const DerivativeSupport& );
    void _setSupports( EOutArgsDgDp_sg arg, int j, int l, const DerivativeSupport& );
    void _set_W_properties( const DerivativeProperties &W_properties );
    void _set_DfDp_properties( int l, const DerivativeProperties &properties );
    void _set_DgDx_dot_properties( int j, const DerivativeProperties &properties );
    void _set_DgDx_properties( int j, const DerivativeProperties &properties );
    void _set_DgDp_properties( int j, int l, const DerivativeProperties &properties );
    void _set_DgDp_sg_properties( int j, int l, const DerivativeProperties &properties );
  private:
    // types
    typedef Teuchos::Array<Evaluation<Epetra_Vector> > g_t;
    typedef Teuchos::Array<sg_vector_t > g_sg_t;
    typedef Teuchos::Array<Derivative> deriv_t;
    typedef Teuchos::Array<DerivativeProperties> deriv_properties_t;
    typedef Teuchos::Array<DerivativeSupport> supports_t;
    // data
    std::string modelEvalDescription_;
    bool supports_[NUM_E_OUT_ARGS_MEMBERS];
    supports_t supports_DfDp_; // Np
    supports_t supports_DgDx_dot_; // Ng
    supports_t supports_DgDx_; // Ng
    supports_t supports_DgDp_; // Ng x Np
    supports_t supports_DgDp_sg_; // Ng_sg x Np
    Evaluation<Epetra_Vector> f_;
    g_t g_;
    g_sg_t g_sg_;
    Teuchos::RefCountPtr<Epetra_Operator> W_;
    DerivativeProperties W_properties_;
    deriv_t DfDp_; // Np
    deriv_properties_t DfDp_properties_; // Np
    deriv_t DgDx_dot_; // Ng
    deriv_t DgDx_; // Ng
    deriv_properties_t DgDx_dot_properties_; // Ng
    deriv_properties_t DgDx_properties_; // Ng
    deriv_t DgDp_; // Ng x Np
    deriv_properties_t DgDp_properties_; // Ng x Np
    Teuchos::RefCountPtr<Teuchos::Polynomial<Epetra_Vector> > f_poly_;
    sg_vector_t f_sg_;
    sg_operator_t W_sg_;
    Teuchos::Array<sg_deriv_t> DgDp_sg_; // Ng_sg x Np_sg
    deriv_properties_t DgDp_sg_properties_; // Ng_sg x Np_sg
    int Np_sg_;
    // functions
    void assert_supports(EOutArgsMembers arg) const;
    void assert_supports(EOutArgsDfDp arg, int l) const;
    void assert_supports(EOutArgsDgDx_dot arg, int j) const;
    void assert_supports(EOutArgsDgDx arg, int j) const;
    void assert_supports(EOutArgsDgDp arg, int j, int l) const;
    void assert_supports(EOutArgsDgDp_sg arg, int j, int l) const;
    void assert_l(int l) const;
    void assert_j(int j) const;
    void assert_l_sg(int l) const;
    void assert_j_sg(int j) const;
  };



  virtual ~ModelEvaluator();



  virtual Teuchos::RefCountPtr<const Epetra_Map> get_x_map() const = 0;

  virtual Teuchos::RefCountPtr<const Epetra_Map> get_f_map() const = 0;

  virtual Teuchos::RefCountPtr<const Epetra_Map> get_p_map(int l) const;

  virtual Teuchos::RefCountPtr<const Teuchos::Array<std::string> > get_p_names(int l) const;

  virtual Teuchos::RefCountPtr<const Epetra_Map> get_g_map(int j) const;



  virtual Teuchos::RefCountPtr<const Epetra_Vector> get_x_init() const;

  virtual Teuchos::RefCountPtr<const Epetra_Vector> get_x_dot_init() const;

  virtual Teuchos::RefCountPtr<const Epetra_Vector> get_p_init(int l) const;

  virtual double get_t_init() const;



  virtual double getInfBound() const;

  virtual Teuchos::RefCountPtr<const Epetra_Vector> get_x_lower_bounds() const;

  virtual Teuchos::RefCountPtr<const Epetra_Vector> get_x_upper_bounds() const;

  virtual Teuchos::RefCountPtr<const Epetra_Vector> get_p_lower_bounds(int l) const;

  virtual Teuchos::RefCountPtr<const Epetra_Vector> get_p_upper_bounds(int l) const;

  virtual double get_t_lower_bound() const;

  virtual double get_t_upper_bound() const;



  virtual Teuchos::RefCountPtr<Epetra_Operator> create_W() const;

  virtual Teuchos::RefCountPtr<Epetra_Operator> create_DfDp_op(int l) const;

  virtual Teuchos::RefCountPtr<Epetra_Operator> create_DgDx_dot_op(int j) const;

  virtual Teuchos::RefCountPtr<Epetra_Operator> create_DgDx_op(int j) const;

  virtual Teuchos::RefCountPtr<Epetra_Operator> create_DgDp_op( int j, int l ) const;



  virtual InArgs createInArgs() const = 0;

  virtual OutArgs createOutArgs() const = 0;

  virtual void evalModel( const InArgs& inArgs, const OutArgs& outArgs ) const = 0;

#ifdef HAVE_PYTRILINOS

  friend InArgs convertInArgsFromPython(PyObject * source);

  friend OutArgs convertOutArgsFromPython(PyObject * source);
#endif


protected:


  class InArgsSetup : public InArgs {
  public:
    void setModelEvalDescription( const std::string &modelEvalDescription );
    void set_Np(int Np);
    void set_Np_sg(int Np);
    void setSupports( EInArgsMembers arg, bool supports = true );
  };

  class OutArgsSetup : public OutArgs {
  public:
    void setModelEvalDescription( const std::string &modelEvalDescription );
    void set_Np_Ng(int Np, int Ng);
    void set_Np_Ng_sg(int Np_sg, int Ng_sg);
    void setSupports( EOutArgsMembers arg, bool supports = true );
    void setSupports(EOutArgsDfDp arg, int l, const DerivativeSupport& );
    void setSupports(EOutArgsDgDx_dot arg, int j, const DerivativeSupport& );
    void setSupports(EOutArgsDgDx arg, int j, const DerivativeSupport& );
    void setSupports(EOutArgsDgDp arg, int j, int l, const DerivativeSupport& );
    void setSupports(EOutArgsDgDp_sg arg, int j, int l, const DerivativeSupport& );
    void set_W_properties( const DerivativeProperties &properties );
    void set_DfDp_properties( int l, const DerivativeProperties &properties );
    void set_DgDx_dot_properties( int j, const DerivativeProperties &properties );
    void set_DgDx_properties( int j, const DerivativeProperties &properties );
    void set_DgDp_properties( int j, int l, const DerivativeProperties &properties );
    void set_DgDp_sg_properties( int j, int l, const DerivativeProperties &properties );
  };


};

// ////////////////////////////
// Helper functions

std::string toString( ModelEvaluator::EDerivativeMultiVectorOrientation orientation );

std::string toString( ModelEvaluator::EInArgsMembers inArg );

std::string toString( ModelEvaluator::EOutArgsMembers outArg );

Teuchos::RefCountPtr<Epetra_Operator>
getLinearOp(
  const std::string &modelEvalDescription,
  const ModelEvaluator::Derivative &deriv,
  const std::string &derivName
  );

Teuchos::RefCountPtr<Epetra_MultiVector>
getMultiVector(
  const std::string &modelEvalDescription,
  const ModelEvaluator::Derivative &deriv,
  const std::string &derivName,
  const ModelEvaluator::EDerivativeMultiVectorOrientation mvOrientation
  );

Teuchos::RefCountPtr<Epetra_Operator>
get_DfDp_op(
  const int l
  ,const ModelEvaluator::OutArgs &outArgs
  );

Teuchos::RefCountPtr<Epetra_MultiVector>
get_DfDp_mv(
  const int l
  ,const ModelEvaluator::OutArgs &outArgs
  );

Teuchos::RefCountPtr<Epetra_MultiVector>
get_DgDx_dot_mv(
  const int j
  ,const ModelEvaluator::OutArgs &outArgs
  ,const ModelEvaluator::EDerivativeMultiVectorOrientation mvOrientation
  );

Teuchos::RefCountPtr<Epetra_MultiVector>
get_DgDx_mv(
  const int j
  ,const ModelEvaluator::OutArgs &outArgs
  ,const ModelEvaluator::EDerivativeMultiVectorOrientation mvOrientation
  );

Teuchos::RefCountPtr<Epetra_MultiVector>
get_DgDp_mv(
  const int j
  ,const int l
  ,const ModelEvaluator::OutArgs &outArgs
  ,const ModelEvaluator::EDerivativeMultiVectorOrientation mvOrientation
  );

// ///////////////////////////
// Inline Functions

//
// ModelEvaluator::InArgs
//

inline
std::string ModelEvaluator::InArgs::modelEvalDescription() const
{ return modelEvalDescription_; }

inline
int ModelEvaluator::InArgs::Np() const
{ return p_.size(); }

inline
int ModelEvaluator::InArgs::Np_sg() const
{ return p_sg_.size(); }

inline
void ModelEvaluator::InArgs::set_x_dot( const Teuchos::RefCountPtr<const Epetra_Vector> &x_dot )
{ assert_supports(IN_ARG_x_dot); x_dot_ = x_dot; }

inline
Teuchos::RefCountPtr<const Epetra_Vector> ModelEvaluator::InArgs::get_x_dot() const
{ assert_supports(IN_ARG_x_dot); return x_dot_; }

inline
void ModelEvaluator::InArgs::set_x( const Teuchos::RefCountPtr<const Epetra_Vector> &x )
{ assert_supports(IN_ARG_x); x_ = x; }

inline
Teuchos::RefCountPtr<const Epetra_Vector> ModelEvaluator::InArgs::get_x() const
{ assert_supports(IN_ARG_x); return x_; }

inline 
void ModelEvaluator::InArgs::set_x_dot_poly( const Teuchos::RefCountPtr<const Teuchos::Polynomial<Epetra_Vector> > &x_dot_poly )
{ assert_supports(IN_ARG_x_dot_poly); x_dot_poly_ = x_dot_poly; }

inline 
Teuchos::RefCountPtr<const Teuchos::Polynomial<Epetra_Vector> >
ModelEvaluator::InArgs::get_x_dot_poly() const
{ assert_supports(IN_ARG_x_dot_poly); return x_dot_poly_; }

inline 
void ModelEvaluator::InArgs::set_x_poly( const Teuchos::RefCountPtr<const Teuchos::Polynomial<Epetra_Vector> > &x_poly )
{ assert_supports(IN_ARG_x_poly); x_poly_ = x_poly; }

inline 
Teuchos::RefCountPtr<const Teuchos::Polynomial<Epetra_Vector> >
ModelEvaluator::InArgs::get_x_poly() const
{ assert_supports(IN_ARG_x_poly); return x_poly_; }

inline 
void ModelEvaluator::InArgs::set_x_dot_sg( const ModelEvaluator::InArgs::sg_const_vector_t &x_dot_sg )
{ assert_supports(IN_ARG_x_dot_sg); x_dot_sg_ = x_dot_sg; }

inline 
ModelEvaluator::InArgs::sg_const_vector_t
ModelEvaluator::InArgs::get_x_dot_sg() const
{ assert_supports(IN_ARG_x_dot_sg); return x_dot_sg_; }

inline 
void ModelEvaluator::InArgs::set_x_sg( const ModelEvaluator::InArgs::sg_const_vector_t &x_sg )
{ assert_supports(IN_ARG_x_sg); x_sg_ = x_sg; }

inline 
ModelEvaluator::InArgs::sg_const_vector_t
ModelEvaluator::InArgs::get_x_sg() const
{ assert_supports(IN_ARG_x_sg); return x_sg_; }

inline
void ModelEvaluator::InArgs::set_p( int l, const Teuchos::RefCountPtr<const Epetra_Vector> &p_l )
{ assert_l(l); p_[l] = p_l; }

inline
Teuchos::RefCountPtr<const Epetra_Vector> ModelEvaluator::InArgs::get_p(int l) const
{ assert_l(l); return p_[l]; }

inline
void ModelEvaluator::InArgs::set_p_sg( int l, 
               const ModelEvaluator::InArgs::sg_const_vector_t &p_sg_l )
{ assert_l(l); p_sg_[l] = p_sg_l; }

inline
ModelEvaluator::InArgs::sg_const_vector_t 
ModelEvaluator::InArgs::get_p_sg(int l) const
{ assert_l(l); return p_sg_[l]; }

inline
void ModelEvaluator::InArgs::set_t( double t )
{ assert_supports(IN_ARG_t); t_ = t; }

inline
double ModelEvaluator::InArgs::get_t() const
{ assert_supports(IN_ARG_t); return t_; }

inline
void ModelEvaluator::InArgs::set_alpha( double alpha )
{ assert_supports(IN_ARG_alpha); alpha_ = alpha; }

inline
double ModelEvaluator::InArgs::get_alpha() const
{ assert_supports(IN_ARG_alpha); return alpha_; }

inline
void ModelEvaluator::InArgs::set_beta( double beta )
{ assert_supports(IN_ARG_beta); beta_ = beta; }

inline
double ModelEvaluator::InArgs::get_beta() const
{ assert_supports(IN_ARG_beta); return beta_; }

inline
void ModelEvaluator::InArgs::_setModelEvalDescription( const std::string &modelEvalDescription )
{
  modelEvalDescription_ = modelEvalDescription;
}

inline
void ModelEvaluator::InArgs::_set_Np(int Np)
{
  p_.resize(Np);
}

inline
void ModelEvaluator::InArgs::_set_Np_sg(int Np)
{
  p_sg_.resize(Np);
}

//
// ModelEvaluator::OutArgs
//

inline
std::string ModelEvaluator::OutArgs::modelEvalDescription() const
{ return modelEvalDescription_; }

inline
int ModelEvaluator::OutArgs::Np() const
{
  return DfDp_.size();
}

inline
int ModelEvaluator::OutArgs::Ng() const
{ 
  return g_.size();
}

inline
int ModelEvaluator::OutArgs::Np_sg() const
{
  return Np_sg_;
}

inline
int ModelEvaluator::OutArgs::Ng_sg() const
{ 
  return g_sg_.size();
}

inline
void ModelEvaluator::OutArgs::set_f( const Evaluation<Epetra_Vector> &f ) { f_ = f; }

inline
ModelEvaluator::Evaluation<Epetra_Vector>
ModelEvaluator::OutArgs::get_f() const { return f_; }

inline
void ModelEvaluator::OutArgs::set_g( int j, const Evaluation<Epetra_Vector> &g_j )
{
  assert_j(j);
  g_[j] = g_j;
}

inline
ModelEvaluator::Evaluation<Epetra_Vector>
ModelEvaluator::OutArgs::get_g(int j) const
{
  assert_j(j);
  return g_[j];
}

inline
void ModelEvaluator::OutArgs::set_g_sg( int j, const sg_vector_t &g_sg_j )
{
  assert_j_sg(j);
  g_sg_[j] = g_sg_j;
}

inline
ModelEvaluator::OutArgs::sg_vector_t
ModelEvaluator::OutArgs::get_g_sg(int j) const
{
  assert_j_sg(j);
  return g_sg_[j];
}

inline
void ModelEvaluator::OutArgs::set_W( const Teuchos::RefCountPtr<Epetra_Operator> &W ) { W_ = W; }

inline
Teuchos::RefCountPtr<Epetra_Operator> ModelEvaluator::OutArgs::get_W() const { return W_; }

inline
ModelEvaluator::DerivativeProperties ModelEvaluator::OutArgs::get_W_properties() const
{
  return W_properties_;
}

inline
void ModelEvaluator::OutArgs::set_DfDp( int l, const Derivative &DfDp_l )
{
  assert_supports(OUT_ARG_DfDp,l);
  DfDp_[l] = DfDp_l;
}

inline
ModelEvaluator::Derivative
ModelEvaluator::OutArgs::get_DfDp(int l) const
{
  assert_supports(OUT_ARG_DfDp,l);
  return DfDp_[l];
}

inline
ModelEvaluator::DerivativeProperties
ModelEvaluator::OutArgs::get_DfDp_properties(int l) const
{
  assert_supports(OUT_ARG_DfDp,l);
  return DfDp_properties_[l];
}

inline
void ModelEvaluator::OutArgs::set_DgDx_dot( int j, const Derivative &DgDx_dot_j )
{
  assert_supports(OUT_ARG_DgDx_dot,j);
  DgDx_dot_[j] = DgDx_dot_j;
}

inline
ModelEvaluator::Derivative
ModelEvaluator::OutArgs::get_DgDx_dot(int j) const
{
  assert_supports(OUT_ARG_DgDx_dot,j);
  return DgDx_dot_[j];
}

inline
ModelEvaluator::DerivativeProperties
ModelEvaluator::OutArgs::get_DgDx_dot_properties(int j) const
{
  assert_supports(OUT_ARG_DgDx_dot,j);
  return DgDx_dot_properties_[j];
}

inline
void ModelEvaluator::OutArgs::set_DgDx( int j, const Derivative &DgDx_j )
{
  assert_supports(OUT_ARG_DgDx,j);
  DgDx_[j] = DgDx_j;
}

inline
ModelEvaluator::Derivative
ModelEvaluator::OutArgs::get_DgDx(int j) const
{
  assert_supports(OUT_ARG_DgDx,j);
  return DgDx_[j];
}

inline
ModelEvaluator::DerivativeProperties
ModelEvaluator::OutArgs::get_DgDx_properties(int j) const
{
  assert_supports(OUT_ARG_DgDx,j);
  return DgDx_properties_[j];
}

inline
void ModelEvaluator::OutArgs::set_DgDp( int j, int l, const Derivative &DgDp_j_l )
{
  assert_supports(OUT_ARG_DgDp,j,l);
  DgDp_[ j*Np() + l ] = DgDp_j_l;
}

inline
ModelEvaluator::Derivative
ModelEvaluator::OutArgs::get_DgDp(int j, int l) const
{
  assert_supports(OUT_ARG_DgDp,j,l);
  return DgDp_[ j*Np() + l ];
}

inline
ModelEvaluator::DerivativeProperties
ModelEvaluator::OutArgs::get_DgDp_properties(int j, int l) const
{
  assert_supports(OUT_ARG_DgDp,j,l);
  return DgDp_properties_[ j*Np() + l ];
}

inline
void ModelEvaluator::OutArgs::set_DgDp_sg( int j, int l, const ModelEvaluator::OutArgs::sg_deriv_t &DgDp_sg_j_l )
{
  assert_supports(OUT_ARG_DgDp_sg,j,l);
  DgDp_sg_[ j*Np_sg() + l ] = DgDp_sg_j_l;
}

inline
ModelEvaluator::OutArgs::sg_deriv_t
ModelEvaluator::OutArgs::get_DgDp_sg(int j, int l) const
{
  assert_supports(OUT_ARG_DgDp_sg,j,l);
  return DgDp_sg_[ j*Np_sg() + l ];
}

inline
ModelEvaluator::DerivativeProperties
ModelEvaluator::OutArgs::get_DgDp_sg_properties(int j, int l) const
{
  assert_supports(OUT_ARG_DgDp_sg,j,l);
  return DgDp_sg_properties_[ j*Np_sg() + l ];
}

inline
void ModelEvaluator::OutArgs::set_f_poly( const Teuchos::RefCountPtr<Teuchos::Polynomial<Epetra_Vector> > &f_poly )
{ f_poly_ = f_poly; }

inline
Teuchos::RefCountPtr<Teuchos::Polynomial<Epetra_Vector> >
ModelEvaluator::OutArgs::get_f_poly() const
{ return f_poly_; }

inline
void ModelEvaluator::OutArgs::set_f_sg( const ModelEvaluator::OutArgs::sg_vector_t& f_sg )
{ f_sg_ = f_sg; }

inline
ModelEvaluator::OutArgs::sg_vector_t
ModelEvaluator::OutArgs::get_f_sg() const
{ return f_sg_; }

inline
void ModelEvaluator::OutArgs::set_W_sg( const ModelEvaluator::OutArgs::sg_operator_t& W_sg ) { W_sg_ = W_sg; }

inline
ModelEvaluator::OutArgs::sg_operator_t ModelEvaluator::OutArgs::get_W_sg() const { return W_sg_; }

//
// ModelEvaluator::InArgsSetup
//

inline
void ModelEvaluator::InArgsSetup::setModelEvalDescription( const std::string &modelEvalDescription )
{
  this->_setModelEvalDescription(modelEvalDescription);
}

inline
void ModelEvaluator::InArgsSetup::set_Np(int Np)
{ this->_set_Np(Np); }

inline
void ModelEvaluator::InArgsSetup::set_Np_sg(int Np)
{ this->_set_Np_sg(Np); }

inline
void ModelEvaluator::InArgsSetup::setSupports( EInArgsMembers arg, bool supports )
{ this->_setSupports(arg,supports); }

//
// ModelEvaluator::OutArgsSetup
//

inline
void ModelEvaluator::OutArgsSetup::setModelEvalDescription( const std::string &modelEvalDescription )
{
  this->_setModelEvalDescription(modelEvalDescription);
}

inline
void ModelEvaluator::OutArgsSetup::set_Np_Ng(int Np, int Ng)
{ this->_set_Np_Ng(Np,Ng); }

inline
void ModelEvaluator::OutArgsSetup::set_Np_Ng_sg(int Np_sg, int Ng_sg)
{ this->_set_Np_Ng_sg(Np_sg, Ng_sg); }

inline
void ModelEvaluator::OutArgsSetup::setSupports( EOutArgsMembers arg, bool supports )
{ this->_setSupports(arg,supports); }

inline
void ModelEvaluator::OutArgsSetup::setSupports( EOutArgsDfDp arg, int l, const DerivativeSupport& supports )
{ this->_setSupports(arg,l,supports); }

inline
void ModelEvaluator::OutArgsSetup::setSupports( EOutArgsDgDx_dot arg, int j, const DerivativeSupport& supports )
{ this->_setSupports(arg,j,supports); }

inline
void ModelEvaluator::OutArgsSetup::setSupports( EOutArgsDgDx arg, int j, const DerivativeSupport& supports )
{ this->_setSupports(arg,j,supports); }

inline
void ModelEvaluator::OutArgsSetup::setSupports( EOutArgsDgDp arg, int j, int l, const DerivativeSupport& supports )
{ this->_setSupports(arg,j,l,supports); }

inline
void ModelEvaluator::OutArgsSetup::setSupports( EOutArgsDgDp_sg arg, int j, int l, const DerivativeSupport& supports )
{ this->_setSupports(arg,j,l,supports); }

inline
void ModelEvaluator::OutArgsSetup::set_W_properties( const DerivativeProperties &properties )
{ this->_set_W_properties(properties); }

inline
void ModelEvaluator::OutArgsSetup::set_DfDp_properties( int l, const DerivativeProperties &properties )
{
  this->_set_DfDp_properties(l,properties);
}

inline
void ModelEvaluator::OutArgsSetup::set_DgDx_dot_properties( int j, const DerivativeProperties &properties )
{
  this->_set_DgDx_dot_properties(j,properties);
}

inline
void ModelEvaluator::OutArgsSetup::set_DgDx_properties( int j, const DerivativeProperties &properties )
{
  this->_set_DgDx_properties(j,properties);
}

inline
void ModelEvaluator::OutArgsSetup::set_DgDp_properties( int j, int l, const DerivativeProperties &properties )
{
  this->_set_DgDp_properties(j,l,properties);
}

inline
void ModelEvaluator::OutArgsSetup::set_DgDp_sg_properties( int j, int l, const DerivativeProperties &properties )
{
  this->_set_DgDp_sg_properties(j,l,properties);
}

} // namespace EpetraExt

#endif // EPETRA_EXT_MODEL_EVALUATOR_HPP

---