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