MueLu_AdaptiveSaMLParameterListInterpreter_decl.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//        MueLu: A package for multigrid based preconditioning
//
// Copyright 2012 NTESS and the MueLu contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
/*
 * MueLu_AdaptiveSaMLParamterListInterpreter_decl.hpp
 *
 *  Created on: Jan 28, 2013
 *      Author: tobias
 */
 
#ifndef MUELU_ADAPTIVESAMLPARAMTERLISTINTERPRETER_DECL_HPP_
#define MUELU_ADAPTIVESAMLPARAMTERLISTINTERPRETER_DECL_HPP_
 
#include <Teuchos_ParameterList.hpp>
 
#include <Xpetra_Matrix_fwd.hpp>
#include <Xpetra_MultiVector_fwd.hpp>
#include <Xpetra_Operator_fwd.hpp>
 
#include "MueLu_ConfigDefs.hpp"
#include "MueLu_HierarchyManager.hpp"
#include "MueLu_AdaptiveSaMLParameterListInterpreter_fwd.hpp"
 
#include "MueLu_Hierarchy_fwd.hpp"
#include "MueLu_SmootherFactory_fwd.hpp"
 
#include "MueLu_TentativePFactory_fwd.hpp"
#include "MueLu_SaPFactory_fwd.hpp"
#include "MueLu_PgPFactory_fwd.hpp"
#include "MueLu_TransPFactory_fwd.hpp"
#include "MueLu_GenericRFactory_fwd.hpp"
#include "MueLu_SmootherPrototype_fwd.hpp"
#include "MueLu_TrilinosSmoother_fwd.hpp"
#include "MueLu_RAPFactory_fwd.hpp"
#include "MueLu_CoalesceDropFactory_fwd.hpp"
#include "MueLu_UncoupledAggregationFactory_fwd.hpp"
#include "MueLu_NullspaceFactory_fwd.hpp"
#include "MueLu_FactoryBase_fwd.hpp"
#include "MueLu_ParameterListInterpreter_fwd.hpp"
 
namespace MueLu {
 
/*
  Utility that from an existing Teuchos::ParameterList creates a new list, in
  which level-specific parameters are replaced with sublists.
 
  Currently, level-specific parameters that begin with "smoother:"
  or "aggregation:" are placed in sublists. Coarse options are also placed
  in a coarse list.
 
  Example:
  Input:
  smoother: type (level 0) = symmetric Gauss-Seidel
  smoother: sweeps (level 0) = 1
  Output:
  smoother: list (level 0) ->
  smoother: type = symmetric Gauss-Seidel
  smoother: sweeps = 1
*/
// This function is a copy of ML_CreateSublists to avoid dependency on ML
// Throw exception on error instead of exit()
// void CreateSublists(const ParameterList &List, ParameterList &newList);
 
template <class Scalar        = DefaultScalar,
          class LocalOrdinal  = DefaultLocalOrdinal,
          class GlobalOrdinal = DefaultGlobalOrdinal,
          class Node          = DefaultNode>
class AdaptiveSaMLParameterListInterpreter : public HierarchyManager<Scalar, LocalOrdinal, GlobalOrdinal, Node> {
#undef MUELU_ADAPTIVESAMLPARAMETERLISTINTERPRETER_SHORT
#include "MueLu_UseShortNames.hpp"
 
 public:
 
 
  AdaptiveSaMLParameterListInterpreter()
    : nullspace_(NULL)
    , blksize_(1) {}
 
  AdaptiveSaMLParameterListInterpreter(Teuchos::ParameterList& paramList, std::vector<RCP<FactoryBase> > factoryList = std::vector<RCP<FactoryBase> >(0));
 
  AdaptiveSaMLParameterListInterpreter(const std::string& xmlFileName, std::vector<RCP<FactoryBase> > factoryList = std::vector<RCP<FactoryBase> >(0));
 
  virtual ~AdaptiveSaMLParameterListInterpreter() {}
 
 
 
  void SetParameterList(const Teuchos::ParameterList& paramList);
 
 
 
  virtual void SetupHierarchy(Hierarchy& H) const;
 
 
 
 
 
  void AddTransferFactory(const RCP<FactoryBase>& factory);
 
  size_t NumTransferFactories() const;
 
 private:
  void SetupInitHierarchy(Hierarchy& H) const;
 
  void AddInitFactoryManager(int startLevel, int numDesiredLevel, RCP<FactoryManagerBase> manager) {
    const int lastLevel = startLevel + numDesiredLevel - 1;
    if (init_levelManagers_.size() < lastLevel + 1) init_levelManagers_.resize(lastLevel + 1);
 
    for (int iLevel = startLevel; iLevel <= lastLevel; iLevel++) {
      init_levelManagers_[iLevel] = manager;
    }
  }
 
  Teuchos::RCP<FactoryManagerBase> InitLvlMngr(int levelID, int lastLevelID) const {
    // Please not that the order of the 'if' statements is important.
 
    if (levelID == -1) return Teuchos::null;               // when this routine is called with levelID == '-1', it means that we are processing the finest Level (there is no finer level)
    if (levelID == lastLevelID + 1) return Teuchos::null;  // when this routine is called with levelID == 'lastLevelID+1', it means that we are processing the last level (ie: there is no nextLevel...)
 
    if (0 == init_levelManagers_.size()) {  // default factory manager.
      // the default manager is shared across levels, initialized only if needed and deleted with the HierarchyManager.
      static RCP<FactoryManagerBase> defaultMngr = rcp(new FactoryManager());
      return defaultMngr;
    }
    if (levelID >= init_levelManagers_.size()) return init_levelManagers_[init_levelManagers_.size() - 1];  // last levelManager is used for all the remaining levels.
 
    return init_levelManagers_[levelID];  // throw exception if out of bound.
  }
 
  int nullspaceDim_;
  double* nullspace_;
 
  bool bExportAggregates_;  
 
  std::vector<RCP<FactoryBase> > TransferFacts_;
 
  Array<RCP<FactoryManagerBase> > init_levelManagers_;
 
 
  virtual void SetupOperator(Operator& Op) const;
 
  int blksize_;
 
};  // class AdaptiveSaMLParameterListInterpreter
 
}  // namespace MueLu
 
#define MUELU_ADAPTIVESAMLPARAMETERLISTINTERPRETER_SHORT
#endif /* MUELU_ADAPTIVESAMLPARAMTERLISTINTERPRETER_DECL_HPP_ */