Panzer_ResponseLibrary.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//           Panzer: A partial differential equation assembly
//       engine for strongly coupled complex multiphysics systems
//
// Copyright 2011 NTESS and the Panzer contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef __Panzer_ResponseLibrary_hpp__
#define __Panzer_ResponseLibrary_hpp__
 
#include <iostream>
#include <string>
#include <vector>
#include <map>
 
#include <unordered_map>
 
#include "Teuchos_ParameterList.hpp"
 
#include "Phalanx_FieldManager.hpp"
 
#include "PanzerDiscFE_config.hpp"
#include "Panzer_ResponseBase.hpp"
#include "Panzer_FieldManagerBuilder.hpp"
 
#include "Panzer_AssemblyEngine_InArgs.hpp"
#include "Panzer_AssemblyEngine_TemplateManager.hpp"
#include "Panzer_PhysicsBlock.hpp"
 
#include "Panzer_WorksetContainer.hpp"
#include "Panzer_WorksetDescriptor.hpp"
#include "Panzer_GlobalIndexer.hpp"
#include "Panzer_LinearObjFactory.hpp"
#include "Panzer_TypeAssocMap.hpp"
 
#include "Panzer_ResponseEvaluatorFactory_TemplateManager.hpp"
 
namespace panzer {
 
class LinearObjContainer;
 
template <typename TraitsT>
class ResponseLibrary {
public:
   typedef typename TraitsT::EvalTypes TypeSeq;
 
   ResponseLibrary();
 
   ResponseLibrary(const Teuchos::RCP<WorksetContainer> & wc,
                   const Teuchos::RCP<const GlobalIndexer> & ugi,
                   const Teuchos::RCP<const LinearObjFactory<TraitsT> > & lof,
                   bool residualType=false); 
 
   ResponseLibrary(const ResponseLibrary & rl);
 
   void initialize(const Teuchos::RCP<WorksetContainer> & wc,
                   const Teuchos::RCP<const GlobalIndexer> & ugi,
                   const Teuchos::RCP<const LinearObjFactory<TraitsT> > & lof); 
 
   void initializeResidualType(const Teuchos::RCP<WorksetContainer> & wc,
                               const Teuchos::RCP<const GlobalIndexer> & ugi,
                               const Teuchos::RCP<const LinearObjFactory<TraitsT> > & lof); 
 
 
   void initialize(const ResponseLibrary & rl);
 
   void copyResponses(const ResponseLibrary & rl);
 
   Teuchos::RCP<WorksetContainer> getWorksetContainer() const
   { return wkstContainer_; }
 
   Teuchos::RCP<const GlobalIndexer> getGlobalIndexer() const 
   { return globalIndexer_; }
 
   Teuchos::RCP<const LinearObjFactory<TraitsT> > getLinearObjFactory() const 
   { return linObjFactory_; }
 
   template <typename ResponseEvaluatorFactory_BuilderT>
   void addResponse(const std::string & responseName,
                    const std::vector<std::string> & blocks,
                    const ResponseEvaluatorFactory_BuilderT & builder); 
 
   template <typename ResponseEvaluatorFactory_BuilderT>
   void addResponse(const std::string & responseName,
                    const std::vector<std::pair<std::string,std::string> > & sideset_blocks,
                    const ResponseEvaluatorFactory_BuilderT & builder); 
 
   template <typename ResponseEvaluatorFactory_BuilderT>
   void addResponse(const std::string & responseName,
                    const std::vector<WorksetDescriptor> & wkst_desc,
                    const ResponseEvaluatorFactory_BuilderT & builder); 
                   
   template <typename EvalT>
   Teuchos::RCP<ResponseBase> getResponse(const std::string & responseName) const;
 
   template <typename EvalT>
   void getResponses(std::vector<Teuchos::RCP<ResponseBase> > & responses) const;
 
   void buildResponseEvaluators(
         const std::vector<Teuchos::RCP<panzer::PhysicsBlock> >& physicsBlocks,
         const panzer::ClosureModelFactory_TemplateManager<panzer::Traits>& cm_factory,
         const Teuchos::ParameterList& closure_models,
         const Teuchos::ParameterList& user_data,
         const bool write_graphviz_file=false,
         const std::string& graphviz_file_prefix="")
   { buildResponseEvaluators(physicsBlocks,Teuchos::null,cm_factory,closure_models,user_data,write_graphviz_file,graphviz_file_prefix); }
 
   void buildResponseEvaluators(
         const std::vector<Teuchos::RCP<panzer::PhysicsBlock> >& physicsBlocks,
         const panzer::EquationSetFactory & eqset_factory,
         const panzer::ClosureModelFactory_TemplateManager<panzer::Traits>& cm_factory,
         const Teuchos::ParameterList& closure_models,
         const Teuchos::ParameterList& user_data,
         const bool write_graphviz_file=false,
         const std::string& graphviz_file_prefix="")
   { buildResponseEvaluators(physicsBlocks,Teuchos::ptrFromRef(eqset_factory),cm_factory,closure_models,user_data,write_graphviz_file,graphviz_file_prefix); }
 
   void buildResidualResponseEvaluators(
         const std::vector<Teuchos::RCP<panzer::PhysicsBlock> >& physicsBlocks,
         const panzer::EquationSetFactory & eqset_factory,
         const std::vector<BC> & bcs,
         const panzer::BCStrategyFactory & bc_factory,
         const panzer::ClosureModelFactory_TemplateManager<panzer::Traits>& cm_factory,
         const Teuchos::ParameterList& closure_models,
         const Teuchos::ParameterList& user_data,
         const bool write_graphviz_file=false,
         const std::string& graphviz_file_prefix="");
 
   bool responseEvaluatorsBuilt() const
   { return responseEvaluatorsBuilt_; }
 
   template <typename EvalT> 
   void addResponsesToInArgs(panzer::AssemblyEngineInArgs & input_args) const;
 
   template <typename EvalT> 
   void evaluate(const panzer::AssemblyEngineInArgs& input_args);
 
   void print(std::ostream & os) const;
 
   void useClosureModelByEBlockInResponse(bool value)
   { closureModelByEBlock_ = value; }
 
   void disableGather(bool value)
   { disableGather_ = value; }
 
   void disableScatter(bool value)
   { disableScatter_ = value; }
 
   bool isResidualType() const 
   { return residualType_; }
 
   template <typename EvalT>
   void writeGraphvizFiles(const std::string& prefix = "");
 
protected:
 
   void buildResponseEvaluators(
         const std::vector<Teuchos::RCP<panzer::PhysicsBlock> >& physicsBlocks,
         const Teuchos::Ptr<const panzer::EquationSetFactory> & eqset_factory,
         const panzer::ClosureModelFactory_TemplateManager<panzer::Traits>& cm_factory,
         const Teuchos::ParameterList& closure_models,
         const Teuchos::ParameterList& user_data,
         const bool write_graphviz_file,
         const std::string& graphviz_file_prefix);
 
   void addResidualResponse();
 
   template <typename EvalT> struct Overloader {};
 
   void addResidualResponsesToInArgs(Overloader<typename TraitsT::Residual>,panzer::AssemblyEngineInArgs & input_args) const;
 
   void addResidualResponsesToInArgs(Overloader<typename TraitsT::Jacobian>,panzer::AssemblyEngineInArgs & input_args) const;
 
   void addResidualResponsesToInArgs(Overloader<typename TraitsT::Tangent>,panzer::AssemblyEngineInArgs & input_args) const;
 
#ifdef Panzer_BUILD_HESSIAN_SUPPORT
   void addResidualResponsesToInArgs(Overloader<typename TraitsT::Hessian>,panzer::AssemblyEngineInArgs & input_args) const;
#endif
 
   void addResponse(const std::string & responseName,
                    const std::vector<WorksetDescriptor> & wkst_desc,
                    const Teuchos::RCP<ResponseEvaluatorFactory_TemplateManager<TraitsT> > & modelFact_tm);
 
private:
 
   Teuchos::RCP<WorksetContainer> wkstContainer_;
   Teuchos::RCP<const GlobalIndexer> globalIndexer_;
   Teuchos::RCP<const LinearObjFactory<TraitsT> > linObjFactory_;
 
   typedef TypeAssocMap<panzer::Traits::EvalTypes,Teuchos::RCP<ResponseBase> > Response_TemplateManager;
 
   Teuchos::RCP<FieldManagerBuilder> fmb2_;
   AssemblyEngine_TemplateManager<panzer::Traits> ae_tm2_;
 
   typedef std::unordered_map<panzer::BC,
                                Teuchos::RCP<std::vector<std::pair<std::string,Teuchos::RCP<ResponseEvaluatorFactory_TemplateManager<TraitsT> > > > >,
                                BC::BCHash,BC::BCEquality > BCHashMap;
 
   // Store up response factories by element block
   std::unordered_map<WorksetDescriptor,
                        std::vector<std::pair<std::string,Teuchos::RCP<ResponseEvaluatorFactory_TemplateManager<TraitsT> > > > > respFactories_;
   BCHashMap respBCFactories_;
   std::size_t nextBC_id;
 
   std::unordered_map<std::string, Response_TemplateManager> responseObjects_;
   bool closureModelByEBlock_;
   bool disableGather_;
   bool disableScatter_;
   bool residualType_;
 
   bool responseEvaluatorsBuilt_;
 
   mutable Teuchos::RCP<LinearObjContainer> ghostedContainer_;
 
   struct Printer {
     const Response_TemplateManager & tm_;
     std::ostream & os_;
     Printer(const Response_TemplateManager & tm,std::ostream & os) : tm_(tm), os_(os) {}
     template <typename T> void operator()(T) const { 
//       os_ << PHX::TypeString<T>::value << "=";
       if(tm_.get<T>()!=Teuchos::null) 
         os_ << "ON ";
       else
         os_ << "OFF ";
     }
  };
};
 
}
 
#include "Panzer_ResponseLibrary_impl.hpp"
 
#endif