//--------------------------------------------------------------------------
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
}
