Xpetra_BlockReorderManager.hpp

Go to the documentation of this file.

// @HEADER
//
// ***********************************************************************
//
//             Xpetra: A linear algebra interface package
//                  Copyright 2012 Sandia Corporation
//
// Under the 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
//                    Jonathan Hu       (jhu@sandia.gov)
//                    Andrey Prokopenko (aprokop@sandia.gov)
//                    Ray Tuminaro      (rstumin@sandia.gov)
//                    Tobias Wiesner    (tawiesn@sandia.gov)
//
// ***********************************************************************
//
// @HEADER
#ifndef XPETRA_BLOCKREORDERMANAGER_HPP_
#define XPETRA_BLOCKREORDERMANAGER_HPP_

#include <stack>

#include <Teuchos_StrUtils.hpp>

namespace Xpetra {
class BlockReorderManager {
 public:

  BlockReorderManager()
    : children_(0) {}

  BlockReorderManager(const BlockReorderManager& bmm)
    : children_(bmm.children_.size()) {
    for (size_t 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(size_t sz) {
    children_.clear();
    children_.resize(sz);
  }

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


  virtual void SetBlock(int blockIndex, int reorder); /* {
     TEUCHOS_ASSERT(blockIndex < (int) children_.size());
     Teuchos::RCP<BlockReorderManager> child = Teuchos::rcp(new BlockReorderLeaf(reorder));
     children_[blockIndex] = child;
   }*/


  virtual void SetBlock(int blockIndex, const Teuchos::RCP<BlockReorderManager>& reorder); /* {
    TEUCHOS_ASSERT(blockIndex < (int) children_.size());
    children_[blockIndex] = reorder;
  }*/

  virtual const Teuchos::RCP<BlockReorderManager> GetBlock(int blockIndex) {
    TEUCHOS_ASSERT(blockIndex < (int)children_.size());

    if (children_[blockIndex] == Teuchos::null)
      children_[blockIndex] = Teuchos::rcp(new BlockReorderManager());
    return children_[blockIndex];
  }

  virtual const Teuchos::RCP<const BlockReorderManager> GetBlock(int blockIndex) const {
    TEUCHOS_ASSERT(blockIndex < (int)children_.size());
    return children_[blockIndex];
  }

  virtual std::string toString() const {
    // build the string by recursively calling each child
    std::stringstream ss;
    ss << "[";
    for (size_t i = 0; i < children_.size(); i++) {
      if (children_[i] == Teuchos::null)
        ss << " <NULL> ";
      else
        ss << " " << children_[i]->toString() << " ";
    }
    ss << "]";
    return ss.str();
  }

  virtual int LargestIndex() const {
    int max = 0;
    for (size_t i = 0; i < children_.size(); i++) {
      if (children_[i] != Teuchos::null) {
        int subMax = children_[i]->LargestIndex();
        max        = max > subMax ? max : subMax;
      }
    }
    return max;
  }

 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 size_t GetNumBlocks() const { return 0; }
  virtual void SetNumBlocks(size_t /* sz */) {}
  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 */) {
    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:
  int value_;

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

void tokenize(std::string srcInput, std::string whitespace, std::string prefer, std::vector<std::string>& tokens);

// this function takes a set of tokens and returns the first "block", i.e. those
// values (including) brackets that correspond to the first block
std::vector<std::string>::const_iterator buildSubBlock(
    std::vector<std::string>::const_iterator begin,
    std::vector<std::string>::const_iterator end,
    std::vector<std::string>& subBlock);

// This function takes a tokenized vector and converts it to a block reorder manager
Teuchos::RCP<Xpetra::BlockReorderManager> blockedReorderFromTokens(const std::vector<std::string>& tokens);

Teuchos::RCP<const Xpetra::BlockReorderManager> blockedReorderFromString(std::string reorder);
}  // namespace Xpetra

#endif /* XPETRA_BLOCKREORDERMANAGER_HPP_ */