MueLu_AdaptiveSaMLParameterListInterpreter_decl.hpp

Go to the documentation of this file.

/*
 * 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_MLParameterListInterpreter_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_ */