AnasaziThyraDebugAdapter.hpp

Go to the documentation of this file.

// @HEADER
// ***********************************************************************
//
//                 Anasazi: Block Eigensolvers Package
//                 Copyright 2004 Sandia Corporation
//
// Under 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 ANASAZI_THYRA_DEBUG_ADAPTER_HPP
#define ANASAZI_THYRA_DEBUG_ADAPTER_HPP
 
#include "AnasaziConfigDefs.hpp"
#include "AnasaziTypes.hpp"
#include "AnasaziMultiVec.hpp"
#include "AnasaziOperator.hpp"
 
#include "AnasaziThyraAdapter.hpp"
#include <Thyra_DetachedMultiVectorView.hpp>
#include <Thyra_MultiVectorBase.hpp>
#include <Thyra_MultiVectorStdOps.hpp>
 
#include "Teuchos_Assert.hpp"
#include "Teuchos_SerialDenseMatrix.hpp"
#include "Teuchos_RCP.hpp"
#include "Teuchos_TimeMonitor.hpp"
 
namespace Anasazi {


  //
  //--------template class AnasaziThyraMultiVec-----------------
  //

  template<class ScalarType>
  class ThyraMultiVec : public MultiVec<ScalarType> {
  public:
 
    typedef MultiVecTraits<ScalarType,Thyra::MultiVectorBase<ScalarType> > MVT;
    typedef Teuchos::ScalarTraits<ScalarType> SCT;
    typedef typename Teuchos::ScalarTraits<ScalarType>::magnitudeType MagnitudeType;
    typedef Teuchos::ScalarTraits<MagnitudeType> MT;




    ThyraMultiVec( const Teuchos::RCP<Thyra::MultiVectorBase< ScalarType > > & mv ) :
      _timerCreate(Teuchos::TimeMonitor::getNewTimer("ThyraMultiVec::create")),
      _timerClone(Teuchos::TimeMonitor::getNewTimer("ThyraMultiVec::clone")),
      _timerDestroy(Teuchos::TimeMonitor::getNewTimer("ThyraMultiVec::destroy")),
      _timerMvTimesMatAddMv(Teuchos::TimeMonitor::getNewTimer("ThyraMultiVec::mvtimesmataddmv")),
      _timerMvTransMv(Teuchos::TimeMonitor::getNewTimer("ThyraMultiVec::mvtransmv")),
      _timerMvAddMv(Teuchos::TimeMonitor::getNewTimer("ThyraMultiVec::mvaddmv")),
      _timerMvDot(Teuchos::TimeMonitor::getNewTimer("ThyraMultiVec::mvdot")),
      _timerMvNorm(Teuchos::TimeMonitor::getNewTimer("ThyraMultiVec::mvnorm")),
      _timerMvScale(Teuchos::TimeMonitor::getNewTimer("ThyraMultiVec::mvscale")),
      _timerSetBlock(Teuchos::TimeMonitor::getNewTimer("ThyraMultiVec::setblock")),
      _timerMvInit(Teuchos::TimeMonitor::getNewTimer("ThyraMultiVec::mvinit")),
      _timerMvRandom(Teuchos::TimeMonitor::getNewTimer("ThyraMultiVec::mvrandom"))
    {
      Teuchos::TimeMonitor timer(*_timerCreate);
      Thyra_MV = mv;
    }


    ThyraMultiVec( const Teuchos::RCP<Thyra::MultiVectorBase< ScalarType > > & mv, std::vector<Teuchos::RCP<Teuchos::Time> >& timers )
    {
      copyTimers( timers );
      Teuchos::TimeMonitor timer(*_timerCreate);
      Thyra_MV = mv;
    }


    ThyraMultiVec( const ThyraMultiVec<ScalarType> & mv )
    {
      copyTimers( mv.getTimers() );
      Teuchos::TimeMonitor timer(*_timerCreate);
      Thyra_MV = MVT::CloneCopy( *(mv.getRCP()) );
    }

    virtual ~ThyraMultiVec() { Teuchos::TimeMonitor timer(*_timerDestroy); }




    MultiVec<ScalarType> * Clone ( const int numvecs ) const
    {
      Teuchos::TimeMonitor timer(*_timerClone);
      std::vector<Teuchos::RCP<Teuchos::Time> >  myTimers = getTimers();
      return new ThyraMultiVec<ScalarType>( MVT::Clone( *Thyra_MV, numvecs ), myTimers ); }

    MultiVec<ScalarType> * CloneCopy () const
    {
      Teuchos::TimeMonitor timer(*_timerClone);
      std::vector<Teuchos::RCP<Teuchos::Time> >  myTimers = getTimers();
      return new ThyraMultiVec<ScalarType>( MVT::CloneCopy( *Thyra_MV ), myTimers );
    }

    MultiVec<ScalarType> * CloneCopy ( const std::vector<int>& index ) const
    {
      Teuchos::TimeMonitor timer(*_timerClone);
      std::vector<Teuchos::RCP<Teuchos::Time> >  myTimers = getTimers();
      return new ThyraMultiVec<ScalarType>( MVT::CloneCopy( *Thyra_MV, index ), myTimers );
    }

    MultiVec<ScalarType> * CloneViewNonConst ( const std::vector<int>& index )
    {
      Teuchos::TimeMonitor timer(*_timerClone);
      std::vector<Teuchos::RCP<Teuchos::Time> >  myTimers = getTimers();
      return new ThyraMultiVec<ScalarType>( MVT::CloneViewNonConst( *Thyra_MV, index ), myTimers );
    }

    const MultiVec<ScalarType> * CloneView ( const std::vector<int>& index ) const
    {
      Teuchos::TimeMonitor timer(*_timerClone);
      std::vector<Teuchos::RCP<Teuchos::Time> >  myTimers = getTimers();
      Teuchos::RCP<Thyra::MultiVectorBase<ScalarType> > nonconst_ptr_to_const_view = Teuchos::rcp_const_cast<Thyra::MultiVectorBase<ScalarType> >( MVT::CloneView(*Thyra_MV,index) );
      const MultiVec<ScalarType> * const_ret = new ThyraMultiVec<ScalarType>( nonconst_ptr_to_const_view, myTimers );
      return const_ret;
    }




    int GetNumberVecs () const { return MVT::GetNumberVecs( *Thyra_MV ); }

    ptrdiff_t GetGlobalLength () const { return MVT::GetGlobalLength( *Thyra_MV ); }




    void MvTimesMatAddMv ( ScalarType alpha, const MultiVec<ScalarType>& A,
                           const Teuchos::SerialDenseMatrix<int,ScalarType>& B,
                           ScalarType beta )
    {
      Teuchos::TimeMonitor timer(*_timerMvTimesMatAddMv);
      const Anasazi::ThyraMultiVec<ScalarType>* vec_A = dynamic_cast<const Anasazi::ThyraMultiVec<ScalarType>* >(&A);
      MVT::MvTimesMatAddMv( alpha, *(vec_A->getRCP()), B, beta, *Thyra_MV );
    }

    void MvAddMv ( ScalarType alpha, const MultiVec<ScalarType>& A,
                   ScalarType beta, const MultiVec<ScalarType>& B)
    {
      Teuchos::TimeMonitor timer(*_timerMvAddMv);
      const Anasazi::ThyraMultiVec<ScalarType>* vec_A = dynamic_cast<const Anasazi::ThyraMultiVec<ScalarType>* >(&A);
      const Anasazi::ThyraMultiVec<ScalarType>* vec_B = dynamic_cast<const Anasazi::ThyraMultiVec<ScalarType>* >(&B);
      MVT::MvAddMv( alpha, *(vec_A->getRCP()), beta, *(vec_B->getRCP()), *Thyra_MV );
    }

    void MvTransMv ( ScalarType alpha, const MultiVec<ScalarType>& A, Teuchos::SerialDenseMatrix<int,ScalarType>& B
#ifdef HAVE_ANASAZI_EXPERIMENTAL
        , ConjType conj = Anasazi::CONJ
#endif
        ) const
    {
      Teuchos::TimeMonitor timer(*_timerMvTransMv);
      const Anasazi::ThyraMultiVec<ScalarType>* vec_A = dynamic_cast<const Anasazi::ThyraMultiVec<ScalarType>* >(&A);
      MVT::MvTransMv( alpha, *(vec_A->getRCP()), *Thyra_MV, B );
    }

    void MvDot ( const MultiVec<ScalarType>& A, std::vector<ScalarType> &b
#ifdef HAVE_ANASAZI_EXPERIMENTAL
        , ConjType conj = Anasazi::CONJ
#endif
        ) const
    {
      Teuchos::TimeMonitor timer(*_timerMvDot);
      const Anasazi::ThyraMultiVec<ScalarType>* vec_A = dynamic_cast<const Anasazi::ThyraMultiVec<ScalarType>* >(&A);
      MVT::MvDot( *Thyra_MV, *(vec_A->getRCP()), b );
    }

    void MvScale ( ScalarType alpha ) { Teuchos::TimeMonitor timer(*_timerMvScale); MVT::MvScale( *Thyra_MV, alpha ); }

    void MvScale ( const std::vector<ScalarType>& alpha ) { Teuchos::TimeMonitor timer(*_timerMvScale); MVT::MvScale( *Thyra_MV, alpha ); }



    void MvNorm ( std::vector<typename Teuchos::ScalarTraits<ScalarType>::magnitudeType> &normvec ) const { Teuchos::TimeMonitor timer(*_timerMvNorm); MVT::MvNorm( *Thyra_MV, normvec ); }



    void SetBlock ( const MultiVec<ScalarType>& A, const std::vector<int>& index )
    {
      Teuchos::TimeMonitor timer(*_timerSetBlock);
      const Anasazi::ThyraMultiVec<ScalarType>* vec_A = dynamic_cast<const Anasazi::ThyraMultiVec<ScalarType>* >(&A);
      MVT::SetBlock( *(vec_A->getRCP()), index, *Thyra_MV );
    }

    void MvRandom() { Teuchos::TimeMonitor timer(*_timerMvRandom); MVT::MvRandom( *Thyra_MV ); }

    void MvInit ( ScalarType alpha ) { Teuchos::TimeMonitor timer(*_timerMvInit);  MVT::MvInit( *Thyra_MV, alpha ); }



    Teuchos::RCP< Thyra::MultiVectorBase<ScalarType> > getRCP() { return Thyra_MV; }

    Teuchos::RCP< const Thyra::MultiVectorBase<ScalarType> > getRCP() const { return Thyra_MV; }

    std::vector<Teuchos::RCP<Teuchos::Time> > getTimers() const {
     std::vector<Teuchos::RCP<Teuchos::Time> > timers;
     timers.push_back( _timerCreate );
     timers.push_back( _timerClone );
     timers.push_back( _timerDestroy );
     timers.push_back( _timerMvTimesMatAddMv );
     timers.push_back( _timerMvTransMv );
     timers.push_back( _timerMvAddMv );
     timers.push_back( _timerMvDot );
     timers.push_back( _timerMvNorm );
     timers.push_back( _timerMvScale );
     timers.push_back( _timerSetBlock );
     timers.push_back( _timerMvInit );
     timers.push_back( _timerMvRandom );
 
     return timers;
   }

   void copyTimers( const std::vector<Teuchos::RCP<Teuchos::Time> >& timers ) {
     _timerCreate = timers[0];
     _timerClone = timers[1];
     _timerDestroy = timers[2];
     _timerMvTimesMatAddMv = timers[3];
     _timerMvTransMv = timers[4];
     _timerMvAddMv = timers[5];
     _timerMvDot = timers[6];
     _timerMvNorm = timers[7];
     _timerMvScale = timers[8];
     _timerSetBlock = timers[9];
     _timerMvInit = timers[10];
     _timerMvRandom = timers[11];
   }




    void MvPrint( std::ostream& os ) const { MVT::MvPrint( *Thyra_MV, os ); }
 
  private:
 
    Teuchos::RCP<Thyra::MultiVectorBase<ScalarType> > Thyra_MV;
    Teuchos::RCP<Teuchos::Time> _timerCreate, _timerClone, _timerDestroy;
    Teuchos::RCP<Teuchos::Time> _timerMvTimesMatAddMv, _timerMvTransMv, _timerMvAddMv, _timerMvDot;
    Teuchos::RCP<Teuchos::Time> _timerMvNorm, _timerMvScale, _timerSetBlock, _timerMvInit, _timerMvRandom;
  };
  //-------------------------------------------------------------

  //
  //--------template class AnasaziThyraOp---------------------
  //

  template<class ScalarType>
  class ThyraOp : public virtual Operator<ScalarType> {
  public:
 
    typedef OperatorTraits<ScalarType,Thyra::MultiVectorBase<ScalarType>,Thyra::LinearOpBase<ScalarType> > OPT;



    ThyraOp(const Teuchos::RCP<const Thyra::LinearOpBase<ScalarType> > &Op ) { Thyra_Op = Op; }

    ~ThyraOp() {}



    void Apply ( const MultiVec<ScalarType>& X, MultiVec<ScalarType>& Y ) const
    {
      const Anasazi::ThyraMultiVec<ScalarType>* vec_X = dynamic_cast<const Anasazi::ThyraMultiVec<ScalarType>* >(&X);
      Anasazi::ThyraMultiVec<ScalarType>* vec_Y = dynamic_cast<Anasazi::ThyraMultiVec<ScalarType>* >(&Y);
      OPT::Apply( *Thyra_Op, *(vec_X->getRCP()), *(vec_Y->getRCP()) );
    }

 
  private:
    Teuchos::RCP<const Thyra::LinearOpBase<ScalarType> > Thyra_Op;
  };
 
} // end of Anasazi namespace
 
#endif
// end of file ANASAZI_THYRA_DEBUG_ADAPTER_HPP