//-------------------------------------------------------------------------- void HexNElementDescription::set_face_node_connectivities() { std::vector<ordinal_type> faceOrdinals(numFaces); std::iota(faceOrdinals.begin(), faceOrdinals.end(), 0); auto faceNodeOrdinals = face_node_ordinals(); // there's a disconnect between the exodus node ordering and face ordering, // the first "new" face node is entered on face #5 (4 in C-numbering). ordinal_type faceMap[6] = { 4, 5, 3, 1, 0, 2 }; auto beginIterator = faceNodeOrdinals.begin(); for (const auto faceOrdinal : faceOrdinals) { auto endIterator = beginIterator + newNodesPerFace; faceNodeConnectivities.insert({faceMap[faceOrdinal], std::vector<ordinal_type>{beginIterator,endIterator}}); beginIterator = endIterator; } }
//-------------------------------------------------------------------------- //-------- execute --------------------------------------------------------- //-------------------------------------------------------------------------- void AssembleMomentumEdgeOpenSolverAlgorithm::execute() { stk::mesh::BulkData & bulk_data = realm_.bulk_data(); stk::mesh::MetaData & meta_data = realm_.meta_data(); const int nDim = meta_data.spatial_dimension(); // nearest face entrainment const double nfEntrain = realm_.solutionOptions_->nearestFaceEntrain_; const double om_nfEntrain = 1.0-nfEntrain; // space for dui/dxj; the modified gradient with NOC std::vector<double> duidxj(nDim*nDim); // lhs/rhs space std::vector<stk::mesh::Entity> connected_nodes; std::vector<double> rhs; std::vector<double> lhs; std::vector<double> nx(nDim); std::vector<double> fx(nDim); // pointers double *p_duidxj = &duidxj[0]; double *p_nx = &nx[0]; double *p_fx = &fx[0]; // deal with state VectorFieldType &velocityNp1 = velocity_->field_of_state(stk::mesh::StateNP1); // define vector of parent topos std::vector<stk::topology> parentTopo; // define some common selectors stk::mesh::Selector s_locally_owned_union = meta_data.locally_owned_part() &stk::mesh::selectUnion(partVec_); stk::mesh::BucketVector const& face_buckets = realm_.get_buckets( meta_data.side_rank(), s_locally_owned_union ); for ( stk::mesh::BucketVector::const_iterator ib = face_buckets.begin(); ib != face_buckets.end() ; ++ib ) { stk::mesh::Bucket & b = **ib ; // extract connected element topology b.parent_topology(stk::topology::ELEMENT_RANK, parentTopo); ThrowAssert ( parentTopo.size() == 1 ); stk::topology theElemTopo = parentTopo[0]; MasterElement *meSCS = realm_.get_surface_master_element(theElemTopo); const int nodesPerElement = meSCS->nodesPerElement_; // resize some things; matrix related const int lhsSize = nodesPerElement*nDim*nodesPerElement*nDim; const int rhsSize = nodesPerElement*nDim; lhs.resize(lhsSize); rhs.resize(rhsSize); connected_nodes.resize(nodesPerElement); // pointer to lhs/rhs double *p_lhs = &lhs[0]; double *p_rhs = &rhs[0]; // size some things that are useful const int num_face_nodes = b.topology().num_nodes(); std::vector<int> face_node_ordinals(num_face_nodes); const stk::mesh::Bucket::size_type length = b.size(); for ( stk::mesh::Bucket::size_type k = 0 ; k < length ; ++k ) { // zero lhs/rhs for ( int p = 0; p < lhsSize; ++p ) p_lhs[p] = 0.0; for ( int p = 0; p < rhsSize; ++p ) p_rhs[p] = 0.0; // pointer to face data const double * areaVec = stk::mesh::field_data(*exposedAreaVec_, b, k); const double * mdot = stk::mesh::field_data(*openMassFlowRate_, b, k); // extract the connected element to this exposed face; should be single in size! stk::mesh::Entity const * face_elem_rels = b.begin_elements(k); ThrowAssert( b.num_elements(k) == 1 ); // get element; its face ordinal number and populate face_node_ordinals stk::mesh::Entity element = face_elem_rels[0]; const int face_ordinal = b.begin_element_ordinals(k)[0]; theElemTopo.side_node_ordinals(face_ordinal, face_node_ordinals.begin()); // get the relations; populate connected nodes stk::mesh::Entity const * elem_node_rels = bulk_data.begin_nodes(element); int num_nodes = bulk_data.num_nodes(element); // sanity check on num nodes ThrowAssert( num_nodes == nodesPerElement ); for ( int ni = 0; ni < num_nodes; ++ni ) { // set connected nodes connected_nodes[ni] = elem_node_rels[ni]; } // loop over face nodes (maps directly to ips) for ( int ip = 0; ip < num_face_nodes; ++ip ) { const int opposingNode = meSCS->opposingNodes(face_ordinal,ip); // "Left" const int nearestNode = face_node_ordinals[ip]; // "Right" // left and right nodes; right is on the face; left is the opposing node stk::mesh::Entity nodeL = elem_node_rels[opposingNode]; stk::mesh::Entity nodeR = elem_node_rels[nearestNode]; // extract nodal fields const double * coordL = stk::mesh::field_data(*coordinates_, nodeL ); const double * coordR = stk::mesh::field_data(*coordinates_, nodeR ); const double * uNp1L = stk::mesh::field_data(velocityNp1, nodeL ); const double * uNp1R = stk::mesh::field_data(velocityNp1, nodeR ); const double viscosityR = *stk::mesh::field_data(*viscosity_, nodeR ); const double viscBip = viscosityR; // a few only required (or even defined) on nodeR const double *bcVelocity = stk::mesh::field_data(*velocityBc_, nodeR ); const double * dudxR = stk::mesh::field_data(*dudx_, nodeR ); // offset for bip area vector const int faceOffSet = ip*nDim; // compute geometry double axdx = 0.0; double asq = 0.0; double udotx = 0.0; for ( int j = 0; j < nDim; ++j ) { const double axj = areaVec[faceOffSet+j]; const double dxj = coordR[j] - coordL[j]; asq += axj*axj; axdx += axj*dxj; udotx += 0.5*dxj*(uNp1L[j] + uNp1R[j]); } const double inv_axdx = 1.0/axdx; const double amag = std::sqrt(asq); // form duidxj with over-relaxed procedure of Jasak: for ( int i = 0; i < nDim; ++i ) { // difference between R and L nodes for component i const double uidiff = uNp1R[i] - uNp1L[i]; // offset into all forms of dudx const int offSetI = nDim*i; // start sum for NOC contribution double GlUidxl = 0.0; for ( int l = 0; l< nDim; ++l ) { const int offSetIL = offSetI+l; const double dxl = coordR[l] - coordL[l]; const double GlUi = dudxR[offSetIL]; GlUidxl += GlUi*dxl; } // form full tensor dui/dxj with NOC for ( int j = 0; j < nDim; ++j ) { const int offSetIJ = offSetI+j; const double axj = areaVec[faceOffSet+j]; const double GjUi = dudxR[offSetIJ]; p_duidxj[offSetIJ] = GjUi + (uidiff - GlUidxl)*axj*inv_axdx; } } // divU double divU = 0.0; for ( int j = 0; j < nDim; ++j) divU += p_duidxj[j*nDim+j]; double fxnx = 0.0; double uxnx = 0.0; double uxnxip = 0.0; double uspecxnx = 0.0; for (int i = 0; i < nDim; ++i ) { const double axi = areaVec[faceOffSet+i]; double fxi = 2.0/3.0*viscBip*divU*axi*includeDivU_; const int offSetI = nDim*i; const double nxi = axi/amag; for ( int j = 0; j < nDim; ++j ) { const int offSetTrans = nDim*j+i; const double axj = areaVec[faceOffSet+j]; fxi += -viscBip*(p_duidxj[offSetI+j] + p_duidxj[offSetTrans])*axj; } fxnx += nxi*fxi; uxnx += nxi*uNp1R[i]; uxnxip += 0.5*nxi*(uNp1L[i]+uNp1R[i]); uspecxnx += nxi*bcVelocity[i]; // save off normal and force for each component i p_nx[i] = nxi; p_fx[i] = fxi; } // full stress, sigma_ij for (int i = 0; i < nDim; ++i ) { // setup for matrix contribution assembly const int indexL = opposingNode*nDim + i; const int indexR = nearestNode*nDim + i; const int rowR = indexR*nodesPerElement*nDim; const int rRiL_i = rowR+indexL; const int rRiR_i = rowR+indexR; // subtract normal component const double diffFlux = p_fx[i] - p_nx[i]*fxnx; const double om_nxinxi = 1.0-p_nx[i]*p_nx[i]; p_rhs[indexR] -= diffFlux; double lhsFac = -viscBip*asq*inv_axdx*om_nxinxi; p_lhs[rRiL_i] -= lhsFac; p_lhs[rRiR_i] += lhsFac; const double axi = areaVec[faceOffSet+i]; for ( int j = 0; j < nDim; ++j ) { const double axj = areaVec[faceOffSet+j]; lhsFac = -viscBip*axi*axj*inv_axdx*om_nxinxi; const int colL = opposingNode*nDim + j; const int colR = nearestNode*nDim + j; const int rRiL_j = rowR+colL; const int rRiR_j = rowR+colR; p_lhs[rRiL_j] -= lhsFac; p_lhs[rRiR_j] += lhsFac; if ( i == j ) { // nothing } else { const double nxinxj = p_nx[i]*p_nx[j]; lhsFac = viscBip*asq*inv_axdx*nxinxj; p_lhs[rRiL_j] -= lhsFac; p_lhs[rRiR_j] += lhsFac; lhsFac = viscBip*axj*axj*inv_axdx*nxinxj; p_lhs[rRiL_j] -= lhsFac; p_lhs[rRiR_j] += lhsFac; lhsFac = viscBip*axj*axi*inv_axdx*nxinxj; p_lhs[rRiL_i] -= lhsFac; p_lhs[rRiR_i] += lhsFac; } } } // advection const double tmdot = mdot[ip]; if ( tmdot > 0 ) { // leaving the domain for ( int i = 0; i < nDim; ++i ) { // setup for matrix contribution assembly const int indexR = nearestNode*nDim + i; const int rowR = indexR*nodesPerElement*nDim; const int rRiR = rowR+indexR; p_rhs[indexR] -= tmdot*uNp1R[i]; p_lhs[rRiR] += tmdot; } } else { // entraining; constrain to be normal for ( int i = 0; i < nDim; ++i ) { // setup for matrix contribution assembly const int indexR = nearestNode*nDim + i; const int rowR = indexR*nodesPerElement*nDim; // constrain to be normal p_rhs[indexR] -= tmdot*(nfEntrain*uxnx + om_nfEntrain*uxnxip)*p_nx[i]; // user spec entrainment (tangential) p_rhs[indexR] -= tmdot*(bcVelocity[i]-uspecxnx*p_nx[i]); for ( int j = 0; j < nDim; ++j ) { const int colL = opposingNode*nDim + j; const int colR = nearestNode*nDim + j; p_lhs[rowR+colR] += tmdot*(nfEntrain + om_nfEntrain*0.5)*p_nx[i]*p_nx[j]; p_lhs[rowR+colL] += tmdot*om_nfEntrain*0.5*p_nx[i]*p_nx[j]; } } } } apply_coeff(connected_nodes, rhs, lhs, __FILE__); } } }
//-------------------------------------------------------------------------- //-------- execute --------------------------------------------------------- //-------------------------------------------------------------------------- void AssembleScalarEdgeOpenSolverAlgorithm::execute() { stk::mesh::BulkData & bulk_data = realm_.bulk_data(); stk::mesh::MetaData & meta_data = realm_.meta_data(); // space for LHS/RHS; nodesPerElement*nodesPerElement and nodesPerElement std::vector<double> lhs; std::vector<double> rhs; std::vector<stk::mesh::Entity> connected_nodes; // deal with state ScalarFieldType &scalarQNp1 = scalarQ_->field_of_state(stk::mesh::StateNP1); // define vector of parent topos; should always be UNITY in size std::vector<stk::topology> parentTopo; // define some common selectors stk::mesh::Selector s_locally_owned_union = meta_data.locally_owned_part() &stk::mesh::selectUnion(partVec_); stk::mesh::BucketVector const& face_buckets = realm_.get_buckets( meta_data.side_rank(), s_locally_owned_union ); for ( stk::mesh::BucketVector::const_iterator ib = face_buckets.begin(); ib != face_buckets.end() ; ++ib ) { stk::mesh::Bucket & b = **ib ; // extract connected element topology b.parent_topology(stk::topology::ELEMENT_RANK, parentTopo); ThrowAssert ( parentTopo.size() == 1 ); stk::topology theElemTopo = parentTopo[0]; // volume master element MasterElement *meSCS = realm_.get_surface_master_element(theElemTopo); const int nodesPerElement = meSCS->nodesPerElement_; // face master element MasterElement *meFC = realm_.get_surface_master_element(b.topology()); const int nodesPerFace = meFC->nodesPerElement_; std::vector<int> face_node_ordinal_vec(nodesPerFace); // resize some things; matrix related const int lhsSize = nodesPerElement*nodesPerElement; const int rhsSize = nodesPerElement; lhs.resize(lhsSize); rhs.resize(rhsSize); connected_nodes.resize(nodesPerElement); // pointers double *p_lhs = &lhs[0]; double *p_rhs = &rhs[0]; // size some things that are useful const int num_face_nodes = b.topology().num_nodes(); std::vector<int> face_node_ordinals(num_face_nodes); const stk::mesh::Bucket::size_type length = b.size(); for ( stk::mesh::Bucket::size_type k = 0 ; k < length ; ++k ) { // zero lhs/rhs for ( int p = 0; p < lhsSize; ++p ) p_lhs[p] = 0.0; for ( int p = 0; p < rhsSize; ++p ) p_rhs[p] = 0.0; // get face stk::mesh::Entity face = b[k]; // pointer to face data const double * mdot = stk::mesh::field_data(*openMassFlowRate_, face); // extract the connected element to this exposed face; should be single in size! const stk::mesh::Entity* face_elem_rels = bulk_data.begin_elements(face); ThrowAssert( bulk_data.num_elements(face) == 1 ); // get element; its face ordinal number and populate face_node_ordinal_vec stk::mesh::Entity element = face_elem_rels[0]; const int face_ordinal = bulk_data.begin_element_ordinals(face)[0]; theElemTopo.side_node_ordinals(face_ordinal, face_node_ordinal_vec.begin()); //========================================== // gather nodal data off of element; n/a //========================================== const stk::mesh::Entity* elem_node_rels = bulk_data.begin_nodes(element); const int num_nodes = bulk_data.num_nodes(element); // sanity check on num nodes ThrowAssert( num_nodes == nodesPerElement ); for ( int ni = 0; ni < num_nodes; ++ni ) { stk::mesh::Entity node = elem_node_rels[ni]; // set connected nodes connected_nodes[ni] = node; } // loop over face nodes for ( int ip = 0; ip < num_face_nodes; ++ip ) { const int nearestNode = face_node_ordinal_vec[ip]; // left and right nodes; right is on the face; left is the opposing node stk::mesh::Entity nodeR = elem_node_rels[nearestNode]; const double qR = *stk::mesh::field_data( scalarQNp1, nodeR ); const double qEntrain = *stk::mesh::field_data( *bcScalarQ_, nodeR ); //================================ // advection first (and only) //================================ const double tmdot = mdot[ip]; const int rowR = nearestNode*nodesPerElement; // advection; leaving the domain if ( tmdot > 0.0 ) { // total advection const double aflux = tmdot*qR; p_rhs[nearestNode] -= aflux; // upwind lhs p_lhs[rowR+nearestNode] += tmdot; } else { // extrainment; advect in from specified value const double aflux = tmdot*qEntrain; p_rhs[nearestNode] -= aflux; } } apply_coeff(connected_nodes, rhs, lhs, __FILE__); } } }
//-------------------------------------------------------------------------- //-------- execute --------------------------------------------------------- //-------------------------------------------------------------------------- void ComputeHeatTransferElemWallAlgorithm::execute() { stk::mesh::BulkData & bulk_data = realm_.bulk_data(); stk::mesh::MetaData & meta_data = realm_.meta_data(); const int nDim = meta_data.spatial_dimension(); const double dt = realm_.get_time_step(); // nodal fields to gather std::vector<double> ws_coordinates; std::vector<double> ws_temperature; std::vector<double> ws_thermalCond; std::vector<double> ws_density; std::vector<double> ws_specificHeat; // master element std::vector<double> ws_face_shape_function; std::vector<double> ws_dndx; std::vector<double> ws_det_j; // array for face nodes and nodes off face std::vector<double> ws_nodesOnFace; std::vector<double> ws_nodesOffFace; // define vector of parent topos; should always be UNITY in size std::vector<stk::topology> parentTopo; // define some common selectors stk::mesh::Selector s_locally_owned_union = meta_data.locally_owned_part() &stk::mesh::selectUnion(partVec_); stk::mesh::BucketVector const& face_buckets = realm_.get_buckets( meta_data.side_rank(), s_locally_owned_union ); for ( stk::mesh::BucketVector::const_iterator ib = face_buckets.begin(); ib != face_buckets.end() ; ++ib ) { stk::mesh::Bucket & b = **ib ; // extract connected element topology b.parent_topology(stk::topology::ELEMENT_RANK, parentTopo); ThrowAssert ( parentTopo.size() == 1 ); stk::topology theElemTopo = parentTopo[0]; MasterElement *meSCS = realm_.get_surface_master_element(theElemTopo); const int nodesPerElement = meSCS->nodesPerElement_; // face master element MasterElement *meFC = realm_.get_surface_master_element(b.topology()); const int nodesPerFace = meFC->nodesPerElement_; // size some things that are useful int num_face_nodes = b.topology().num_nodes(); std::vector<int> face_node_ordinals(num_face_nodes); // algorithm related; element ws_coordinates.resize(nodesPerElement*nDim); ws_temperature.resize(nodesPerElement); ws_thermalCond.resize(nodesPerFace); ws_density.resize(nodesPerFace); ws_specificHeat.resize(nodesPerFace); ws_face_shape_function.resize(nodesPerFace*nodesPerFace); ws_dndx.resize(nDim*nodesPerFace*nodesPerElement); ws_det_j.resize(nodesPerFace); ws_nodesOnFace.resize(nodesPerElement); ws_nodesOffFace.resize(nodesPerElement); // pointers double *p_coordinates = &ws_coordinates[0]; double *p_temperature = &ws_temperature[0]; double *p_thermalCond = &ws_thermalCond[0]; double *p_density = &ws_density[0]; double *p_specificHeat = &ws_specificHeat[0]; double *p_face_shape_function = &ws_face_shape_function[0]; double *p_dndx = &ws_dndx[0]; double *p_nodesOnFace = &ws_nodesOnFace[0]; double *p_nodesOffFace = &ws_nodesOffFace[0]; // shape function meFC->shape_fcn(&p_face_shape_function[0]); const stk::mesh::Bucket::size_type length = b.size(); for ( stk::mesh::Bucket::size_type k = 0 ; k < length ; ++k ) { // get face stk::mesh::Entity face = b[k]; // pointer to face data const double * areaVec = stk::mesh::field_data(*exposedAreaVec_, b, k); //====================================== // gather nodal data off of face //====================================== stk::mesh::Entity const * face_node_rels = bulk_data.begin_nodes(face); num_face_nodes = bulk_data.num_nodes(face); // sanity check on num nodes ThrowAssert( num_face_nodes == nodesPerFace ); for ( int ni = 0; ni < num_face_nodes; ++ni ) { stk::mesh::Entity node = face_node_rels[ni]; // gather scalars p_density[ni] = *stk::mesh::field_data(*density_, node); const double mu = *stk::mesh::field_data(*viscosity_, node); const double Cp = *stk::mesh::field_data(*specificHeat_, node); p_specificHeat[ni] = Cp; p_thermalCond[ni] = mu*Cp/Pr_; } // extract the connected element to this exposed face; should be single in size! stk::mesh::Entity const * face_elem_rels = b.begin_elements(k); ThrowAssert( b.num_elements(k) == 1 ); // get element; its face ordinal number and populate face_node_ordinals stk::mesh::Entity element = face_elem_rels[0]; const int face_ordinal = b.begin_element_ordinals(k)[0]; theElemTopo.side_node_ordinals(face_ordinal, face_node_ordinals.begin()); //========================================== // gather nodal data off of element //========================================== stk::mesh::Entity const * elem_node_rels = bulk_data.begin_nodes(element); int num_nodes = bulk_data.num_nodes(element); // sanity check on num nodes ThrowAssert( num_nodes == nodesPerElement ); for ( int ni = 0; ni < num_nodes; ++ni ) { // sneak in nodesOn/offFace p_nodesOnFace[ni] = 0.0; p_nodesOffFace[ni] = 1.0; stk::mesh::Entity node = elem_node_rels[ni]; // gather scalars p_temperature[ni] = *stk::mesh::field_data(*temperature_, node); // gather vectors double * coords = stk::mesh::field_data(*coordinates_, node); const int offSet = ni*nDim; for ( int j=0; j < nDim; ++j ) { p_coordinates[offSet+j] = coords[j]; } } // process on/off while looping over face nodes for ( int ip = 0; ip < num_face_nodes; ++ip ) { const int nearestNode = face_node_ordinals[ip]; p_nodesOnFace[nearestNode] = 1.0; p_nodesOffFace[nearestNode] = 0.0; } // compute dndx double scs_error = 0.0; meSCS->face_grad_op(1, face_ordinal, &p_coordinates[0], &p_dndx[0], &ws_det_j[0], &scs_error); for ( int ip = 0; ip < num_face_nodes; ++ip ) { const int nearestNode = face_node_ordinals[ip]; stk::mesh::Entity nodeR = elem_node_rels[nearestNode]; // pointers to nearest node data double *assembledWallArea = stk::mesh::field_data(*assembledWallArea_, nodeR); double *referenceTemperature = stk::mesh::field_data(*referenceTemperature_, nodeR); double *heatTransferCoefficient = stk::mesh::field_data(*heatTransferCoefficient_, nodeR); double *normalHeatFlux = stk::mesh::field_data(*normalHeatFlux_, nodeR); double *robinCouplingParameter = stk::mesh::field_data(*robinCouplingParameter_, nodeR); // offset for bip area vector and types of shape function const int faceOffSet = ip*nDim; const int offSetSF_face = ip*nodesPerFace; // interpolate to bip double thermalCondBip = 0.0; double densityBip = 0.0; double specificHeatBip = 0.0; for ( int ic = 0; ic < nodesPerFace; ++ic ) { const double r = p_face_shape_function[offSetSF_face+ic]; thermalCondBip += r*p_thermalCond[ic]; densityBip += r*p_density[ic]; specificHeatBip += r*p_specificHeat[ic]; } // handle flux due to on and off face in a single loop (on/off provided above) double dndx = 0.0; double dndxOn = 0.0; double dndxOff = 0.0; double invEltLen = 0.0; for ( int ic = 0; ic < nodesPerElement; ++ic ) { const int offSetDnDx = nDim*nodesPerElement*ip + ic*nDim; const double nodesOnFace = p_nodesOnFace[ic]; const double nodesOffFace = p_nodesOffFace[ic]; const double tempIC = p_temperature[ic]; for ( int j = 0; j < nDim; ++j ) { const double axj = areaVec[faceOffSet+j]; const double dndxj = p_dndx[offSetDnDx+j]; const double dTdA = dndxj*axj*tempIC; dndx += dTdA; dndxOn += dTdA*nodesOnFace; dndxOff += dTdA*nodesOffFace; invEltLen += dndxj*axj*nodesOnFace; } } // compute assembled area double aMag = 0.0; for ( int j = 0; j < nDim; ++j ) { const double axj = areaVec[faceOffSet+j]; aMag += axj*axj; } aMag = std::sqrt(aMag); double eltLen = aMag/invEltLen; // compute coupling parameter const double chi = densityBip * specificHeatBip * eltLen * eltLen / (2 * thermalCondBip * dt); const double alpha = compute_coupling_parameter(thermalCondBip, eltLen, chi); // assemble the nodal quantities *assembledWallArea += aMag; *normalHeatFlux -= thermalCondBip*dndx; *referenceTemperature -= thermalCondBip*dndxOff; *heatTransferCoefficient -= thermalCondBip*dndxOn; *robinCouplingParameter += alpha*aMag; } } } }
//-------------------------------------------------------------------------- //-------- add_elem_gradq -------------------------------------------------- //-------------------------------------------------------------------------- void AssembleNodalGradElemContactAlgorithm::add_elem_gradq() { stk::mesh::MetaData & meta_data = realm_.meta_data(); stk::mesh::BulkData & bulk_data = realm_.bulk_data(); // fields VectorFieldType *coordinates = meta_data.get_field<VectorFieldType>(stk::topology::NODE_RANK, realm_.get_coordinates_name()); VectorFieldType *haloDxj = meta_data.get_field<VectorFieldType>(stk::topology::NODE_RANK, "halo_dxj"); const int nDim = meta_data.spatial_dimension(); // loop over locally owned faces and construct missing elemental contributions stk::mesh::Selector s_locally_owned = meta_data.locally_owned_part() &stk::mesh::selectUnion(partVec_); stk::mesh::BucketVector const& face_buckets = realm_.get_buckets( meta_data.side_rank(), s_locally_owned ); for ( stk::mesh::BucketVector::const_iterator ib = face_buckets.begin(); ib != face_buckets.end() ; ++ib ) { stk::mesh::Bucket & b = **ib; // extract master element; hard coded for quad or hex; // quad is always true for 2D while for 3D, either hex or wedge apply const stk::topology & theElemTopo = (nDim == 2) ? stk::topology::QUAD_4_2D : stk::topology::HEX_8; const int num_face_nodes = (nDim == 2) ? 2 : 4; std::vector<int> face_node_ordinals(num_face_nodes); // extract master element for extruded element type MasterElement *meSCS = realm_.get_surface_master_element(theElemTopo); MasterElement *meSCV = realm_.get_volume_master_element(theElemTopo); // extract master element specifics const int nodesPerElement = meSCV->nodesPerElement_; const int numScsIp = meSCS->numIntPoints_; // mapping between exposed face and extruded element's overlapping face const int *faceNodeOnExtrudedElem = meSCS->faceNodeOnExtrudedElem(); // mapping between exposed face and extruded element's opposing face const int *opposingNodeOnExtrudedElem = meSCS->opposingNodeOnExtrudedElem(); // mapping between exposed face scs ips and halo edge const int *faceScsIpOnExtrudedElem = meSCS->faceScsIpOnExtrudedElem(); // mapping between exposed face scs ips and exposed face edge const int *faceScsIpOnFaceEdges = meSCS->faceScsIpOnFaceEdges(); // alignment of face:edge ordering and scsip area vector const double *edgeAlignedArea = meSCS->edgeAlignedArea(); // define scratch field std::vector<double > ws_coordinates(nodesPerElement*nDim); std::vector<double > ws_scs_areav(numScsIp*nDim); std::vector<double > ws_scalarQ(nodesPerElement); std::vector<double> ws_shape_function(numScsIp*nodesPerElement); // pointers double *p_shape_function = &ws_shape_function[0]; meSCS->shape_fcn(&p_shape_function[0]); const stk::mesh::Bucket::size_type length = b.size(); for ( stk::mesh::Bucket::size_type k = 0 ; k < length ; ++k ) { // get face stk::mesh::Entity face = b[k]; // extract the connected element to this exposed face; should be single in size! stk::mesh::Entity const* face_elem_rels = bulk_data.begin_elements(face); stk::mesh::ConnectivityOrdinal const* face_elem_ords = bulk_data.begin_element_ordinals(face); const int num_elements = bulk_data.num_elements(face); ThrowRequire( num_elements == 1 ); stk::mesh::Entity element = face_elem_rels[0]; const int face_ordinal = face_elem_ords[0]; theElemTopo.side_node_ordinals(face_ordinal, face_node_ordinals.begin()); // concentrate on loading up the nodal coordinates/scalarQ for the extruded element stk::mesh::Entity const * face_node_rels = b.begin_nodes(k); int num_nodes = b.num_nodes(k); for ( int ni = 0; ni < num_nodes; ++ni ) { stk::mesh::Entity node = face_node_rels[ni]; const double * coords = stk::mesh::field_data(*coordinates, node); const double * hDxj = stk::mesh::field_data( *haloDxj, node ); const int faceNode = faceNodeOnExtrudedElem[face_ordinal*num_nodes + ni]; const int opposingNode = opposingNodeOnExtrudedElem[face_ordinal*num_nodes + ni]; const int offSetFN = faceNode*nDim; const int offSetON = opposingNode*nDim; // populate scalars ws_scalarQ[faceNode] = *stk::mesh::field_data(*scalarQ_, node); ws_scalarQ[opposingNode] = *stk::mesh::field_data(*haloQ_, node); // now vectors for ( int j=0; j < nDim; ++j ) { // face node ws_coordinates[offSetFN+j] = coords[j]; ws_coordinates[offSetON+j] = coords[j] + hDxj[j]; } } // compute scs integration point areavec double scs_error = 0.0; meSCS->determinant(1, &ws_coordinates[0], &ws_scs_areav[0], &scs_error); // assemble halo ip contribution for face node for ( int ni = 0; ni < num_nodes; ++ni ) { stk::mesh::Entity node = face_node_rels[ni]; const double &dualNodalVolume = *stk::mesh::field_data( *dualNodalVolume_, node ); // area vector for halo edge; // face ordinal 0 for extruded element has all scs area vectors pointing from face to opposing face const int scsIp = faceScsIpOnExtrudedElem[face_ordinal*num_nodes + ni]; // interpolate element nodal values to this scsIp of interest double scalarQ_scsIp = 0.0; for ( int ic = 0; ic < nodesPerElement; ++ic ) scalarQ_scsIp += p_shape_function[scsIp*nodesPerElement + ic]*ws_scalarQ[ic]; // add in nodal gradient contribution double *dqdx = stk::mesh::field_data( *dqdx_, node ); for ( int j = 0; j < nDim; ++j ) { dqdx[j] += scalarQ_scsIp*ws_scs_areav[scsIp*nDim+j]/dualNodalVolume; } } // deal with edges on the exposed face and each stk::mesh::Entity const* elem_node_rels = bulk_data.begin_nodes(element); // face edge relations; if this is 2D then the face is a edge and size is unity stk::mesh::Entity const* face_edge_rels = bulk_data.begin_edges(face); const int num_face_edges = bulk_data.num_edges(face); int num_edges = (nDim == 3) ? num_face_edges : 1; for ( int i = 0; i < num_edges; ++i ) { // get edge stk::mesh::Entity edge = (nDim == 3) ? face_edge_rels[i] : face; // get the relations from edge stk::mesh::Entity const* edge_node_rels = bulk_data.begin_nodes(edge); const int edge_num_nodes = bulk_data.num_nodes(edge); // sanity check on num nodes if ( edge_num_nodes != 2 ){ throw std::runtime_error("num nodes is not 2"); } // extract ip for this edge const int scsIp = faceScsIpOnFaceEdges[face_ordinal*num_edges + i]; // correct area for edge and scs area vector from extruded element alignment const double alignmentFac = edgeAlignedArea[face_ordinal*num_edges + i]; // interpolate element nodal values to this scsIp of interest double scalarQ_scsIp = 0.0; for ( int ic = 0; ic < nodesPerElement; ++ic ) scalarQ_scsIp += p_shape_function[scsIp*nodesPerElement + ic]*ws_scalarQ[ic]; // left and right nodes on the edge stk::mesh::Entity nodeL = edge_node_rels[0]; stk::mesh::Entity nodeR = edge_node_rels[1]; // does edge point correctly const int leftNode = face_node_ordinals[i]; const size_t iglob_Lelem = bulk_data.identifier(elem_node_rels[leftNode]); const size_t iglob_Ledge = bulk_data.identifier(edge_node_rels[0]); // determine the sign value for area vector; if Left node is the same, // then the element and edge relations are aligned const double sign = ( iglob_Lelem == iglob_Ledge ) ? 1.0 : -1.0; // add in nodal gradient contribution double *dqdxL = stk::mesh::field_data( *dqdx_, nodeL ); double *dqdxR = stk::mesh::field_data( *dqdx_, nodeR ); const double &dualNodalVolumeL = *stk::mesh::field_data( *dualNodalVolume_, nodeL ); const double &dualNodalVolumeR = *stk::mesh::field_data( *dualNodalVolume_, nodeR ); for ( int j = 0; j < nDim; ++j ) { dqdxL[j] += scalarQ_scsIp*ws_scs_areav[scsIp*nDim+j]/dualNodalVolumeL*sign*alignmentFac; dqdxR[j] -= scalarQ_scsIp*ws_scs_areav[scsIp*nDim+j]/dualNodalVolumeR*sign*alignmentFac; } } } } // parallel assembly handled elsewhere }