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) Sandia Corporation
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact Roger P. Pawlowski (rppawlo@sandia.gov) and
// Eric C. Cyr (eccyr@sandia.gov)
// ***********************************************************************
// @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 WorksetDetails {
  public:
    typedef PHX::MDField<double,Cell,NODE,Dim> CellCoordArray;

    typedef std::size_t GO;
    typedef int LO;

    WorksetDetails()
      : _num_owned_cells(-1)
      , _num_ghost_cells(-1)
      , _num_virtual_cells(-1)
    { }

    void setup(const panzer::LocalMeshPartition & partition, const panzer::WorksetNeeds & needs);

    void setupNeeds(Teuchos::RCP<const shards::CellTopology> cell_topology,
                    const Kokkos::View<double***,PHX::Device> & cell_vertices,
                    const panzer::WorksetNeeds & needs);

    Kokkos::View<const int*,PHX::Device> cell_local_ids_k;
    std::vector<GO> cell_local_ids;
    CellCoordArray cell_vertex_coordinates;
    std::string block_id;

    int subcell_index; 

    //TEUCHOS_DEPRECATED
    Teuchos::RCP< std::vector<int> > ir_degrees;
    
    //TEUCHOS_DEPRECATED
    std::vector<Teuchos::RCP<panzer::IntegrationValues2<double> > > int_rules;
    
    //TEUCHOS_DEPRECATED
    Teuchos::RCP< std::vector<std::string> > basis_names;

    //TEUCHOS_DEPRECATED
    std::vector<Teuchos::RCP< panzer::BasisValues2<double> > > bases;

    const panzer::SubcellConnectivity & getFaceConnectivity() const;

    const panzer::IntegrationValues2<double> & getIntegrationValues(const panzer::IntegrationDescriptor & description) const;

    const panzer::IntegrationRule & getIntegrationRule(const panzer::IntegrationDescriptor & description) const;

    panzer::BasisValues2<double> & getBasisValues(const panzer::BasisDescriptor & basis_description, 
                                                  const panzer::IntegrationDescriptor & integration_description);

    const panzer::BasisValues2<double> & getBasisValues(const panzer::BasisDescriptor & basis_description, 
                                                        const panzer::IntegrationDescriptor & integration_description) const;

    const panzer::BasisValues2<double> & getBasisValues(const panzer::BasisDescriptor & basis_description, 
                                                        const panzer::PointDescriptor & point_description) const;

    const panzer::PointValues2<double> & getPointValues(const panzer::PointDescriptor & point_description) const;

    const panzer::PureBasis & getBasis(const panzer::BasisDescriptor & description) const;

    int numOwnedCells() const {return _num_owned_cells;}

    int numGhostCells() const {return _num_ghost_cells;}

    int numVirtualCells() const {return _num_virtual_cells;}

    void setNumberOfCells(int o_cells,int g_cells,int v_cells)
    {
      _num_owned_cells = o_cells;
      _num_ghost_cells = g_cells;
      _num_virtual_cells = v_cells;
    }

  protected:

    int _num_owned_cells;
    int _num_ghost_cells;
    int _num_virtual_cells;

    std::map<size_t,Teuchos::RCP<const panzer::IntegrationRule > > _integration_rule_map;
    std::map<size_t,Teuchos::RCP<const panzer::IntegrationValues2<double> > > _integrator_map;

    std::map<size_t,Teuchos::RCP<const panzer::PureBasis > > _pure_basis_map;
    std::map<size_t,std::map<size_t,Teuchos::RCP<panzer::BasisValues2<double> > > > _basis_map;

    std::map<size_t,Teuchos::RCP<const panzer::PointRule > > _point_rule_map;
    std::map<size_t,Teuchos::RCP<const panzer::PointValues2<double> > > _point_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_; }

    index_t num_cells;
    int subcell_dim; 
    
    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