Example #1
0
int isPredefinedCell(const CellTopology& cell) {
  
  switch(cell.getKey() ) {
    case Node::key:
    case Particle::key:
    case Line<2>::key:
    case Line<3>::key:
    case ShellLine<2>::key:
    case ShellLine<3>::key:
    case Beam<2>::key:
    case Beam<3>::key:
      
    case Triangle<3>::key:
    case Triangle<4>::key:
    case Triangle<6>::key:
    case ShellTriangle<3>::key:
    case ShellTriangle<6>::key:
      
    case Quadrilateral<4>::key:
    case Quadrilateral<8>::key:
    case Quadrilateral<9>::key:
    case ShellQuadrilateral<4>::key:
    case ShellQuadrilateral<8>::key:
    case ShellQuadrilateral<9>::key:
      
    case Tetrahedron<4>::key:
    case Tetrahedron<8>::key:
    case Tetrahedron<10>::key:
    case Tetrahedron<11>::key:
      
    case Hexahedron<8>::key:
    case Hexahedron<20>::key:
    case Hexahedron<27>::key:
      
    case Pyramid<5>::key:
    case Pyramid<13>::key:
    case Pyramid<14>::key:
      
    case Wedge<6>::key:
    case Wedge<15>::key:
    case Wedge<18>::key:
      
    case Pentagon<5>::key:
    case Hexagon<6>::key:
      return 1;
      break;
      
    default:
      return 0;
  }
  
}
Example #2
0
    TopologyId
    getCellTopologyId(
                      const CellTopology &  cell_topology)
    {
      if (cell_topology.getCellTopologyData() == 0)
        return INVALID;
  
      IdCellTopologyMap &cell_topology_map = get_id_cell_topology_map();

      IdCellTopologyMap::const_iterator it = cell_topology_map.find(cell_topology);
  
      if (it == cell_topology_map.end())
        {
          //throw RuntimeError() << "Cell topology " << cell_topology.getName() << " is not defined";
          std::ostringstream msg;
          msg << "Cell topology " << cell_topology.getName() << " is not defined";
          throw std::runtime_error(msg.str());

        }

      return (*it).second;
    }
Example #3
0
CellTopology get_cell_topology_new( const Bucket & bucket)
{
  const BulkData   &  bulk_data = BulkData::get(bucket);
  const FEMMetaData & fem_meta_data = FEMMetaData::get(bulk_data);
  const PartVector & all_parts = fem_meta_data.get_parts();

  CellTopology cell_topology;

  const std::pair< const unsigned *, const unsigned * > supersets = bucket.superset_part_ordinals();

  if (supersets.first != supersets.second) {
    const Part *first_found_part = NULL;

    for ( const unsigned * it = supersets.first ; it != supersets.second ; ++it ) {

      const Part & part = * all_parts[*it] ;

      if ( part.primary_entity_rank() == bucket.entity_rank() ) {

        CellTopology top = fem_meta_data.get_cell_topology( part );

        if ( ! cell_topology.getCellTopologyData() ) {
          cell_topology = top ;

          if (!first_found_part)
            first_found_part = &part;
        }
        else {
          ThrowErrorMsgIf( top.getCellTopologyData() && top != cell_topology,
            "Cell topology is ambiguously defined. It is defined as " << cell_topology.getName() <<
            " on part " << first_found_part->name() << " and as " << top.getName() << " on its superset part " << part.name() );
        }
      }
    }
  }

  return cell_topology ;  
}
Example #4
0
int findPermutation( const CellTopology top ,
                     const id_type * const expected_node ,
                     const id_type * const actual_node )
{
  return shards::findPermutation( *top.getCellTopologyData() , expected_node , actual_node );
}
Example #5
0
    double GeometryVerifier::getEquiVol(CellTopology& cell_topo)
    {
      double volEqui = 1.0;
      switch(cell_topo.getKey() )
        {

          // Tet cells
        case shards::Tetrahedron<4>::key:
        case shards::Tetrahedron<8>::key:
        case shards::Tetrahedron<10>::key:
          volEqui = std::sqrt(2.)/12.;
          break;

          // Hex cells
        case shards::Hexahedron<8>::key:
        case shards::Hexahedron<20>::key:
        case shards::Hexahedron<27>::key:
          volEqui = 1.0;
          break;

          // Pyramid cells
        case shards::Pyramid<5>::key:
        case shards::Pyramid<13>::key:
        case shards::Pyramid<14>::key:
          volEqui = std::sqrt(2.)/6.;
          break;

          // Wedge cells
        case shards::Wedge<6>::key:
        case shards::Wedge<15>::key:
        case shards::Wedge<18>::key:
          volEqui = std::sqrt(3.)/4.;
          break;

        case shards::Triangle<3>::key:
        case shards::Triangle<4>::key:
        case shards::Triangle<6>::key:
          volEqui = std::sqrt(3.)/4.;
          break;

        case shards::Quadrilateral<4>::key:
        case shards::Quadrilateral<8>::key:
        case shards::Quadrilateral<9>::key:
          volEqui = 1.0;
          break;

        case shards::ShellTriangle<3>::key:
        case shards::ShellTriangle<6>::key:
          volEqui = std::sqrt(3.)/4.;
          break;

        case shards::ShellQuadrilateral<4>::key:
        case shards::ShellQuadrilateral<8>::key:
        case shards::ShellQuadrilateral<9>::key:
          volEqui = 1.0;
          break;

        case shards::ShellLine<2>::key:
        case shards::ShellLine<3>::key:
        case shards::Beam<2>::key:
        case shards::Beam<3>::key:
          volEqui = 1.0;
          break;

        default:
          break;
        }//cell key
      return volEqui;
    }