//-------------------------------------------------------------------------- //-------- clip_min_distance_to_wall --------------------------------------- //-------------------------------------------------------------------------- void ShearStressTransportEquationSystem::clip_min_distance_to_wall() { // if this is a restart, then min distance has already been clipped if (realm_.restarted_simulation()) return; // okay, no restart: proceed with clipping of minimum wall distance stk::mesh::BulkData & bulk_data = realm_.bulk_data(); stk::mesh::MetaData & meta_data = realm_.meta_data(); const int nDim = meta_data.spatial_dimension(); // extract fields required GenericFieldType *exposedAreaVec = meta_data.get_field<GenericFieldType>(meta_data.side_rank(), "exposed_area_vector"); VectorFieldType *coordinates = meta_data.get_field<VectorFieldType>(stk::topology::NODE_RANK, realm_.get_coordinates_name()); // define vector of parent topos; should always be UNITY in size std::vector<stk::topology> parentTopo; // selector stk::mesh::Selector s_locally_owned_union = meta_data.locally_owned_part() &stk::mesh::selectUnion(wallBcPart_); 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]; // extract master element MasterElement *meSCS = realm_.get_surface_master_element(theElemTopo); // face master element const int nodesPerFace = b.topology().num_nodes(); std::vector<int> face_node_ordinal_vec(nodesPerFace); 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]; int num_face_nodes = bulk_data.num_nodes(face); // pointer to face data const double * areaVec = stk::mesh::field_data(*exposedAreaVec, 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()); // get the relations off of element stk::mesh::Entity const * elem_node_rels = bulk_data.begin_nodes(element); // loop over face nodes for ( int ip = 0; ip < num_face_nodes; ++ip ) { const int offSetAveraVec = ip*nDim; const int opposingNode = meSCS->opposingNodes(face_ordinal,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 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 ); double aMag = 0.0; for ( int j = 0; j < nDim; ++j ) { const double axj = areaVec[offSetAveraVec+j]; aMag += axj*axj; } aMag = std::sqrt(aMag); // form unit normal and determine yp (approximated by 1/4 distance along edge) double ypbip = 0.0; for ( int j = 0; j < nDim; ++j ) { const double nj = areaVec[offSetAveraVec+j]/aMag; const double ej = 0.25*(coordR[j] - coordL[j]); ypbip += nj*ej*nj*ej; } ypbip = std::sqrt(ypbip); // assemble to nodal quantities double *minD = stk::mesh::field_data(*minDistanceToWall_, nodeR ); *minD = std::max(*minD, ypbip); } } } }
//-------------------------------------------------------------------------- //-------- 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 AssembleScalarElemOpenSolverAlgorithm::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 small = 1.0e-16; // extract user advection options (allow to potentially change over time) const std::string dofName = scalarQ_->name(); const double alphaUpw = realm_.get_alpha_upw_factor(dofName); const double hoUpwind = realm_.get_upw_factor(dofName); // one minus flavor.. const double om_alphaUpw = 1.0-alphaUpw; // space for LHS/RHS; nodesPerElement*nodesPerElement and nodesPerElement std::vector<double> lhs; std::vector<double> rhs; std::vector<int> scratchIds; std::vector<double> scratchVals; std::vector<stk::mesh::Entity> connected_nodes; // ip values; only boundary std::vector<double> coordBip(nDim); // pointers to fixed values double *p_coordBip = &coordBip[0]; // nodal fields to gather std::vector<double> ws_face_coordinates; std::vector<double> ws_scalarQNp1; std::vector<double> ws_bcScalarQ; // master element std::vector<double> ws_face_shape_function; // deal with state ScalarFieldType &scalarQNp1 = scalarQ_->field_of_state(stk::mesh::StateNP1); ScalarFieldType &densityNp1 = density_->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_; const int numScsBip = meFC->numIntPoints_; 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); scratchIds.resize(rhsSize); scratchVals.resize(rhsSize); connected_nodes.resize(nodesPerElement); // algorithm related; element ws_face_coordinates.resize(nodesPerFace*nDim); ws_scalarQNp1.resize(nodesPerFace); ws_bcScalarQ.resize(nodesPerFace); ws_face_shape_function.resize(numScsBip*nodesPerFace); // pointers double *p_lhs = &lhs[0]; double *p_rhs = &rhs[0]; double *p_face_coordinates = &ws_face_coordinates[0]; double *p_scalarQNp1 = &ws_scalarQNp1[0]; double *p_bcScalarQ = &ws_bcScalarQ[0]; double *p_face_shape_function = &ws_face_shape_function[0]; // shape functions 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 ) { // 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); //====================================== // gather nodal data off of face //====================================== stk::mesh::Entity const * face_node_rels = bulk_data.begin_nodes(face); int 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_scalarQNp1[ni] = *stk::mesh::field_data(scalarQNp1, node); p_bcScalarQ[ni] = *stk::mesh::field_data(*bcScalarQ_, node); // gather vectors double * coords = stk::mesh::field_data(*coordinates_, node); const int offSet = ni*nDim; for ( int i=0; i < nDim; ++i ) { p_face_coordinates[offSet+i] = coords[i]; } } // 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()); // mapping from ip to nodes for this ordinal const int *ipNodeMap = meSCS->ipNodeMap(face_ordinal); //========================================== // gather nodal data off of element; n/a //========================================== 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 for ( int ip = 0; ip < numScsBip; ++ip ) { const int opposingNode = meSCS->opposingNodes(face_ordinal,ip); const int nearestNode = ipNodeMap[ip]; const int offSetSF_face = ip*nodesPerFace; // 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]; // zero out vector quantities for ( int j = 0; j < nDim; ++j ) p_coordBip[j] = 0.0; // interpolate to bip double qIp = 0.0; double qIpEntrain = 0.0; for ( int ic = 0; ic < nodesPerFace; ++ic ) { const double r = p_face_shape_function[offSetSF_face+ic]; qIp += r*p_scalarQNp1[ic]; qIpEntrain += r*p_bcScalarQ[ic]; const int offSetFN = ic*nDim; for ( int j = 0; j < nDim; ++j ) { p_coordBip[j] += r*p_face_coordinates[offSetFN+j]; } } // Peclet factor; along the edge is fine const double densL = *stk::mesh::field_data(densityNp1, nodeL); const double densR = *stk::mesh::field_data(densityNp1, nodeR); const double diffCoeffL = *stk::mesh::field_data(*diffFluxCoeff_, nodeL); const double diffCoeffR = *stk::mesh::field_data(*diffFluxCoeff_, nodeR); const double scalarQNp1R = *stk::mesh::field_data(scalarQNp1, nodeR); const double *vrtmL = stk::mesh::field_data(*velocityRTM_, nodeL); const double *vrtmR = stk::mesh::field_data(*velocityRTM_, nodeR); const double *coordL = stk::mesh::field_data(*coordinates_, nodeL); const double *coordR = stk::mesh::field_data(*coordinates_, nodeR); const double *dqdxR = stk::mesh::field_data(*dqdx_, nodeR); double udotx = 0.0; double dqR = 0.0; for ( int i = 0; i < nDim; ++i ) { const double dxi = coordR[i] - coordL[i]; udotx += 0.5*dxi*(vrtmL[i] + vrtmR[i]); // extrapolation const double dx_bip = coordBip[i] - coordR[i]; dqR += dx_bip*dqdxR[i]*hoUpwind; } const double qIpUpw = scalarQNp1R + dqR; const double diffIp = 0.5*(diffCoeffL/densL + diffCoeffR/densR); const double pecfac = pecletFunction_->execute(std::abs(udotx)/(diffIp+small)); const double om_pecfac = 1.0-pecfac; //================================ // advection first (and only) //================================ const double tmdot = mdot[ip]; const int rowR = nearestNode*nodesPerElement; // advection; leaving the domain if ( tmdot > 0.0 ) { // central; is simply qIp // upwind const double qUpwind = alphaUpw*qIpUpw + (om_alphaUpw)*qIp; // total advection const double aflux = tmdot*(pecfac*qUpwind+om_pecfac*qIp); p_rhs[nearestNode] -= aflux; // upwind lhs p_lhs[rowR+nearestNode] += tmdot*pecfac*alphaUpw; // central part const double fac = tmdot*(pecfac*om_alphaUpw+om_pecfac); for ( int ic = 0; ic < nodesPerFace; ++ic ) { const double r = p_face_shape_function[offSetSF_face+ic]; const int nn = face_node_ordinal_vec[ic]; p_lhs[rowR+nn] += r*fac; } } else { // extrainment; advect in from specified value const double aflux = tmdot*qIpEntrain; p_rhs[nearestNode] -= aflux; } } apply_coeff(connected_nodes, scratchIds, scratchVals, rhs, lhs, __FILE__); } } }
//-------------------------------------------------------------------------- //-------- execute --------------------------------------------------------- //-------------------------------------------------------------------------- void AssemblePressureForceBCSolverAlgorithm::execute() { stk::mesh::BulkData & bulk_data = realm_.bulk_data(); stk::mesh::MetaData & meta_data = realm_.meta_data(); const int nDim = meta_data.spatial_dimension(); // space for LHS/RHS; nodesPerElem*nDim*nodesPerElem*nDim and nodesPerElem*nDim std::vector<double> lhs; std::vector<double> rhs; std::vector<stk::mesh::Entity> connected_nodes; // nodal fields to gather std::vector<double> ws_face_coordinates; std::vector<double> ws_bcScalarQ; // master element std::vector<double> ws_face_shape_function; // 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*nDim*nodesPerElement*nDim; const int rhsSize = nodesPerElement*nDim; lhs.resize(lhsSize); rhs.resize(rhsSize); connected_nodes.resize(nodesPerElement); // algorithm related; element ws_face_coordinates.resize(nodesPerFace*nDim); ws_bcScalarQ.resize(nodesPerFace); ws_face_shape_function.resize(nodesPerFace*nodesPerFace); // pointers double *p_lhs = &lhs[0]; double *p_rhs = &rhs[0]; double *p_face_coordinates = &ws_face_coordinates[0]; double *p_bcScalarQ = &ws_bcScalarQ[0]; double *p_face_shape_function = &ws_face_shape_function[0]; // shape functions if (use_shifted_integration_) { meFC->shifted_shape_fcn(&p_face_shape_function[0]); } else{ meFC->shape_fcn(&p_face_shape_function[0]); } const size_t length = b.size(); for ( size_t 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]; //====================================== // gather nodal data off of face //====================================== stk::mesh::Entity const * face_node_rels = bulk_data .begin_nodes(face); int 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]; p_bcScalarQ[ni] = *stk::mesh::field_data(*bcScalarQ_, node); // gather vectors double * coords = stk::mesh::field_data(*coordinates_, node); const int offSet = ni*nDim; for ( int i=0; i < nDim; ++i ) { p_face_coordinates[offSet+i] = coords[i]; } } // 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 //========================================== 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 ) { stk::mesh::Entity node = elem_node_rels[ni]; // set connected nodes connected_nodes[ni] = node; } // pointer to face data double * areaVec = stk::mesh::field_data(*exposedAreaVec_, face); // loop over face nodes for ( int ip = 0; ip < num_face_nodes; ++ip ) { const int nearestNode = face_node_ordinal_vec[ip]; const int offSetSF_face = ip*nodesPerFace; // interpolate to bip double fluxBip = 0.0; for ( int ic = 0; ic < nodesPerFace; ++ic ) { const double r = p_face_shape_function[offSetSF_face+ic]; fluxBip += r*p_bcScalarQ[ic]; } // assemble for each of the ith component for ( int i = 0; i < nDim; ++i ) { const int indexR = nearestNode*nDim + i; p_rhs[indexR] -= fluxBip*areaVec[ip*nDim+i]; // RHS only, no need to populate LHS (is zeroed out) } } apply_coeff(connected_nodes, rhs, lhs, __FILE__); } } }
//-------------------------------------------------------------------------- //-------- execute --------------------------------------------------------- //-------------------------------------------------------------------------- void SurfaceForceAndMomentAlgorithm::execute() { // check to see if this is a valid step to process output file const int timeStepCount = realm_.get_time_step_count(); const bool processMe = (timeStepCount % frequency_) == 0 ? true : false; // do not waste time here if ( !processMe ) return; // common stk::mesh::BulkData & bulk_data = realm_.bulk_data(); stk::mesh::MetaData & meta_data = realm_.meta_data(); const int nDim = meta_data.spatial_dimension(); // set min and max values double yplusMin = 1.0e8; double yplusMax = -1.0e8; // nodal fields to gather std::vector<double> ws_pressure; std::vector<double> ws_density; std::vector<double> ws_viscosity; // master element std::vector<double> ws_face_shape_function; // deal with state ScalarFieldType &densityNp1 = density_->field_of_state(stk::mesh::StateNP1); // define vector of parent topos; should always be UNITY in size std::vector<stk::topology> parentTopo; const double currentTime = realm_.get_current_time(); // local force and moment; i.e., to be assembled double l_force_moment[9] = {}; // work force, moment and radius; i.e., to be pushed to cross_product() double ws_p_force[3] = {}; double ws_v_force[3] = {}; double ws_t_force[3] = {}; double ws_tau[3] = {}; double ws_moment[3] = {}; double ws_radius[3] = {}; // will need surface normal double ws_normal[3] = {}; // centroid double centroid[3] = {}; for ( size_t k = 0; k < parameters_.size(); ++k) centroid[k] = parameters_[k]; // 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 ; // 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); // extract connected element topology b.parent_topology(stk::topology::ELEMENT_RANK, parentTopo); ThrowAssert ( parentTopo.size() == 1 ); stk::topology theElemTopo = parentTopo[0]; // extract master element for this element topo MasterElement *meSCS = realm_.get_surface_master_element(theElemTopo); // algorithm related; element ws_pressure.resize(nodesPerFace); ws_density.resize(nodesPerFace); ws_viscosity.resize(nodesPerFace); ws_face_shape_function.resize(nodesPerFace*nodesPerFace); // pointers double *p_pressure = &ws_pressure[0]; double *p_density = &ws_density[0]; double *p_viscosity = &ws_viscosity[0]; double *p_face_shape_function = &ws_face_shape_function[0]; // shape functions if ( useShifted_ ) meFC->shifted_shape_fcn(&p_face_shape_function[0]); else 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]; // face node relations stk::mesh::Entity const * face_node_rels = bulk_data.begin_nodes(face); //====================================== // gather nodal data off of face //====================================== for ( int ni = 0; ni < nodesPerFace; ++ni ) { stk::mesh::Entity node = face_node_rels[ni]; // gather scalars p_pressure[ni] = *stk::mesh::field_data(*pressure_, node); p_density[ni] = *stk::mesh::field_data(densityNp1, node); p_viscosity[ni] = *stk::mesh::field_data(*viscosity_, node); } // pointer to face data const double * areaVec = stk::mesh::field_data(*exposedAreaVec_, 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()); // get the relations off of element stk::mesh::Entity const * elem_node_rels = bulk_data.begin_nodes(element); for ( int ip = 0; ip < nodesPerFace; ++ip ) { // offsets const int offSetAveraVec = ip*nDim; const int offSetSF_face = ip*nodesPerFace; // interpolate to bip double pBip = 0.0; double rhoBip = 0.0; double muBip = 0.0; for ( int ic = 0; ic < nodesPerFace; ++ic ) { const double r = p_face_shape_function[offSetSF_face+ic]; pBip += r*p_pressure[ic]; rhoBip += r*p_density[ic]; muBip += r*p_viscosity[ic]; } // extract nodal fields stk::mesh::Entity node = face_node_rels[ip]; const double * coord = stk::mesh::field_data(*coordinates_, node ); const double *duidxj = stk::mesh::field_data(*dudx_, node ); double *pressureForce = stk::mesh::field_data(*pressureForce_, node ); double *tauWall = stk::mesh::field_data(*tauWall_, node ); double *yplus = stk::mesh::field_data(*yplus_, node ); const double assembledArea = *stk::mesh::field_data(*assembledArea_, node ); // divU and aMag double divU = 0.0; double aMag = 0.0; for ( int j = 0; j < nDim; ++j) { divU += duidxj[j*nDim+j]; aMag += areaVec[offSetAveraVec+j]*areaVec[offSetAveraVec+j]; } aMag = std::sqrt(aMag); // normal for ( int i = 0; i < nDim; ++i ) { const double ai = areaVec[offSetAveraVec+i]; ws_normal[i] = ai/aMag; } // load radius; assemble force -sigma_ij*njdS and compute tau_ij njDs for ( int i = 0; i < nDim; ++i ) { const double ai = areaVec[offSetAveraVec+i]; ws_radius[i] = coord[i] - centroid[i]; // set forces ws_v_force[i] = 2.0/3.0*muBip*divU*includeDivU_*ai; ws_p_force[i] = pBip*ai; pressureForce[i] += pBip*ai; double dflux = 0.0; double tauijNj = 0.0; const int offSetI = nDim*i; for ( int j = 0; j < nDim; ++j ) { const int offSetTrans = nDim*j+i; dflux += -muBip*(duidxj[offSetI+j] + duidxj[offSetTrans])*areaVec[offSetAveraVec+j]; tauijNj += -muBip*(duidxj[offSetI+j] + duidxj[offSetTrans])*ws_normal[j]; } // accumulate viscous force and set tau for component i ws_v_force[i] += dflux; ws_tau[i] = tauijNj; } // compute total force and tangential tau double tauTangential = 0.0; for ( int i = 0; i < nDim; ++i ) { ws_t_force[i] = ws_p_force[i] + ws_v_force[i]; double tauiTangential = (1.0-ws_normal[i]*ws_normal[i])*ws_tau[i]; for ( int j = 0; j < nDim; ++j ) { if ( i != j ) tauiTangential -= ws_normal[i]*ws_normal[j]*ws_tau[j]; } tauTangential += tauiTangential*tauiTangential; } // assemble nodal quantities; scaled by area for L2 lumped nodal projection const double areaFac = aMag/assembledArea; *tauWall += std::sqrt(tauTangential)*areaFac; cross_product(&ws_t_force[0], &ws_moment[0], &ws_radius[0]); // assemble force and moment for ( int j = 0; j < 3; ++j ) { l_force_moment[j] += ws_p_force[j]; l_force_moment[j+3] += ws_v_force[j]; l_force_moment[j+6] += ws_moment[j]; } // deal with yplus const int opposingNode = meSCS->opposingNodes(face_ordinal,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 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 ); // determine yp (approximated by 1/4 distance along edge) double ypBip = 0.0; for ( int j = 0; j < nDim; ++j ) { const double nj = ws_normal[j]; const double ej = 0.25*(coordR[j] - coordL[j]); ypBip += nj*ej*nj*ej; } ypBip = std::sqrt(ypBip); const double tauW = std::sqrt(tauTangential); const double uTau = std::sqrt(tauW/rhoBip); const double yplusBip = rhoBip*ypBip/muBip*uTau; // nodal field *yplus += yplusBip*areaFac; // min and max yplusMin = std::min(yplusMin, yplusBip); yplusMax = std::max(yplusMax, yplusBip); } } } if ( processMe ) { // parallel assemble and output double g_force_moment[9] = {}; stk::ParallelMachine comm = NaluEnv::self().parallel_comm(); // Parallel assembly of L2 stk::all_reduce_sum(comm, &l_force_moment[0], &g_force_moment[0], 9); // min/max double g_yplusMin = 0.0, g_yplusMax = 0.0; stk::all_reduce_min(comm, &yplusMin, &g_yplusMin, 1); stk::all_reduce_max(comm, &yplusMax, &g_yplusMax, 1); // deal with file name and banner if ( NaluEnv::self().parallel_rank() == 0 ) { std::ofstream myfile; myfile.open(outputFileName_.c_str(), std::ios_base::app); myfile << std::setprecision(6) << std::setw(w_) << currentTime << std::setw(w_) << g_force_moment[0] << std::setw(w_) << g_force_moment[1] << std::setw(w_) << g_force_moment[2] << std::setw(w_) << g_force_moment[3] << std::setw(w_) << g_force_moment[4] << std::setw(w_) << g_force_moment[5] << std::setw(w_) << g_force_moment[6] << std::setw(w_) << g_force_moment[7] << std::setw(w_) << g_force_moment[8] << std::setw(w_) << g_yplusMin << std::setw(w_) << g_yplusMax << std::endl; myfile.close(); } } }
//-------------------------------------------------------------------------- //-------- execute --------------------------------------------------------- //-------------------------------------------------------------------------- void AssembleContinuityElemOpenSolverAlgorithm::execute() { stk::mesh::BulkData & bulk_data = realm_.bulk_data(); stk::mesh::MetaData & meta_data = realm_.meta_data(); const int nDim = meta_data.spatial_dimension(); // extract noc const std::string dofName = "pressure"; const double includeNOC = (realm_.get_noc_usage(dofName) == true) ? 1.0 : 0.0; // space for LHS/RHS; nodesPerElem*nodesPerElem and nodesPerElem std::vector<double> lhs; std::vector<double> rhs; std::vector<stk::mesh::Entity> connected_nodes; // ip values; both boundary and opposing surface std::vector<double> uBip(nDim); std::vector<double> rho_uBip(nDim); std::vector<double> GpdxBip(nDim); std::vector<double> coordBip(nDim); std::vector<double> coordScs(nDim); // pointers to fixed values double *p_uBip = &uBip[0]; double *p_rho_uBip = &rho_uBip[0]; double *p_GpdxBip = &GpdxBip[0]; double *p_coordBip = &coordBip[0]; double *p_coordScs = &coordScs[0]; // nodal fields to gather std::vector<double> ws_coordinates; std::vector<double> ws_pressure; std::vector<double> ws_vrtm; std::vector<double> ws_Gpdx; std::vector<double> ws_density; std::vector<double> ws_bcPressure; // master element std::vector<double> ws_shape_function; std::vector<double> ws_shape_function_lhs; std::vector<double> ws_face_shape_function; // time step const double dt = realm_.get_time_step(); const double gamma1 = realm_.get_gamma1(); const double projTimeScale = dt/gamma1; // deal with interpolation procedure const double interpTogether = realm_.get_mdot_interp(); const double om_interpTogether = 1.0-interpTogether; // deal with state ScalarFieldType &densityNp1 = density_->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_; const int numScsIp = meSCS->numIntPoints_; // face master element MasterElement *meFC = realm_.get_surface_master_element(b.topology()); const int nodesPerFace = b.topology().num_nodes(); const int numScsBip = meFC->numIntPoints_; 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); // algorithm related; element ws_coordinates.resize(nodesPerElement*nDim); ws_pressure.resize(nodesPerElement); ws_vrtm.resize(nodesPerFace*nDim); ws_Gpdx.resize(nodesPerFace*nDim); ws_density.resize(nodesPerFace); ws_bcPressure.resize(nodesPerFace); ws_shape_function.resize(numScsIp*nodesPerElement); ws_shape_function_lhs.resize(numScsIp*nodesPerElement); ws_face_shape_function.resize(numScsBip*nodesPerFace); // pointers double *p_lhs = &lhs[0]; double *p_rhs = &rhs[0]; double *p_coordinates = &ws_coordinates[0]; double *p_pressure = &ws_pressure[0]; double *p_vrtm = &ws_vrtm[0]; double *p_Gpdx = &ws_Gpdx[0]; double *p_density = &ws_density[0]; double *p_bcPressure = &ws_bcPressure[0]; double *p_shape_function = &ws_shape_function[0]; double *p_shape_function_lhs = shiftPoisson_ ? &ws_shape_function[0] : reducedSensitivities_ ? &ws_shape_function_lhs[0] : &ws_shape_function[0]; double *p_face_shape_function = &ws_face_shape_function[0]; // shape functions; interior if ( shiftPoisson_ ) meSCS->shifted_shape_fcn(&p_shape_function[0]); else meSCS->shape_fcn(&p_shape_function[0]); if ( !shiftPoisson_ && reducedSensitivities_ ) meSCS->shifted_shape_fcn(&p_shape_function_lhs[0]); // shape functions; boundary if ( shiftMdot_ ) meFC->shifted_shape_fcn(&p_face_shape_function[0]); else 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 ) { // 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]; //====================================== // gather nodal data off of face //====================================== stk::mesh::Entity const * face_node_rels = bulk_data.begin_nodes(face); int 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(densityNp1, node); p_bcPressure[ni] = *stk::mesh::field_data(*pressureBc_, node); // gather vectors const double * vrtm = stk::mesh::field_data(*velocityRTM_, node); const double * Gjp = stk::mesh::field_data(*Gpdx_, node); const int offSet = ni*nDim; for ( int j=0; j < nDim; ++j ) { p_vrtm[offSet+j] = vrtm[j]; p_Gpdx[offSet+j] = Gjp[j]; } } // pointer to face data const double * areaVec = stk::mesh::field_data(*exposedAreaVec_, 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 stk::mesh::ConnectivityOrdinal* face_elem_ords = bulk_data.begin_element_ordinals(face); const int face_ordinal = face_elem_ords[0]; theElemTopo.side_node_ordinals(face_ordinal, face_node_ordinal_vec.begin()); // mapping from ip to nodes for this ordinal const int *ipNodeMap = meSCS->ipNodeMap(face_ordinal); //====================================== // 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 ) { stk::mesh::Entity node = elem_node_rels[ni]; // set connected nodes connected_nodes[ni] = node; // gather scalars p_pressure[ni] = *stk::mesh::field_data(*pressure_, node); // gather vectors const 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]; } } // loop over boundary ips for ( int ip = 0; ip < numScsBip; ++ip ) { const int nearestNode = ipNodeMap[ip]; const int opposingScsIp = meSCS->opposingFace(face_ordinal,ip); // zero out vector quantities for ( int j = 0; j < nDim; ++j ) { p_uBip[j] = 0.0; p_rho_uBip[j] = 0.0; p_GpdxBip[j] = 0.0; p_coordBip[j] = 0.0; p_coordScs[j] = 0.0; } double rhoBip = 0.0; // interpolate to bip double pBip = 0.0; const int offSetSF_face = ip*nodesPerFace; for ( int ic = 0; ic < nodesPerFace; ++ic ) { const int fn = face_node_ordinal_vec[ic]; const double r = p_face_shape_function[offSetSF_face+ic]; const double rhoIC = p_density[ic]; rhoBip += r*rhoIC; pBip += r*p_bcPressure[ic]; const int offSetFN = ic*nDim; const int offSetEN = fn*nDim; for ( int j = 0; j < nDim; ++j ) { p_uBip[j] += r*p_vrtm[offSetFN+j]; p_rho_uBip[j] += r*rhoIC*p_vrtm[offSetFN+j]; p_GpdxBip[j] += r*p_Gpdx[offSetFN+j]; p_coordBip[j] += r*p_coordinates[offSetEN+j]; } } // data at interior opposing face double pScs = 0.0; const int offSetSF_elem = opposingScsIp*nodesPerElement; for ( int ic = 0; ic < nodesPerElement; ++ic ) { const double r = p_shape_function[offSetSF_elem+ic]; pScs += r*p_pressure[ic]; const int offSet = ic*nDim; for ( int j = 0; j < nDim; ++j ) { p_coordScs[j] += r*p_coordinates[offSet+j]; } } // form axdx, asq and mdot (without dp/dn or noc) double asq = 0.0; double axdx = 0.0; double mdot = 0.0; for ( int j = 0; j < nDim; ++j ) { const double dxj = p_coordBip[j] - p_coordScs[j]; const double axj = areaVec[ip*nDim+j]; asq += axj*axj; axdx += axj*dxj; mdot += (interpTogether*p_rho_uBip[j] + om_interpTogether*rhoBip*p_uBip[j] + projTimeScale*p_GpdxBip[j])*axj; } const double inv_axdx = 1.0/axdx; // deal with noc double noc = 0.0; for ( int j = 0; j < nDim; ++j ) { const double dxj = p_coordBip[j] - p_coordScs[j]; const double axj = areaVec[ip*nDim+j]; const double kxj = axj - asq*inv_axdx*dxj; // NOC noc += kxj*p_GpdxBip[j]; } // lhs for pressure system int rowR = nearestNode*nodesPerElement; for ( int ic = 0; ic < nodesPerElement; ++ic ) { const double r = p_shape_function_lhs[offSetSF_elem+ic]; p_lhs[rowR+ic] += r*asq*inv_axdx; } // final mdot mdot += -projTimeScale*((pBip-pScs)*asq*inv_axdx + noc*includeNOC); // residual p_rhs[nearestNode] -= mdot/projTimeScale; } apply_coeff(connected_nodes, rhs, lhs, __FILE__); } } }
//-------------------------------------------------------------------------- //-------- execute --------------------------------------------------------- //-------------------------------------------------------------------------- void ComputeLowReynoldsSDRWallAlgorithm::execute() { stk::mesh::BulkData & bulk_data = realm_.bulk_data(); stk::mesh::MetaData & meta_data = realm_.meta_data(); const int nDim = meta_data.spatial_dimension(); // nodal fields to gather std::vector<double> ws_density; std::vector<double> ws_viscosity; // master element std::vector<double> ws_face_shape_function; // deal with state ScalarFieldType &densityNp1 = density_->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]; // extract master element MasterElement *meSCS = realm_.get_surface_master_element(theElemTopo); // face master element MasterElement *meFC = realm_.get_surface_master_element(b.topology()); const int nodesPerFace = b.topology().num_nodes(); std::vector<int> face_node_ordinal_vec(nodesPerFace); // algorithm related; element ws_density.resize(nodesPerFace); ws_viscosity.resize(nodesPerFace); ws_face_shape_function.resize(nodesPerFace*nodesPerFace); // pointers double *p_density = &ws_density[0]; double *p_viscosity = &ws_viscosity[0]; double *p_face_shape_function = &ws_face_shape_function[0]; // shape functions if ( useShifted_ ) meFC->shifted_shape_fcn(&p_face_shape_function[0]); else 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]; //====================================== // gather nodal data off of face //====================================== stk::mesh::Entity const * face_node_rels = bulk_data.begin_nodes(face); int 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(densityNp1, node); p_viscosity[ni] = *stk::mesh::field_data(*viscosity_, node); } // pointer to face data const double * areaVec = stk::mesh::field_data(*exposedAreaVec_, 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()); // get the relations off of element stk::mesh::Entity const * elem_node_rels = bulk_data.begin_nodes(element); // loop over face nodes for ( int ip = 0; ip < num_face_nodes; ++ip ) { const int offSetAveraVec = ip*nDim; const int opposingNode = meSCS->opposingNodes(face_ordinal,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 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 ); // aMag double aMag = 0.0; for ( int j = 0; j < nDim; ++j ) { const double axj = areaVec[offSetAveraVec+j]; aMag += axj*axj; } aMag = std::sqrt(aMag); // interpolate to bip double rhoBip = 0.0; double muBip = 0.0; const int offSetSF_face = ip*nodesPerFace; for ( int ic = 0; ic < nodesPerFace; ++ic ) { const double r = p_face_shape_function[offSetSF_face+ic]; rhoBip += r*p_density[ic]; muBip += r*p_viscosity[ic]; } const double nuBip = muBip/rhoBip; // determine yp (approximated by 1/4 distance along edge) double ypbip = 0.0; for ( int j = 0; j < nDim; ++j ) { const double nj = areaVec[offSetAveraVec+j]/aMag; const double ej = 0.25*(coordR[j] - coordL[j]); ypbip += nj*ej*nj*ej; } ypbip = std::sqrt(ypbip); // compute low Re wall sdr const double lowReSdr = wallFactor_*6.0*nuBip/betaOne_/ypbip/ypbip; // assemble to nodal quantities; will normalize and assemble in driver double * assembledWallArea = stk::mesh::field_data(*assembledWallArea_, nodeR ); double * sdrBc = stk::mesh::field_data(*sdrBc_, nodeR ); *assembledWallArea += aMag; *sdrBc += lowReSdr*aMag; } } } }