Panzer_Workset.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_WORKSET_HPP
#define PANZER_WORKSET_HPP
 
#include <cstddef>
#include <vector>
#include <map>
#include <iostream>
 
#include "Panzer_Dimension.hpp"
#include "Panzer_BasisValues2.hpp"
#include "Panzer_PointValues2.hpp"
#include "Panzer_IntegrationValues2.hpp"
#include "Panzer_Dimension.hpp"
 
#include "Panzer_IntegrationDescriptor.hpp"
#include "Panzer_BasisDescriptor.hpp"
 
#include "Phalanx_KokkosDeviceTypes.hpp"
 
namespace panzer {
 
  struct WorksetNeeds;
 
  struct LocalMeshPartition;
 
  class SubcellConnectivity;
 
  class OrientationsInterface;
 
  struct
  WorksetOptions
  {
    WorksetOptions():
      side_assembly_(false),
      align_side_points_(false)
    {
 
    }
 
    bool side_assembly_;
 
    bool align_side_points_;
 
    Teuchos::RCP<const OrientationsInterface> orientations_;
  };
 
  class WorksetDetails {
  public:
    typedef PHX::MDField<double,Cell,NODE,Dim> CellCoordArray;
 
    WorksetDetails();
 
    void
    setup(const LocalMeshPartition & partition,
          const WorksetOptions & options);
 
    int num_cells;
 
    int subcell_dim;
 
    // DEPRECATED - use: getLocalCellIDs()
    PHX::View<const int*> cell_local_ids_k;
 
    // DEPRECATED - use: getLocalCellIDs()
    std::vector<size_t> cell_local_ids;
 
    CellCoordArray cell_node_coordinates;
 
    std::string block_id;
 
    int subcell_index; 
 
    //TEUCHOS_DEPRECATED
    Teuchos::RCP< std::vector<int> > ir_degrees;
 
    //TEUCHOS_DEPRECATED
    mutable std::vector<Teuchos::RCP<panzer::IntegrationValues2<double> > > int_rules;
 
    //TEUCHOS_DEPRECATED
    Teuchos::RCP< std::vector<std::string> > basis_names;
 
    //TEUCHOS_DEPRECATED
    mutable std::vector<Teuchos::RCP< panzer::BasisValues2<double> > > bases;
 
    const panzer::SubcellConnectivity & getFaceConnectivity() const;
 
    const panzer::IntegrationRule & getIntegrationRule(const panzer::IntegrationDescriptor & description) const;
 
    const panzer::PureBasis & getBasis(const panzer::BasisDescriptor & description) const;
 
    const std::string &
    getElementBlock() const
    {return block_id;}
 
    const std::string &
    getSideset() const
    {return sideset_;}
 
    unsigned int
    numDimensions() const
    {return num_dimensions_;}
 
    int
    getSubcellIndex() const
    {return subcell_index;}
 
    int
    getSubcellDimension() const
    {return subcell_dim;}
 
    CellCoordArray
    getCellNodes() const
    {return cell_node_coordinates;}
 
    Kokkos::View<const int*,PHX::Device>
    getLocalCellIDs() const
    {return cell_local_ids_k;}
 
    const SubcellConnectivity &
    getSubcellConnectivity(const unsigned int subcell_dimension) const;
 
    bool
    hasSubcellConnectivity(const unsigned int subcell_dimension) const;
 
    const panzer::IntegrationValues2<double> &
    getIntegrationValues(const panzer::IntegrationDescriptor & description,
                         const bool lazy_version=false) const;
 
    /*
     * \brief Grab the basis values for a given basis description
     *
     * \note An arbitrary integration order is used - only use for getting basis coordinates
     *
     * \throws If setup has not been called
     *
     * \param[in] basis_description Description of requested basis
     * \param[in] lazy_version Get an empty BasisValues2 object that will construct/allocate itself on demand (less memory - EXPERIMENTAL)
     *
     * \return Object containing basis values
     */
    const panzer::BasisValues2<double> &
    getBasisValues(const panzer::BasisDescriptor & basis_description,
                   const bool lazy_version=false) const;
 
    /*
     * \brief Grab the basis values for a given basis description
     *
     * \throws If setup has not been called
     *
     * \todo This needs to be const, but one path for workset construction requires non-const
     *
     * \param[in] basis_description Description of requested basis
     * \param[in] integration_description Descriptor for integration scheme
     * \param[in] lazy_version Get an empty BasisValues2 object that will construct/allocate itself on demand (less memory - EXPERIMENTAL)
     *
     * \return Object containing basis values
     */
    panzer::BasisValues2<double> &
    getBasisValues(const panzer::BasisDescriptor & basis_description,
                   const panzer::IntegrationDescriptor & integration_description,
                   const bool lazy_version=false) const;
 
    /*
     * \brief Grab the basis values for a given basis description
     *
     * \throws If setup has not been called
     * \throws if point_descriptor has not been registered
     *
     * \param[in] basis_description Description of requested basis
     * \param[in] point_description Descriptor for points
     * \param[in] lazy_version Get an empty BasisValues2 object that will construct/allocate itself on demand (less memory - EXPERIMENTAL)
     *
     * \return Object containing basis values
     */
    const panzer::BasisValues2<double> &
    getBasisValues(const panzer::BasisDescriptor & basis_description,
                   const panzer::PointDescriptor & point_description,
                   const bool lazy_version=false) const;
 
    panzer::PointValues2<double> &
    getPointValues(const panzer::PointDescriptor & point_description) const;
 
    int numCells() const {return num_cells;}
 
    int numOwnedCells() const {return num_owned_cells_;}
 
    int numGhostCells() const {return num_ghost_cells_;}
 
    int numVirtualCells() const {return num_virtual_cells_;}
 
    void setNumberOfCells(const int owned_cells,
                          const int ghost_cells,
                          const int virtual_cells);
 
  protected:
 
    bool setup_;
 
    int num_owned_cells_;
    int num_ghost_cells_;
    int num_virtual_cells_;
 
    int num_dimensions_;
 
    std::string sideset_;
 
    WorksetOptions options_;
 
    Teuchos::RCP<const shards::CellTopology> cell_topology_;
 
    // TODO: Const vs non-const is complicated here due to how point values are generated and orientations are applied
    // Unifying the construction method for worksets will help reduce the clutter here, but point values will almost always be non-const
    mutable std::map<size_t,Teuchos::RCP<const panzer::PureBasis > > _pure_basis_map;
    mutable std::map<size_t,Teuchos::RCP<const panzer::IntegrationRule > > _integration_rule_map;
    mutable std::map<size_t,Teuchos::RCP<const panzer::PointRule > > _point_rule_map;
 
    mutable std::map<size_t,Teuchos::RCP<const panzer::IntegrationValues2<double> > > integration_values_map_;
    mutable std::map<size_t,Teuchos::RCP<panzer::PointValues2<double> > > point_values_map_;
    mutable std::map<size_t,std::map<size_t,Teuchos::RCP<panzer::BasisValues2<double> > > > basis_integration_values_map_;
    mutable std::map<size_t,std::map<size_t,Teuchos::RCP<panzer::BasisValues2<double> > > > basis_point_values_map_;
 
    Teuchos::RCP<panzer::SubcellConnectivity> face_connectivity_;
 
  };
 
  class Workset : public WorksetDetails {
  public:
    Workset() : identifier_(0) {}
 
    Workset(std::size_t identifier) : identifier_(identifier) {}
 
    void setIdentifier(std::size_t identifier) { identifier_ = identifier; }
 
    std::size_t getIdentifier() const { return identifier_; }
 
    double alpha;
    double beta;
    double time;
    double step_size;
    double stage_number;
    std::vector<double> gather_seeds; // generic gather seeds
    bool evaluate_transient_terms;
 
    Teuchos::RCP<WorksetDetails> other;
 
    WorksetDetails& operator()(const int i) {
      TEUCHOS_ASSERT(i == 0 || (i == 1 && Teuchos::nonnull(other)));
      return i == 0 ? static_cast<WorksetDetails&>(*this) : *other;
    }
    const WorksetDetails& operator()(const int i) const {
      TEUCHOS_ASSERT(i == 0 || (i == 1 && Teuchos::nonnull(other)));
      return i == 0 ? static_cast<const WorksetDetails&>(*this) : *other;
    }
    WorksetDetails& details(const int i) { return operator()(i); }
    const WorksetDetails& details(const int i) const { return operator()(i); }
    size_t numDetails() const { return Teuchos::nonnull(other) ? 2 : 1; }
 
  private:
    std::size_t identifier_;
  };
 
  std::ostream& operator<<(std::ostream& os, const panzer::Workset& w);
 
  class WorksetDetailsAccessor {
  public:
    WorksetDetailsAccessor() : details_index_(0) {}
    void setDetailsIndex(const int di) { details_index_ = di; }
    int getDetailsIndex() const { return details_index_; }
    WorksetDetails& operator()(Workset& workset) const {
      return workset(details_index_);
    }
    const WorksetDetails& operator()(const Workset& workset) const {
      return workset(details_index_);
    }
  private:
    int details_index_;
  };
 
} // namespace panzer
 
#endif