Panzer_STK_PeriodicBC_Matcher.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_STK_PeriodicBC_Matcher_hpp__
#define __Panzer_STK_PeriodicBC_Matcher_hpp__
 
#include "Teuchos_Tuple.hpp"
#include "Teuchos_RCP.hpp"
 
#include "Panzer_STK_Version.hpp"
#include "PanzerAdaptersSTK_config.hpp"
#include "Panzer_STK_Interface.hpp"
 
#ifdef PANZER_HAVE_STKSEARCH
#include "stk_search/CoarseSearch.hpp"
#endif
 
namespace panzer_stk {
 
namespace periodic_helpers {
 
#ifdef PANZER_HAVE_STKSEARCH
  // Copied from PeriodicBoundarySearch
  typedef stk::search::IdentProc<stk::mesh::EntityKey> SearchId;
  typedef stk::search::Sphere<double> Sphere;
  typedef std::vector< std::pair<Sphere,SearchId> > SphereIdVector;
  typedef std::vector<std::pair<SearchId,SearchId> > SearchPairVector;
  typedef std::vector<std::pair<stk::mesh::EntityKey,stk::mesh::EntityKey> > SearchPairSet;
#endif
 
   template <typename Matcher>
   Teuchos::RCP<std::vector<std::pair<std::size_t,std::size_t> > >
   matchPeriodicSides(const std::string & left,const std::string & right,
                     const STK_Interface & mesh,
                     const Matcher & matcher, const std::string type_ = "coord");
 
   template <typename Matcher>
   Teuchos::RCP<std::vector<std::pair<std::size_t,std::size_t> > >
   matchPeriodicSides(const std::string & left,const std::string & right,
                     const STK_Interface & mesh,
                     const Matcher & matcher,
                     const std::vector<std::pair<std::size_t,std::size_t> > & current, const std::string type_ = "coord");
 
   std::pair<Teuchos::RCP<std::vector<std::size_t> >,
             Teuchos::RCP<std::vector<Teuchos::Tuple<double,3> > > >
   getSideIdsAndCoords(const STK_Interface & mesh,
                       const std::string & sideName, const std::string type_ = "coord");
 
   std::pair<Teuchos::RCP<std::vector<std::size_t> >,
             Teuchos::RCP<std::vector<Teuchos::Tuple<double,3> > > >
   getLocalSideIdsAndCoords(const STK_Interface & mesh,
                            const std::string & sideName, const std::string type_ = "coord");
 
   Teuchos::RCP<std::vector<std::size_t> >
   getLocalSideIds(const STK_Interface & mesh,
                   const std::string & sideName, const std::string type_ = "coord");
 
   template <typename Matcher>
   Teuchos::RCP<std::vector<std::pair<std::size_t,std::size_t> > >
   getLocallyMatchedSideIds(const std::vector<std::size_t> & side_ids,
                            const std::vector<Teuchos::Tuple<double,3> > & side_coords,
                            const STK_Interface & mesh,
                            const std::string & sideName,const Matcher & matcher, const std::string type_ = "coord");
 
   Teuchos::RCP<std::vector<std::pair<std::size_t,std::size_t> > >
   getGlobalPairing(const std::vector<std::size_t> & locallyRequiredIds,
                    const std::vector<std::pair<std::size_t,std::size_t> > & locallyMatchedIds,
                    const STK_Interface & mesh,bool failure);
 
#ifdef PANZER_HAVE_STKSEARCH
  void fillLocalSearchVector(const STK_Interface & mesh, SphereIdVector & searchVector, const double & error,
                             const std::string & sideName, const std::string & type_, const bool & getGhostedIDs, 
                             const std::vector<std::string> & matchedSides, std::vector<SearchId> & potentialIDsToRemap);
 
  void fillLocalSearchVector(const STK_Interface & mesh, SphereIdVector & searchVector, const double & error,
                             const std::string & sideName, const std::string & type_, const bool & getGhostedIDs = false);
 
  const std::vector<double> computeGlobalCentroid(const STK_Interface & mesh, const std::string & sideName);
 
  template<typename Matcher> void
  transformLocalSearchVector(SphereIdVector & searchVectorSideA, const Matcher & matcher, const std::vector<double> & centroidSideB );
 
  template <typename Matcher>
  Teuchos::RCP<std::vector<std::pair<size_t,size_t> > > 
  matchPeriodicSidesSearch(const std::string & sideA,const std::string & sideB,
                           const STK_Interface & mesh,
                           const Matcher & matcher, const std::vector<std::string> & matchedSides,
                           const std::vector<std::pair<size_t,size_t> > & previousMatches,
                           const std::string type_ = "coord");
 
  template <typename Matcher>
  Teuchos::RCP<std::vector<std::pair<size_t,size_t> > > 
  matchPeriodicSidesSearch(const std::string & sideA, const std::string & sideB,
                           const STK_Interface & mesh,
                           const Matcher & matcher, const std::string type_ = "coord");
 
  void updateMapping(Teuchos::RCP<std::vector<std::pair<size_t,size_t> > > & currentMatches,
                     const std::vector<std::pair<size_t,size_t> > & previousMatches,
                     const std::vector<SearchId> & IDsToRemap, const STK_Interface & mesh);
 
  void appendMapping(Teuchos::RCP<std::vector<std::pair<size_t,size_t> > > & currentMatches,
                     const std::vector<std::pair<size_t,size_t> > & previousMatches);
#endif
} // end periodic_helpers
 
class PeriodicBC_MatcherBase {
public:
   virtual ~PeriodicBC_MatcherBase() {}
 
   virtual 
   Teuchos::RCP<std::vector<std::pair<std::size_t,std::size_t> > >
   getMatchedPair(const STK_Interface & mesh,
                  const Teuchos::RCP<const std::vector<std::pair<std::size_t,std::size_t> > > & currentState = Teuchos::null
                  ) const = 0;
 
#ifdef PANZER_HAVE_STKSEARCH
   virtual 
   Teuchos::RCP<std::vector<std::pair<std::size_t,std::size_t> > >
   getMatchedPair(const STK_Interface & mesh, const std::vector<std::string> & matchedSides,
                  const Teuchos::RCP<const std::vector<std::pair<std::size_t,std::size_t> > > & currentState = Teuchos::null
                  ) const = 0;
#endif 
 
   virtual std::string getString() const = 0;
 
   virtual std::string getType() const = 0;
 
   virtual std::string getLeftSidesetName() const = 0;
 
   virtual std::string getRightSidesetName() const = 0;
 
  template<typename T>
  const T* getAs() const {return dynamic_cast<const T*>(this);}
};
 
template <typename Matcher>
class PeriodicBC_Matcher : public PeriodicBC_MatcherBase {
public:
   PeriodicBC_Matcher(const std::string & left, const std::string & right,const Matcher & matcher, const std::string type = "coord")
      : left_(left), right_(right), matcher_(matcher), type_(type) {}
   PeriodicBC_Matcher(const PeriodicBC_Matcher & src)
      : left_(src.left_), right_(src.right_), matcher_(src.matcher_), type_(src.type_) {}
 
   Teuchos::RCP<std::vector<std::pair<std::size_t,std::size_t> > >
   getMatchedPair(const STK_Interface & mesh,
                  const Teuchos::RCP<const std::vector<std::pair<std::size_t,std::size_t> > > & currentState = Teuchos::null
                  ) const
   { 
      if(currentState==Teuchos::null) 
         return periodic_helpers::matchPeriodicSides(left_,right_,mesh,matcher_,type_); 
      else
         return periodic_helpers::matchPeriodicSides(left_,right_,mesh,matcher_,*currentState,type_); 
   }
 
#ifdef PANZER_HAVE_STKSEARCH
   Teuchos::RCP<std::vector<std::pair<std::size_t,std::size_t> > >
   getMatchedPair(const STK_Interface & mesh, const std::vector<std::string> & matchedSides,
                  const Teuchos::RCP<const std::vector<std::pair<std::size_t,std::size_t> > > & currentState = Teuchos::null
                  ) const
   { 
      if(currentState==Teuchos::null) 
         return periodic_helpers::matchPeriodicSidesSearch(left_,right_,mesh,matcher_,type_); 
      else
         return periodic_helpers::matchPeriodicSidesSearch(left_,right_,mesh,matcher_,matchedSides,*currentState,type_); 
   }
#endif
 
   std::string getString() const 
   { 
      std::stringstream ss;
      ss << "condition: " << matcher_.getString() << ", sides = [ "
         << "\"" << left_ << "\", "
         << "\"" << right_ << "\" ]";
      return ss.str();
   }
 
   std::string getType() const 
   {return type_;}
 
   std::string getLeftSidesetName() const
   {return left_;}
 
   std::string getRightSidesetName() const
   {return right_;}
 
   const Matcher& getMatcher() const
   {return matcher_;}
 
private:
   PeriodicBC_Matcher(); // hidden!
 
   std::string left_;  // here left & right are stand in names just so
   std::string right_; // that we realize that these boundaries are
                               // opposite of each other.
   Matcher matcher_;
 
   std::string type_; // type of periodic BC: coord, edge, face
 
};
 
template <typename Matcher>
Teuchos::RCP<PeriodicBC_MatcherBase> 
buildPeriodicBC_Matcher(const std::string & left, const std::string & right, const Matcher & matcher, const std::string type = "coord")
{ return Teuchos::rcp(new PeriodicBC_Matcher<Matcher>(left,right,matcher,type)); }
 
} // end panzer_stk
 
#include "Panzer_STK_PeriodicBC_Matcher_impl.hpp"
 
#ifdef PANZER_HAVE_STKSEARCH
#include "Panzer_STK_PeriodicBC_Search_impl.hpp"
#endif
 
#endif