Skip to content
Snippets Groups Projects
Select Git revision
  • cdcc53a139cefd47fbf9773224d38e63fab6bc11
  • master default protected
  • clem_dev
  • clem_dev_corrected
  • kokkos
  • devel
  • bcast_debug
  • MC/high_order_geometry
  • MC/mpi_nonblocking
  • MC/multigpu
  • MC/lifting_oneshot
  • MC/physent
  • curls_marco
  • MC/gefpg_lua_binding
  • emdant/dg-cherry-pick-8f1f09f5
  • v0.3.0
  • v0.2.0
  • v0.1.0
18 results

test_lifting_gpu.cpp

Blame
  • FuncSpaceData.cpp 4.42 KiB
    // Gmsh - Copyright (C) 1997-2012 C. Geuzaine, J.-B-> Remacle
    //
    // See the LICENSE.txt file for license information. Please report all
    // bugs and problems to the public mailing list <gmsh@onelab.info>.
    
    #include "FuncSpaceData.h"
    #include "MElement.h"
    
    FuncSpaceData::FuncSpaceData(const FuncSpaceData &fsd,
                                 int order,
                                 const bool *serendip) :
      _tag(fsd._tag), _spaceOrder(order),
      _serendipity(serendip ? *serendip : fsd._serendipity),
      _nij(0), _nk(_spaceOrder), _pyramidalSpace(fsd._pyramidalSpace)
    {}
    
    FuncSpaceData::FuncSpaceData(const FuncSpaceData &fsd,
                                 int nij, int nk,
                                 const bool *serendip) :
      _tag(fsd._tag), _spaceOrder(fsd._pyramidalSpace ? nij+nk : std::max(nij, nk)),
      _serendipity(serendip ? *serendip : fsd._serendipity),
      _nij(nij), _nk(nk), _pyramidalSpace(fsd._pyramidalSpace)
    {}
    
    FuncSpaceData::FuncSpaceData(const MElement *el, const bool *serendip) :
      _tag(el->getTypeForMSH()), _spaceOrder(el->getPolynomialOrder()),
      _serendipity(serendip ? *serendip : el->getIsOnlySerendipity()),
      _nij(0), _nk(_spaceOrder), _pyramidalSpace(el->getType() == TYPE_PYR)
    {}
    
    FuncSpaceData::FuncSpaceData(const MElement *el, int order, const bool *serendip) :
      _tag(el->getTypeForMSH()), _spaceOrder(order),
      _serendipity(serendip ? *serendip : el->getIsOnlySerendipity()),
      _nij(0), _nk(_spaceOrder), _pyramidalSpace(el->getType() == TYPE_PYR)
    {}
    
    FuncSpaceData::FuncSpaceData(const MElement *el, bool pyr, int nij, int nk,
                                 const bool *serendip) :
      _tag(el->getTypeForMSH()), _spaceOrder(pyr ? nij+nk : std::max(nij, nk)),
      _serendipity(serendip ? *serendip : el->getIsOnlySerendipity()),
      _nij(nij), _nk(nk), _pyramidalSpace(pyr)
    {
      if (el->getType() != TYPE_PYR)
        Msg::Error("Creation of pyramidal space data for a non-pyramid element !");
    }
    
    FuncSpaceData::FuncSpaceData(int tag, const bool *serendip) :
      _tag(tag), _spaceOrder(ElementType::OrderFromTag(tag)),
      _serendipity(serendip ? *serendip : ElementType::SerendipityFromTag(_tag) > 1),
      _nij(0), _nk(_spaceOrder),
      _pyramidalSpace(ElementType::ParentTypeFromTag(tag) == TYPE_PYR)
    {}
    
    FuncSpaceData::FuncSpaceData(bool isTag, int tagOrType, int order,
                                 const bool *serendip, bool elemIsSerendip) :
      _tag(isTag ? tagOrType : ElementType::getTag(tagOrType, order, elemIsSerendip)),
      _spaceOrder(order),
      _serendipity(serendip ? *serendip : ElementType::SerendipityFromTag(_tag) > 1),
      _nij(0), _nk(_spaceOrder),
      _pyramidalSpace(isTag ?
          ElementType::ParentTypeFromTag(tagOrType) == TYPE_PYR :
          tagOrType == TYPE_PYR)
    {}
    
    FuncSpaceData::FuncSpaceData(bool isTag, int tagOrType, bool pyr, int nij,
                                 int nk, const bool *serendip, bool elemIsSerendip) :
      _tag(isTag ? tagOrType :
           ElementType::getTag(tagOrType, pyr ? nij+nk : std::max(nij, nk), elemIsSerendip)),
      _spaceOrder(pyr ? nij+nk : std::max(nij, nk)),
      _serendipity(serendip ? *serendip : ElementType::SerendipityFromTag(_tag) > 1),
      _nij(nij), _nk(nk), _pyramidalSpace(pyr)
    {
      if (ElementType::ParentTypeFromTag(_tag) != TYPE_PYR)
        Msg::Error("Creation of pyramidal space data for a non-pyramid element!");
    }
    
    void FuncSpaceData::getOrderForBezier(int order[3], int exponentZ) const
    {
      if (_pyramidalSpace && exponentZ < 0) {
        Msg::Error("getOrderForBezier needs third exponent for pyramidal space!");
        order[0] = order[1] = order[2] = -1;
        return;
      }
      if (elementType() == TYPE_PYR) {
        if (_pyramidalSpace) {
          order[0] = order[1] = _nij + exponentZ;
          order[2] = _nk;
        }
        else {
          order[0] = order[1] = _nij;
          order[2] = _nk;
        }
      }
      else
        order[0] = order[1] = order[2] = _spaceOrder;
    }
    
    FuncSpaceData FuncSpaceData::getForPrimaryElement() const
    {
      int type = elementType();
      int primTag = ElementType::getTag(type, 1, elementIsOnlySerendipity());
    
      if (primTag == _tag) return *this;
    
      if (type == TYPE_PYR)
        return FuncSpaceData(true, primTag, _pyramidalSpace, _nij, _nk, &_serendipity);
      else
        return FuncSpaceData(true, primTag, _spaceOrder, &_serendipity);
    }
    
    FuncSpaceData FuncSpaceData::getForNonSerendipitySpace() const
    {
      if (!_serendipity) return *this;
    
      int type = elementType();
      bool serendip = false;
      if (type == TYPE_PYR)
        return FuncSpaceData(true, _tag, _pyramidalSpace, _nij, _nk, &serendip);
      else
        return FuncSpaceData(true, _tag, _spaceOrder, &serendip);
    }