//--------------------------------------------------------------------------
//-------- 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__);
}
}
}
//--------------------------------------------------------------------------
//-------- 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
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
ComputeHeatTransferEdgeWallAlgorithm::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();
// 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 = sierra::nalu::MasterElementRepo::get_surface_master_element(theElemTopo);
// size some things that are useful
const int num_face_nodes = b.topology().num_nodes();
const stk::mesh::Bucket::size_type length = b.size();
for ( stk::mesh::Bucket::size_type k = 0 ; k < length ; ++k ) {
// pointer to face data
const double * areaVec = stk::mesh::field_data(*exposedAreaVec_, 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];
const int *face_node_ordinals = meSCS->side_node_ordinals(face_ordinal);
// get the relations
stk::mesh::Entity const * elem_node_rels = bulk_data.begin_nodes(element);
for ( int ip = 0; ip < num_face_nodes; ++ip ) {
const int opposingNode = meSCS->opposingNodes(face_ordinal,ip);
const int nearestNode = face_node_ordinals[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 );
const double tempL = *stk::mesh::field_data(*temperature_, nodeL );
const double tempR = *stk::mesh::field_data(*temperature_, nodeR );
// nearest nodes; gathered and to-be-scattered
const double * dhdxR = stk::mesh::field_data(*dhdx_, nodeR );
const double densityR = *stk::mesh::field_data(*density_, nodeR );
const double thermalCondR = *stk::mesh::field_data(*thermalCond_, nodeR );
const double specificHeatR = *stk::mesh::field_data(*specificHeat_, nodeR );
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
const int faceOffSet = ip*nDim;
// compute geometry
double axdx = 0.0;
double asq = 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;
}
const double inv_axdx = 1.0/axdx;
const double aMag = std::sqrt(asq);
const double edgeLen = axdx/aMag;
// NOC; convert dhdx to dTdx
double nonOrth = 0.0;
for ( int j = 0; j < nDim; ++j ) {
const double axj = areaVec[faceOffSet+j];
const double dxj = coordR[j] - coordL[j];
const double kxj = axj - asq*inv_axdx*dxj;
const double GjT = dhdxR[j]/specificHeatR;
nonOrth += -thermalCondR*kxj*GjT;
}
// compute coupling parameter
const double chi = densityR * specificHeatR * edgeLen * edgeLen
/ (2 * thermalCondR * dt);
const double alpha = compute_coupling_parameter(thermalCondR, edgeLen, chi);
// assemble the nodal quantities; group NOC on reference temp
// if NOC is < 0; Too will be greater than Tphyscial
// if NOC is > 0; Too will be less than Tphysical
// grouping NOC on H reverses the above, however, who knows which is best..
*assembledWallArea += aMag;
*referenceTemperature += thermalCondR*tempL*asq*inv_axdx - nonOrth;
*heatTransferCoefficient += -thermalCondR*tempR*asq*inv_axdx;
*normalHeatFlux += thermalCondR*(tempL-tempR)*asq*inv_axdx - nonOrth;
*robinCouplingParameter += alpha*aMag;
}
}
}
}
//--------------------------------------------------------------------------
//-------- 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
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;
}
}
}
}