EpetraExt_ModelEvaluator.h

Go to the documentation of this file.

//@HEADER
// ***********************************************************************
//
//     EpetraExt: Epetra Extended - Linear Algebra Services Package
//                 Copyright (2011) Sandia Corporation
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// 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_RCP.hpp"
#include "Teuchos_Describable.hpp"
#include "Teuchos_Polynomial.hpp"
#include "Teuchos_Array.hpp"
#include "Teuchos_CompilerCodeTweakMacros.hpp"
 
#ifdef HAVE_PYTRILINOS
#ifndef PyObject_HEAD
struct _object;
typedef _object PyObject;
#endif
#endif
 
class Epetra_Map;
class Epetra_Vector;
class Epetra_Operator;
 
// Forward declaration of Stochastic Galerkin (SG) argument types
namespace Stokhos {
  class EpetraVectorOrthogPoly;
  class EpetraMultiVectorOrthogPoly;
  class EpetraOperatorOrthogPoly;
  template <typename ordinal_type, typename scalar_type> class OrthogPolyBasis;
  template <typename ordinal_type, typename scalar_type> class Quadrature;
  template <typename ordinal_type, typename scalar_type> class StandardStorage;
  template <typename ordinal_type, typename scalar_type, typename node_type> class OrthogPolyExpansion;
 
  class ProductEpetraVector;
  class ProductEpetraMultiVector;
  class ProductEpetraOperator;
}
 
namespace EpetraExt {

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

 
  typedef Teuchos::RCP<const Stokhos::ProductEpetraVector> mp_const_vector_t;
  typedef Teuchos::RCP<const Stokhos::ProductEpetraMultiVector> mp_const_multivector_t;
  typedef Teuchos::RCP<const Stokhos::ProductEpetraOperator > mp_const_operator_t;
  typedef Teuchos::RCP<Stokhos::ProductEpetraVector> mp_vector_t;
  typedef Teuchos::RCP<Stokhos::ProductEpetraMultiVector> mp_multivector_t;
  typedef Teuchos::RCP<Stokhos::ProductEpetraOperator > mp_operator_t;

  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_x_dot_mp,      
    IN_ARG_x_mp,          
    IN_ARG_t,
    IN_ARG_alpha,
    IN_ARG_beta,
    IN_ARG_step_size,
    IN_ARG_stage_number,
    IN_ARG_x_dotdot,
    IN_ARG_x_dotdot_poly, 
    IN_ARG_x_dotdot_sg,   
    IN_ARG_x_dotdot_mp,   
    IN_ARG_omega,         
    IN_ARG_sg_basis,      
    IN_ARG_sg_quadrature, 
    IN_ARG_sg_expansion   
  };
  static const int NUM_E_IN_ARGS_MEMBERS=21;

  enum EInArgs_p_sg {
    IN_ARG_p_sg   
  };

  enum EInArgs_p_mp {
    IN_ARG_p_mp   
  };

  class InArgs {
  public:

    typedef Teuchos::RCP<const Stokhos::EpetraVectorOrthogPoly> sg_const_vector_t;

    InArgs();
    std::string modelEvalDescription() const;
    int Np() const;
    void set_x_dot( const Teuchos::RCP<const Epetra_Vector> &x_dot );
    void set_x_dotdot( const Teuchos::RCP<const Epetra_Vector> &x_dotdot );
    Teuchos::RCP<const Epetra_Vector> get_x_dot() const;
    Teuchos::RCP<const Epetra_Vector> get_x_dotdot() const;
    void set_x( const Teuchos::RCP<const Epetra_Vector> &x );
    Teuchos::RCP<const Epetra_Vector> get_x() const;
    void set_x_poly(
      const Teuchos::RCP<const Teuchos::Polynomial<Epetra_Vector> > &x_poly
      );
    Teuchos::RCP<const Teuchos::Polynomial<Epetra_Vector> > get_x_poly() const;
    void set_x_dot_poly(
      const Teuchos::RCP<const Teuchos::Polynomial<Epetra_Vector> > &x_dot_poly
      );
    void set_x_dotdot_poly(
      const Teuchos::RCP<const Teuchos::Polynomial<Epetra_Vector> > &x_dotdot_poly
      );
    Teuchos::RCP<const Teuchos::Polynomial<Epetra_Vector> > get_x_dot_poly() const;
    Teuchos::RCP<const Teuchos::Polynomial<Epetra_Vector> > get_x_dotdot_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);
    void set_x_dotdot_sg(const sg_const_vector_t &x_dotdot_sg);
    sg_const_vector_t get_x_dot_sg() const;
    sg_const_vector_t get_x_dotdot_sg() const;
    void set_x_mp(const mp_const_vector_t &x_mp);
    mp_const_vector_t get_x_mp() const;
    void set_x_dot_mp(const mp_const_vector_t &x_dot_mp);
    void set_x_dotdot_mp(const mp_const_vector_t &x_dotdot_mp);
    mp_const_vector_t get_x_dot_mp() const;
    mp_const_vector_t get_x_dotdot_mp() const;
    void set_p( int l, const Teuchos::RCP<const Epetra_Vector> &p_l );
    Teuchos::RCP<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_p_mp( int l, const mp_const_vector_t &p_mp_l );
    mp_const_vector_t get_p_mp(int l) const;
    void set_t( double t );
    double get_alpha() const;
    void set_alpha( double alpha );
    double get_omega() const;
    void set_omega( double omega );
    double get_beta() const;
    void set_beta( double beta );
    double get_t() const;
    double get_step_size() const;
    void set_step_size(double step_size);
    int get_stage_number() const;
    void set_stage_number(int stage_number);
    Teuchos::RCP<const Stokhos::OrthogPolyBasis<int,double> > get_sg_basis() const;
    void set_sg_basis( const Teuchos::RCP<const Stokhos::OrthogPolyBasis<int,double> >& basis );
    Teuchos::RCP<const Stokhos::Quadrature<int,double> > get_sg_quadrature() const;
    void set_sg_quadrature( const Teuchos::RCP<const Stokhos::Quadrature<int,double> >& quad );
    Teuchos::RCP<Stokhos::OrthogPolyExpansion<int,double,Stokhos::StandardStorage<int,double> > > get_sg_expansion() const;
    void set_sg_expansion( const Teuchos::RCP<Stokhos::OrthogPolyExpansion<int,double,Stokhos::StandardStorage<int,double> > >& exp );
    bool supports(EInArgsMembers arg) const;
    bool supports(EInArgs_p_sg arg, int l) const;
    bool supports(EInArgs_p_mp arg, int l) const;
  protected:
    void _setModelEvalDescription( const std::string &modelEvalDescription );
    void _set_Np(int Np);
    void _setSupports( EInArgsMembers arg, bool supports );
    void _setSupports( EInArgs_p_sg arg, int l, bool supports );
    void _setSupports( EInArgs_p_mp arg, int l, bool supports );
  private:
    // types
    typedef Teuchos::Array<Teuchos::RCP<const Epetra_Vector> > p_t;
    typedef Teuchos::Array<sg_const_vector_t > p_sg_t;
    typedef Teuchos::Array<mp_const_vector_t > p_mp_t;
    typedef Teuchos::Array<bool> supports_p_sg_t;
    // data
    std::string modelEvalDescription_;
    Teuchos::RCP<const Epetra_Vector>  x_dot_;
    Teuchos::RCP<const Epetra_Vector>  x_dotdot_;
    Teuchos::RCP<const Epetra_Vector>  x_;
    Teuchos::RCP<const Teuchos::Polynomial<Epetra_Vector> > x_dot_poly_;
    Teuchos::RCP<const Teuchos::Polynomial<Epetra_Vector> > x_dotdot_poly_;
    Teuchos::RCP<const Teuchos::Polynomial<Epetra_Vector> > x_poly_;
    sg_const_vector_t                          x_dot_sg_;
    sg_const_vector_t                          x_dotdot_sg_;
    sg_const_vector_t                          x_sg_;
    mp_const_vector_t                          x_dot_mp_;
    mp_const_vector_t                          x_dotdot_mp_;
    mp_const_vector_t                          x_mp_;
    p_t                                        p_;
    p_sg_t                                     p_sg_;
    p_mp_t                                     p_mp_;
    double                                     t_;
    double                                     alpha_;
    double                                     omega_;
    double                                     beta_;
    double                                     step_size_;
    int                                        stage_number_;
    Teuchos::RCP<const Stokhos::OrthogPolyBasis<int,double> > sg_basis_;
    Teuchos::RCP<const Stokhos::Quadrature<int,double> > sg_quad_;
    Teuchos::RCP<Stokhos::OrthogPolyExpansion<int,double,Stokhos::StandardStorage<int,double> > > sg_exp_;
    bool supports_[NUM_E_IN_ARGS_MEMBERS];
    supports_p_sg_t supports_p_sg_; // Np
    supports_p_sg_t supports_p_mp_; // Np
    // functions
    void assert_supports(EInArgsMembers arg) const;
    void assert_supports(EInArgs_p_sg arg, int l) const;
    void assert_supports(EInArgs_p_mp arg, int l) 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::RCP<ObjType> {
  public:
    Evaluation() : evalType_(EVAL_TYPE_EXACT) {}
    Evaluation( const Teuchos::RCP<ObjType> &obj )
      : Teuchos::RCP<ObjType>(obj), evalType_(EVAL_TYPE_EXACT) {}

    Evaluation( const Teuchos::RCP<ObjType> &obj, EEvalType evalType )
      : Teuchos::RCP<ObjType>(obj), evalType_(evalType) {}

    EEvalType getType() const { return evalType_; }
    void reset( const Teuchos::RCP<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: TEUCHOS_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: TEUCHOS_TEST_FOR_EXCEPT(true);
        }
        TEUCHOS_UNREACHABLE_RETURN(false);
      }
  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::RCP<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::RCP<Epetra_MultiVector> getMultiVector() const
      { return mv_; }

    EDerivativeMultiVectorOrientation getOrientation() const
      { return orientation_; }

    const Teuchos::Array<int>& getParamIndexes() const
      { return paramIndexes_; }
  private:
    Teuchos::RCP<Epetra_MultiVector> mv_;
    EDerivativeMultiVectorOrientation orientation_;
    Teuchos::Array<int> paramIndexes_;
  };

  class Derivative {
  public:
    Derivative() {}
    Derivative( const Teuchos::RCP<Epetra_Operator> &lo )
      : lo_(lo) {}

    Derivative(
      const Teuchos::RCP<Epetra_MultiVector> &mv
      ,const EDerivativeMultiVectorOrientation orientation = DERIV_MV_BY_COL
      ) : dmv_(mv,orientation) {}

    Derivative( const DerivativeMultiVector &dmv )
      : dmv_(dmv) {}

    Teuchos::RCP<Epetra_Operator> getLinearOp() const
      { return lo_; }

    Teuchos::RCP<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::RCP<Epetra_Operator> lo_;
    DerivativeMultiVector dmv_;
  };

  struct Preconditioner {
    Preconditioner() : PrecOp(Teuchos::null), isAlreadyInverted(false) {}
    Preconditioner(const Teuchos::RCP<Epetra_Operator>& PrecOp_,
                     bool isAlreadyInverted_ )
      : PrecOp(PrecOp_), isAlreadyInverted(isAlreadyInverted_) {}

    Teuchos::RCP<Epetra_Operator> PrecOp;
    bool isAlreadyInverted;
  };

  class SGDerivativeMultiVector {
  public:
    SGDerivativeMultiVector() {}
    SGDerivativeMultiVector(
      const Teuchos::RCP< Stokhos::EpetraMultiVectorOrthogPoly > &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::RCP< Stokhos::EpetraMultiVectorOrthogPoly > getMultiVector() const
      { return mv_; }

    EDerivativeMultiVectorOrientation getOrientation() const
      { return orientation_; }

    const Teuchos::Array<int>& getParamIndexes() const
      { return paramIndexes_; }
  private:
    Teuchos::RCP< Stokhos::EpetraMultiVectorOrthogPoly > mv_;
    EDerivativeMultiVectorOrientation orientation_;
    Teuchos::Array<int> paramIndexes_;
  };

  class SGDerivative {
  public:
    SGDerivative() {}
    SGDerivative( const Teuchos::RCP< Stokhos::EpetraOperatorOrthogPoly > &lo )
      : lo_(lo) {}

    SGDerivative(
      const Teuchos::RCP< Stokhos::EpetraMultiVectorOrthogPoly > &mv
      ,const EDerivativeMultiVectorOrientation orientation = DERIV_MV_BY_COL
      ) : dmv_(mv,orientation) {}

    SGDerivative( const SGDerivativeMultiVector &dmv )
      : dmv_(dmv) {}

    Teuchos::RCP< Stokhos::EpetraOperatorOrthogPoly > getLinearOp() const
      { return lo_; }

    Teuchos::RCP< Stokhos::EpetraMultiVectorOrthogPoly > getMultiVector() const
      { return dmv_.getMultiVector(); }

    EDerivativeMultiVectorOrientation getMultiVectorOrientation() const
      { return dmv_.getOrientation(); }

    SGDerivativeMultiVector getDerivativeMultiVector() const
      { return dmv_; }

    bool isEmpty() const
        { return !lo_.get() && !dmv_.getMultiVector().get(); }
  private:
    Teuchos::RCP< Stokhos::EpetraOperatorOrthogPoly > lo_;
    SGDerivativeMultiVector dmv_;
  };

  class MPDerivativeMultiVector {
  public:

    MPDerivativeMultiVector() {}
    MPDerivativeMultiVector(
      const mp_multivector_t &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; };

    mp_multivector_t getMultiVector() const
      { return mv_; }

    EDerivativeMultiVectorOrientation getOrientation() const
      { return orientation_; }

    const Teuchos::Array<int>& getParamIndexes() const
      { return paramIndexes_; }
  private:
    mp_multivector_t mv_;
    EDerivativeMultiVectorOrientation orientation_;
    Teuchos::Array<int> paramIndexes_;
  };

  class MPDerivative {
  public:

    MPDerivative() {}
    MPDerivative( const mp_operator_t &lo )
      : lo_(lo) {}

    MPDerivative(
      const mp_multivector_t &mv
      ,const EDerivativeMultiVectorOrientation orientation = DERIV_MV_BY_COL
      ) : dmv_(mv,orientation) {}

    MPDerivative( const MPDerivativeMultiVector &dmv )
      : dmv_(dmv) {}

    mp_operator_t getLinearOp() const
      { return lo_; }

    mp_multivector_t getMultiVector() const
      { return dmv_.getMultiVector(); }

    EDerivativeMultiVectorOrientation getMultiVectorOrientation() const
      { return dmv_.getOrientation(); }

    MPDerivativeMultiVector getDerivativeMultiVector() const
      { return dmv_; }

    bool isEmpty() const
        { return !lo_.get() && !dmv_.getMultiVector().get(); }
  private:
    mp_operator_t lo_;
    MPDerivativeMultiVector dmv_;
  };

  enum EOutArgsMembers {
    OUT_ARG_f,
    OUT_ARG_W,
    OUT_ARG_f_poly,   
    OUT_ARG_f_sg,     
    OUT_ARG_W_sg,     
    OUT_ARG_f_mp,     
    OUT_ARG_W_mp,     
    OUT_ARG_WPrec     
  };
  static const int NUM_E_OUT_ARGS_MEMBERS=9;

  enum EOutArgsDfDp {
    OUT_ARG_DfDp   
  };

  enum EOutArgsDgDx_dot {
    OUT_ARG_DgDx_dot   
  };

  enum EOutArgsDgDx_dotdot {
    OUT_ARG_DgDx_dotdot   
  };

  enum EOutArgsDgDx {
    OUT_ARG_DgDx   
  };

  enum EOutArgsDgDp {
    OUT_ARG_DgDp   
  };

  enum EOutArgsDfDp_sg {
    OUT_ARG_DfDp_sg   
  };

  enum EOutArgs_g_sg {
    OUT_ARG_g_sg   
  };

  enum EOutArgsDgDx_dot_sg {
    OUT_ARG_DgDx_dot_sg   
  };

  enum EOutArgsDgDx_dotdot_sg {
    OUT_ARG_DgDx_dotdot_sg   
  };

  enum EOutArgsDgDx_sg {
    OUT_ARG_DgDx_sg   
  };

  enum EOutArgsDgDp_sg {
    OUT_ARG_DgDp_sg   
  };

  enum EOutArgsDfDp_mp {
    OUT_ARG_DfDp_mp   
  };

  enum EOutArgs_g_mp {
    OUT_ARG_g_mp   
  };

  enum EOutArgsDgDx_dot_mp {
    OUT_ARG_DgDx_dot_mp   
  };

  enum EOutArgsDgDx_dotdot_mp {
    OUT_ARG_DgDx_dotdot_mp   
  };

  enum EOutArgsDgDx_mp {
    OUT_ARG_DgDx_mp   
  };

  enum EOutArgsDgDp_mp {
    OUT_ARG_DgDp_mp   
  };

  class OutArgs {
  public:

    typedef Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_vector_t;

    typedef Teuchos::RCP<Stokhos::EpetraOperatorOrthogPoly > sg_operator_t;

    OutArgs();
    std::string modelEvalDescription() const;
    int Np() const;
    int Ng() 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_dotdot arg, int j) const;
    const DerivativeSupport& supports(EOutArgsDgDx arg, int j) const;
    const DerivativeSupport& supports(EOutArgsDgDp arg, int j, int l) const;
    bool supports(EOutArgs_g_sg arg, int j) const;
    const DerivativeSupport& supports(EOutArgsDfDp_sg arg, int l) const;
    const DerivativeSupport& supports(EOutArgsDgDx_dot_sg arg, int j) const;
    const DerivativeSupport& supports(EOutArgsDgDx_dotdot_sg arg, int j) const;
    const DerivativeSupport& supports(EOutArgsDgDx_sg arg, int j) const;
    const DerivativeSupport& supports(EOutArgsDgDp_sg arg, int j, int l) const;
    const DerivativeSupport& supports(EOutArgsDfDp_mp arg, int l) const;
    bool supports(EOutArgs_g_mp arg, int j) const;
    const DerivativeSupport& supports(EOutArgsDgDx_dot_mp arg, int j) const;
    const DerivativeSupport& supports(EOutArgsDgDx_dotdot_mp arg, int j) const;
    const DerivativeSupport& supports(EOutArgsDgDx_mp arg, int j) const;
    const DerivativeSupport& supports(EOutArgsDgDp_mp 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_f_mp( const mp_vector_t& f_mp );
    mp_vector_t get_f_mp() 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_g_mp( int j, const mp_vector_t &g_mp_j );
    mp_vector_t get_g_mp(int j) const;
    void set_W( const Teuchos::RCP<Epetra_Operator> &W );
    void set_WPrec( const Teuchos::RCP<Epetra_Operator> &WPrec );
    Teuchos::RCP<Epetra_Operator> get_W() const;
    Teuchos::RCP<Epetra_Operator> get_WPrec() const;
    DerivativeProperties get_W_properties() const;
    DerivativeProperties get_WPrec_properties() const;
    void set_W_sg( const sg_operator_t& W_sg );
    sg_operator_t get_W_sg() const;
    void set_W_mp( const mp_operator_t& W_sg );
    mp_operator_t get_W_mp() 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_DfDp_sg(int l,  const SGDerivative &DfDp_sg_l);
    SGDerivative get_DfDp_sg(int l) const;
    DerivativeProperties get_DfDp_sg_properties(int l) const;
    void set_DfDp_mp(int l,  const MPDerivative &DfDp_mp_l);
    MPDerivative get_DfDp_mp(int l) const;
    DerivativeProperties get_DfDp_mp_properties(int l) const;
    void set_DgDx_dot(int j, const Derivative &DgDx_dot_j);
    void set_DgDx_dotdot(int j, const Derivative &DgDx_dotdot_j);
    Derivative get_DgDx_dot(int j) const;
    Derivative get_DgDx_dotdot(int j) const;
    DerivativeProperties get_DgDx_dot_properties(int j) const;
    DerivativeProperties get_DgDx_dotdot_properties(int j) const;
    void set_DgDx_dot_sg(int j, const SGDerivative &DgDx_dot_j);
    void set_DgDx_dotdot_sg(int j, const SGDerivative &DgDx_dotdot_j);
    SGDerivative get_DgDx_dot_sg(int j) const;
    SGDerivative get_DgDx_dotdot_sg(int j) const;
    DerivativeProperties get_DgDx_dot_sg_properties(int j) const;
    DerivativeProperties get_DgDx_dotdot_sg_properties(int j) const;
    void set_DgDx_dot_mp(int j, const MPDerivative &DgDx_dot_j);
    void set_DgDx_dotdot_mp(int j, const MPDerivative &DgDx_dotdot_j);
    MPDerivative get_DgDx_dot_mp(int j) const;
    MPDerivative get_DgDx_dotdot_mp(int j) const;
    DerivativeProperties get_DgDx_dot_mp_properties(int j) const;
    DerivativeProperties get_DgDx_dotdot_mp_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_DgDx_sg(int j, const SGDerivative &DgDx_j);
    SGDerivative get_DgDx_sg(int j) const;
    DerivativeProperties get_DgDx_sg_properties(int j) const;
    void set_DgDx_mp(int j, const MPDerivative &DgDx_j);
    MPDerivative get_DgDx_mp(int j) const;
    DerivativeProperties get_DgDx_mp_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 SGDerivative &DgDp_sg_j_l );
    SGDerivative get_DgDp_sg(int j, int l) const;
    DerivativeProperties get_DgDp_sg_properties(int j, int l) const;
    void set_DgDp_mp( int j, int l, const MPDerivative &DgDp_mp_j_l );
    MPDerivative get_DgDp_mp(int j, int l) const;
    DerivativeProperties get_DgDp_mp_properties(int j, int l) const;

    void set_f_poly( const Teuchos::RCP<Teuchos::Polynomial<Epetra_Vector> > &f_poly );
    Teuchos::RCP<Teuchos::Polynomial<Epetra_Vector> > get_f_poly() const;
 

    bool funcOrDerivesAreSet(EOutArgsMembers arg) const;

    void setFailed() const;
    bool isFailed() const;
 
  protected:
    void _setModelEvalDescription( const std::string &modelEvalDescription );
    void _set_Np_Ng(int Np, int Ng);
    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_dotdot 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( EOutArgs_g_sg arg, int j, bool supports );
    void _setSupports( EOutArgsDfDp_sg arg, int l, const DerivativeSupport& );
    void _setSupports( EOutArgsDgDx_dot_sg arg, int j, const DerivativeSupport& );
    void _setSupports( EOutArgsDgDx_dotdot_sg arg, int j, const DerivativeSupport& );
    void _setSupports( EOutArgsDgDx_sg arg, int j, const DerivativeSupport& );
    void _setSupports( EOutArgsDgDp_sg arg, int j, int l, const DerivativeSupport& );

    void _setSupports( EOutArgs_g_mp arg, int j, bool supports );
    void _setSupports( EOutArgsDfDp_mp arg, int l, const DerivativeSupport& );
    void _setSupports( EOutArgsDgDx_dot_mp arg, int j, const DerivativeSupport& );
    void _setSupports( EOutArgsDgDx_dotdot_mp arg, int j, const DerivativeSupport& );
    void _setSupports( EOutArgsDgDx_mp arg, int j, const DerivativeSupport& );
    void _setSupports( EOutArgsDgDp_mp arg, int j, int l, const DerivativeSupport& );
    void _set_W_properties( const DerivativeProperties &W_properties );
    void _set_WPrec_properties( const DerivativeProperties &WPrec_properties );
    void _set_DfDp_properties( int l, const DerivativeProperties &properties );
    void _set_DgDx_dot_properties( int j, const DerivativeProperties &properties );
    void _set_DgDx_dotdot_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_DfDp_sg_properties( int l, const DerivativeProperties &properties );
    void _set_DgDx_dot_sg_properties( int j, const DerivativeProperties &properties );
    void _set_DgDx_dotdot_sg_properties( int j, const DerivativeProperties &properties );
    void _set_DgDx_sg_properties( int j, const DerivativeProperties &properties );
    void _set_DgDp_sg_properties( int j, int l, const DerivativeProperties &properties );

    void _set_DfDp_mp_properties( int l, const DerivativeProperties &properties );
    void _set_DgDx_dot_mp_properties( int j, const DerivativeProperties &properties );
    void _set_DgDx_dotdot_mp_properties( int j, const DerivativeProperties &properties );
    void _set_DgDx_mp_properties( int j, const DerivativeProperties &properties );
    void _set_DgDp_mp_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<mp_vector_t > g_mp_t;
    typedef Teuchos::Array<Derivative> deriv_t;
    typedef Teuchos::Array<SGDerivative> sg_deriv_t;
    typedef Teuchos::Array<MPDerivative> mp_deriv_t;
    typedef Teuchos::Array<DerivativeProperties> deriv_properties_t;
    typedef Teuchos::Array<DerivativeSupport> supports_t;
    typedef Teuchos::Array<bool> supports_g_sg_t;
    // data
    std::string modelEvalDescription_;
    mutable bool isFailed_;
    bool supports_[NUM_E_OUT_ARGS_MEMBERS];
    supports_t supports_DfDp_; // Np
    supports_t supports_DgDx_dot_; // Ng
    supports_t supports_DgDx_dotdot_; // Ng
    supports_t supports_DgDx_; // Ng
    supports_t supports_DgDp_; // Ng x Np
    supports_g_sg_t supports_g_sg_; // Ng
    supports_t supports_DfDp_sg_; // Np
    supports_t supports_DgDx_dot_sg_; // Ng
    supports_t supports_DgDx_dotdot_sg_; // Ng
    supports_t supports_DgDx_sg_; // Ng
    supports_t supports_DgDp_sg_; // Ng x Np
    supports_g_sg_t supports_g_mp_; // Ng
    supports_t supports_DfDp_mp_; // Np_mp
    supports_t supports_DgDx_dot_mp_; // Ng_mp
    supports_t supports_DgDx_dotdot_mp_; // Ng_mp
    supports_t supports_DgDx_mp_; // Ng_mp
    supports_t supports_DgDp_mp_; // Ng_mp x Np_mp
    Evaluation<Epetra_Vector> f_;
    g_t g_;
    g_sg_t g_sg_;
    g_mp_t g_mp_;
    Teuchos::RCP<Epetra_Operator> W_;
    Teuchos::RCP<Epetra_Operator> WPrec_;
    DerivativeProperties W_properties_;
    DerivativeProperties WPrec_properties_;
    deriv_t DfDp_; // Np
    deriv_properties_t DfDp_properties_; // Np
    deriv_t DgDx_dot_; // Ng
    deriv_t DgDx_dotdot_; // Ng
    deriv_t DgDx_; // Ng
    deriv_properties_t DgDx_dot_properties_; // Ng
    deriv_properties_t DgDx_dotdot_properties_; // Ng
    deriv_properties_t DgDx_properties_; // Ng
    deriv_t DgDp_; // Ng x Np
    deriv_properties_t DgDp_properties_; // Ng x Np
    Teuchos::RCP<Teuchos::Polynomial<Epetra_Vector> > f_poly_;
    sg_vector_t f_sg_;
    sg_operator_t W_sg_;
    sg_deriv_t DfDp_sg_; // Np
    deriv_properties_t DfDp_sg_properties_; // Np
    sg_deriv_t DgDx_dot_sg_; // Ng
    sg_deriv_t DgDx_dotdot_sg_; // Ng
    sg_deriv_t DgDx_sg_; // Ng
    deriv_properties_t DgDx_dot_sg_properties_; // Ng
    deriv_properties_t DgDx_dotdot_sg_properties_; // Ng
    deriv_properties_t DgDx_sg_properties_; // Ng
    sg_deriv_t DgDp_sg_; // Ng x Np
    deriv_properties_t DgDp_sg_properties_; // Ng x Np
    mp_vector_t f_mp_;
    mp_operator_t W_mp_;
    mp_deriv_t DfDp_mp_; // Np
    deriv_properties_t DfDp_mp_properties_; // Np
    mp_deriv_t DgDx_dot_mp_; // Ng
    mp_deriv_t DgDx_dotdot_mp_; // Ng
    mp_deriv_t DgDx_mp_; // Ng
    deriv_properties_t DgDx_dot_mp_properties_; // Ng
    deriv_properties_t DgDx_dotdot_mp_properties_; // Ng
    deriv_properties_t DgDx_mp_properties_; // Ng
    mp_deriv_t DgDp_mp_; // Ng x Np
    deriv_properties_t DgDp_mp_properties_; // Ng x Np
    // 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_dotdot 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(EOutArgs_g_sg arg, int j) const;
    void assert_supports(EOutArgsDfDp_sg arg, int l) const;
    void assert_supports(EOutArgsDgDx_dot_sg arg, int j) const;
    void assert_supports(EOutArgsDgDx_dotdot_sg arg, int j) const;
    void assert_supports(EOutArgsDgDx_sg arg, int j) const;
    void assert_supports(EOutArgsDgDp_sg arg, int j, int l) const;
    void assert_supports(EOutArgs_g_mp arg, int j) const;
    void assert_supports(EOutArgsDfDp_mp arg, int l) const;
    void assert_supports(EOutArgsDgDx_dot_mp arg, int j) const;
    void assert_supports(EOutArgsDgDx_dotdot_mp arg, int j) const;
    void assert_supports(EOutArgsDgDx_mp arg, int j) const;
    void assert_supports(EOutArgsDgDp_mp arg, int j, int l) const;
    void assert_l(int l) const;
    void assert_j(int j) const;
  };



  virtual ~ModelEvaluator();



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

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

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

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

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

  virtual Teuchos::ArrayView<const std::string> get_g_names(int j) const;



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

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

  virtual Teuchos::RCP<const Epetra_Vector> get_x_dotdot_init() const;

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

  virtual double get_t_init() const;



  virtual double getInfBound() const;

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

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

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

  virtual Teuchos::RCP<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::RCP<Epetra_Operator> create_W() const;
  virtual Teuchos::RCP<EpetraExt::ModelEvaluator::Preconditioner> create_WPrec() const;

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

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

  virtual Teuchos::RCP<Epetra_Operator> create_DgDx_dotdot_op(int j) const;

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

  virtual Teuchos::RCP<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 setSupports( EInArgsMembers arg, bool supports = true );
    void setSupports( EInArgs_p_sg arg, int l, bool supports );
    void setSupports( EInArgs_p_mp arg, int l, bool supports );
  };

  class OutArgsSetup : public OutArgs {
  public:
    void setModelEvalDescription( const std::string &modelEvalDescription );
    void set_Np_Ng(int Np, int Ng);
    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_dotdot 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( EOutArgs_g_sg arg, int j, bool supports );
    void setSupports(EOutArgsDfDp_sg arg, int l, const DerivativeSupport& );
    void setSupports(EOutArgsDgDx_dot_sg arg, int j, const DerivativeSupport& );
    void setSupports(EOutArgsDgDx_dotdot_sg arg, int j, const DerivativeSupport& );
    void setSupports(EOutArgsDgDx_sg arg, int j, const DerivativeSupport& );
    void setSupports(EOutArgsDgDp_sg arg, int j, int l, const DerivativeSupport& );
    void setSupports( EOutArgs_g_mp arg, int j, bool supports );
    void setSupports(EOutArgsDfDp_mp arg, int l, const DerivativeSupport& );
    void setSupports(EOutArgsDgDx_dot_mp arg, int j, const DerivativeSupport& );
    void setSupports(EOutArgsDgDx_dotdot_mp arg, int j, const DerivativeSupport& );
    void setSupports(EOutArgsDgDx_mp arg, int j, const DerivativeSupport& );
    void setSupports(EOutArgsDgDp_mp arg, int j, int l, const DerivativeSupport& );
    void set_W_properties( const DerivativeProperties &properties );
    void set_WPrec_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_dotdot_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_DfDp_sg_properties( int l, const DerivativeProperties &properties );
    void set_DgDx_dot_sg_properties( int j, const DerivativeProperties &properties );
    void set_DgDx_dotdot_sg_properties( int j, const DerivativeProperties &properties );
    void set_DgDx_sg_properties( int j, const DerivativeProperties &properties );
    void set_DgDp_sg_properties( int j, int l, const DerivativeProperties &properties );
    void set_DfDp_mp_properties( int l, const DerivativeProperties &properties );
    void set_DgDx_dot_mp_properties( int j, const DerivativeProperties &properties );
    void set_DgDx_dotdot_mp_properties( int j, const DerivativeProperties &properties );
    void set_DgDx_mp_properties( int j, const DerivativeProperties &properties );
    void set_DgDp_mp_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::RCP<Epetra_Operator>
getLinearOp(
  const std::string &modelEvalDescription,
  const ModelEvaluator::Derivative &deriv,
  const std::string &derivName
  );

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

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

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

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

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

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

Teuchos::RCP<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
void ModelEvaluator::InArgs::set_x_dot( const Teuchos::RCP<const Epetra_Vector> &x_dot )
{ assert_supports(IN_ARG_x_dot); x_dot_ = x_dot; }
 
inline
void ModelEvaluator::InArgs::set_x_dotdot( const Teuchos::RCP<const Epetra_Vector> &x_dotdot )
{ assert_supports(IN_ARG_x_dotdot); x_dotdot_ = x_dotdot; }
 
inline
Teuchos::RCP<const Epetra_Vector> ModelEvaluator::InArgs::get_x_dot() const
{ assert_supports(IN_ARG_x_dot); return x_dot_; }
 
inline
Teuchos::RCP<const Epetra_Vector> ModelEvaluator::InArgs::get_x_dotdot() const
{ assert_supports(IN_ARG_x_dotdot); return x_dotdot_; }
 
inline
void ModelEvaluator::InArgs::set_x( const Teuchos::RCP<const Epetra_Vector> &x )
{ assert_supports(IN_ARG_x); x_ = x; }
 
inline
Teuchos::RCP<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::RCP<const Teuchos::Polynomial<Epetra_Vector> > &x_dot_poly )
{ assert_supports(IN_ARG_x_dot_poly); x_dot_poly_ = x_dot_poly; }
 
inline
void ModelEvaluator::InArgs::set_x_dotdot_poly( const Teuchos::RCP<const Teuchos::Polynomial<Epetra_Vector> > &x_dotdot_poly )
{ assert_supports(IN_ARG_x_dotdot_poly); x_dotdot_poly_ = x_dotdot_poly; }
 
inline
Teuchos::RCP<const Teuchos::Polynomial<Epetra_Vector> >
ModelEvaluator::InArgs::get_x_dot_poly() const
{ assert_supports(IN_ARG_x_dot_poly); return x_dot_poly_; }
 
inline
Teuchos::RCP<const Teuchos::Polynomial<Epetra_Vector> >
ModelEvaluator::InArgs::get_x_dotdot_poly() const
{ assert_supports(IN_ARG_x_dotdot_poly); return x_dotdot_poly_; }
 
inline
void ModelEvaluator::InArgs::set_x_poly( const Teuchos::RCP<const Teuchos::Polynomial<Epetra_Vector> > &x_poly )
{ assert_supports(IN_ARG_x_poly); x_poly_ = x_poly; }
 
inline
Teuchos::RCP<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
void ModelEvaluator::InArgs::set_x_dotdot_sg( const ModelEvaluator::InArgs::sg_const_vector_t &x_dotdot_sg )
{ assert_supports(IN_ARG_x_dotdot_sg); x_dotdot_sg_ = x_dotdot_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
ModelEvaluator::InArgs::sg_const_vector_t
ModelEvaluator::InArgs::get_x_dotdot_sg() const
{ assert_supports(IN_ARG_x_dotdot_sg); return x_dotdot_sg_; }
 
inline
void ModelEvaluator::InArgs::set_x_dot_mp( const ModelEvaluator::mp_const_vector_t &x_dot_mp )
{ assert_supports(IN_ARG_x_dot_mp); x_dot_mp_ = x_dot_mp; }
 
inline
void ModelEvaluator::InArgs::set_x_dotdot_mp( const ModelEvaluator::mp_const_vector_t &x_dotdot_mp )
{ assert_supports(IN_ARG_x_dotdot_mp); x_dotdot_mp_ = x_dotdot_mp; }
 
inline
ModelEvaluator::mp_const_vector_t
ModelEvaluator::InArgs::get_x_dot_mp() const
{ assert_supports(IN_ARG_x_dot_mp); return x_dot_mp_; }
 
inline
ModelEvaluator::mp_const_vector_t
ModelEvaluator::InArgs::get_x_dotdot_mp() const
{ assert_supports(IN_ARG_x_dotdot_mp); return x_dotdot_mp_; }
 
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_x_mp( const ModelEvaluator::mp_const_vector_t &x_mp )
{ assert_supports(IN_ARG_x_mp); x_mp_ = x_mp; }
 
inline
ModelEvaluator::mp_const_vector_t
ModelEvaluator::InArgs::get_x_mp() const
{ assert_supports(IN_ARG_x_mp); return x_mp_; }
 
inline
void ModelEvaluator::InArgs::set_p( int l, const Teuchos::RCP<const Epetra_Vector> &p_l )
{ assert_l(l); p_[l] = p_l; }
 
inline
Teuchos::RCP<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_supports(IN_ARG_p_sg, l); p_sg_[l] = p_sg_l; }
 
inline
ModelEvaluator::InArgs::sg_const_vector_t
ModelEvaluator::InArgs::get_p_sg(int l) const
{ assert_supports(IN_ARG_p_sg, l); return p_sg_[l]; }
 
inline
void ModelEvaluator::InArgs::set_p_mp( int l,
                                       const ModelEvaluator::mp_const_vector_t &p_mp_l )
{ assert_supports(IN_ARG_p_mp, l); p_mp_[l] = p_mp_l; }
 
inline
ModelEvaluator::mp_const_vector_t
ModelEvaluator::InArgs::get_p_mp(int l) const
{ assert_supports(IN_ARG_p_mp, l); return p_mp_[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_omega( double omega )
{ assert_supports(IN_ARG_omega); omega_ = omega; }
 
inline
double ModelEvaluator::InArgs::get_omega() const
{ assert_supports(IN_ARG_omega); return omega_; }
 
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::set_step_size( double step_size)
{ assert_supports(IN_ARG_step_size); step_size_ = step_size; }
 
inline
double ModelEvaluator::InArgs::get_step_size() const
{ assert_supports(IN_ARG_step_size); return step_size_; }
 
inline
void ModelEvaluator::InArgs::set_stage_number( int stage_number)
{ assert_supports(IN_ARG_stage_number); stage_number_ = stage_number; }
 
inline
int ModelEvaluator::InArgs::get_stage_number() const
{ assert_supports(IN_ARG_stage_number); return stage_number_; }
 
    inline
void ModelEvaluator::InArgs::set_sg_basis( const Teuchos::RCP<const Stokhos::OrthogPolyBasis<int,double> >& basis )
{ assert_supports(IN_ARG_sg_basis); sg_basis_ = basis; }
 
inline
Teuchos::RCP<const Stokhos::OrthogPolyBasis<int,double> >
ModelEvaluator::InArgs::get_sg_basis() const
{ assert_supports(IN_ARG_sg_basis); return sg_basis_; }
 
inline
void ModelEvaluator::InArgs::set_sg_quadrature( const Teuchos::RCP<const Stokhos::Quadrature<int,double> >& quad )
{ assert_supports(IN_ARG_sg_quadrature); sg_quad_ = quad; }
 
inline
Teuchos::RCP<const Stokhos::Quadrature<int,double> >
ModelEvaluator::InArgs::get_sg_quadrature() const
{ assert_supports(IN_ARG_sg_quadrature); return sg_quad_; }
 
inline
void ModelEvaluator::InArgs::set_sg_expansion( const Teuchos::RCP<Stokhos::OrthogPolyExpansion<int,double,Stokhos::StandardStorage<int,double> > >& exp )
{ assert_supports(IN_ARG_sg_expansion); sg_exp_ = exp; }
 
inline
Teuchos::RCP<Stokhos::OrthogPolyExpansion<int,double,Stokhos::StandardStorage<int,double> > >
ModelEvaluator::InArgs::get_sg_expansion() const
{ assert_supports(IN_ARG_sg_expansion); return sg_exp_; }
 
inline
void ModelEvaluator::InArgs::_setModelEvalDescription( const std::string &new_modelEvalDescription )
{
  modelEvalDescription_ = new_modelEvalDescription;
}
 
inline
void ModelEvaluator::InArgs::_set_Np(int new_Np)
{
  p_.resize(new_Np);
  p_sg_.resize(new_Np);
  p_mp_.resize(new_Np);
  supports_p_sg_.resize(new_Np);
  supports_p_mp_.resize(new_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
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_supports(OUT_ARG_g_sg, j);
  g_sg_[j] = g_sg_j;
}
 
inline
ModelEvaluator::OutArgs::sg_vector_t
ModelEvaluator::OutArgs::get_g_sg(int j) const
{
  assert_supports(OUT_ARG_g_sg, j);
  return g_sg_[j];
}
 
inline
void ModelEvaluator::OutArgs::set_g_mp( int j, const mp_vector_t &g_mp_j )
{
  assert_supports(OUT_ARG_g_mp, j);
  g_mp_[j] = g_mp_j;
}
 
inline
ModelEvaluator::mp_vector_t
ModelEvaluator::OutArgs::get_g_mp(int j) const
{
  assert_supports(OUT_ARG_g_mp, j);
  return g_mp_[j];
}
 
inline
void ModelEvaluator::OutArgs::set_W( const Teuchos::RCP<Epetra_Operator> &W ) { W_ = W; }
inline
void ModelEvaluator::OutArgs::set_WPrec( const Teuchos::RCP<Epetra_Operator> &WPrec ) { WPrec_ = WPrec; }
 
inline
Teuchos::RCP<Epetra_Operator> ModelEvaluator::OutArgs::get_W() const { return W_; }
inline
Teuchos::RCP<Epetra_Operator> ModelEvaluator::OutArgs::get_WPrec() const { return WPrec_; }
 
inline
ModelEvaluator::DerivativeProperties ModelEvaluator::OutArgs::get_W_properties() const
{ return W_properties_; }
inline
ModelEvaluator::DerivativeProperties ModelEvaluator::OutArgs::get_WPrec_properties() const
{ return WPrec_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_DfDp_sg( int l, const SGDerivative &DfDp_sg_l )
{
  assert_supports(OUT_ARG_DfDp_sg,l);
  DfDp_sg_[l] = DfDp_sg_l;
}
 
inline
ModelEvaluator::SGDerivative
ModelEvaluator::OutArgs::get_DfDp_sg(int l) const
{
  assert_supports(OUT_ARG_DfDp_sg,l);
  return DfDp_sg_[l];
}
 
inline
ModelEvaluator::DerivativeProperties
ModelEvaluator::OutArgs::get_DfDp_sg_properties(int l) const
{
  assert_supports(OUT_ARG_DfDp_sg,l);
  return DfDp_sg_properties_[l];
}
 
inline
void ModelEvaluator::OutArgs::set_DfDp_mp( int l, const MPDerivative &DfDp_mp_l )
{
  assert_supports(OUT_ARG_DfDp_mp,l);
  DfDp_mp_[l] = DfDp_mp_l;
}
 
inline
ModelEvaluator::MPDerivative
ModelEvaluator::OutArgs::get_DfDp_mp(int l) const
{
  assert_supports(OUT_ARG_DfDp_mp,l);
  return DfDp_mp_[l];
}
 
inline
ModelEvaluator::DerivativeProperties
ModelEvaluator::OutArgs::get_DfDp_mp_properties(int l) const
{
  assert_supports(OUT_ARG_DfDp_mp,l);
  return DfDp_mp_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_dot_sg( int j, const SGDerivative &DgDx_dot_sg_j )
{
  assert_supports(OUT_ARG_DgDx_dot_sg,j);
  DgDx_dot_sg_[j] = DgDx_dot_sg_j;
}
 
inline
ModelEvaluator::SGDerivative
ModelEvaluator::OutArgs::get_DgDx_dot_sg(int j) const
{
  assert_supports(OUT_ARG_DgDx_dot_sg,j);
  return DgDx_dot_sg_[j];
}
 
inline
ModelEvaluator::DerivativeProperties
ModelEvaluator::OutArgs::get_DgDx_dot_sg_properties(int j) const
{
  assert_supports(OUT_ARG_DgDx_dot_sg,j);
  return DgDx_dot_sg_properties_[j];
}
 
inline
void ModelEvaluator::OutArgs::set_DgDx_dot_mp( int j, const MPDerivative &DgDx_dot_mp_j )
{
  assert_supports(OUT_ARG_DgDx_dot_mp,j);
  DgDx_dot_mp_[j] = DgDx_dot_mp_j;
}
 
inline
ModelEvaluator::MPDerivative
ModelEvaluator::OutArgs::get_DgDx_dot_mp(int j) const
{
  assert_supports(OUT_ARG_DgDx_dot_mp,j);
  return DgDx_dot_mp_[j];
}
 
inline
ModelEvaluator::DerivativeProperties
ModelEvaluator::OutArgs::get_DgDx_dot_mp_properties(int j) const
{
  assert_supports(OUT_ARG_DgDx_dot_mp,j);
  return DgDx_dot_mp_properties_[j];
}
 
inline
void ModelEvaluator::OutArgs::set_DgDx_dotdot( int j, const Derivative &DgDx_dotdot_j )
{
  assert_supports(OUT_ARG_DgDx_dotdot,j);
  DgDx_dotdot_[j] = DgDx_dotdot_j;
}
 
inline
ModelEvaluator::Derivative
ModelEvaluator::OutArgs::get_DgDx_dotdot(int j) const
{
  assert_supports(OUT_ARG_DgDx_dotdot,j);
  return DgDx_dotdot_[j];
}
 
inline
ModelEvaluator::DerivativeProperties
ModelEvaluator::OutArgs::get_DgDx_dotdot_properties(int j) const
{
  assert_supports(OUT_ARG_DgDx_dotdot,j);
  return DgDx_dotdot_properties_[j];
}
 
inline
void ModelEvaluator::OutArgs::set_DgDx_dotdot_sg( int j, const SGDerivative &DgDx_dotdot_sg_j )
{
  assert_supports(OUT_ARG_DgDx_dotdot_sg,j);
  DgDx_dotdot_sg_[j] = DgDx_dotdot_sg_j;
}
 
inline
ModelEvaluator::SGDerivative
ModelEvaluator::OutArgs::get_DgDx_dotdot_sg(int j) const
{
  assert_supports(OUT_ARG_DgDx_dotdot_sg,j);
  return DgDx_dotdot_sg_[j];
}
 
inline
ModelEvaluator::DerivativeProperties
ModelEvaluator::OutArgs::get_DgDx_dotdot_sg_properties(int j) const
{
  assert_supports(OUT_ARG_DgDx_dotdot_sg,j);
  return DgDx_dotdot_sg_properties_[j];
}
 
inline
void ModelEvaluator::OutArgs::set_DgDx_dotdot_mp( int j, const MPDerivative &DgDx_dotdot_mp_j )
{
  assert_supports(OUT_ARG_DgDx_dotdot_mp,j);
  DgDx_dotdot_mp_[j] = DgDx_dotdot_mp_j;
}
 
inline
ModelEvaluator::MPDerivative
ModelEvaluator::OutArgs::get_DgDx_dotdot_mp(int j) const
{
  assert_supports(OUT_ARG_DgDx_dotdot_mp,j);
  return DgDx_dotdot_mp_[j];
}
 
inline
ModelEvaluator::DerivativeProperties
ModelEvaluator::OutArgs::get_DgDx_dotdot_mp_properties(int j) const
{
  assert_supports(OUT_ARG_DgDx_dotdot_mp,j);
  return DgDx_dotdot_mp_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_DgDx_sg( int j, const SGDerivative &DgDx_sg_j )
{
  assert_supports(OUT_ARG_DgDx_sg,j);
  DgDx_sg_[j] = DgDx_sg_j;
}
 
inline
ModelEvaluator::SGDerivative
ModelEvaluator::OutArgs::get_DgDx_sg(int j) const
{
  assert_supports(OUT_ARG_DgDx_sg,j);
  return DgDx_sg_[j];
}
 
inline
ModelEvaluator::DerivativeProperties
ModelEvaluator::OutArgs::get_DgDx_sg_properties(int j) const
{
  assert_supports(OUT_ARG_DgDx_sg,j);
  return DgDx_sg_properties_[j];
}
 
inline
void ModelEvaluator::OutArgs::set_DgDx_mp( int j, const MPDerivative &DgDx_mp_j )
{
  assert_supports(OUT_ARG_DgDx_mp,j);
  DgDx_mp_[j] = DgDx_mp_j;
}
 
inline
ModelEvaluator::MPDerivative
ModelEvaluator::OutArgs::get_DgDx_mp(int j) const
{
  assert_supports(OUT_ARG_DgDx_mp,j);
  return DgDx_mp_[j];
}
 
inline
ModelEvaluator::DerivativeProperties
ModelEvaluator::OutArgs::get_DgDx_mp_properties(int j) const
{
  assert_supports(OUT_ARG_DgDx_mp,j);
  return DgDx_mp_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 SGDerivative &DgDp_sg_j_l )
{
  assert_supports(OUT_ARG_DgDp_sg,j,l);
  DgDp_sg_[ j*Np() + l ] = DgDp_sg_j_l;
}
 
inline
ModelEvaluator::SGDerivative
ModelEvaluator::OutArgs::get_DgDp_sg(int j, int l) const
{
  assert_supports(OUT_ARG_DgDp_sg,j,l);
  return DgDp_sg_[ j*Np() + 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() + l ];
}
 
inline
void ModelEvaluator::OutArgs::set_DgDp_mp( int j, int l, const MPDerivative &DgDp_mp_j_l )
{
  assert_supports(OUT_ARG_DgDp_mp,j,l);
  DgDp_mp_[ j*Np() + l ] = DgDp_mp_j_l;
}
 
inline
ModelEvaluator::MPDerivative
ModelEvaluator::OutArgs::get_DgDp_mp(int j, int l) const
{
  assert_supports(OUT_ARG_DgDp_mp,j,l);
  return DgDp_mp_[ j*Np() + l ];
}
 
inline
ModelEvaluator::DerivativeProperties
ModelEvaluator::OutArgs::get_DgDp_mp_properties(int j, int l) const
{
  assert_supports(OUT_ARG_DgDp_mp,j,l);
  return DgDp_mp_properties_[ j*Np() + l ];
}
 
inline
void ModelEvaluator::OutArgs::set_f_poly( const Teuchos::RCP<Teuchos::Polynomial<Epetra_Vector> > &f_poly )
{ f_poly_ = f_poly; }
 
inline
Teuchos::RCP<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_; }
 
inline
void ModelEvaluator::OutArgs::set_f_mp( const ModelEvaluator::mp_vector_t& f_mp )
{ f_mp_ = f_mp; }
 
inline
ModelEvaluator::mp_vector_t
ModelEvaluator::OutArgs::get_f_mp() const
{ return f_mp_; }
 
inline
void ModelEvaluator::OutArgs::set_W_mp( const ModelEvaluator::mp_operator_t& W_mp ) { W_mp_ = W_mp; }
 
inline
ModelEvaluator::mp_operator_t ModelEvaluator::OutArgs::get_W_mp() const { return W_mp_; }
 
//
// ModelEvaluator::InArgsSetup
//
 
inline
void ModelEvaluator::InArgsSetup::setModelEvalDescription( const std::string &new_modelEvalDescription )
{
  this->_setModelEvalDescription(new_modelEvalDescription);
}
 
inline
void ModelEvaluator::InArgsSetup::set_Np(int new_Np)
{ this->_set_Np(new_Np); }
 
inline
void ModelEvaluator::InArgsSetup::setSupports( EInArgsMembers arg, bool new_supports )
{ this->_setSupports(arg,new_supports); }
 
inline
void ModelEvaluator::InArgsSetup::setSupports( EInArgs_p_sg arg, int l, bool new_supports )
{ this->_setSupports(arg,l,new_supports); }
 
inline
void ModelEvaluator::InArgsSetup::setSupports( EInArgs_p_mp arg, int l, bool new_supports )
{ this->_setSupports(arg,l,new_supports); }
 
//
// ModelEvaluator::OutArgsSetup
//
 
inline
void ModelEvaluator::OutArgsSetup::setModelEvalDescription( const std::string &new_modelEvalDescription )
{
  this->_setModelEvalDescription(new_modelEvalDescription);
}
 
inline
void ModelEvaluator::OutArgsSetup::set_Np_Ng(int new_Np, int new_Ng)
{ this->_set_Np_Ng(new_Np,new_Ng); }
 
inline
void ModelEvaluator::OutArgsSetup::setSupports( EOutArgsMembers arg, bool new_supports )
{ this->_setSupports(arg,new_supports); }
 
inline
void ModelEvaluator::OutArgsSetup::setSupports( EOutArgsDfDp arg, int l, const DerivativeSupport& new_supports )
{ this->_setSupports(arg,l,new_supports); }
 
inline
void ModelEvaluator::OutArgsSetup::setSupports( EOutArgsDgDx_dot arg, int j, const DerivativeSupport& new_supports )
{ this->_setSupports(arg,j,new_supports); }
 
inline
void ModelEvaluator::OutArgsSetup::setSupports( EOutArgsDgDx_dotdot arg, int j, const DerivativeSupport& new_supports )
{ this->_setSupports(arg,j,new_supports); }
 
inline
void ModelEvaluator::OutArgsSetup::setSupports( EOutArgsDgDx arg, int j, const DerivativeSupport& new_supports )
{ this->_setSupports(arg,j,new_supports); }
 
inline
void ModelEvaluator::OutArgsSetup::setSupports( EOutArgsDgDp arg, int j, int l, const DerivativeSupport& new_supports )
{ this->_setSupports(arg,j,l,new_supports); }
 
inline
void ModelEvaluator::OutArgsSetup::setSupports( EOutArgs_g_sg arg, int j, bool new_supports )
{ this->_setSupports(arg,j,new_supports); }
 
inline
void ModelEvaluator::OutArgsSetup::setSupports( EOutArgsDfDp_sg arg, int l, const DerivativeSupport& new_supports )
{ this->_setSupports(arg,l,new_supports); }
 
inline
void ModelEvaluator::OutArgsSetup::setSupports( EOutArgsDgDx_dot_sg arg, int j, const DerivativeSupport& new_supports )
{ this->_setSupports(arg,j,new_supports); }
 
inline
void ModelEvaluator::OutArgsSetup::setSupports( EOutArgsDgDx_dotdot_sg arg, int j, const DerivativeSupport& new_supports )
{ this->_setSupports(arg,j,new_supports); }
 
inline
void ModelEvaluator::OutArgsSetup::setSupports( EOutArgsDgDx_sg arg, int j, const DerivativeSupport& new_supports )
{ this->_setSupports(arg,j,new_supports); }
 
inline
void ModelEvaluator::OutArgsSetup::setSupports( EOutArgsDgDp_sg arg, int j, int l, const DerivativeSupport& new_supports )
{ this->_setSupports(arg,j,l,new_supports); }
 
inline
void ModelEvaluator::OutArgsSetup::setSupports( EOutArgs_g_mp arg, int j, bool new_supports )
{ this->_setSupports(arg,j,new_supports); }
 
inline
void ModelEvaluator::OutArgsSetup::setSupports( EOutArgsDfDp_mp arg, int l, const DerivativeSupport& new_supports )
{ this->_setSupports(arg,l,new_supports); }
 
inline
void ModelEvaluator::OutArgsSetup::setSupports( EOutArgsDgDx_dot_mp arg, int j, const DerivativeSupport& new_supports )
{ this->_setSupports(arg,j,new_supports); }
 
inline
void ModelEvaluator::OutArgsSetup::setSupports( EOutArgsDgDx_dotdot_mp arg, int j, const DerivativeSupport& new_supports )
{ this->_setSupports(arg,j,new_supports); }
 
inline
void ModelEvaluator::OutArgsSetup::setSupports( EOutArgsDgDx_mp arg, int j, const DerivativeSupport& new_supports )
{ this->_setSupports(arg,j,new_supports); }
 
inline
void ModelEvaluator::OutArgsSetup::setSupports( EOutArgsDgDp_mp arg, int j, int l, const DerivativeSupport& new_supports )
{ this->_setSupports(arg,j,l,new_supports); }
 
inline
void ModelEvaluator::OutArgsSetup::set_W_properties( const DerivativeProperties &properties )
{ this->_set_W_properties(properties); }
inline
void ModelEvaluator::OutArgsSetup::set_WPrec_properties( const DerivativeProperties &properties )
{ this->_set_WPrec_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_dotdot_properties( int j, const DerivativeProperties &properties )
{
  this->_set_DgDx_dotdot_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_DfDp_sg_properties( int l, const DerivativeProperties &properties )
{
  this->_set_DfDp_sg_properties(l,properties);
}
 
inline
void ModelEvaluator::OutArgsSetup::set_DgDx_dot_sg_properties( int j, const DerivativeProperties &properties )
{
  this->_set_DgDx_dot_sg_properties(j,properties);
}
 
inline
void ModelEvaluator::OutArgsSetup::set_DgDx_dotdot_sg_properties( int j, const DerivativeProperties &properties )
{
  this->_set_DgDx_dotdot_sg_properties(j,properties);
}
 
inline
void ModelEvaluator::OutArgsSetup::set_DgDx_sg_properties( int j, const DerivativeProperties &properties )
{
  this->_set_DgDx_sg_properties(j,properties);
}
 
inline
void ModelEvaluator::OutArgsSetup::set_DgDp_sg_properties( int j, int l, const DerivativeProperties &properties )
{
  this->_set_DgDp_sg_properties(j,l,properties);
}
 
inline
void ModelEvaluator::OutArgsSetup::set_DfDp_mp_properties( int l, const DerivativeProperties &properties )
{
  this->_set_DfDp_mp_properties(l,properties);
}
 
inline
void ModelEvaluator::OutArgsSetup::set_DgDx_dot_mp_properties( int j, const DerivativeProperties &properties )
{
  this->_set_DgDx_dot_mp_properties(j,properties);
}
 
inline
void ModelEvaluator::OutArgsSetup::set_DgDx_dotdot_mp_properties( int j, const DerivativeProperties &properties )
{
  this->_set_DgDx_dotdot_mp_properties(j,properties);
}
 
inline
void ModelEvaluator::OutArgsSetup::set_DgDx_mp_properties( int j, const DerivativeProperties &properties )
{
  this->_set_DgDx_mp_properties(j,properties);
}
 
inline
void ModelEvaluator::OutArgsSetup::set_DgDp_mp_properties( int j, int l, const DerivativeProperties &properties )
{
  this->_set_DgDp_mp_properties(j,l,properties);
}
 
} // namespace EpetraExt
 
#endif // EPETRA_EXT_MODEL_EVALUATOR_HPP