Teko_BlockedReordering.hpp

// @HEADER
// *****************************************************************************
//      Teko: A package for block and physics based preconditioning
//
// Copyright 2010 NTESS and the Teko contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef __Teko_BlockedReordering_hpp__
#define __Teko_BlockedReordering_hpp__
 
#include <string>
#include <vector>
 
#include "Teuchos_RCP.hpp"
 
#include "Thyra_LinearOpBase.hpp"
#include "Thyra_LinearOpDefaultBase.hpp"
#include "Thyra_BlockedLinearOpBase.hpp"
#include "Thyra_ProductMultiVectorBase.hpp"
 
namespace Teko {

class BlockReorderManager {
 public:


  BlockReorderManager() : children_(0) {}

  BlockReorderManager(int sz) : children_(sz, Teuchos::null) {}

  BlockReorderManager(const BlockReorderManager& bmm) : children_(bmm.children_.size()) {
    for (unsigned int i = 0; i < children_.size(); i++) children_[i] = bmm.children_[i]->Copy();
  }

  virtual ~BlockReorderManager() {}


  virtual Teuchos::RCP<BlockReorderManager> Copy() const {
    return Teuchos::rcp(new BlockReorderManager(*this));
  }

  virtual void SetNumBlocks(int sz) {
    children_.clear();
    children_.resize(sz);
  }

  virtual int GetNumBlocks() const { return children_.size(); }

  virtual void SetBlock(int blockIndex, int reorder);

  virtual void SetBlock(int blockIndex, const Teuchos::RCP<BlockReorderManager>& reorder);

  virtual const Teuchos::RCP<BlockReorderManager> GetBlock(int blockIndex);

  virtual const Teuchos::RCP<const BlockReorderManager> GetBlock(int blockIndex) const;

  virtual std::string toString() const;

  virtual int LargestIndex() const;
 
 protected:
  std::vector<Teuchos::RCP<BlockReorderManager> > children_;
};

class BlockReorderLeaf : public BlockReorderManager {
 public:


  BlockReorderLeaf(int ind) : value_(ind) {}

  BlockReorderLeaf(const BlockReorderLeaf& brl) : value_(brl.value_) {}

  virtual Teuchos::RCP<BlockReorderManager> Copy() const {
    return Teuchos::rcp(new BlockReorderLeaf(*this));
  }

  virtual int GetNumBlocks() const { return 0; }

  virtual void SetNumBlocks(int /* sz */) {}

  virtual void SetBlock(int /* blockIndex */, int /* reorder */) {}

  virtual const Teuchos::RCP<BlockReorderManager> GetBlock(int /* blockIndex */) {
    return Teuchos::null;
  }

  virtual const Teuchos::RCP<const BlockReorderManager> GetBlock(int /* blockIndex */) const {
    return Teuchos::null;
  }

  int GetIndex() const { return value_; }

  virtual std::string toString() const {
    std::stringstream ss;
    ss << value_;
    return ss.str();
  }

  virtual int LargestIndex() const { return value_; }
 
 protected:
  using BlockReorderManager::SetBlock;

  int value_;
 
 private:
  BlockReorderLeaf();  // hidden from users
};

Teuchos::RCP<const Thyra::LinearOpBase<double> > buildReorderedLinearOp(
    const BlockReorderManager& bmm,
    const Teuchos::RCP<const Thyra::BlockedLinearOpBase<double> >& blkOp);

Teuchos::RCP<const Thyra::LinearOpBase<double> > buildReorderedLinearOp(
    const BlockReorderManager& rowMgr, const BlockReorderManager& colMgr,
    const Teuchos::RCP<const Thyra::BlockedLinearOpBase<double> >& blkOp);

Teuchos::RCP<const Thyra::VectorSpaceBase<double> > buildReorderedVectorSpace(
    const BlockReorderManager& mgr,
    const Teuchos::RCP<const Thyra::ProductVectorSpaceBase<double> >& blkSpc);

Teuchos::RCP<Thyra::MultiVectorBase<double> > buildReorderedMultiVector(
    const BlockReorderManager& mgr,
    const Teuchos::RCP<Thyra::ProductMultiVectorBase<double> >& blkVec);

Teuchos::RCP<const Thyra::MultiVectorBase<double> > buildReorderedMultiVector(
    const BlockReorderManager& mgr,
    const Teuchos::RCP<const Thyra::ProductMultiVectorBase<double> >& blkVec);

Teuchos::RCP<Thyra::MultiVectorBase<double> > buildFlatMultiVector(
    const BlockReorderManager& mgr,
    const Teuchos::RCP<Thyra::ProductMultiVectorBase<double> >& blkVec);

Teuchos::RCP<const Thyra::MultiVectorBase<double> > buildFlatMultiVector(
    const BlockReorderManager& mgr,
    const Teuchos::RCP<const Thyra::ProductMultiVectorBase<double> >& blkVec);

Teuchos::RCP<const Thyra::VectorSpaceBase<double> > buildFlatVectorSpace(
    const BlockReorderManager& mgr,
    const Teuchos::RCP<const Thyra::VectorSpaceBase<double> >& blkSpc);

Teuchos::RCP<const BlockReorderManager> blockedReorderFromString(std::string& reorder);
 
}  // end namespace Teko
 
#endif