//---------------------------------------------------------------------------- // // Random fracture criterion function. // bool RandomCriterion::computeFractureCriterion(stk::mesh::Entity& entity, double p) { // Fracture only defined on the boundary of the elements stk::mesh::EntityRank rank = entity.entity_rank(); assert(rank == num_dim_ - 1); stk::mesh::PairIterRelation neighbor_elems = entity.relations(element_rank_); // Need an element on each side if(neighbor_elems.size() != 2) return false; bool is_open = false; // All we need to do is generate a number between 0 and 1 double random = 0.5 + 0.5 * Teuchos::ScalarTraits<double>::random(); if(random < p) { is_open = true; } return is_open; }
bool AAdapt::STKUnifUnrefineField::operator()(const stk::mesh::Entity element, stk::mesh::FieldBase* field, const stk::mesh::BulkData& bulkData) { const stk::mesh::PairIterRelation elem_nodes = element.relations(stk::topology::NODE_RANK); unsigned num_node = elem_nodes.size(); double* f_data = stk::percept::PerceptMesh::field_data_entity(field, element); Albany::AbstractSTKFieldContainer::VectorFieldType* coordField = m_eMesh.get_coordinates_field(); bool found = true; for(unsigned inode = 0; inode < num_node; inode++) { stk::mesh::Entity node = * elem_nodes[ inode ].entity(); double* coord_data = stk::percept::PerceptMesh::field_data(coordField, node); if(coord_data[0] < 0.0 || coord_data[1] < 0.0) { // || coord_data[2] > 1.1) found = false; break; } } if(found) f_data[0] = -1.0; else f_data[0] = 0.0; return false; // don't terminate the loop }
void SideConnector::connect_side_to_all_elements(stk::mesh::Entity sideEntity, stk::mesh::Entity elemEntity, int elemSide) { connect_side_to_elem(sideEntity, elemEntity, elemSide); stk::mesh::impl::LocalId elemLocalId = m_entity_to_local_id[elemEntity.local_offset()]; connect_side_to_coincident_elements(sideEntity, elemLocalId, elemSide); connect_side_to_adjacent_elements(sideEntity, elemLocalId, elemSide); }
int IEdgeAdapter::markUnrefine(const stk::mesh::Entity& element) { const CellTopologyData * const cell_topo_data = stk::percept::PerceptMesh::get_cell_topology(element); CellTopology cell_topo(cell_topo_data); const mesh::PairIterRelation elem_nodes = element.relations(stk::mesh::fem::FEMMetaData::NODE_RANK); VectorFieldType* coordField = m_eMesh.get_coordinates_field(); unsigned numSubDimNeededEntities = 0; numSubDimNeededEntities = cell_topo_data->edge_count; bool unrefAllEdges = true; for (unsigned iSubDimOrd = 0; iSubDimOrd < numSubDimNeededEntities; iSubDimOrd++) { stk::mesh::Entity & node0 = *elem_nodes[cell_topo_data->edge[iSubDimOrd].node[0]].entity(); stk::mesh::Entity & node1 = *elem_nodes[cell_topo_data->edge[iSubDimOrd].node[1]].entity(); double * const coord0 = stk::mesh::field_data( *coordField , node0 ); double * const coord1 = stk::mesh::field_data( *coordField , node1 ); int markInfo = mark(element, iSubDimOrd, node0, node1, coord0, coord1, 0); bool do_unref = markInfo & DO_UNREFINE; if (!do_unref) { unrefAllEdges = false; break; } } if (unrefAllEdges) return -1; else return 0; }
bool gather_field_data(unsigned expected_num_rel, const field_type & field, const stk::mesh::Entity & entity, typename stk::mesh::FieldTraits<field_type>::data_type * dst, stk::mesh::EntityRank entity_rank, const int dim) { typedef typename stk::mesh::FieldTraits<field_type>::data_type T; stk::mesh::PairIterRelation rel = entity.relations(entity_rank); bool result = expected_num_rel == (unsigned) rel.size(); if (result) { // Iterate over field data for each related entity and copy data // into src for one entity at a time T * const dst_end = dst + dim * expected_num_rel; for (; dst < dst_end; ++rel, dst += dim) { const T* src = field_data(field, *rel->entity()); if (!src) { break; } // FIXME: if (dim == 1) stk::Copy<1>(dst, src); if (dim == 2) stk::Copy<2>(dst, src); if (dim == 3) stk::Copy<3>(dst, src); } result = dst == dst_end; } return result; }
bool AAdapt::STKUnifRefineField::operator()(const stk::mesh::Entity element, stk::mesh::FieldBase* field, const stk::mesh::BulkData& bulkData) { /* double plane_point[3] = {2, 0, 0}; double plane_normal[3] = {1, .5, -.5}; */ double plane_point[3] = {0, 0.7, 0}; double plane_normal[3] = {0, 1, 0}; const stk::mesh::PairIterRelation elem_nodes = element.relations(stk::topology::NODE_RANK); unsigned num_node = elem_nodes.size(); double* f_data = stk::percept::PerceptMesh::field_data_entity(field, element); Albany::AbstractSTKFieldContainer::VectorFieldType* coordField = m_eMesh.get_coordinates_field(); bool found = false; for(unsigned inode = 0; inode < num_node - 1; inode++) { stk::mesh::Entity node_i = * elem_nodes[ inode ].entity(); double* coord_data_i = stk::percept::PerceptMesh::field_data(coordField, node_i); for(unsigned jnode = inode + 1; jnode < num_node; jnode++) { stk::mesh::Entity node_j = * elem_nodes[ jnode ].entity(); double* coord_data_j = stk::percept::PerceptMesh::field_data(coordField, node_j); double dot_0 = plane_dot_product(plane_point, plane_normal, coord_data_i); double dot_1 = plane_dot_product(plane_point, plane_normal, coord_data_j); // if edge crosses the plane... if(dot_0 * dot_1 < 0) { found = true; break; } } } if(found) { f_data[0] = 1.0; // std::cout << "Splitting: " << element.identifier() << std::endl; } else { f_data[0] = 0.0; // std::cout << "Not splitting: " << element.identifier() << std::endl; } return false; // don't terminate the loop }
KOKKOS_INLINE_FUNCTION unsigned get_bucket_id(stk::mesh::Entity entity) const { const stk::mesh::FastMeshIndex& meshIndex = constMeshIndices(entity.local_offset()); return meshIndex.bucket_id; }
STK_FUNCTION unsigned get_index(stk::mesh::Entity entity) const { const stk::mesh::FastMeshIndex& meshIndex = constMeshIndices(entity.local_offset()); return meshIndex.bucket_id * bucketCapacity + meshIndex.bucket_ord; }
bool helperSubDim(const stk::mesh::Entity& child_element, stk::mesh::FieldBase *field, const mesh::BulkData& bulkData) { EXCEPTWATCH; const CellTopologyData * const child_cell_topo_data = stk::percept::PerceptMesh::get_cell_topology(child_element); CellTopology child_cell_topo(child_cell_topo_data); int child_cell_dimension = child_cell_topo.getDimension(); int meta_dimension = mesh::fem::FEMMetaData::get_meta_data(mesh::fem::FEMMetaData::get(bulkData)).get_spatial_dimension(); // for now, only allow face (or edge) VERIFY_OP_ON(child_cell_dimension, ==, meta_dimension - 1, "Dimensions don't match"); VectorFieldType& coord_field = *(mesh::fem::FEMMetaData::get(bulkData)).get_field<VectorFieldType>("coordinates"); // FIXME for fields not on a Node unsigned nDOF = m_nDOFs; unsigned nCells = PerceptMesh::size1(child_element); m_count_elems += nCells; typedef IntrepidManager IM; unsigned cubDegree = m_cubDegree; const stk::mesh::PairIterRelation parent_elements = child_element.relations(child_element.entity_rank() + 1); VERIFY_OP_ON(parent_elements.size(), ==, 1, "cant find parent"); const stk::mesh::Entity& element = *parent_elements[0].entity(); unsigned i_face = parent_elements[0].identifier(); const CellTopologyData * const cell_topo_data = stk::percept::PerceptMesh::get_cell_topology(element); CellTopology cell_topo(cell_topo_data); int cell_dimension = cell_topo.getDimension(); VERIFY_OP_ON(cell_dimension, ==, meta_dimension , "Dimensions don't match"); IM im(Elements_Tag(nCells), cell_topo, cubDegree); IM imChild(Elements_Tag(nCells), child_cell_topo, cubDegree); unsigned numCubPoints_child = imChild.m_cub->getNumPoints(); im.m_Cub_Points_Tag = Cub_Points_Tag(numCubPoints_child); if (0) { std::cout << "numCubPoints_child= " << numCubPoints_child << " parent rank= " << element.entity_rank() << " parent topo= " << cell_topo.getName() << std::endl; } // FIXME im.m_DOFs_Tag.num = m_nDOFs; // FIXME // _c suffix is for the child (face) element IM::Jacobian J (im); IM::FaceNormal fn (im); //IM::JacobianDet dJ (im); IM::CubaturePoints xi (im); IM::CubaturePoints xi_c (imChild); IM::CellWorkSet cn (im); IM::CubatureWeights wt (im); IM::CubatureWeights wt_c (imChild); IM::PhysicalCoords pc (im); IM::IntegrandValues iv (im); IM::IntegrandValuesDOF ivD (im); IM::Integral Io (im); IM::Bases Nb (im); IM::WeightedMeasure wXfn (im); IM::FieldValues fv (im); imChild.m_cub->getCubature(xi_c, wt_c); unsigned spaceDim = im.m_Spatial_Dim_Tag.num; PerceptMesh::fillCellNodes(element, &coord_field, cn, spaceDim); // get parent cell integration points // Map Gauss points on quad to reference face: paramGaussPoints -> refGaussPoints CellTools<double>::mapToReferenceSubcell(xi, xi_c, 2, i_face, cell_topo); // FIXME magic // get jacobian J(xi, cn, cell_topo); //dJ(J); //shards::ArrayVector<double, shards::NaturalOrder, Elements_Tag, Cub_Points_Tag > fn_Norm; // FIXME //fn(J, i_face, cell_topo); MDArray J_mda; J.copyTo(J_mda); MDArray fn_mda(im.m_Elements_Tag.num, numCubPoints_child, spaceDim); CellTools<double>::getPhysicalFaceNormals(fn_mda, J_mda, i_face, cell_topo); /// get norm of fn for (int icell = 0; icell < im.m_Elements_Tag.num; icell++) { for (int ipt = 0; ipt < (int)numCubPoints_child; ipt++) { double sum = 0.0; for (int i = 0; i < (int)spaceDim; i++) { sum += square(fn_mda(icell, ipt, i)); } wXfn(icell, ipt) = std::sqrt(sum) * wt_c(ipt); } } if (0) { using namespace shards; //std::cout << "dJ= \n" << dJ << std::endl; std::cout << "wXfn= \n" << wXfn << std::endl; std::cout << "xi= \n" << xi << std::endl; std::cout << "wt= \n" << wt << std::endl; std::cout << "cn= \n" << cn << std::endl; Util::setDoPause(true); Util::pause(true); } // get physical coordinates at integration points pc(cn, xi); // get bases #if 1 // FIXME MDArray xi_mda; xi.copyTo(xi_mda); Nb(element, xi_mda); #else Nb(element, xi); #endif // apply integrand (right now we have MDArray hard-coded... FIXME - templatize on its type) // it should look like this (one instead of multiple lines): #if 0 m_integrand(pc, v); #else MDArray pc_mda; pc.copyTo(pc_mda); std::vector<int> ivDims; ivD.dimensions( ivDims); /// NOTE: m_integrand requires the ranks of in/out MDArrays to be such that out_rank >= in_rank /// Thus, we use IntegrandValuesDOF with [DOF] = 1, and then copy the result to IntegrandValues /// which does not have the additional rightmost DOF index (Intrepid doesn't have the concept of /// DOF's, it works on scalars only for the integration routines, or at least that's how I understand /// it currently. // create an array that stk::percept::Function will like to hold the results ivDims[ivDims.size()-1] = m_nDOFs; MDArray iv_mda ( Teuchos::Array<int>(ivDims.begin(), ivDims.end())); if (m_turboOpt == TURBO_ELEMENT || m_turboOpt == TURBO_BUCKET) { m_integrand(pc_mda, iv_mda, element, xi_mda); } else { m_integrand(pc_mda, iv_mda); } // now, copy from the results to an array that Intrepid::integrate will like #endif for (unsigned iDof = 0; iDof < nDOF; iDof++) { iv.copyFrom(im, iv_mda, iDof); // get the integral if (m_accumulation_type == ACCUMULATE_SUM) { Io(iv, wXfn, COMP_BLAS); } //optional design: // // Io(integrand(pc_mda, v), wXdJ(w, dJ(J(xi, c, cell_topo)), COMP_BLAS); for (unsigned iCell = 0; iCell < nCells; iCell++) { // if (Util::getFlag(0)) // { // std::cout << "tmp Io(iCell)= " << Io(iCell) << std::endl; // Util::pause(true, "Io(iCell)"); // } if (m_accumulation_type == ACCUMULATE_SUM) { m_accumulation_buffer[iDof] += Io(iCell); } else if (m_accumulation_type == ACCUMULATE_MAX) { double valIo = 0.0; for (int ivpts = 0; ivpts < iv.dimension(1); ivpts++) { valIo = std::max(valIo, iv((int)iCell, ivpts)); } //std::cout << "m_accumulation_buffer[iDof] = " << m_accumulation_buffer[iDof] << " valIO= " << valIo << std::endl; m_accumulation_buffer[iDof] = std::max(m_accumulation_buffer[iDof], valIo); } } } return false; }
void TestLocalRefinerTri2:: refineMethodApply(NodeRegistry::ElementFunctionPrototype function, const stk::mesh::Entity& element, vector<NeededEntityType>& needed_entity_ranks) { const CellTopologyData * const cell_topo_data = stk::percept::PerceptMesh::get_cell_topology(element); CellTopology cell_topo(cell_topo_data); const mesh::PairIterRelation elem_nodes = element.relations(stk::mesh::fem::FEMMetaData::NODE_RANK); VectorFieldType* coordField = m_eMesh.get_coordinates_field(); for (unsigned ineed_ent=0; ineed_ent < needed_entity_ranks.size(); ineed_ent++) { unsigned numSubDimNeededEntities = 0; stk::mesh::EntityRank needed_entity_rank = needed_entity_ranks[ineed_ent].first; if (needed_entity_rank == m_eMesh.edge_rank()) { numSubDimNeededEntities = cell_topo_data->edge_count; } else if (needed_entity_rank == m_eMesh.face_rank()) { numSubDimNeededEntities = cell_topo_data->side_count; } else if (needed_entity_rank == m_eMesh.element_rank()) { numSubDimNeededEntities = 1; } // see how many edges are already marked int num_marked=0; if (needed_entity_rank == m_eMesh.edge_rank()) { for (unsigned iSubDimOrd = 0; iSubDimOrd < numSubDimNeededEntities; iSubDimOrd++) { bool is_empty = m_nodeRegistry->is_empty( element, needed_entity_rank, iSubDimOrd); if (!is_empty) ++num_marked; } } for (unsigned iSubDimOrd = 0; iSubDimOrd < numSubDimNeededEntities; iSubDimOrd++) { /// note: at this level of granularity we can do single edge refinement, hanging nodes, etc. //SubDimCell_SDSEntityType subDimEntity; //getSubDimEntity(subDimEntity, element, needed_entity_rank, iSubDimOrd); //bool is_empty = m_nodeRegistry->is_empty( element, needed_entity_rank, iSubDimOrd); //if(1||!is_empty) if (needed_entity_rank == m_eMesh.edge_rank()) { stk::mesh::Entity & node0 = *elem_nodes[cell_topo_data->edge[iSubDimOrd].node[0]].entity(); stk::mesh::Entity & node1 = *elem_nodes[cell_topo_data->edge[iSubDimOrd].node[1]].entity(); double * const coord0 = stk::mesh::field_data( *coordField , node0 ); double * const coord1 = stk::mesh::field_data( *coordField , node1 ); // only refine diagonals of the split quads if (m_diagonals) { if ( std::abs(coord0[0]-coord1[0]) > 1.e-3 && std::abs(coord0[1]-coord1[1]) > 1.e-3 ) { (m_nodeRegistry ->* function)(element, needed_entity_ranks[ineed_ent], iSubDimOrd, true); } } else { if ( std::abs(coord0[0]-coord1[0]) < 1.e-3 && std::abs(coord0[1]-coord1[1]) > 1.e-3 ) { (m_nodeRegistry ->* function)(element, needed_entity_ranks[ineed_ent], iSubDimOrd, true); } } } } // iSubDimOrd } // ineed_ent }
inline int Albany::STKDiscretization::gid(const stk::mesh::Entity& node) const { return node.identifier()-1; }
unsigned Albany::STKDiscretization::determine_local_side_id( const stk::mesh::Entity & elem , stk::mesh::Entity & side ) { using namespace stk; const CellTopologyData * const elem_top = mesh::fem::get_cell_topology( elem ).getCellTopologyData(); const mesh::PairIterRelation elem_nodes = elem.relations( mesh::fem::FEMMetaData::NODE_RANK ); const mesh::PairIterRelation side_nodes = side.relations( mesh::fem::FEMMetaData::NODE_RANK ); int side_id = -1 ; if(elem_nodes.size() == 0 || side_nodes.size() == 0){ // Node relations are not present, look at elem->face int elem_rank = elem.entity_rank(); const mesh::PairIterRelation elem_sides = elem.relations( elem_rank - 1); for ( unsigned i = 0 ; i < elem_sides.size() ; ++i ) { const stk::mesh::Entity & elem_side = *elem_sides[i].entity(); if(elem_side.identifier() == side.identifier()){ // Found the local side in the element side_id = static_cast<int>(i); return side_id; } } if ( side_id < 0 ) { std::ostringstream msg ; msg << "determine_local_side_id( " ; msg << elem_top->name ; msg << " , Element[ " ; msg << elem.identifier(); msg << " ]{" ; for ( unsigned i = 0 ; i < elem_sides.size() ; ++i ) { msg << " " << elem_sides[i].entity()->identifier(); } msg << " } , Side[ " ; msg << side.identifier(); msg << " ] ) FAILED" ; throw std::runtime_error( msg.str() ); } } else { // Conventional elem->node - side->node connectivity present for ( unsigned i = 0 ; side_id == -1 && i < elem_top->side_count ; ++i ) { const CellTopologyData & side_top = * elem_top->side[i].topology ; const unsigned * side_map = elem_top->side[i].node ; if ( side_nodes.size() == side_top.node_count ) { side_id = i ; for ( unsigned j = 0 ; side_id == static_cast<int>(i) && j < side_top.node_count ; ++j ) { mesh::Entity * const elem_node = elem_nodes[ side_map[j] ].entity(); bool found = false ; for ( unsigned k = 0 ; ! found && k < side_top.node_count ; ++k ) { found = elem_node == side_nodes[k].entity(); } if ( ! found ) { side_id = -1 ; } } } } if ( side_id < 0 ) { std::ostringstream msg ; msg << "determine_local_side_id( " ; msg << elem_top->name ; msg << " , Element[ " ; msg << elem.identifier(); msg << " ]{" ; for ( unsigned i = 0 ; i < elem_nodes.size() ; ++i ) { msg << " " << elem_nodes[i].entity()->identifier(); } msg << " } , Side[ " ; msg << side.identifier(); msg << " ]{" ; for ( unsigned i = 0 ; i < side_nodes.size() ; ++i ) { msg << " " << side_nodes[i].entity()->identifier(); } msg << " } ) FAILED" ; throw std::runtime_error( msg.str() ); } } return static_cast<unsigned>(side_id) ; }
void TestLocalRefinerTet_N_2_1:: refineMethodApply(NodeRegistry::ElementFunctionPrototype function, const stk::mesh::Entity& element, vector<NeededEntityType>& needed_entity_ranks) { //static int n_seq = 400; const CellTopologyData * const cell_topo_data = stk::percept::PerceptMesh::get_cell_topology(element); CellTopology cell_topo(cell_topo_data); const mesh::PairIterRelation elem_nodes = element.relations(stk::mesh::fem::FEMMetaData::NODE_RANK); //VectorFieldType* coordField = m_eMesh.get_coordinates_field(); for (unsigned ineed_ent=0; ineed_ent < needed_entity_ranks.size(); ineed_ent++) { unsigned numSubDimNeededEntities = 0; stk::mesh::EntityRank needed_entity_rank = needed_entity_ranks[ineed_ent].first; if (needed_entity_rank == m_eMesh.edge_rank()) { numSubDimNeededEntities = cell_topo_data->edge_count; } else if (needed_entity_rank == m_eMesh.face_rank()) { numSubDimNeededEntities = cell_topo_data->side_count; } else if (needed_entity_rank == m_eMesh.element_rank()) { numSubDimNeededEntities = 1; } // see how many edges are already marked int num_marked=0; if (needed_entity_rank == m_eMesh.edge_rank()) { for (unsigned iSubDimOrd = 0; iSubDimOrd < numSubDimNeededEntities; iSubDimOrd++) { bool is_empty = m_nodeRegistry->is_empty( element, needed_entity_rank, iSubDimOrd); if (!is_empty) ++num_marked; } } for (unsigned iSubDimOrd = 0; iSubDimOrd < numSubDimNeededEntities; iSubDimOrd++) { /// note: at this level of granularity we can do single edge refinement, hanging nodes, etc. //SubDimCell_SDSEntityType subDimEntity; //getSubDimEntity(subDimEntity, element, needed_entity_rank, iSubDimOrd); //bool is_empty = m_nodeRegistry->is_empty( element, needed_entity_rank, iSubDimOrd); //if(1||!is_empty) if (needed_entity_rank == m_eMesh.edge_rank()) { #if 0 stk::mesh::Entity & node0 = *elem_nodes[cell_topo_data->edge[iSubDimOrd].node[0]].entity(); stk::mesh::Entity & node1 = *elem_nodes[cell_topo_data->edge[iSubDimOrd].node[1]].entity(); double * const coord0 = stk::mesh::field_data( *coordField , node0 ); double * const coord1 = stk::mesh::field_data( *coordField , node1 ); // vertical line position const double vx = 0.21; // horizontal line position const double vy = 1.21; // choose to refine or not if ( ( std::fabs(coord0[0]-coord1[0]) > 1.e-3 && ( (coord0[0] < vx && vx < coord1[0]) || (coord1[0] < vx && vx < coord0[0]) ) ) || ( std::fabs(coord0[1]-coord1[1]) > 1.e-3 && ( (coord0[1] < vy && vy < coord1[1]) || (coord1[1] < vy && vy < coord0[1]) ) ) ) { (m_nodeRegistry ->* function)(element, needed_entity_ranks[ineed_ent], iSubDimOrd, true); } #endif // mark first m_edge_mark_bitcode edges std::cout << "tmp TestLocalRefinerTet_N_2_1 element.identifier() = " << element.identifier() << " m_edge_mark_bitcode= " << m_edge_mark_bitcode << std::endl; if ( ((1 << iSubDimOrd) & m_edge_mark_bitcode) && element.identifier() == 1) (m_nodeRegistry ->* function)(element, needed_entity_ranks[ineed_ent], iSubDimOrd, true); } } // iSubDimOrd } // ineed_ent }
void createNewElements(percept::PerceptMesh& eMesh, NodeRegistry& nodeRegistry, stk::mesh::Entity& element, NewSubEntityNodesType& new_sub_entity_nodes, vector<stk::mesh::Entity *>::iterator& element_pool, stk::mesh::FieldBase *proc_rank_field=0) { const CellTopologyData * const cell_topo_data = stk::percept::PerceptMesh::get_cell_topology(element); typedef boost::tuple<stk::mesh::EntityId, stk::mesh::EntityId, stk::mesh::EntityId, stk::mesh::EntityId> quad_tuple_type; static vector<quad_tuple_type> elems(4); CellTopology cell_topo(cell_topo_data); const stk::mesh::PairIterRelation elem_nodes = element.relations(stk::mesh::fem::FEMMetaData::NODE_RANK); //stk::mesh::Part & active = mesh->ActivePart(); //stk::mesh::Part & quad4 = mesh->QuadPart(); std::vector<stk::mesh::Part*> add_parts; std::vector<stk::mesh::Part*> remove_parts; //add_parts.push_back( &active ); //FIXME //add_parts.push_back( const_cast<mesh::Part*>( eMesh.getPart(m_toTopoPartName) )); add_parts = m_toParts; double tmp_x[3]; for (int iedge = 0; iedge < 4; iedge++) { double * mp = midPoint(EDGE_COORD(iedge,0), EDGE_COORD(iedge,1), eMesh.get_spatial_dim(), tmp_x); if (!EDGE_N(iedge)) { std::cout << "P[" << eMesh.get_rank() << " nid ## = 0 << " << std::endl; } eMesh.createOrGetNode(EDGE_N(iedge), mp); } nodeRegistry.makeCentroidCoords(*const_cast<stk::mesh::Entity *>(&element), m_eMesh.element_rank(), 0u); // new_sub_entity_nodes[i][j] #define CENTROID_N NN(m_primaryEntityRank,0) elems[0] = quad_tuple_type(VERT_N(0), EDGE_N(0), CENTROID_N, EDGE_N(3)); elems[1] = quad_tuple_type(VERT_N(1), EDGE_N(1), CENTROID_N, EDGE_N(0)); elems[2] = quad_tuple_type(VERT_N(2), EDGE_N(2), CENTROID_N, EDGE_N(1)); elems[3] = quad_tuple_type(VERT_N(3), EDGE_N(3), CENTROID_N, EDGE_N(2)); #undef CENTROID_N // write a diagram of the refinement pattern as a vtk file, or a latex/tikz/pgf file #define WRITE_DIAGRAM 0 #if WRITE_DIAGRAM #endif for (unsigned ielem=0; ielem < elems.size(); ielem++) { stk::mesh::Entity& newElement = *(*element_pool); if (proc_rank_field) { double *fdata = stk::mesh::field_data( *static_cast<const ScalarFieldType *>(proc_rank_field) , newElement ); //fdata[0] = double(m_eMesh.get_rank()); fdata[0] = double(newElement.owner_rank()); } eMesh.get_bulk_data()->change_entity_parts( newElement, add_parts, remove_parts ); { if (!elems[ielem].get<0>()) { std::cout << "P[" << eMesh.get_rank() << " nid = 0 << " << std::endl; exit(1); } } eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<0>()), 0); eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<1>()), 1); eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<2>()), 2); eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<3>()), 3); set_parent_child_relations(eMesh, element, newElement, ielem); element_pool++; } }
//---------------------------------------------------------------------------- // // Stress fracture criterion function. // bool StressFracture::computeFractureCriterion(stk::mesh::Entity entity, double p) { // Fracture only defined on the boundary of the elements stk::mesh::EntityRank rank = entity.entity_rank(); assert(rank == num_dim_ - 1); stk::mesh::PairIterRelation neighbor_elems = entity.relations(element_rank_); // Need an element on each side of the edge if(neighbor_elems.size() != 2) return false; // Note that these are element GIDs stk::mesh::EntityId elem_0_Id = neighbor_elems[0].entity()->identifier(); stk::mesh::EntityId elem_1_Id = neighbor_elems[1].entity()->identifier(); Albany::WsLIDList& elemGIDws = stk_.getElemGIDws(); // Have two elements, one on each size of the edge (or // face). Check and see if the stresses are such that we want to // split the mesh here. // // Initial hack - GAH: if the average stress between two elements // is above the input value "Fracture Stress", split them at the // edge bool is_open = false; // Check criterion // If average between cells is above crit, split // if (0.5 * (avg_stresses[elemGIDws[elem_0_Id].ws][elemGIDws[elem_0_Id].LID] + // avg_stresses[elemGIDws[elem_1_Id].ws][elemGIDws[elem_1_Id].LID]) >= crit_stress){ // If stress difference across face it above crit, split // if (fabs(avg_stresses[elemGIDws[elem_0_Id].ws][elemGIDws[elem_0_Id].LID] - // avg_stresses[elemGIDws[elem_1_Id].ws][elemGIDws[elem_1_Id].LID]) >= crit_stress){ // Just split the doggone elements already!!! if(p == 5) { if((elem_0_Id - 1 == 35 && elem_1_Id - 1 == 140) || (elem_1_Id - 1 == 35 && elem_0_Id - 1 == 140)) { is_open = true; std::cout << "Splitting elements " << elem_0_Id - 1 << " and " << elem_1_Id - 1 << std::endl; //std::cout << avg_stresses[elemGIDws[elem_0_Id].ws][elemGIDws[elem_0_Id].LID] << " " << // avg_stresses[elemGIDws[elem_1_Id].ws][elemGIDws[elem_1_Id].LID] << std::endl; } } else if(p == 10) { if((elem_0_Id - 1 == 42 && elem_1_Id - 1 == 147) || (elem_1_Id - 1 == 42 && elem_0_Id - 1 == 147)) { is_open = true; std::cout << "Splitting elements " << elem_0_Id - 1 << " and " << elem_1_Id - 1 << std::endl; } } else if(p == 15) { if((elem_0_Id - 1 == 49 && elem_1_Id - 1 == 154) || (elem_1_Id - 1 == 49 && elem_0_Id - 1 == 154)) { is_open = true; std::cout << "Splitting elements " << elem_0_Id - 1 << " and " << elem_1_Id - 1 << std::endl; } } return is_open; }
void createNewElements(percept::PerceptMesh& eMesh, NodeRegistry& nodeRegistry, stk::mesh::Entity& element, NewSubEntityNodesType& new_sub_entity_nodes, vector<stk::mesh::Entity *>::iterator& element_pool, stk::mesh::FieldBase *proc_rank_field=0) { const CellTopologyData * const cell_topo_data = stk::percept::PerceptMesh::get_cell_topology(element); typedef boost::tuple<stk::mesh::EntityId, stk::mesh::EntityId> line_tuple_type; static vector<line_tuple_type> elems(2); CellTopology cell_topo(cell_topo_data); const stk::mesh::PairIterRelation elem_nodes = element.relations(stk::mesh::fem::FEMMetaData::NODE_RANK); std::vector<stk::mesh::Part*> add_parts; std::vector<stk::mesh::Part*> remove_parts; add_parts = m_toParts; unsigned num_nodes_on_edge = new_sub_entity_nodes[m_eMesh.edge_rank()][0].size(); if (!num_nodes_on_edge) return; double coord_x[3]; for (int iedge = 0; iedge < 1; iedge++) { //double * mp = midPoint(EDGE_COORD(iedge,0), EDGE_COORD(iedge,1), eMesh.get_spatial_dim(), coord_x); //double * mp = midPoint(FACE_COORD(iedge,0), FACE_COORD(iedge,1), eMesh.get_spatial_dim(), coord_x); double * mp = midPoint(VERT_COORD(0), VERT_COORD(1), eMesh.get_spatial_dim(), coord_x); if (!EDGE_N(iedge)) { std::cout << "P[" << eMesh.get_rank() << " nid ## = 0 " << std::endl; } eMesh.createOrGetNode(EDGE_N(iedge), mp); } // FIXME nodeRegistry.makeCentroidCoords(*const_cast<stk::mesh::Entity *>(&element), m_primaryEntityRank, 0u); nodeRegistry.addToExistingParts(*const_cast<stk::mesh::Entity *>(&element), m_primaryEntityRank, 0u); nodeRegistry.interpolateFields(*const_cast<stk::mesh::Entity *>(&element), m_primaryEntityRank, 0u); Elem::CellTopology elem_celltopo = Elem::getCellTopology< FromTopology >(); const Elem::RefinementTopology* ref_topo_p = Elem::getRefinementTopology(elem_celltopo); const Elem::RefinementTopology& ref_topo = *ref_topo_p; #ifndef NDEBUG unsigned num_child = ref_topo.num_child(); VERIFY_OP(num_child, == , 2, "createNewElements num_child problem"); bool homogeneous_child = ref_topo.homogeneous_child(); VERIFY_OP(homogeneous_child, ==, true, "createNewElements homogeneous_child"); #endif // new_sub_entity_nodes[i][j] //const UInt * const * child_nodes() const { //const UInt * child_node_0 = ref_topo.child_node(0); typedef Elem::StdMeshObjTopologies::RefTopoX RefTopoX; RefTopoX& l2 = Elem::StdMeshObjTopologies::RefinementTopologyExtra< FromTopology > ::refinement_topology; #define CENTROID_N NN(m_primaryEntityRank,0) for (unsigned iChild = 0; iChild < 2; iChild++) { unsigned EN[2]; for (unsigned jNode = 0; jNode < 2; jNode++) { unsigned childNodeIdx = ref_topo.child_node(iChild)[jNode]; #ifndef NDEBUG unsigned childNodeIdxCheck = l2[childNodeIdx].ordinal_of_node; VERIFY_OP(childNodeIdx, ==, childNodeIdxCheck, "childNodeIdxCheck"); #endif unsigned inode=0; if (l2[childNodeIdx].rank_of_subcell == 0) inode = VERT_N(l2[childNodeIdx].ordinal_of_subcell); else if (l2[childNodeIdx].rank_of_subcell == 1) inode = EDGE_N(l2[childNodeIdx].ordinal_of_subcell); // else if (l2[childNodeIdx].rank_of_subcell == 2) // inode = CENTROID_N; EN[jNode] = inode; } elems[iChild] = line_tuple_type(EN[0], EN[1]); } #undef CENTROID_N for (unsigned ielem=0; ielem < elems.size(); ielem++) { stk::mesh::Entity& newElement = *(*element_pool); #if 0 if (proc_rank_field && proc_rank_field->rank() == m_eMesh.edge_rank()) //&& m_eMesh.get_spatial_dim()==1) { double *fdata = stk::mesh::field_data( *static_cast<const ScalarFieldType *>(proc_rank_field) , newElement ); //fdata[0] = double(m_eMesh.get_rank()); fdata[0] = double(newElement.owner_rank()); } #endif stk::mesh::FieldBase * proc_rank_field_edge = m_eMesh.get_field("proc_rank_edge"); if (proc_rank_field_edge) { double *fdata = stk::mesh::field_data( *static_cast<const ScalarFieldType *>(proc_rank_field_edge) , newElement ); fdata[0] = double(newElement.owner_rank()); //fdata[0] = 1234.56; if (0) std::cout << "P[" << m_eMesh.get_rank() << "] tmp set proc_rank_field_edge to value = " << newElement.owner_rank() << " for side element = " << newElement.identifier() << std::endl; } //eMesh.get_bulk_data()->change_entity_parts( newElement, add_parts, remove_parts ); change_entity_parts(eMesh, element, newElement); { if (!elems[ielem].get<0>()) { std::cout << "P[" << eMesh.get_rank() << " nid = 0 " << std::endl; exit(1); } } eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<0>()), 0); eMesh.get_bulk_data()->declare_relation(newElement, eMesh.createOrGetNode(elems[ielem].get<1>()), 1); set_parent_child_relations(eMesh, element, newElement, ielem); element_pool++; } }
void IEdgeAdapter:: refineMethodApply(NodeRegistry::ElementFunctionPrototype function, const stk::mesh::Entity& element, vector<NeededEntityType>& needed_entity_ranks) { const CellTopologyData * const cell_topo_data = stk::percept::PerceptMesh::get_cell_topology(element); CellTopology cell_topo(cell_topo_data); const mesh::PairIterRelation elem_nodes = element.relations(stk::mesh::fem::FEMMetaData::NODE_RANK); VectorFieldType* coordField = m_eMesh.get_coordinates_field(); for (unsigned ineed_ent=0; ineed_ent < needed_entity_ranks.size(); ineed_ent++) { unsigned numSubDimNeededEntities = 0; stk::mesh::EntityRank needed_entity_rank = needed_entity_ranks[ineed_ent].first; if (needed_entity_rank == m_eMesh.edge_rank()) { numSubDimNeededEntities = cell_topo_data->edge_count; } else if (needed_entity_rank == m_eMesh.face_rank()) { numSubDimNeededEntities = cell_topo_data->side_count; throw std::runtime_error("IEdgeAdapter::apply can't use IEdgeAdapter for RefinerPatterns that require face nodes"); } else if (needed_entity_rank == m_eMesh.element_rank()) { numSubDimNeededEntities = 1; throw std::runtime_error("IEdgeAdapter::apply can't use IEdgeAdapter for RefinerPatterns that require volume nodes"); } // see how many edges are already marked int num_marked=0; std::vector<int> edge_marks(numSubDimNeededEntities,0); if (needed_entity_rank == m_eMesh.edge_rank()) { for (unsigned iSubDimOrd = 0; iSubDimOrd < numSubDimNeededEntities; iSubDimOrd++) { bool is_empty = m_nodeRegistry->is_empty( element, needed_entity_rank, iSubDimOrd); if (!is_empty) { edge_marks[iSubDimOrd] = 1; ++num_marked; } } } for (unsigned iSubDimOrd = 0; iSubDimOrd < numSubDimNeededEntities; iSubDimOrd++) { if (needed_entity_rank == m_eMesh.edge_rank()) { stk::mesh::Entity & node0 = *elem_nodes[cell_topo_data->edge[iSubDimOrd].node[0]].entity(); stk::mesh::Entity & node1 = *elem_nodes[cell_topo_data->edge[iSubDimOrd].node[1]].entity(); double * const coord0 = stk::mesh::field_data( *coordField , node0 ); double * const coord1 = stk::mesh::field_data( *coordField , node1 ); int markInfo = mark(element, iSubDimOrd, node0, node1, coord0, coord1, &edge_marks); bool needNodes = (DO_REFINE & markInfo); { (m_nodeRegistry ->* function)(element, needed_entity_ranks[ineed_ent], iSubDimOrd, needNodes); } } } // iSubDimOrd } // ineed_ent }
/// modeled after code from Mesquite::IdealWeightMeanRatio::evaluate() bool JacobianUtil::operator()(double& m, PerceptMesh& eMesh, stk::mesh::Entity& element, stk::mesh::FieldBase *coord_field, const CellTopologyData * topology_data ) { MsqError err; static MsqMatrix<3,3> J; static Vector3D n; // Surface normal for 2D objects // Prism and Hex element descriptions static const int locs_prism[6][4] = {{0, 1, 2, 3}, {1, 2, 0, 4}, {2, 0, 1, 5}, {3, 5, 4, 0}, {4, 3, 5, 1}, {5, 4, 3, 2}}; static const int locs_hex[8][4] = {{0, 1, 3, 4}, {1, 2, 0, 5}, {2, 3, 1, 6}, {3, 0, 2, 7}, {4, 7, 5, 0}, {5, 4, 6, 1}, {6, 5, 7, 2}, {7, 6, 4, 3}}; int i=0; static const Vector3D d_con(1.0, 1.0, 1.0); bool metric_valid = false; if (!topology_data) topology_data = stk::percept::PerceptMesh::get_cell_topology(element); stk::mesh::PairIterRelation v_i = element.relations(eMesh.node_rank()); m_num_nodes = v_i.size(); //#define VERTEX_2D(vi) vector_2D( eMesh.field_data(coord_field, *vi.entity() ) ) //#define VERTEX_3D(vi) vector_3D( eMesh.field_data(coord_field, *vi.entity() ) ) #define VERTEX_2D(vi) vector_2D( stk::mesh::field_data( *static_cast<const VectorFieldType *>(coord_field) , *vi.entity() ) ) #define VERTEX_3D(vi) vector_3D( stk::mesh::field_data( *static_cast<const VectorFieldType *>(coord_field) , *vi.entity() ) ) switch(topology_data->key) { case shards::Triangle<3>::key: n[0] = 0; n[1] = 0; n[2] = 1; mCoords[0] = VERTEX_2D(v_i[0]); mCoords[1] = VERTEX_2D(v_i[1]); mCoords[2] = VERTEX_2D(v_i[2]); metric_valid = jacobian_matrix_2D(m, J, mCoords, n, d_con); for (i = 0; i < 4; i++) { m_detJ[i] = m; m_J[i] = J; } break; case shards::Quadrilateral<4>::key: n[0] = 0; n[1] = 0; n[2] = 1; for (i = 0; i < 4; ++i) { mCoords[0] = VERTEX_2D(v_i[locs_hex[i][0]]); mCoords[1] = VERTEX_2D(v_i[locs_hex[i][1]]); mCoords[2] = VERTEX_2D(v_i[locs_hex[i][2]]); metric_valid = jacobian_matrix_2D(m_detJ[i], m_J[i], mCoords, n, d_con); } m = average_metrics(m_detJ, 4, err); MSQ_ERRZERO(err); break; case shards::Tetrahedron<4>::key: mCoords[0] = VERTEX_3D(v_i[0]); mCoords[1] = VERTEX_3D(v_i[1]); mCoords[2] = VERTEX_3D(v_i[2]); mCoords[3] = VERTEX_3D(v_i[3]); metric_valid = jacobian_matrix_3D(m, J, mCoords, n, d_con); for (i = 0; i < 4; i++) { m_detJ[i] = m; m_J[i] = J; } break; case shards::Pyramid<5>::key: for (i = 0; i < 4; ++i) { mCoords[0] = VERTEX_3D(v_i[ i ]); mCoords[1] = VERTEX_3D(v_i[(i+1)%4]); mCoords[2] = VERTEX_3D(v_i[(i+3)%4]); mCoords[3] = VERTEX_3D(v_i[ 4 ]); metric_valid = jacobian_matrix_3D(m_detJ[i], m_J[i], mCoords, n, d_con); } // FIXME m_J[4] = (m_J[0]+m_J[1]+m_J[2]+m_J[3]); m_J[4] *= 0.25; m_detJ[4] = det(m_J[4]); m = average_metrics(m_detJ, 5, err); MSQ_ERRZERO(err); break; case shards::Wedge<6>::key: for (i = 0; i < 6; ++i) { mCoords[0] = VERTEX_3D(v_i[locs_prism[i][0]]); mCoords[1] = VERTEX_3D(v_i[locs_prism[i][1]]); mCoords[2] = VERTEX_3D(v_i[locs_prism[i][2]]); mCoords[3] = VERTEX_3D(v_i[locs_prism[i][3]]); metric_valid = jacobian_matrix_3D(m_detJ[i], m_J[i], mCoords, n, d_con); } m = average_metrics(m_detJ, 6, err); MSQ_ERRZERO(err); break; case shards::Hexahedron<8>::key: for (i = 0; i < 8; ++i) { mCoords[0] = VERTEX_3D(v_i[locs_hex[i][0]]); mCoords[1] = VERTEX_3D(v_i[locs_hex[i][1]]); mCoords[2] = VERTEX_3D(v_i[locs_hex[i][2]]); mCoords[3] = VERTEX_3D(v_i[locs_hex[i][3]]); metric_valid = jacobian_matrix_3D(m_detJ[i], m_J[i], mCoords, n, d_con); } m = average_metrics(m_detJ, 8, err); MSQ_ERRZERO(err); break; // unimplemented case shards::Node::key: case shards::Particle::key: case shards::Line<2>::key: case shards::Line<3>::key: case shards::ShellLine<2>::key: case shards::ShellLine<3>::key: case shards::Beam<2>::key: case shards::Beam<3>::key: case shards::Triangle<4>::key: case shards::Triangle<6>::key: case shards::ShellTriangle<3>::key: case shards::ShellTriangle<6>::key: case shards::Quadrilateral<8>::key: case shards::Quadrilateral<9>::key: case shards::ShellQuadrilateral<4>::key: case shards::ShellQuadrilateral<8>::key: case shards::ShellQuadrilateral<9>::key: case shards::Tetrahedron<8>::key: case shards::Tetrahedron<10>::key: case shards::Tetrahedron<11>::key: case shards::Hexahedron<20>::key: case shards::Hexahedron<27>::key: case shards::Pyramid<13>::key: case shards::Pyramid<14>::key: case shards::Wedge<15>::key: case shards::Wedge<18>::key: case shards::Pentagon<5>::key: case shards::Hexagon<6>::key: default: shards::CellTopology topology(topology_data); std::cout << "topology = " << topology.getName() << std::endl; throw std::runtime_error("unknown/unhandled topology in JacobianUtil"); break; } // end switch over element type return metric_valid; }
bool operator()(const stk::mesh::Entity& lhs, const stk::mesh::Entity& rhs) const { const stk::mesh::EntityKey lhs_key = lhs.key(); const stk::mesh::EntityKey rhs_key = rhs.key(); return lhs_key == rhs_key; }