Panzer_STK_ResponseEvaluatorFactory_SolutionWriter.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_STK_ResponseEvaluatorFactory_SolutionWriter_hpp__
#define __Panzer_STK_ResponseEvaluatorFactory_SolutionWriter_hpp__
 
#include <string>
 
#include "PanzerAdaptersSTK_config.hpp"
#include "Panzer_PhysicsBlock.hpp"
#include "Panzer_BC.hpp"
#include "Panzer_Traits.hpp"
#include "Panzer_ResponseEvaluatorFactory.hpp"
 
#include "Panzer_STK_Interface.hpp"
 
#include "Teuchos_RCP.hpp"
#include "Teuchos_ParameterList.hpp"
 
#include <unordered_map>
#include <unordered_set>
 
namespace panzer_stk {
 
template <typename EvalT> 
class ResponseEvaluatorFactory_SolutionWriter : public panzer::ResponseEvaluatorFactory<EvalT> {
public:
 
   ResponseEvaluatorFactory_SolutionWriter(const Teuchos::RCP<STK_Interface> & mesh)
     : mesh_(mesh), addSolutionFields_(true), addCoordinateFields_(true) {}
 
   virtual ~ResponseEvaluatorFactory_SolutionWriter() {}
 
   virtual Teuchos::RCP<panzer::ResponseBase> buildResponseObject(const std::string & responseName) const;
 
   virtual Teuchos::RCP<panzer::ResponseBase> buildResponseObject(const std::string & responseName,
                                                          const std::vector<panzer::WorksetDescriptor>& /* wkstDesc */) const 
   { return buildResponseObject(responseName); }
   
   virtual void buildAndRegisterEvaluators(const std::string & responseName,
                                           PHX::FieldManager<panzer::Traits> & fm,
                                           const panzer::PhysicsBlock & physicsBlock,
                                           const Teuchos::ParameterList & user_data) const;
 
   virtual bool typeSupported() const;
 
   static void bucketByBasisType(const std::vector<std::pair<std::string,Teuchos::RCP<const panzer::PureBasis> > > & providedDofs,
                                 std::map<std::string,std::vector<std::string> > & basisBucket);
 
   void scaleField(const std::string & fieldName,double fieldScalar);
 
   void addAdditionalField(const std::string & fieldName,const Teuchos::RCP<const panzer::PureBasis> & basis);
 
   void setAddSolutionFields(bool asf) 
   { addSolutionFields_ = asf; }
 
   void setAddCoordinateFields(bool acf) 
   { addCoordinateFields_ = acf; }
 
   void removeField(const std::string & fieldName)
   { removedFields_.push_back(fieldName); }
 
  // should be private but needs a lambda
   void computeReferenceCentroid(const std::map<std::string,Teuchos::RCP<const panzer::PureBasis> > & bases,
                                 int baseDimension,
                                 Kokkos::DynRankView<double,PHX::Device> & centroid) const;
 
private:
   void deleteRemovedFields(const std::vector<std::string> & removedFields,
                            std::vector<std::pair<std::string,Teuchos::RCP<const panzer::PureBasis> > > & fields) const;
 
   struct RemovedFieldsSearchUnaryFunctor {
     std::vector<std::string> removedFields_;
     bool operator() (const std::pair<std::string,Teuchos::RCP<const panzer::PureBasis> > & field) 
     { return std::find(removedFields_.begin(),removedFields_.end(),field.first)!=removedFields_.end(); }
   };
 
   Teuchos::RCP<STK_Interface> mesh_;
 
   std::unordered_map<std::string,double> fieldToScalar_;
   std::unordered_set<std::string> scaledFieldsHash_; // used to print the warning about unused scaling
 
   std::vector<std::pair<std::string,Teuchos::RCP<const panzer::PureBasis> > > additionalFields_;
   std::vector<std::string> removedFields_;
   bool addSolutionFields_;
   bool addCoordinateFields_;
};
 
struct RespFactorySolnWriter_Builder {
  RespFactorySolnWriter_Builder() : addSolutionFields_(true), addCoordinateFields_(true) {}
 
  Teuchos::RCP<panzer_stk::STK_Interface> mesh;
 
  void scaleField(const std::string & fieldName,double fieldScalar)
  { fieldToScalar_[fieldName] = fieldScalar; }
 
  void addAdditionalField(const std::string & fieldName,const Teuchos::RCP<const panzer::PureBasis> & basis)
  { additionalFields_.push_back(std::make_pair(fieldName,basis)); }
 
  void removeField(const std::string & fieldName)
  { removedFields_.push_back(fieldName); }
 
  template <typename T>
  Teuchos::RCP<panzer::ResponseEvaluatorFactoryBase> build() const
  { 
    Teuchos::RCP<ResponseEvaluatorFactory_SolutionWriter<T> > ref = 
        Teuchos::rcp(new panzer_stk::ResponseEvaluatorFactory_SolutionWriter<T>(mesh)); 
 
    // disable/enable the solution fields
    ref->setAddSolutionFields(addSolutionFields_);
 
    // disable/enable the coordinate fields
    ref->setAddCoordinateFields(addCoordinateFields_);
 
    // add all additional fields
    for(std::size_t i=0;i<additionalFields_.size();i++)
      ref->addAdditionalField(additionalFields_[i].first,additionalFields_[i].second);
 
    for(std::size_t i=0;i<removedFields_.size();i++)
      ref->removeField(removedFields_[i]);
 
    // set all scaled field values
    for(std::unordered_map<std::string,double>::const_iterator itr=fieldToScalar_.begin();
        itr!=fieldToScalar_.end();++itr) 
      ref->scaleField(itr->first,itr->second);
 
    return ref;
  }
 
   void setAddSolutionFields(bool asf) 
   { addSolutionFields_ = asf; }
 
   void setAddCoordinateFields(bool acf) 
   { addCoordinateFields_ = acf; }
 
private:
  std::unordered_map<std::string,double> fieldToScalar_;
  std::vector<std::pair<std::string,Teuchos::RCP<const panzer::PureBasis> > > additionalFields_;
  std::vector<std::string> removedFields_;
  bool addSolutionFields_;
  bool addCoordinateFields_;
};
 
}
 
#endif