Panzer_WorksetDescriptor.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_WorksetDescriptor_hpp__
#define __Panzer_WorksetDescriptor_hpp__

#include <string>
#include <ostream>
#include <functional>
#include "Panzer_HashUtils.hpp"

namespace panzer {

  enum WorksetSizeType : int {
    CLASSIC_MODE=-2,
    ALL_ELEMENTS=-1,
    NO_ELEMENTS=0,
  };

class WorksetDescriptor {
public:

  WorksetDescriptor(const std::string & elementBlock,
                    const int worksetSize=WorksetSizeType::CLASSIC_MODE,
                    const bool requiresPartitioning=false,
                    const bool applyOrientations=true)
  : elementBlock_(elementBlock),
    worksetSize_(worksetSize),
    requiresPartitioning_(requiresPartitioning),
    applyOrientations_(applyOrientations),
    sideAssembly_(false)
  {
    TEUCHOS_TEST_FOR_EXCEPTION(elementBlock_=="",std::runtime_error,
                                   "WorksetDescriptor constr: Element block name must be non-empty!");
  }

  WorksetDescriptor(const std::string & elementBlock,
                    const std::string & sideset,
                    const bool sideAssembly)
  : elementBlock_(elementBlock),
    sideset_(sideset),
    worksetSize_(CLASSIC_MODE),
    requiresPartitioning_(false),
    applyOrientations_(true),
    sideAssembly_(sideAssembly)
  {
    TEUCHOS_TEST_FOR_EXCEPTION(elementBlock_=="",std::runtime_error,
                               "WorksetDescriptor constr: Element block name must be non-empty!");
    TEUCHOS_TEST_FOR_EXCEPTION(sideset_=="",std::runtime_error,
                               "WorksetDescriptor constr: Side set name must be non-empty!");
  }

  WorksetDescriptor(const std::string & elementBlock,
                    const std::string & sideset,
                    const int worksetSize=WorksetSizeType::CLASSIC_MODE,
                    const bool requiresPartitioning=false,
                    const bool applyOrientations=true)
  : elementBlock_(elementBlock),
    sideset_(sideset),
    worksetSize_(worksetSize),
    requiresPartitioning_(requiresPartitioning),
    applyOrientations_(applyOrientations),
    sideAssembly_(false)
  {
    TEUCHOS_TEST_FOR_EXCEPTION(elementBlock_=="",std::runtime_error,
                               "WorksetDescriptor constr: Element block name must be non-empty!");
    TEUCHOS_TEST_FOR_EXCEPTION(sideset_=="",std::runtime_error,
                               "WorksetDescriptor constr: Side set name must be non-empty!");
  }

  WorksetDescriptor(const std::string & elementBlock_0,
                    const std::string & elementBlock_1,
                    const std::string & sideset_0,
                    const std::string & sideset_1,
                    const int worksetSize=WorksetSizeType::CLASSIC_MODE,
                    const bool requiresPartitioning=false,
                    const bool applyOrientations=true)
  : elementBlock_(elementBlock_0),
    elementBlock_2_(elementBlock_1),
    sideset_(sideset_0),
    sideset_2_(sideset_1),
    worksetSize_(worksetSize),
    requiresPartitioning_(requiresPartitioning),
    applyOrientations_(applyOrientations),
    sideAssembly_(false)
  {
    TEUCHOS_TEST_FOR_EXCEPTION(elementBlock_=="",std::runtime_error,
                               "WorksetDescriptor constr: Element block 0 name must be non-empty!");
    TEUCHOS_TEST_FOR_EXCEPTION(sideset_=="",std::runtime_error,
                               "WorksetDescriptor constr: Side set 0 name must be non-empty!");
    TEUCHOS_TEST_FOR_EXCEPTION(elementBlock_2_=="",std::runtime_error,
                               "WorksetDescriptor constr: Element block 1 name must be non-empty!");
    TEUCHOS_TEST_FOR_EXCEPTION(sideset_2_=="",std::runtime_error,
                               "WorksetDescriptor constr: Side set 1 name must be non-empty!");
  }

  WorksetDescriptor(const WorksetDescriptor & src) = default;

  const std::string & getElementBlock(const int block=0) const
  { return (block==0) ? elementBlock_ : elementBlock_2_; }

  const std::string & getSideset(const int block=0) const
  { return (block==0) ? sideset_ : sideset_2_; }

  //TEUCHOS_DEPRECATED
  bool sideAssembly() const
  { return sideAssembly_; }
//  { return useSideset(); }

  bool connectsElementBlocks() const
  {
    return useSideset() and elementBlock_2_ != "";
  }

  bool requiresPartitioning() const
  {
    return requiresPartitioning_;
  }

  bool useSideset() const
  //{ return useSideset_; }
  { return sideset_ != ""; }

  int getWorksetSize() const
  { return worksetSize_; }

  bool applyOrientations() const {return applyOrientations_;}

private:

  std::string elementBlock_;

  std::string elementBlock_2_;

  std::string sideset_;

  std::string sideset_2_;

  int worksetSize_;

  bool requiresPartitioning_;

  bool applyOrientations_;

  bool sideAssembly_;
};

inline bool operator==(const WorksetDescriptor & a,const WorksetDescriptor & b)
{
  if(a.useSideset())
    // if side set is in use, check all fields
    return    a.getElementBlock()==b.getElementBlock()
        && a.getSideset()==b.getSideset()
        && a.sideAssembly()==b.sideAssembly()
        && a.useSideset()==b.useSideset();
  else
    // otherwise check that both descriptor don't use side sets
    // and check the element block (the remaining fields are allowed
    // to be unset)
    return    a.getElementBlock()==b.getElementBlock()
        && a.useSideset()==b.useSideset();
}

inline std::size_t hash_value(const WorksetDescriptor & wd)
{
  std::size_t seed = 0;

  panzer::hash_combine(seed,wd.getElementBlock());
  if(wd.useSideset()) {
    // optionally hash on side set and side assembly
    panzer::hash_combine(seed,wd.getSideset());
    panzer::hash_combine(seed,wd.sideAssembly());
  }

  return seed;
}

inline std::ostream & operator<<(std::ostream & os,const WorksetDescriptor & wd)
{
  if(wd.useSideset())
    os << "Side descriptor: "
    << "eblock = \"" << wd.getElementBlock() << "\", "
    << "ss = \"" << wd.getSideset() << "\", "
    << "side assembly = " << (wd.sideAssembly() ? "on" : "off");
  else
    os << "Block descriptor: "
    << "eblock = \"" << wd.getElementBlock() << "\"";

  return os;
}

//TEUCHOS_DEPRECATED
inline WorksetDescriptor blockDescriptor(const std::string & eBlock)
{ return WorksetDescriptor(eBlock); }

//TEUCHOS_DEPRECATED
inline WorksetDescriptor sidesetDescriptor(const std::string & eBlock,const std::string & sideset)
{ return WorksetDescriptor(eBlock,sideset,false); }

//TEUCHOS_DEPRECATED
inline WorksetDescriptor sidesetVolumeDescriptor(const std::string & eBlock,const std::string & sideset)
{ return WorksetDescriptor(eBlock,sideset,true); }

}

namespace std {

template <>
struct hash<panzer::WorksetDescriptor>
{
  std::size_t operator()(const panzer::WorksetDescriptor& wd) const
  {
    std::size_t seed = 0;

    panzer::hash_combine(seed,wd.getElementBlock());
    panzer::hash_combine(seed,wd.requiresPartitioning());
    panzer::hash_combine(seed,wd.getWorksetSize());
    if(wd.useSideset()) {
      // optionally hash on side set and side assembly
      panzer::hash_combine(seed,wd.getSideset());
      panzer::hash_combine(seed,wd.sideAssembly());
    }

    return seed;
  }
};

}

#endif