Thyra_DefaultMultiPeriodModelEvaluator.hpp

Go to the documentation of this file.

// @HEADER
// ***********************************************************************
// 
//    Thyra: Interfaces and Support for Abstract Numerical Algorithms
//                 Copyright (2004) 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 THYRA_DEFAULT_MULTI_PERIOD_MODEL_EVALUATOR_HPP
#define THYRA_DEFAULT_MULTI_PERIOD_MODEL_EVALUATOR_HPP

#include "Thyra_ModelEvaluator.hpp"

namespace Thyra {

template<class Scalar>
class DefaultMultiPeriodModelEvaluator : virtual public ModelEvaluator<Scalar> {
public:


  DefaultMultiPeriodModelEvaluator();

  DefaultMultiPeriodModelEvaluator(
    const int                                                     N
    ,const Teuchos::RefCountPtr<ModelEvaluator<Scalar> >          models[]
    ,const Scalar                                                 weights[]
    ,const Teuchos::RefCountPtr<const VectorBase<Scalar> >        z[]
    ,const int                                                    z_index
    ,const Teuchos::RefCountPtr<ProductVectorSpaceBase<Scalar> >  &x_bar_space = Teuchos::null
    ,const Teuchos::RefCountPtr<ProductVectorSpaceBase<Scalar> >  &f_bar_space = Teuchos::null
    //,const AbstractFactory<BlockLinearOpWithSolveBase<Scalar> >   &blockLOWSFF = Teuchos::null
    );

  void initialize(
    const int                                                     N
    ,const Teuchos::RefCountPtr<ModelEvaluator<Scalar> >          models[]
    ,const Scalar                                                 weights[]
    ,const Teuchos::RefCountPtr<const VectorBase<Scalar> >        z[]
    ,const int                                                    z_index
    ,const Teuchos::RefCountPtr<ProductVectorSpaceBase<Scalar> >  &x_bar_space = Teuchos::null
    ,const Teuchos::RefCountPtr<ProductVectorSpaceBase<Scalar> >  &f_bar_space = Teuchos::null
    //,const AbstractFactory<BlockLinearOpWithSolveBase<Scalar> >   &blockLOWSFF = Teuchos::null
    );
  // ToDo: To be more general we would have to define a z_index for each
  // *models[i] object and we would need parameter index maps to map from the
  // parameter subvectors in *models[i] to the a "global" list of parameter
  // subvectors.  This could be added as a different initialization function
  // for the more general use case.
  


  int Np() const;
  int Ng() const;
  Teuchos::RefCountPtr<const VectorSpaceBase<Scalar> > get_x_space() const;
  Teuchos::RefCountPtr<const VectorSpaceBase<Scalar> > get_f_space() const;
  Teuchos::RefCountPtr<const VectorSpaceBase<Scalar> > get_p_space(int l) const;
  Teuchos::RefCountPtr<const VectorSpaceBase<Scalar> > get_g_space(int j) const;
  ModelEvaluatorBase::InArgs<Scalar> getNominalValues() const;
  ModelEvaluatorBase::InArgs<Scalar> getLowerBounds() const;
  ModelEvaluatorBase::InArgs<Scalar> getUpperBounds() const;
  Teuchos::RefCountPtr<LinearOpWithSolveBase<Scalar> > create_W() const;
  Teuchos::RefCountPtr<LinearOpBase<Scalar> > create_W_op() const;
  Teuchos::RefCountPtr<LinearOpBase<Scalar> > create_DfDp_op(int l) const;
  Teuchos::RefCountPtr<LinearOpBase<Scalar> > create_DgDx_op(int j) const;
  Teuchos::RefCountPtr<LinearOpBase<Scalar> > create_DgDp_op( int j, int l ) const;
  ModelEvaluatorBase::InArgs<Scalar> createInArgs() const;
  ModelEvaluatorBase::OutArgs<Scalar> createOutArgs() const;
  void evalModel(
    const ModelEvaluatorBase::InArgs<Scalar>       &inArgs
    ,const ModelEvaluatorBase::OutArgs<Scalar>     &outArgs
    ) const;
  void reportFinalPoint(
    const ModelEvaluatorBase::InArgs<Scalar>      &finalPoint
    ,const bool                                   wasSolved
    );


private:

  // //////////////////////////
  // Private types

  typedef std::vector<Teuchos::RefCountPtr<ModelEvaluator<Scalar> > >    models_t;
  typedef std::vector<Scalar>                                            weights_t;
  typedef std::vector<Teuchos::RefCountPtr<const VectorBase<Scalar> > >  z_t;

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

  models_t                                               models_;  // size == N
  weights_t                                              weights_; // size == N
  z_t                                                    z_;       // size == N
  int                                                    z_index_;
  Teuchos::RefCountPtr<ProductVectorSpaceBase<Scalar> >  x_bar_space_;
  Teuchos::RefCountPtr<ProductVectorSpaceBase<Scalar> >  f_bar_space_;
  
};

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

// Constructors/Intializers/Accessors

template<class Scalar>
DefaultMultiPeriodModelEvaluator<Scalar>::DefaultMultiPeriodModelEvaluator()
  :z_index_(-1)
{}

template<class Scalar>
DefaultMultiPeriodModelEvaluator<Scalar>::DefaultMultiPeriodModelEvaluator(
  const int                                                     N
  ,const Teuchos::RefCountPtr<ModelEvaluator<Scalar> >          models[]
  ,const Scalar                                                 weights[]
  ,const Teuchos::RefCountPtr<const VectorBase<Scalar> >        z[]
  ,const int                                                    z_index
  ,const Teuchos::RefCountPtr<ProductVectorSpaceBase<Scalar> >  &x_bar_space
  ,const Teuchos::RefCountPtr<ProductVectorSpaceBase<Scalar> >  &f_bar_space
  //,const AbstractFactory<BlockLinearOpWithSolveBase<Scalar> >   &blockLOWSFF
  )
{
  initialize(N,models,weights,z,z_index,x_bar_space,f_bar_space);
}

template<class Scalar>
void DefaultMultiPeriodModelEvaluator<Scalar>::initialize(
  const int                                                     N
  ,const Teuchos::RefCountPtr<ModelEvaluator<Scalar> >          models[]
  ,const Scalar                                                 weights[]
  ,const Teuchos::RefCountPtr<const VectorBase<Scalar> >        z[]
  ,const int                                                    z_index
  ,const Teuchos::RefCountPtr<ProductVectorSpaceBase<Scalar> >  &x_bar_space
  ,const Teuchos::RefCountPtr<ProductVectorSpaceBase<Scalar> >  &f_bar_space
  //,const AbstractFactory<BlockLinearOpWithSolveBase<Scalar> >   &blockLOWSFF
  )
{
  typedef Teuchos::ScalarTraits<Scalar> ST;
  TEST_FOR_EXCEPT(!(N>0));
  TEST_FOR_EXCEPT(!(models));
  TEST_FOR_EXCEPT(!((z_index>=0&&z!=NULL)||(z_index==0&&z==NULL)));
  models_.resize(N);
  weights_.resize(N);
  z_.resize(N);
  z_index_ = z_index;
  for( int i = 0; i < N; ++i ) {
    models_[i] = models[i].assert_not_null();
    weights_[i] = ( weights ? weights[i] : ST::one() );
    if( z && z[i].get() )
      z_[i] = z[i];
    else
      z_[i] = Teuchos::null;
  }
  if( x_bar_space.get() ) {
    TEST_FOR_EXCEPT(!(x_bar_space->numBlocks()==N));
    // ToDo: Check the constituent spaces more carefully against models[]->get_x_space().
    x_bar_space_ = x_bar_space;
  }
  else {
    TEST_FOR_EXCEPT(true); // ToDo: Create our own product space!
  }
  if( f_bar_space.get() ) {
    TEST_FOR_EXCEPT(!(f_bar_space->numBlocks()==N));
    // ToDo: Check the constituent spaces more carefully against models[]->get_f_space().
    f_bar_space_ = f_bar_space;
  }
  else {
    TEST_FOR_EXCEPT(true); // ToDo: Create our own product space!
  }
}

// Public functions overridden from ModelEvaulator

template<class Scalar>
int DefaultMultiPeriodModelEvaluator<Scalar>::Np() const
{
  TEST_FOR_EXCEPT(true);
  return 0;
}

template<class Scalar>
int DefaultMultiPeriodModelEvaluator<Scalar>::Ng() const
{
  TEST_FOR_EXCEPT(true);
  return 0;
}

template<class Scalar>
Teuchos::RefCountPtr<const VectorSpaceBase<Scalar> >
DefaultMultiPeriodModelEvaluator<Scalar>::get_x_space() const
{
  TEST_FOR_EXCEPT(true);
  return Teuchos::null;
}

template<class Scalar>
Teuchos::RefCountPtr<const VectorSpaceBase<Scalar> >
DefaultMultiPeriodModelEvaluator<Scalar>::get_f_space() const
{
  TEST_FOR_EXCEPT(true);
  return Teuchos::null;
}

template<class Scalar>
Teuchos::RefCountPtr<const VectorSpaceBase<Scalar> >
DefaultMultiPeriodModelEvaluator<Scalar>::get_p_space(int l) const
{
  TEST_FOR_EXCEPT(true);
  return Teuchos::null;
}

template<class Scalar>
Teuchos::RefCountPtr<const VectorSpaceBase<Scalar> >
DefaultMultiPeriodModelEvaluator<Scalar>::get_g_space(int j) const
{
  TEST_FOR_EXCEPT(true);
  return Teuchos::null;
}

template<class Scalar>
ModelEvaluatorBase::InArgs<Scalar>
DefaultMultiPeriodModelEvaluator<Scalar>::getNominalValues() const
{
  TEST_FOR_EXCEPT(true);
  return ModelEvaluatorBase::InArgs<Scalar>();
}

template<class Scalar>
ModelEvaluatorBase::InArgs<Scalar>
DefaultMultiPeriodModelEvaluator<Scalar>::getLowerBounds() const
{
  TEST_FOR_EXCEPT(true);
  return ModelEvaluatorBase::InArgs<Scalar>();
}

template<class Scalar>
ModelEvaluatorBase::InArgs<Scalar>
DefaultMultiPeriodModelEvaluator<Scalar>::getUpperBounds() const
{
  TEST_FOR_EXCEPT(true);
  return ModelEvaluatorBase::InArgs<Scalar>();
}

template<class Scalar>
Teuchos::RefCountPtr<LinearOpWithSolveBase<Scalar> >
DefaultMultiPeriodModelEvaluator<Scalar>::create_W() const
{
  TEST_FOR_EXCEPT(true);
  return Teuchos::null; // Should never be called!
}

template<class Scalar>
Teuchos::RefCountPtr<LinearOpBase<Scalar> >
DefaultMultiPeriodModelEvaluator<Scalar>::create_W_op() const
{
  TEST_FOR_EXCEPT(true);
  return Teuchos::null; // Should never be called!
}

template<class Scalar>
Teuchos::RefCountPtr<LinearOpBase<Scalar> >
DefaultMultiPeriodModelEvaluator<Scalar>::create_DfDp_op(int l) const
{
  TEST_FOR_EXCEPT(true);
  return Teuchos::null;
}

template<class Scalar>
Teuchos::RefCountPtr<LinearOpBase<Scalar> >
DefaultMultiPeriodModelEvaluator<Scalar>::create_DgDx_op(int j) const
{
  TEST_FOR_EXCEPT(true);
  return Teuchos::null;
}

template<class Scalar>
Teuchos::RefCountPtr<LinearOpBase<Scalar> >
DefaultMultiPeriodModelEvaluator<Scalar>::create_DgDp_op( int j, int l ) const
{
  TEST_FOR_EXCEPT(true);
  return Teuchos::null;
}

template<class Scalar>
ModelEvaluatorBase::InArgs<Scalar>
DefaultMultiPeriodModelEvaluator<Scalar>::createInArgs() const
{
  ModelEvaluatorBase::InArgsSetup<Scalar> inArgs;
  TEST_FOR_EXCEPT(true);
  inArgs.setModelEvalDescription(this->description());
  return inArgs;
}

template<class Scalar>
ModelEvaluatorBase::OutArgs<Scalar>
DefaultMultiPeriodModelEvaluator<Scalar>::createOutArgs() const
{
  ModelEvaluatorBase::OutArgsSetup<Scalar> outArgs;
  TEST_FOR_EXCEPT(true);
  outArgs.setModelEvalDescription(this->description());
  return outArgs;
}

template<class Scalar>
void DefaultMultiPeriodModelEvaluator<Scalar>::evalModel(
  const ModelEvaluatorBase::InArgs<Scalar>       &inArgs
  ,const ModelEvaluatorBase::OutArgs<Scalar>     &outArgs
  ) const
{
  TEST_FOR_EXCEPT(true);
}

template<class Scalar>
void DefaultMultiPeriodModelEvaluator<Scalar>::reportFinalPoint(
  const ModelEvaluatorBase::InArgs<Scalar>      &finalPoint
  ,const bool                                   wasSolved
  )
{
  TEST_FOR_EXCEPT(true);
}

} // namespace Thyra

#endif // THYRA_DEFAULT_MULTI_PERIOD_MODEL_EVALUATOR_HPP

---