AnasaziSaddleOperator.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_SADDLE_OPERATOR_HPP
#define ANASAZI_SADDLE_OPERATOR_HPP

#include "AnasaziConfigDefs.hpp"
#include "AnasaziSaddleContainer.hpp"
#include "AnasaziTraceMinRitzOp.hpp"

#include "Teuchos_SerialDenseSolver.hpp"

using Teuchos::RCP;

enum PrecType {NO_PREC, NONSYM, BD_PREC, HSS_PREC};

namespace Anasazi {
namespace Experimental {

template <class ScalarType, class MV, class OP>
class SaddleOperator : public TraceMinOp<ScalarType,SaddleContainer<ScalarType,MV>,OP>
{
  typedef Anasazi::MultiVecTraits<ScalarType,MV>       MVT;
  typedef Teuchos::SerialDenseMatrix<int,ScalarType>   SerialDenseMatrix;

public:
  // Default constructor
  SaddleOperator( ) { };
  SaddleOperator( const Teuchos::RCP<OP> A, const Teuchos::RCP<const MV> B, PrecType pt=NO_PREC, const ScalarType alpha=1. );

  // Applies the saddle point operator to a "multivector"
  void Apply(const SaddleContainer<ScalarType,MV>& X, SaddleContainer<ScalarType,MV>& Y) const;

  void removeIndices(const std::vector<int>& indicesToRemove) { A_->removeIndices(indicesToRemove); };

private:
  // A is the 1-1 block, and B the 1-2 block
  Teuchos::RCP<OP> A_;
  Teuchos::RCP<const MV> B_;
  Teuchos::RCP<SerialDenseMatrix> Schur_;
  PrecType pt_;
  ScalarType alpha_;
};



// Default constructor
template <class ScalarType, class MV, class OP>
SaddleOperator<ScalarType, MV, OP>::SaddleOperator( const Teuchos::RCP<OP> A, const Teuchos::RCP<const MV> B, PrecType pt, const ScalarType alpha )
{
  // Get a pointer to A and B
  A_ = A;
  B_ = B;
  pt_ = pt;
  alpha_ = alpha;

  if(pt == BD_PREC)
  {
    // Form the Schur complement
    int nvecs = MVT::GetNumberVecs(*B);
    Teuchos::RCP<MV> AinvB = MVT::Clone(*B,nvecs);
    Schur_ = rcp(new SerialDenseMatrix(nvecs,nvecs));

    A_->Apply(*B_,*AinvB);

    MVT::MvTransMv(1., *B_, *AinvB, *Schur_);
  }
}

// Applies the saddle point operator to a "multivector"
template <class ScalarType, class MV, class OP>
void SaddleOperator<ScalarType, MV, OP>::Apply(const SaddleContainer<ScalarType,MV>& X, SaddleContainer<ScalarType,MV>& Y) const
{
  RCP<SerialDenseMatrix> Xlower = X.getLower();
  RCP<SerialDenseMatrix> Ylower = Y.getLower();

  if(pt_ == NO_PREC)
  {
    // trans does literally nothing, because the operator is symmetric
    // Y.bottom = B'X.top
    MVT::MvTransMv(1., *B_, *(X.upper_), *Ylower);
  
    // Y.top = A*X.top+B*X.bottom
    A_->Apply(*(X.upper_), *(Y.upper_));
    MVT::MvTimesMatAddMv(1., *B_, *Xlower, 1., *(Y.upper_));
  }
  else if(pt_ == NONSYM)
  {
    // Y.bottom = -B'X.top
  MVT::MvTransMv(-1., *B_, *(X.upper_), *Ylower);
  
    // Y.top = A*X.top+B*X.bottom
    A_->Apply(*(X.upper_), *(Y.upper_));
    MVT::MvTimesMatAddMv(1., *B_, *Xlower, 1., *(Y.upper_));
  }
  else if(pt_ == BD_PREC)
  {
    Teuchos::SerialDenseSolver<int,ScalarType> MySolver;

    // Solve A Y.X = X.X
    A_->Apply(*(X.upper_),*(Y.upper_));

    // So, let me tell you a funny story about how the SerialDenseSolver destroys the original matrix...
    Teuchos::RCP<SerialDenseMatrix> localSchur = Teuchos::rcp(new SerialDenseMatrix(*Schur_));

    // Solve the small system
    MySolver.setMatrix(localSchur);
    MySolver.setVectors(Ylower, Xlower);
    MySolver.solve();
  }
  // Hermitian-Skew Hermitian splitting has some extra requirements
  // We need B'B = I, which is true for standard eigenvalue problems, but not generalized
  // We also need to use gmres, because our operator is no longer symmetric
  else if(pt_ == HSS_PREC)
  {
//    std::cout << "applying preconditioner to";
//    X.MvPrint(std::cout);

    // Solve (H + alpha I) Y1 = X
    // 1.  Apply preconditioner
    A_->Apply(*(X.upper_),*(Y.upper_));
    // 2. Scale by 1/alpha
    *Ylower = *Xlower; 
    Ylower->scale(1./alpha_);
  
//    std::cout << "H preconditioning produced";
//  Y.setLower(Ylower);
//    Y.MvPrint(std::cout);

    // Solve (S + alpha I) Y = Y1
    // 1.  Y_lower = (B' Y1_upper + alpha Y1_lower) / (1 + alpha^2)
    Teuchos::RCP<SerialDenseMatrix> Y1_lower = Teuchos::rcp(new SerialDenseMatrix(*Ylower));
    MVT::MvTransMv(1,*B_,*(Y.upper_),*Ylower);
//  std::cout << "Y'b1 " << *Ylower;
    Y1_lower->scale(alpha_);
//  std::cout << "alpha b2 " << *Y1_lower;
    *Ylower += *Y1_lower;
//  std::cout << "alpha b2 + Y'b1 " << *Ylower;
    Ylower->scale(1/(1+alpha_*alpha_));
    // 2.  Y_upper = (Y1_upper - B Y_lower) / alpha
    MVT::MvTimesMatAddMv(-1/alpha_,*B_,*Ylower,1/alpha_,*(Y.upper_));

//    std::cout << "preconditioning produced";
//  Y.setLower(Ylower);
//    Y.MvPrint(std::cout);
  }
  else
  {
    std::cout << "Not a valid preconditioner type\n";
  }

  Y.setLower(Ylower);
  
//  std::cout << "result of applying operator";
//  Y.MvPrint(std::cout);
}

} // End namespace Experimental

template<class ScalarType, class MV, class OP>
class OperatorTraits<ScalarType, Experimental::SaddleContainer<ScalarType,MV>, Experimental::SaddleOperator<ScalarType,MV,OP> >
{
public:
  static void Apply( const Experimental::SaddleOperator<ScalarType,MV,OP>& Op, 
                     const Experimental::SaddleContainer<ScalarType,MV>& x, 
                     Experimental::SaddleContainer<ScalarType,MV>& y)
    { Op.Apply( x, y); };
};

} // end namespace Anasazi

#ifdef HAVE_ANASAZI_BELOS
namespace Belos {

template<class ScalarType, class MV, class OP>
class OperatorTraits<ScalarType, Anasazi::Experimental::SaddleContainer<ScalarType,MV>, Anasazi::Experimental::SaddleOperator<ScalarType,MV,OP> >
{
public:
  static void Apply( const Anasazi::Experimental::SaddleOperator<ScalarType,MV,OP>& Op, 
                     const Anasazi::Experimental::SaddleContainer<ScalarType,MV>& x, 
                     Anasazi::Experimental::SaddleContainer<ScalarType,MV>& y)
    { Op.Apply( x, y); };
};

} // end namespace Belos
#endif

#endif