Panzer_IntegrationValues2.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_INTEGRATION_VALUES2_HPP
#define PANZER_INTEGRATION_VALUES2_HPP
 
#include "Teuchos_RCP.hpp"
 
#include "PanzerDiscFE_config.hpp"
#include "Panzer_IntegrationRule.hpp"
#include "Panzer_ArrayTraits.hpp"
#include "Panzer_Dimension.hpp"
#include "Phalanx_MDField.hpp"
#include "Intrepid2_Cubature.hpp"
 
namespace panzer {
 
  class SubcellConnectivity;
 
  template <typename Scalar>
  class IntegrationValues2 {
  public:
    typedef typename ArrayTraits<Scalar,PHX::MDField<Scalar> >::size_type size_type;
 
    typedef PHX::MDField<Scalar> ArrayDynamic;
    typedef PHX::MDField<double> DblArrayDynamic;
 
    typedef PHX::MDField<Scalar,IP>               Array_IP;
    typedef PHX::MDField<Scalar,IP,Dim>           Array_IPDim;
    typedef PHX::MDField<Scalar,Point>            Array_Point;
    typedef PHX::MDField<Scalar,Cell,IP>          Array_CellIP;
    typedef PHX::MDField<Scalar,Cell,IP,Dim>      Array_CellIPDim;
    typedef PHX::MDField<Scalar,Cell,IP,Dim,Dim>  Array_CellIPDimDim;
    typedef PHX::MDField<Scalar,Cell,BASIS,Dim>   Array_CellBASISDim;
 
    typedef PHX::MDField<const Scalar,IP>               ConstArray_IP;
    typedef PHX::MDField<const Scalar,IP,Dim>           ConstArray_IPDim;
    typedef PHX::MDField<const Scalar,Point>            ConstArray_Point;
    typedef PHX::MDField<const Scalar,Cell,IP>          ConstArray_CellIP;
    typedef PHX::MDField<const Scalar,Cell,IP,Dim>      ConstArray_CellIPDim;
    typedef PHX::MDField<const Scalar,Cell,IP,Dim,Dim>  ConstArray_CellIPDimDim;
    typedef PHX::MDField<const Scalar,Cell,BASIS,Dim>   ConstArray_CellBASISDim;
 
    IntegrationValues2(const std::string & pre="",
                       const bool allocArrays=false);
 
 
    // =====================================================================================================
    // Classic Interface (DEPRECATED)
 
    void setupArrays(const Teuchos::RCP<const panzer::IntegrationRule>& ir);
 
    void evaluateValues(const PHX::MDField<Scalar,Cell,NODE,Dim> & cell_node_coordinates,
                        const int num_cells = -1,
                        const Teuchos::RCP<const SubcellConnectivity> & face_connectivity = Teuchos::null,
                        const int num_virtual_cells = -1);
 
    void evaluateValues(const PHX::MDField<Scalar,Cell,NODE,Dim> & cell_node_coordinates,
                        const PHX::MDField<Scalar,Cell,IP,Dim> & other_ip_coordinates,
                        const int num_cells = -1);
 
    // Reference space quantities
    mutable Array_IPDim cub_points;              // <IP,Dim>
    mutable Array_IPDim side_cub_points;         // <IP,Dim> points on face topology (dim-1)
    mutable Array_IP cub_weights;                // <IP>
 
    // Physical space quantities
    mutable Array_CellBASISDim node_coordinates; // <Cell,BASIS,Dim>
    mutable Array_CellIPDimDim jac;              // <Cell,IP,Dim,Dim>
    mutable Array_CellIPDimDim jac_inv;          // <Cell,IP,Dim,Dim>
    mutable Array_CellIP jac_det;                // <Cell,IP>
    mutable Array_CellIP weighted_measure;       // <Cell,IP>
    mutable Array_CellIPDim weighted_normals;    // <Cell,IP,Dim>
    mutable Array_CellIPDim surface_normals;    // <Cell,IP,Dim>
    mutable Array_CellIPDimDim surface_rotation_matrices;    // <Cell,IP,Dim,Dim>
      // this (appears) is a matrix where the first row is the "normal" direction
      // and the remaining two rows lie in the hyperplane
 
    // for Shakib stabilization <Cell,IP,Dim,Dim>
    mutable Array_CellIPDimDim covarient;
    mutable Array_CellIPDimDim contravarient;
    mutable Array_CellIP norm_contravarient;
 
    // integration points
    mutable Array_CellIPDim ip_coordinates;      // <Cell,IP,Dim>
    mutable Array_CellIPDim ref_ip_coordinates;  // <Cell,IP,Dim> for Control Volumes or Surface integrals
 
 
    Teuchos::RCP<const panzer::IntegrationRule> int_rule;
 
    Teuchos::RCP<Intrepid2::Cubature<PHX::Device::execution_space,double,double>> intrepid_cubature;
 
    // =====================================================================================================
    // Lazy evaluation interface
 
    void
    setup(const Teuchos::RCP<const panzer::IntegrationRule>& ir,
          const PHX::MDField<Scalar,Cell,NODE,Dim> & cell_node_coordinates,
          const int num_cells = -1);
 
    void
    setupPermutations(const Teuchos::RCP<const SubcellConnectivity> & face_connectivity,
                      const int num_virtual_cells);
 
    void
    setupPermutations(const PHX::MDField<Scalar,Cell,IP,Dim> & other_ip_coordinates);
 
    ConstArray_IPDim
    getUniformCubaturePointsRef(const bool cache = true,
                                const bool force = false,
                                const bool apply_permutation = true) const;
 
    ConstArray_IPDim
    getUniformSideCubaturePointsRef(const bool cache = true,
                                    const bool force = false,
                                    const bool apply_permutation = true) const;
 
    ConstArray_IP
    getUniformCubatureWeightsRef(const bool cache = true,
                                 const bool force = false,
                                 const bool apply_permutation = true) const;
 
 
    ConstArray_CellBASISDim
    getNodeCoordinates() const;
 
    ConstArray_CellIPDimDim
    getJacobian(const bool cache = true,
                const bool force = false) const;
 
 
    ConstArray_CellIPDimDim
    getJacobianInverse(const bool cache = true,
                       const bool force = false) const;
 
    ConstArray_CellIP
    getJacobianDeterminant(const bool cache = true,
                           const bool force = false) const;
 
    ConstArray_CellIP
    getWeightedMeasure(const bool cache = true,
                       const bool force = false) const;
 
    ConstArray_CellIPDim
    getWeightedNormals(const bool cache = true,
                       const bool force = false) const;
 
    ConstArray_CellIPDim
    getSurfaceNormals(const bool cache = true,
                      const bool force = false) const;
 
    ConstArray_CellIPDimDim
    getSurfaceRotationMatrices(const bool cache = true,
                               const bool force = false) const;
 
    ConstArray_CellIPDimDim
    getCovarientMatrix(const bool cache = true,
                       const bool force = false) const;
 
    ConstArray_CellIPDimDim
    getContravarientMatrix(const bool cache = true,
                           const bool force = false) const;
 
    ConstArray_CellIP
    getNormContravarientMatrix(const bool cache = true,
                               const bool force = false) const;
 
    ConstArray_CellIPDim
    getCubaturePoints(const bool cache = true,
                      const bool force = false) const;
 
    ConstArray_CellIPDim
    getCubaturePointsRef(const bool cache = true,
                         const bool force = false) const;
 
    Teuchos::RCP<const panzer::IntegrationRule>
    getIntegrationRule() const
    {return int_rule;}
 
    // =====================================================================================================
 
  protected:
 
    // Reset all the lazy evaluation arrays
    void
    resetArrays();
 
    // Number of cells in mesh
    int num_cells_;
 
    // Number of cells in mesh to evaluate
    int num_evaluate_cells_;
 
    // Number of virtual cells in the mesh - used for surface evaluations
    int num_virtual_cells_;
 
    // Permutations (used to re-orient arrays similar to orientations in BasisValues2)
    bool requires_permutation_;
 
    // Array contains the mapping from uniform reference space to permuted space
    PHX::MDField<const int,Cell,IP> permutations_;
 
    // TODO: There is a way around this, but it will require some work
    // Subcell connectivity is required for surface evaluations (normals and rotation matrices)
    Teuchos::RCP<const SubcellConnectivity> side_connectivity_;
 
    // Lazy evaluation checks
    mutable bool cub_points_evaluated_;
    mutable bool side_cub_points_evaluated_;
    mutable bool cub_weights_evaluated_;
    mutable bool node_coordinates_evaluated_;
    mutable bool jac_evaluated_;
    mutable bool jac_inv_evaluated_;
    mutable bool jac_det_evaluated_;
    mutable bool weighted_measure_evaluated_;
    mutable bool weighted_normals_evaluated_;
    mutable bool surface_normals_evaluated_;
    mutable bool surface_rotation_matrices_evaluated_;
    mutable bool covarient_evaluated_;
    mutable bool contravarient_evaluated_;
    mutable bool norm_contravarient_evaluated_;
    mutable bool ip_coordinates_evaluated_;
    mutable bool ref_ip_coordinates_evaluated_;
 
    // Backward compatibility call that evaluates all internal values for CV, surface, side, or volume integration schemes
    void
    evaluateEverything();
 
  private:
 
    bool alloc_arrays_;
    std::string prefix_;
    std::vector<PHX::index_size_type> ddims_;
 
  };
 
} // namespace panzer
 
#endif