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