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) 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_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());
    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