Rythmos_StateAndForwardSensitivityModelEvaluator.hpp

//@HEADER
// ***********************************************************************
//
//                           Rythmos Package
//                 Copyright (2006) 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
// USA
// Questions? Contact Todd S. Coffey (tscoffe@sandia.gov)
//
// ***********************************************************************
//@HEADER

#ifndef RYTHMOS_STATE_AND_FORWARD_SENSITIVITY_MODEL_EVALUATOR_HPP
#define RYTHMOS_STATE_AND_FORWARD_SENSITIVITY_MODEL_EVALUATOR_HPP


#include "Rythmos_ForwardSensitivityModelEvaluatorBase.hpp"
#include "Thyra_ModelEvaluator.hpp" // Interface
#include "Thyra_StateFuncModelEvaluatorBase.hpp" // Implementation
#include "Thyra_DefaultProductVectorSpace.hpp"
#include "Thyra_ModelEvaluatorDelegatorBase.hpp"
#include "Thyra_DefaultMultiVectorProductVectorSpace.hpp"
#include "Thyra_DefaultMultiVectorProductVector.hpp"
#include "Thyra_DefaultMultiVectorLinearOpWithSolve.hpp"
#include "Teuchos_implicit_cast.hpp"


namespace Rythmos {


template<class Scalar>
class StateAndForwardSensitivityModelEvaluator
  : virtual public Thyra::StateFuncModelEvaluatorBase<Scalar>
{
public:


  StateAndForwardSensitivityModelEvaluator();

  void initializeStructure(
    const Teuchos::RCP<const ForwardSensitivityModelEvaluatorBase<Scalar> > &sensModel
    );

  // 2007/05/30: rabartl: ToDo: Add function to set the nominal values etc.

  Teuchos::RCP<const Thyra::DefaultProductVector<Scalar> >
  create_x_bar_vec(
    const Teuchos::RCP<const Thyra::VectorBase<Scalar> > &x_vec,
    const Teuchos::RCP<const Thyra::VectorBase<Scalar> > &s_bar_vec
    ) const;



  int Np() const;
  Teuchos::RCP<const Thyra::VectorSpaceBase<Scalar> > get_p_space(int l) const;
  Teuchos::RCP<const Teuchos::Array<std::string> > get_p_names(int l) const;
  Teuchos::RCP<const Thyra::VectorSpaceBase<Scalar> > get_x_space() const;
  Teuchos::RCP<const Thyra::VectorSpaceBase<Scalar> > get_f_space() const;
  Thyra::ModelEvaluatorBase::InArgs<Scalar> getNominalValues() const;
  Teuchos::RCP<Thyra::LinearOpWithSolveBase<Scalar> > create_W() const;
  Thyra::ModelEvaluatorBase::InArgs<Scalar> createInArgs() const;


private:


  Thyra::ModelEvaluatorBase::OutArgs<Scalar> createOutArgsImpl() const;
  void evalModelImpl(
    const Thyra::ModelEvaluatorBase::InArgs<Scalar> &inArgs,
    const Thyra::ModelEvaluatorBase::OutArgs<Scalar> &outArgs
    ) const;


private:

  // /////////////////////////
  // Private data members

  Teuchos::RCP<const ForwardSensitivityModelEvaluatorBase<Scalar> > sensModel_;

  int Np_;
  Teuchos::RCP<const Thyra::DefaultProductVectorSpace<Scalar> > x_bar_space_;
  Teuchos::RCP<const Thyra::DefaultProductVectorSpace<Scalar> > f_bar_space_;
  
};


// /////////////////////////////////
// Implementations


// Constructors/Intializers/Accessors


template<class Scalar>
StateAndForwardSensitivityModelEvaluator<Scalar>::StateAndForwardSensitivityModelEvaluator()
  :Np_(0)
{}


template<class Scalar>
void StateAndForwardSensitivityModelEvaluator<Scalar>::initializeStructure(
  const Teuchos::RCP<const ForwardSensitivityModelEvaluatorBase<Scalar> > &sensModel
  )
{

  using Teuchos::tuple; using Teuchos::RCP;

  TEUCHOS_TEST_FOR_EXCEPT( is_null(sensModel) );
  
  sensModel_ = sensModel;

  const Teuchos::RCP<const Thyra::ModelEvaluator<Scalar> >
    stateModel = sensModel_->getStateModel();
  
  x_bar_space_ = Thyra::productVectorSpace<Scalar>(
    tuple<RCP<const Thyra::VectorSpaceBase<Scalar> > >(
      stateModel->get_x_space(), sensModel_->get_x_space()
      )
    );

  f_bar_space_ = Thyra::productVectorSpace<Scalar>(
    tuple<RCP<const Thyra::VectorSpaceBase<Scalar> > >(
      stateModel->get_f_space(), sensModel_->get_f_space()
      )
    );

  Np_ = stateModel->Np();

}


template<class Scalar> 
Teuchos::RCP<const Thyra::DefaultProductVector<Scalar> >
StateAndForwardSensitivityModelEvaluator<Scalar>::create_x_bar_vec(
  const Teuchos::RCP<const Thyra::VectorBase<Scalar> > &x_vec,
  const Teuchos::RCP<const Thyra::VectorBase<Scalar> > &s_bar_vec
  ) const
{

  using Teuchos::tuple;
  using Teuchos::RCP;
  typedef RCP<const Thyra::VectorBase<Scalar> > RCPCV;

  return Thyra::defaultProductVector<Scalar>(
    x_bar_space_, tuple<RCPCV>(x_vec,s_bar_vec)
    );

}


// Public functions overridden from ModelEvaulator


template<class Scalar>
int StateAndForwardSensitivityModelEvaluator<Scalar>::Np() const
{
  return Np_;
}


template<class Scalar>
Teuchos::RCP<const Thyra::VectorSpaceBase<Scalar> >
StateAndForwardSensitivityModelEvaluator<Scalar>::get_p_space(int l) const
{
  return sensModel_->getStateModel()->get_p_space(l);
}


template<class Scalar>
Teuchos::RCP<const Teuchos::Array<std::string> >
StateAndForwardSensitivityModelEvaluator<Scalar>::get_p_names(int l) const
{
  return sensModel_->getStateModel()->get_p_names(l);
}


template<class Scalar>
Teuchos::RCP<const Thyra::VectorSpaceBase<Scalar> >
StateAndForwardSensitivityModelEvaluator<Scalar>::get_x_space() const
{
  return x_bar_space_;
}


template<class Scalar>
Teuchos::RCP<const Thyra::VectorSpaceBase<Scalar> >
StateAndForwardSensitivityModelEvaluator<Scalar>::get_f_space() const
{
  return f_bar_space_;
}


template<class Scalar>
Thyra::ModelEvaluatorBase::InArgs<Scalar>
StateAndForwardSensitivityModelEvaluator<Scalar>::getNominalValues() const
{
  return this->createInArgs();
}


template<class Scalar>
Teuchos::RCP<Thyra::LinearOpWithSolveBase<Scalar> >
StateAndForwardSensitivityModelEvaluator<Scalar>::create_W() const
{
  TEUCHOS_TEST_FOR_EXCEPT("ToDo: Implement create_W() when needed!");
  return Teuchos::null;
}


template<class Scalar>
Thyra::ModelEvaluatorBase::InArgs<Scalar>
StateAndForwardSensitivityModelEvaluator<Scalar>::createInArgs() const
{
  typedef Thyra::ModelEvaluatorBase MEB;
  MEB::InArgs<Scalar>
    stateModelInArgs = sensModel_->getStateModel()->createInArgs();
  MEB::InArgsSetup<Scalar> inArgs;
  inArgs.setModelEvalDescription(this->description());
  inArgs.set_Np(Np_);
  inArgs.setSupports( MEB::IN_ARG_x_dot,
    stateModelInArgs.supports(MEB::IN_ARG_x_dot) );
  inArgs.setSupports( MEB::IN_ARG_x );
  inArgs.setSupports( MEB::IN_ARG_t );
  inArgs.setSupports( MEB::IN_ARG_alpha,
    stateModelInArgs.supports(MEB::IN_ARG_alpha) );
  inArgs.setSupports( MEB::IN_ARG_beta,
    stateModelInArgs.supports(MEB::IN_ARG_beta) );
  return inArgs;
}


// Private functions overridden from ModelEvaulatorDefaultBase


template<class Scalar>
Thyra::ModelEvaluatorBase::OutArgs<Scalar>
StateAndForwardSensitivityModelEvaluator<Scalar>::createOutArgsImpl() const
{
  typedef Thyra::ModelEvaluatorBase MEB;
  MEB::OutArgs<Scalar>
    stateModelOutArgs = sensModel_->getStateModel()->createOutArgs();
  MEB::OutArgsSetup<Scalar> outArgs;
  outArgs.setModelEvalDescription(this->description());
  outArgs.set_Np_Ng(Np_,0);
  outArgs.setSupports(MEB::OUT_ARG_f);
  if (stateModelOutArgs.supports(MEB::OUT_ARG_W) ) {
    outArgs.setSupports(MEB::OUT_ARG_W);
    outArgs.set_W_properties(stateModelOutArgs.get_W_properties());
  }
  return outArgs;
}


template<class Scalar>
void StateAndForwardSensitivityModelEvaluator<Scalar>::evalModelImpl(
  const Thyra::ModelEvaluatorBase::InArgs<Scalar> &/* inArgs */,
  const Thyra::ModelEvaluatorBase::OutArgs<Scalar> &/* outArgs */
  ) const
{
  TEUCHOS_TEST_FOR_EXCEPT("ToDo: Implement evalModel(...) when needed!");
}


} // namespace Rythmos


#endif // RYTHMOS_STATE_AND_FORWARD_SENSITIVITY_MODEL_EVALUATOR_HPP