//--------------------------------------------------------------------------
//-------- execute ---------------------------------------------------------
//--------------------------------------------------------------------------
void
AssembleContinuityElemSolverAlgorithm::execute()
{
stk::mesh::MetaData & meta_data = realm_.meta_data();
const int nDim = meta_data.spatial_dimension();
// 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;
// space for LHS/RHS; nodesPerElem*nodesPerElem and nodesPerElem
std::vector<double> lhs;
std::vector<double> rhs;
std::vector<stk::mesh::Entity> connected_nodes;
// supplemental algorithm setup
const size_t supplementalAlgSize = supplementalAlg_.size();
for ( size_t i = 0; i < supplementalAlgSize; ++i )
supplementalAlg_[i]->setup();
// nodal fields to gather
std::vector<double> ws_vrtm;
std::vector<double> ws_Gpdx;
std::vector<double> ws_coordinates;
std::vector<double> ws_pressure;
std::vector<double> ws_density;
// geometry related to populate
std::vector<double> ws_scs_areav;
std::vector<double> ws_dndx;
std::vector<double> ws_dndx_lhs;
std::vector<double> ws_deriv;
std::vector<double> ws_det_j;
std::vector<double> ws_shape_function;
// integration point data that depends on size
std::vector<double> uIp(nDim);
std::vector<double> rho_uIp(nDim);
std::vector<double> GpdxIp(nDim);
std::vector<double> dpdxIp(nDim);
// pointers to everyone...
double *p_uIp = &uIp[0];
double *p_rho_uIp = &rho_uIp[0];
double *p_GpdxIp = &GpdxIp[0];
double *p_dpdxIp = &dpdxIp[0];
// deal with state
ScalarFieldType &densityNp1 = density_->field_of_state(stk::mesh::StateNP1);
// define some common selectors
stk::mesh::Selector s_locally_owned_union = meta_data.locally_owned_part()
& stk::mesh::selectUnion(partVec_)
& !(realm_.get_inactive_selector());
stk::mesh::BucketVector const& elem_buckets =
realm_.get_buckets( stk::topology::ELEMENT_RANK, s_locally_owned_union );
for ( stk::mesh::BucketVector::const_iterator ib = elem_buckets.begin();
ib != elem_buckets.end() ; ++ib ) {
stk::mesh::Bucket & b = **ib ;
const stk::mesh::Bucket::size_type length = b.size();
// extract master element
MasterElement *meSCS = realm_.get_surface_master_element(b.topology());
MasterElement *meSCV = realm_.get_volume_master_element(b.topology());
// extract master element specifics
const int nodesPerElement = meSCS->nodesPerElement_;
const int numScsIp = meSCS->numIntPoints_;
const int *lrscv = meSCS->adjacentNodes();
// 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
ws_vrtm.resize(nodesPerElement*nDim);
ws_Gpdx.resize(nodesPerElement*nDim);
ws_coordinates.resize(nodesPerElement*nDim);
ws_pressure.resize(nodesPerElement);
ws_density.resize(nodesPerElement);
ws_scs_areav.resize(numScsIp*nDim);
ws_dndx.resize(nDim*numScsIp*nodesPerElement);
ws_dndx_lhs.resize(nDim*numScsIp*nodesPerElement);
ws_deriv.resize(nDim*numScsIp*nodesPerElement);
ws_det_j.resize(numScsIp);
ws_shape_function.resize(numScsIp*nodesPerElement);
// pointers
double *p_lhs = &lhs[0];
double *p_rhs = &rhs[0];
double *p_vrtm = &ws_vrtm[0];
double *p_Gpdx = &ws_Gpdx[0];
double *p_coordinates = &ws_coordinates[0];
double *p_pressure = &ws_pressure[0];
double *p_density = &ws_density[0];
double *p_scs_areav = &ws_scs_areav[0];
double *p_dndx = &ws_dndx[0];
double *p_dndx_lhs = reducedSensitivities_ ? &ws_dndx_lhs[0] : &ws_dndx[0];
double *p_shape_function = &ws_shape_function[0];
if ( shiftMdot_)
meSCS->shifted_shape_fcn(&p_shape_function[0]);
else
meSCS->shape_fcn(&p_shape_function[0]);
// resize possible supplemental element alg
for ( size_t i = 0; i < supplementalAlgSize; ++i )
supplementalAlg_[i]->elem_resize(meSCS, meSCV);
for ( stk::mesh::Bucket::size_type k = 0 ; k < length ; ++k ) {
// get elem
stk::mesh::Entity elem = b[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;
//===============================================
// gather nodal data; this is how we do it now..
//===============================================
stk::mesh::Entity const * node_rels = b.begin_nodes(k);
int num_nodes = b.num_nodes(k);
// sanity check on num nodes
ThrowAssert( num_nodes == nodesPerElement );
for ( int ni = 0; ni < num_nodes; ++ni ) {
stk::mesh::Entity node = node_rels[ni];
// set connected nodes
connected_nodes[ni] = node;
// pointers to real data
const double * Gjp = stk::mesh::field_data(*Gpdx_, node );
const double * coords = stk::mesh::field_data(*coordinates_, node );
const double * vrtm = stk::mesh::field_data(*velocityRTM_, node );
// gather scalars
p_pressure[ni] = *stk::mesh::field_data(*pressure_, node );
p_density[ni] = *stk::mesh::field_data(densityNp1, node );
// gather vectors
const int niNdim = ni*nDim;
for ( int j=0; j < nDim; ++j ) {
p_vrtm[niNdim+j] = vrtm[j];
p_Gpdx[niNdim+j] = Gjp[j];
p_coordinates[niNdim+j] = coords[j];
}
}
// compute geometry
double scs_error = 0.0;
meSCS->determinant(1, &p_coordinates[0], &p_scs_areav[0], &scs_error);
// compute dndx for residual
if ( shiftPoisson_ )
meSCS->shifted_grad_op(1, &p_coordinates[0], &ws_dndx[0], &ws_deriv[0], &ws_det_j[0], &scs_error);
else
meSCS->grad_op(1, &p_coordinates[0], &ws_dndx[0], &ws_deriv[0], &ws_det_j[0], &scs_error);
// compute dndx for LHS
if ( reducedSensitivities_ )
meSCS->shifted_grad_op(1, &p_coordinates[0], &ws_dndx_lhs[0], &ws_deriv[0], &ws_det_j[0], &scs_error);
for ( int ip = 0; ip < numScsIp; ++ip ) {
// left and right nodes for this ip
const int il = lrscv[2*ip];
const int ir = lrscv[2*ip+1];
// corresponding matrix rows
int rowL = il*nodesPerElement;
int rowR = ir*nodesPerElement;
// setup for ip values; sneak in geometry for possible reduced sens
for ( int j = 0; j < nDim; ++j ) {
p_uIp[j] = 0.0;
p_rho_uIp[j] = 0.0;
p_GpdxIp[j] = 0.0;
p_dpdxIp[j] = 0.0;
}
double rhoIp = 0.0;
const int offSet = ip*nodesPerElement;
for ( int ic = 0; ic < nodesPerElement; ++ic ) {
const double r = p_shape_function[offSet+ic];
const double nodalPressure = p_pressure[ic];
const double nodalRho = p_density[ic];
rhoIp += r*nodalRho;
double lhsfac = 0.0;
const int offSetDnDx = nDim*nodesPerElement*ip + ic*nDim;
for ( int j = 0; j < nDim; ++j ) {
p_GpdxIp[j] += r*p_Gpdx[nDim*ic+j];
p_uIp[j] += r*p_vrtm[nDim*ic+j];
p_rho_uIp[j] += r*nodalRho*p_vrtm[nDim*ic+j];
p_dpdxIp[j] += p_dndx[offSetDnDx+j]*nodalPressure;
lhsfac += -p_dndx_lhs[offSetDnDx+j]*p_scs_areav[ip*nDim+j];
}
// assemble to lhs; left
p_lhs[rowL+ic] += lhsfac;
// assemble to lhs; right
p_lhs[rowR+ic] -= lhsfac;
}
// assemble mdot
double mdot = 0.0;
for ( int j = 0; j < nDim; ++j ) {
mdot += (interpTogether*p_rho_uIp[j] + om_interpTogether*rhoIp*p_uIp[j]
- projTimeScale*(p_dpdxIp[j] - p_GpdxIp[j]))*p_scs_areav[ip*nDim+j];
}
// residual; left and right
p_rhs[il] -= mdot/projTimeScale;
p_rhs[ir] += mdot/projTimeScale;
}
// call supplemental
for ( size_t i = 0; i < supplementalAlgSize; ++i )
supplementalAlg_[i]->elem_execute( &lhs[0], &rhs[0], elem, meSCS, meSCV);
apply_coeff(connected_nodes, rhs, lhs, __FILE__);
}
}
}
//--------------------------------------------------------------------------
//-------- execute ---------------------------------------------------------
//--------------------------------------------------------------------------
void
AssembleMeshDisplacementElemSolverAlgorithm::execute()
{
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<int> scratchIds;
std::vector<double> scratchVals;
std::vector<stk::mesh::Entity> connected_nodes;
// nodal fields to gather
std::vector<double> ws_displacementNp1;
std::vector<double> ws_coordinates;
std::vector<double> ws_modelCoordinates;
std::vector<double> ws_mu;
std::vector<double> ws_lambda;
// geometry related to populate
std::vector<double> ws_scs_areav;
std::vector<double> ws_dndx;
std::vector<double> ws_deriv;
std::vector<double> ws_det_j;
std::vector<double> ws_shape_function;
// deal with state
VectorFieldType &displacementNp1 = meshDisplacement_->field_of_state(stk::mesh::StateNP1);
// define some common selectors
stk::mesh::Selector s_locally_owned_union = meta_data.locally_owned_part()
&stk::mesh::selectUnion(partVec_);
stk::mesh::BucketVector const& elem_buckets =
realm_.get_buckets( stk::topology::ELEMENT_RANK, s_locally_owned_union );
for ( stk::mesh::BucketVector::const_iterator ib = elem_buckets.begin();
ib != elem_buckets.end() ; ++ib ) {
stk::mesh::Bucket & b = **ib ;
const stk::mesh::Bucket::size_type length = b.size();
// extract master element
MasterElement *meSCS = sierra::nalu::MasterElementRepo::get_surface_master_element(b.topology());
// extract master element specifics
const int nodesPerElement = meSCS->nodesPerElement_;
const int numScsIp = meSCS->numIntPoints_;
const int *lrscv = meSCS->adjacentNodes();
// resize some things; matrix related
const int lhsSize = nodesPerElement*nDim*nodesPerElement*nDim;
const int rhsSize = nodesPerElement*nDim;
lhs.resize(lhsSize);
rhs.resize(rhsSize);
scratchIds.resize(rhsSize);
scratchVals.resize(rhsSize);
connected_nodes.resize(nodesPerElement);
// algorithm related
ws_displacementNp1.resize(nodesPerElement*nDim);
ws_coordinates.resize(nodesPerElement*nDim);
ws_modelCoordinates.resize(nodesPerElement*nDim);
ws_mu.resize(nodesPerElement);
ws_lambda.resize(nodesPerElement);
ws_scs_areav.resize(numScsIp*nDim);
ws_dndx.resize(nDim*numScsIp*nodesPerElement);
ws_deriv.resize(nDim*numScsIp*nodesPerElement);
ws_det_j.resize(numScsIp);
ws_shape_function.resize(numScsIp*nodesPerElement);
// pointer to lhs/rhs
double *p_lhs = &lhs[0];
double *p_rhs = &rhs[0];
double *p_displacementNp1 = &ws_displacementNp1[0];
double *p_coordinates = &ws_coordinates[0];
double *p_modelCoordinates = &ws_modelCoordinates[0];
double *p_mu = &ws_mu[0];
double *p_lambda = &ws_lambda[0];
double *p_scs_areav = &ws_scs_areav[0];
double *p_dndx = &ws_dndx[0];
double *p_shape_function = &ws_shape_function[0];
// extract shape function
meSCS->shape_fcn(&p_shape_function[0]);
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;
//===============================================
// gather nodal data; this is how we do it now..
//===============================================
stk::mesh::Entity const * node_rels = b.begin_nodes(k);
int num_nodes = b.num_nodes(k);
// sanity check on num nodes
ThrowAssert( num_nodes == nodesPerElement );
for ( int ni = 0; ni < num_nodes; ++ni ) {
stk::mesh::Entity node = node_rels[ni];
// set connected nodes
connected_nodes[ni] = node;
// pointers to real data
const double * dxNp1 = stk::mesh::field_data(displacementNp1, node);
const double * coords = stk::mesh::field_data(*coordinates_, node);
const double * modelCoords = stk::mesh::field_data(*modelCoordinates_, node);
const double mu = *stk::mesh::field_data(*mu_, node);
const double lambda = *stk::mesh::field_data(*lambda_, node);
// gather scalars
p_mu[ni] = mu;
p_lambda[ni] = lambda;
// gather vectors
const int niNdim = ni*nDim;
for ( int i=0; i < nDim; ++i ) {
p_displacementNp1[niNdim+i] = dxNp1[i];
p_coordinates[niNdim+i] = coords[i];
p_modelCoordinates[niNdim+i] = modelCoords[i];
}
}
// compute geometry
double scs_error = 0.0;
meSCS->determinant(1, &p_coordinates[0], &p_scs_areav[0], &scs_error);
// compute dndx; model coords or displaced?
if ( deformWrtModelCoords_ ) {
meSCS->grad_op(1, &p_modelCoordinates[0], &p_dndx[0], &ws_deriv[0], &ws_det_j[0], &scs_error);
}
else {
meSCS->grad_op(1, &p_coordinates[0], &p_dndx[0], &ws_deriv[0], &ws_det_j[0], &scs_error);
}
for ( int ip = 0; ip < numScsIp; ++ip ) {
const int ipNdim = ip*nDim;
const int offSetSF = ip*nodesPerElement;
// left and right nodes for this ip
const int il = lrscv[2*ip];
const int ir = lrscv[2*ip+1];
// save off some offsets
const int ilNdim = il*nDim;
const int irNdim = ir*nDim;
// compute scs point values; offset to Shape Function; sneak in divU
double muIp = 0.0;
double lambdaIp = 0.0;
double divDx = 0.0;
for ( int ic = 0; ic < nodesPerElement; ++ic ) {
const double r = p_shape_function[offSetSF+ic];
muIp += r*p_mu[ic];
lambdaIp += r*p_lambda[ic];
const int offSetDnDx = nDim*nodesPerElement*ip + ic*nDim;
for ( int j = 0; j < nDim; ++j ) {
const double dxj = p_displacementNp1[ic*nDim+j];
divDx += dxj*p_dndx[offSetDnDx+j];
}
}
// assemble divDx term (explicit)
for ( int i = 0; i < nDim; ++i ) {
// divU stress term
const double divTerm = -lambdaIp*divDx*p_scs_areav[ipNdim+i];
const int indexL = ilNdim + i;
const int indexR = irNdim + i;
// right hand side; L and R
p_rhs[indexL] -= divTerm;
p_rhs[indexR] += divTerm;
}
// stress
for ( int ic = 0; ic < nodesPerElement; ++ic ) {
const int icNdim = ic*nDim;
for ( int i = 0; i < nDim; ++i ) {
const int indexL = ilNdim + i;
const int indexR = irNdim + i;
const int rowL = indexL*nodesPerElement*nDim;
const int rowR = indexR*nodesPerElement*nDim;
const int rLiC_i = rowL+icNdim+i;
const int rRiC_i = rowR+icNdim+i;
// viscous stress
const int offSetDnDx = nDim*nodesPerElement*ip + icNdim;
double lhs_riC_i = 0.0;
for ( int j = 0; j < nDim; ++j ) {
const double axj = p_scs_areav[ipNdim+j];
const double dxj = p_displacementNp1[icNdim+j];
// -mu*dxi/dxj*A_j; fixed i over j loop; see below..
const double lhsfacDiff_i = -muIp*p_dndx[offSetDnDx+j]*axj;
// lhs; il then ir
lhs_riC_i += lhsfacDiff_i;
// -mu*dxj/dxi*A_j
const double lhsfacDiff_j = -muIp*p_dndx[offSetDnDx+i]*axj;
// lhs; il then ir
p_lhs[rowL+icNdim+j] += lhsfacDiff_j;
p_lhs[rowR+icNdim+j] -= lhsfacDiff_j;
// rhs; il then ir
p_rhs[indexL] -= lhsfacDiff_j*dxj;
p_rhs[indexR] += lhsfacDiff_j*dxj;
}
// deal with accumulated lhs and flux for -mu*dxi/dxj*Aj
p_lhs[rLiC_i] += lhs_riC_i;
p_lhs[rRiC_i] -= lhs_riC_i;
const double dxi = p_displacementNp1[icNdim+i];
p_rhs[indexL] -= lhs_riC_i*dxi;
p_rhs[indexR] += lhs_riC_i*dxi;
}
}
}
apply_coeff(connected_nodes, scratchIds, scratchVals, rhs, lhs, __FILE__);
}
}
}
//--------------------------------------------------------------------------
//-------- execute ---------------------------------------------------------
//--------------------------------------------------------------------------
void
AssembleRadTransElemSolverAlgorithm::execute()
{
stk::mesh::MetaData & meta_data = realm_.meta_data();
const int nDim = meta_data.spatial_dimension();
// use edge-based length scale
const bool useEdgeH = true;
// extract current ordinate direction
std::vector<double> Sk(nDim,0.0);
radEqSystem_->get_current_ordinate(&Sk[0]);
const double *p_Sk = &Sk[0];
intensity_ = radEqSystem_->get_intensity();
const double invPi = 1.0/(std::acos(-1.0));
// space for LHS/RHS; nodesPerElem*nodesPerElem and nodesPerElem
std::vector<double> lhs;
std::vector<double> rhs;
std::vector<stk::mesh::Entity> connected_nodes;
// nodal fields to gather
std::vector<double> ws_coordinates;
std::vector<double> ws_intensity;
std::vector<double> ws_absorption;
std::vector<double> ws_scattering;
std::vector<double> ws_scalarFlux;
std::vector<double> ws_radiationSource;
std::vector<double> ws_dualVolume;
// geometry related to populate
std::vector<double> ws_scs_areav;
std::vector<double> ws_dndx;
std::vector<double> ws_deriv;
std::vector<double> ws_det_j;
std::vector<double> ws_shape_function;
// define some common selectors
stk::mesh::Selector s_locally_owned_union = meta_data.locally_owned_part()
&stk::mesh::selectUnion(partVec_);
stk::mesh::BucketVector const& elem_buckets =
realm_.get_buckets( stk::topology::ELEMENT_RANK, s_locally_owned_union );
for ( stk::mesh::BucketVector::const_iterator ib = elem_buckets.begin();
ib != elem_buckets.end() ; ++ib ) {
stk::mesh::Bucket & b = **ib ;
const size_t length = b.size();
// extract master element
MasterElement *meSCS = realm_.get_surface_master_element(b.topology());
// extract master element specifics
const int nodesPerElement = meSCS->nodesPerElement_;
const int numScsIp = meSCS->numIntPoints_;
const int *lrscv = meSCS->adjacentNodes();
// 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
ws_coordinates.resize(nodesPerElement*nDim);
ws_intensity.resize(nodesPerElement);
ws_absorption.resize(nodesPerElement);
ws_scattering.resize(nodesPerElement);
ws_scalarFlux.resize(nodesPerElement);
ws_radiationSource.resize(nodesPerElement);
ws_dualVolume.resize(nodesPerElement);
ws_scs_areav.resize(numScsIp*nDim);
ws_dndx.resize(nDim*numScsIp*nodesPerElement);
ws_deriv.resize(nDim*numScsIp*nodesPerElement);
ws_det_j.resize(numScsIp);
ws_shape_function.resize(numScsIp*nodesPerElement);
// pointers
double *p_lhs = &lhs[0];
double *p_rhs = &rhs[0];
double *p_coordinates = &ws_coordinates[0];
double *p_intensity = &ws_intensity[0];
double *p_absorption = &ws_absorption[0];
double *p_scattering = &ws_scattering[0];
double *p_scalarFlux = &ws_scalarFlux[0];
double *p_radiationSource = &ws_radiationSource[0];
double *p_dualVolume = &ws_dualVolume[0];
double *p_scs_areav = &ws_scs_areav[0];
double *p_dndx = &ws_dndx[0];
double *p_shape_function = &ws_shape_function[0];
meSCS->shape_fcn(&p_shape_function[0]);
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 elem and its node relations
unsigned elem_offset = k;
//===============================================
// gather nodal data; this is how we do it now..
//===============================================
stk::mesh::Entity const * node_rels = b.begin_nodes(elem_offset);
int num_nodes = b.num_nodes(elem_offset);
// sanity check on num nodes
ThrowAssert( num_nodes == nodesPerElement );
for ( int ni = 0; ni < num_nodes; ++ni ) {
stk::mesh::Entity node = node_rels[ni];
// set connected nodes
connected_nodes[ni] = node;
// pointers to real data
const double * coords = stk::mesh::field_data(*coordinates_, node);
// gather scalars
p_intensity[ni] = *stk::mesh::field_data(*intensity_, node);
p_absorption[ni] = *stk::mesh::field_data(*absorption_, node );
p_scattering[ni] = *stk::mesh::field_data(*scattering_, node );
p_scalarFlux[ni] = *stk::mesh::field_data(*scalarFlux_, node );
p_radiationSource[ni] = *stk::mesh::field_data(*radiationSource_, node );
p_dualVolume[ni] = *stk::mesh::field_data(*dualNodalVolume_, node );
// gather vectors
const int offSet = ni*nDim;
for ( int j=0; j < nDim; ++j ) {
p_coordinates[offSet+j] = coords[j];
}
}
// compute geometry
double scs_error = 0.0;
meSCS->determinant(1, &p_coordinates[0], &p_scs_areav[0], &scs_error);
// compute dndx
meSCS->grad_op(1, &p_coordinates[0], &p_dndx[0], &ws_deriv[0], &ws_det_j[0], &scs_error);
for ( int ip = 0; ip < numScsIp; ++ip ) {
// left and right nodes for this ip
const int il = lrscv[2*ip];
const int ir = lrscv[2*ip+1];
// corresponding matrix rows
int rowL = il*nodesPerElement;
int rowR = ir*nodesPerElement;
// form sj*njdS (part of the lhs for central term; I*sj*njdS)
double sjaj = 0.0;
double asq = 0.0;
for ( int j = 0; j < nDim; ++j ) {
const double aj = p_scs_areav[ip*nDim+j];
sjaj += p_Sk[j]*aj;
asq += aj*aj;
}
const double aMag = std::sqrt(asq);
// integration point interpolation
double Iscs = 0.0;
double extCoeffscs = 0.0;
double ePscs = 0.0;
double isotropicScatterscs = 0.0;
double dualNodalVscs = 0.0;
const int offSet = ip*nodesPerElement;
for ( int ic = 0; ic < nodesPerElement; ++ic ) {
const double r = p_shape_function[offSet+ic];
// save of some variables
const double I = p_intensity[ic];
const double mua = p_absorption[ic];
const double mus = p_scattering[ic];
// interpolation to scs
Iscs += r*I;
extCoeffscs += r*(mua+mus);
ePscs += r*p_radiationSource[ic];
isotropicScatterscs += r*mus*p_scalarFlux[ic]/4.0*invPi;
dualNodalVscs += r*p_dualVolume[ic];
// assemble I*sj*njdS to lhs; left/right
p_lhs[rowL+ic] += sjaj*r;
p_lhs[rowR+ic] -= sjaj*r;
}
// rhs residual for I*sj*njdS
p_rhs[il] -= Iscs*sjaj;
p_rhs[ir] += Iscs*sjaj;
// now work on SUCV stabilization terms; needed tau, hence second ic loop
double h_edge = 0.0;
for ( int j = 0; j < nDim; ++j ) {
const double nj = p_scs_areav[ip*nDim+j]/aMag;
const double dxj = p_coordinates[ir*nDim+j]-p_coordinates[il*nDim+j];
h_edge += nj*dxj;
}
// alternative h
const double h_vol = std::pow(dualNodalVscs, 1.0/(double)nDim);
// form tau
const double h = (useEdgeH) ? h_edge : h_vol;
const double tau = std::sqrt(1.0/((2.0/h)*(2.0/h) + extCoeffscs*extCoeffscs));
double sidIdxi = 0.0;
for ( int ic = 0; ic < nodesPerElement; ++ic ) {
const double r = p_shape_function[offSet+ic];
// save of some variables
const double I = p_intensity[ic];
// SUCV -tau*sj*aj*(mua+mus)*I term; left/right (residual below)
p_lhs[rowL+ic] += -tau*sjaj*r*extCoeffscs;
p_lhs[rowR+ic] -= -tau*sjaj*r*extCoeffscs;
// SUCV diffusion-like term; -tau*si*dI/dxi*sjaj (residual below)
double lhsfac = 0.0;
const int offSetDnDx = nDim*nodesPerElement*ip + ic*nDim;
for ( int j = 0; j < nDim; ++j ) {
const double sjdNj = p_Sk[j]*p_dndx[offSetDnDx+j];
sidIdxi += sjdNj*I;
lhsfac += -sjdNj;
}
p_lhs[rowL+ic] += tau*sjaj*lhsfac;
p_lhs[rowR+ic] -= tau*sjaj*lhsfac;
}
// full sucv residual
const double residual = -tau*sjaj*(sidIdxi + extCoeffscs*Iscs - ePscs - isotropicScatterscs);
// residual; left and right
p_rhs[il] -= residual;
p_rhs[ir] += residual;
}
apply_coeff(connected_nodes, rhs, lhs, __FILE__);
}
}
}
//--------------------------------------------------------------------------
//-------- execute ---------------------------------------------------------
//--------------------------------------------------------------------------
void
AssembleScalarElemSolverAlgorithm::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 hybridFactor = realm_.get_hybrid_factor(dofName);
const double alpha = realm_.get_alpha_factor(dofName);
const double alphaUpw = realm_.get_alpha_upw_factor(dofName);
const double hoUpwind = realm_.get_upw_factor(dofName);
const bool useLimiter = realm_.primitive_uses_limiter(dofName);
// one minus flavor..
const double om_alpha = 1.0-alpha;
const double om_alphaUpw = 1.0-alphaUpw;
// space for LHS/RHS; nodesPerElem*nodesPerElem* and nodesPerElem
std::vector<double> lhs;
std::vector<double> rhs;
std::vector<stk::mesh::Entity> connected_nodes;
// supplemental algorithm size and setup
const size_t supplementalAlgSize = supplementalAlg_.size();
for ( size_t i = 0; i < supplementalAlgSize; ++i )
supplementalAlg_[i]->setup();
// nodal fields to gather
std::vector<double> ws_velocityNp1;
std::vector<double> ws_meshVelocity;
std::vector<double> ws_vrtm;
std::vector<double> ws_coordinates;
std::vector<double> ws_scalarQNp1;
std::vector<double> ws_dqdx;
std::vector<double> ws_density;
std::vector<double> ws_diffFluxCoeff;
// geometry related to populate
std::vector<double> ws_scs_areav;
std::vector<double> ws_dndx;
std::vector<double> ws_deriv;
std::vector<double> ws_det_j;
std::vector<double> ws_shape_function;
// ip values
std::vector<double>coordIp(nDim);
// pointers
double *p_coordIp = &coordIp[0];
// deal with state
ScalarFieldType &scalarQNp1 = scalarQ_->field_of_state(stk::mesh::StateNP1);
VectorFieldType &velocityNp1 = velocity_->field_of_state(stk::mesh::StateNP1);
ScalarFieldType &densityNp1 = density_->field_of_state(stk::mesh::StateNP1);
// define some common selectors
stk::mesh::Selector s_locally_owned_union = meta_data.locally_owned_part()
&stk::mesh::selectUnion(partVec_);
stk::mesh::BucketVector const& elem_buckets =
realm_.get_buckets( stk::topology::ELEMENT_RANK, s_locally_owned_union );
for ( stk::mesh::BucketVector::const_iterator ib = elem_buckets.begin();
ib != elem_buckets.end() ; ++ib ) {
stk::mesh::Bucket & b = **ib ;
const stk::mesh::Bucket::size_type length = b.size();
// extract master element
MasterElement *meSCS = realm_.get_surface_master_element(b.topology());
// extract master element specifics
const int nodesPerElement = meSCS->nodesPerElement_;
const int numScsIp = meSCS->numIntPoints_;
const int *lrscv = meSCS->adjacentNodes();
// 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
ws_velocityNp1.resize(nodesPerElement*nDim);
ws_meshVelocity.resize(nodesPerElement*nDim);
ws_vrtm.resize(nodesPerElement*nDim);
ws_coordinates.resize(nodesPerElement*nDim);
ws_dqdx.resize(nodesPerElement*nDim);
ws_scalarQNp1.resize(nodesPerElement);
ws_density.resize(nodesPerElement);
ws_diffFluxCoeff.resize(nodesPerElement);
ws_scs_areav.resize(numScsIp*nDim);
ws_dndx.resize(nDim*numScsIp*nodesPerElement);
ws_deriv.resize(nDim*numScsIp*nodesPerElement);
ws_det_j.resize(numScsIp);
ws_shape_function.resize(numScsIp*nodesPerElement);
// pointer to lhs/rhs
double *p_lhs = &lhs[0];
double *p_rhs = &rhs[0];
double *p_velocityNp1 = &ws_velocityNp1[0];
double *p_meshVelocity = &ws_meshVelocity[0];
double *p_vrtm = &ws_vrtm[0];
double *p_coordinates = &ws_coordinates[0];
double *p_dqdx = &ws_dqdx[0];
double *p_scalarQNp1 = &ws_scalarQNp1[0];
double *p_density = &ws_density[0];
double *p_diffFluxCoeff = &ws_diffFluxCoeff[0];
double *p_scs_areav = &ws_scs_areav[0];
double *p_dndx = &ws_dndx[0];
double *p_shape_function = &ws_shape_function[0];
// extract shape function
meSCS->shape_fcn(&p_shape_function[0]);
for ( stk::mesh::Bucket::size_type k = 0 ; k < length ; ++k ) {
// get elem
stk::mesh::Entity elem = b[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;
// ip data for this element; scs and scv
const double *mdot = stk::mesh::field_data(*massFlowRate_, elem );
//===============================================
// gather nodal data; this is how we do it now..
//===============================================
stk::mesh::Entity const * node_rels = bulk_data.begin_nodes(elem);
int num_nodes = bulk_data.num_nodes(elem);
// sanity check on num nodes
ThrowAssert( num_nodes == nodesPerElement );
for ( int ni = 0; ni < num_nodes; ++ni ) {
stk::mesh::Entity node = node_rels[ni];
// set connected nodes
connected_nodes[ni] = node;
// pointers to real data
const double * uNp1 = stk::mesh::field_data(velocityNp1, node );
const double * vNp1 = stk::mesh::field_data(*meshVelocity_, node);
const double * coords = stk::mesh::field_data(*coordinates_, node );
const double * dq = stk::mesh::field_data(*dqdx_, node );
// gather scalars
p_scalarQNp1[ni] = *stk::mesh::field_data(scalarQNp1, node );
p_density[ni] = *stk::mesh::field_data(densityNp1, node );
p_diffFluxCoeff[ni] = *stk::mesh::field_data(*diffFluxCoeff_, node );
// gather vectors
const int niNdim = ni*nDim;
for ( int i=0; i < nDim; ++i ) {
p_velocityNp1[niNdim+i] = uNp1[i];
p_vrtm[niNdim+i] = uNp1[i];
p_meshVelocity[niNdim+i] = vNp1[i];
p_coordinates[niNdim+i] = coords[i];
p_dqdx[niNdim+i] = dq[i];
}
}
// compute geometry
double scs_error = 0.0;
meSCS->determinant(1, &p_coordinates[0], &p_scs_areav[0], &scs_error);
// compute dndx
meSCS->grad_op(1, &p_coordinates[0], &p_dndx[0], &ws_deriv[0], &ws_det_j[0], &scs_error);
// manage velocity relative to mesh
if ( meshMotion_ ) {
const int kSize = num_nodes*nDim;
for ( int k = 0; k < kSize; ++k ) {
p_vrtm[k] -= p_meshVelocity[k];
}
}
for ( int ip = 0; ip < numScsIp; ++ip ) {
// left and right nodes for this ip
const int il = lrscv[2*ip];
const int ir = lrscv[2*ip+1];
// corresponding matrix rows
const int rowL = il*nodesPerElement;
const int rowR = ir*nodesPerElement;
// save off mdot
const double tmdot = mdot[ip];
// zero out values of interest for this ip
for ( int j = 0; j < nDim; ++j ) {
p_coordIp[j] = 0.0;
}
// save off ip values; offset to Shape Function
double rhoIp = 0.0;
double muIp = 0.0;
double qIp = 0.0;
const int offSetSF = ip*nodesPerElement;
for ( int ic = 0; ic < nodesPerElement; ++ic ) {
const double r = p_shape_function[offSetSF+ic];
rhoIp += r*p_density[ic];
muIp += r*p_diffFluxCoeff[ic];
qIp += r*p_scalarQNp1[ic];
// compute scs point values
for ( int i = 0; i < nDim; ++i ) {
p_coordIp[i] += r*p_coordinates[ic*nDim+i];
}
}
// Peclet factor; along the edge
const double diffIp = 0.5*(p_diffFluxCoeff[il]/p_density[il]
+ p_diffFluxCoeff[ir]/p_density[ir]);
double udotx = 0.0;
for(int j = 0; j < nDim; ++j ) {
const double dxj = p_coordinates[ir*nDim+j]-p_coordinates[il*nDim+j];
const double uj = 0.5*(p_vrtm[il*nDim+j] + p_vrtm[ir*nDim+j]);
udotx += uj*dxj;
}
double pecfac = hybridFactor*udotx/(diffIp+small);
pecfac = pecfac*pecfac/(5.0 + pecfac*pecfac);
const double om_pecfac = 1.0-pecfac;
// left and right extrapolation
double dqL = 0.0;
double dqR = 0.0;
for(int j = 0; j < nDim; ++j ) {
const double dxjL = p_coordIp[j] - p_coordinates[il*nDim+j];
const double dxjR = p_coordinates[ir*nDim+j] - p_coordIp[j];
dqL += dxjL*p_dqdx[nDim*il+j];
dqR += dxjR*p_dqdx[nDim*ir+j];
}
// add limiter if appropriate
double limitL = 1.0;
double limitR = 1.0;
if ( useLimiter ) {
const double dq = p_scalarQNp1[ir] - p_scalarQNp1[il];
const double dqMl = 2.0*2.0*dqL - dq;
const double dqMr = 2.0*2.0*dqR - dq;
limitL = van_leer(dqMl, dq, small);
limitR = van_leer(dqMr, dq, small);
}
// extrapolated; for now limit (along edge is fine)
const double qIpL = p_scalarQNp1[il] + dqL*hoUpwind*limitL;
const double qIpR = p_scalarQNp1[ir] - dqR*hoUpwind*limitR;
// assemble advection; rhs and upwind contributions
// 2nd order central; simply qIp from above
// upwind
const double qUpwind = (tmdot > 0) ? alphaUpw*qIpL + om_alphaUpw*qIp
: alphaUpw*qIpR + om_alphaUpw*qIp;
// generalized central (2nd and 4th order)
const double qHatL = alpha*qIpL + om_alpha*qIp;
const double qHatR = alpha*qIpR + om_alpha*qIp;
const double qCds = 0.5*(qHatL + qHatR);
// total advection
const double aflux = tmdot*(pecfac*qUpwind + om_pecfac*qCds);
// right hand side; L and R
p_rhs[il] -= aflux;
p_rhs[ir] += aflux;
// advection operator sens; all but central
// upwind advection (includes 4th); left node
const double alhsfacL = 0.5*(tmdot+std::abs(tmdot))*pecfac*alphaUpw
+ 0.5*alpha*om_pecfac*tmdot;
p_lhs[rowL+il] += alhsfacL;
p_lhs[rowR+il] -= alhsfacL;
// upwind advection; right node
const double alhsfacR = 0.5*(tmdot-std::abs(tmdot))*pecfac*alphaUpw
+ 0.5*alpha*om_pecfac*tmdot;
p_lhs[rowR+ir] -= alhsfacR;
p_lhs[rowL+ir] += alhsfacR;
double qDiff = 0.0;
for ( int ic = 0; ic < nodesPerElement; ++ic ) {
// shape function
const double r = p_shape_function[offSetSF+ic];
// upwind (il/ir) handled above; collect terms on alpha and alphaUpw
const double lhsfacAdv = r*tmdot*(pecfac*om_alphaUpw + om_pecfac*om_alpha);
// advection operator lhs; rhs handled above
// lhs; il then ir
p_lhs[rowL+ic] += lhsfacAdv;
p_lhs[rowR+ic] -= lhsfacAdv;
// diffusion
double lhsfacDiff = 0.0;
const int offSetDnDx = nDim*nodesPerElement*ip + ic*nDim;
for ( int j = 0; j < nDim; ++j ) {
lhsfacDiff += -muIp*p_dndx[offSetDnDx+j]*p_scs_areav[ip*nDim+j];
}
qDiff += lhsfacDiff*p_scalarQNp1[ic];
// lhs; il then ir
p_lhs[rowL+ic] += lhsfacDiff;
p_lhs[rowR+ic] -= lhsfacDiff;
}
// rhs; il then ir
p_rhs[il] -= qDiff;
p_rhs[ir] += qDiff;
}
// call supplemental
for ( size_t i = 0; i < supplementalAlgSize; ++i )
supplementalAlg_[i]->elem_execute( nodesPerElement, numScsIp, &lhs[0], &rhs[0], elem);
apply_coeff(connected_nodes, rhs, lhs, __FILE__);
}
}
}
//--------------------------------------------------------------------------
//-------- execute ---------------------------------------------------------
//--------------------------------------------------------------------------
void
AssembleNodalGradUElemAlgorithm::execute()
{
stk::mesh::MetaData & meta_data = realm_.meta_data();
const int nDim = meta_data.spatial_dimension();
// extract fields
ScalarFieldType *dualNodalVolume = meta_data.get_field<ScalarFieldType>(stk::topology::NODE_RANK, "dual_nodal_volume");
VectorFieldType *coordinates = meta_data.get_field<VectorFieldType>(stk::topology::NODE_RANK, realm_.get_coordinates_name());
// nodal fields to gather; gather everything other than what we are assembling
std::vector<double> ws_vectorQ;
std::vector<double> ws_dualVolume;
std::vector<double> ws_coordinates;
// geometry related to populate
std::vector<double> ws_scs_areav;
std::vector<double> ws_shape_function;
// ip data
std::vector<double>qIp(nDim);
// define some common selectors
stk::mesh::Selector s_locally_owned_union = meta_data.locally_owned_part()
&stk::mesh::selectUnion(partVec_);
stk::mesh::BucketVector const& elem_buckets =
realm_.get_buckets( stk::topology::ELEMENT_RANK, s_locally_owned_union );
for ( stk::mesh::BucketVector::const_iterator ib = elem_buckets.begin();
ib != elem_buckets.end() ; ++ib ) {
stk::mesh::Bucket & b = **ib ;
const stk::mesh::Bucket::size_type length = b.size();
// extract master element
MasterElement *meSCS = realm_.get_surface_master_element(b.topology());
// extract master element specifics
const int nodesPerElement = meSCS->nodesPerElement_;
const int numScsIp = meSCS->numIntPoints_;
const int *lrscv = meSCS->adjacentNodes();
// algorithm related
ws_vectorQ.resize(nodesPerElement*nDim);
ws_dualVolume.resize(nodesPerElement);
ws_coordinates.resize(nodesPerElement*nDim);
ws_scs_areav.resize(numScsIp*nDim);
ws_shape_function.resize(numScsIp*nodesPerElement);
// pointers.
double *p_vectorQ = &ws_vectorQ[0];
double *p_dualVolume = &ws_dualVolume[0];
double *p_coordinates = &ws_coordinates[0];
double *p_scs_areav = &ws_scs_areav[0];
double *p_shape_function = &ws_shape_function[0];
if ( useShifted_ )
meSCS->shifted_shape_fcn(&p_shape_function[0]);
else
meSCS->shape_fcn(&p_shape_function[0]);
for ( stk::mesh::Bucket::size_type k = 0 ; k < length ; ++k ) {
//===============================================
// gather nodal data; this is how we do it now..
//===============================================
stk::mesh::Entity const * node_rels = b.begin_nodes(k);
int num_nodes = b.num_nodes(k);
// sanity check on num nodes
ThrowAssert( num_nodes == nodesPerElement );
// note: we absolutely need to gather coords since it
// is required to compute the area vector. however,
// ws_scalarQ and ws_dualVolume are choices to avoid
// field data call for interpolation
for ( int ni = 0; ni < num_nodes; ++ni ) {
stk::mesh::Entity node = node_rels[ni];
// pointers to real data
double * coords = stk::mesh::field_data(*coordinates, node);
double * vectorQ = stk::mesh::field_data(*vectorQ_, node);
// gather scalars
p_dualVolume[ni] = *stk::mesh::field_data(*dualNodalVolume, node);
// gather vectors
const int offSet = ni*nDim;
for ( int j=0; j < nDim; ++j ) {
p_coordinates[offSet+j] = coords[j];
p_vectorQ[offSet+j] = vectorQ[j];
}
}
// compute geometry
double scs_error = 0.0;
meSCS->determinant(1, &p_coordinates[0], &p_scs_areav[0], &scs_error);
// start assembly
for ( int ip = 0; ip < numScsIp; ++ip ) {
// left and right nodes for this ip
const int il = lrscv[2*ip];
const int ir = lrscv[2*ip+1];
stk::mesh::Entity nodeL = node_rels[il];
stk::mesh::Entity nodeR = node_rels[ir];
// pointer to fields to assemble
double *gradQL = stk::mesh::field_data(*dqdx_, nodeL);
double *gradQR = stk::mesh::field_data(*dqdx_, nodeR);
// interpolate to scs point; operate on saved off ws_field
for (int j=0; j < nDim; ++j )
qIp[j] = 0.0;
const int offSet = ip*nodesPerElement;
for ( int ic = 0; ic < nodesPerElement; ++ic ) {
const double r = p_shape_function[offSet+ic];
for ( int j = 0; j < nDim; ++j ) {
qIp[j] += r*p_vectorQ[ic*nDim+j];
}
}
// left and right volume
double inv_volL = 1.0/p_dualVolume[il];
double inv_volR = 1.0/p_dualVolume[ir];
// assemble to il/ir
for ( int i = 0; i < nDim; ++i ) {
const int row_gradQ = i*nDim;
const double qip = qIp[i];
for ( int j = 0; j < nDim; ++j ) {
double fac = qip*p_scs_areav[ip*nDim+j];
gradQL[row_gradQ+j] += fac*inv_volL;
gradQR[row_gradQ+j] -= fac*inv_volR;
}
}
}
}
}
}
//--------------------------------------------------------------------------
//-------- 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
}
void fill_pre_req_data(
ElemDataRequests& dataNeeded,
const stk::mesh::BulkData& bulkData,
stk::topology topo,
stk::mesh::Entity elem,
const stk::mesh::FieldBase* coordField,
ScratchViews& prereqData)
{
int nodesPerElem = topo.num_nodes();
MasterElement *meSCS = dataNeeded.get_cvfem_surface_me();
MasterElement *meSCV = dataNeeded.get_cvfem_volume_me();
prereqData.elemNodes = bulkData.begin_nodes(elem);
const FieldSet& neededFields = dataNeeded.get_fields();
for(const FieldInfo& fieldInfo : neededFields) {
stk::mesh::EntityRank fieldEntityRank = fieldInfo.field->entity_rank();
unsigned scalarsDim1 = fieldInfo.scalarsDim1;
bool isTensorField = fieldInfo.scalarsDim2 > 1;
if (fieldEntityRank==stk::topology::ELEM_RANK) {
if (isTensorField) {
SharedMemView<double**>& shmemView = prereqData.get_scratch_view_2D(*fieldInfo.field);
gather_elem_tensor_field(*fieldInfo.field, elem, scalarsDim1, fieldInfo.scalarsDim2, shmemView);
}
else {
SharedMemView<double*>& shmemView = prereqData.get_scratch_view_1D(*fieldInfo.field);
unsigned len = shmemView.dimension(0);
double* fieldDataPtr = static_cast<double*>(stk::mesh::field_data(*fieldInfo.field, elem));
for(unsigned i=0; i<len; ++i) {
shmemView(i) = fieldDataPtr[i];
}
}
}
else if (fieldEntityRank == stk::topology::NODE_RANK) {
if (isTensorField) {
SharedMemView<double***>& shmemView3D = prereqData.get_scratch_view_3D(*fieldInfo.field);
gather_elem_node_tensor_field(*fieldInfo.field, nodesPerElem, scalarsDim1, fieldInfo.scalarsDim2, bulkData.begin_nodes(elem), shmemView3D);
}
else {
if (scalarsDim1 == 1) {
SharedMemView<double*>& shmemView1D = prereqData.get_scratch_view_1D(*fieldInfo.field);
gather_elem_node_field(*fieldInfo.field, nodesPerElem, prereqData.elemNodes, shmemView1D);
}
else {
SharedMemView<double**>& shmemView2D = prereqData.get_scratch_view_2D(*fieldInfo.field);
if (scalarsDim1 == 3) {
gather_elem_node_field_3D(*fieldInfo.field, nodesPerElem, prereqData.elemNodes, shmemView2D);
}
else {
gather_elem_node_field(*fieldInfo.field, nodesPerElem, scalarsDim1, prereqData.elemNodes, shmemView2D);
}
}
}
}
else {
ThrowRequireMsg(false, "Only node and element fields supported currently.");
}
}
SharedMemView<double**>* coordsView = nullptr;
if (coordField != nullptr) {
coordsView = &prereqData.get_scratch_view_2D(*coordField);
}
const std::set<ELEM_DATA_NEEDED>& dataEnums = dataNeeded.get_data_enums();
double error = 0;
for(ELEM_DATA_NEEDED data : dataEnums) {
switch(data)
{
case SCS_AREAV:
ThrowRequireMsg(meSCS != nullptr, "ERROR, meSCS needs to be non-null if SCS_AREAV is requested.");
ThrowRequireMsg(coordsView != nullptr, "ERROR, coords null but SCS_AREAV requested.");
meSCS->determinant(1, &((*coordsView)(0,0)), &prereqData.scs_areav(0,0), &error);
break;
case SCS_GRAD_OP:
ThrowRequireMsg(meSCS != nullptr, "ERROR, meSCS needs to be non-null if SCS_GRAD_OP is requested.");
ThrowRequireMsg(coordsView != nullptr, "ERROR, coords null but SCS_GRAD_OP requested.");
meSCS->grad_op(1, &((*coordsView)(0,0)), &prereqData.dndx(0,0,0), &prereqData.deriv(0), &prereqData.det_j(0), &error);
break;
case SCS_SHIFTED_GRAD_OP:
ThrowRequireMsg(meSCS != nullptr, "ERROR, meSCS needs to be non-null if SCS_GRAD_OP is requested.");
ThrowRequireMsg(coordsView != nullptr, "ERROR, coords null but SCS_GRAD_OP requested.");
meSCS->shifted_grad_op(1, &((*coordsView)(0,0)), &prereqData.dndx_shifted(0,0,0), &prereqData.deriv(0), &prereqData.det_j(0), &error);
break;
case SCS_GIJ:
ThrowRequireMsg(meSCS != nullptr, "ERROR, meSCS needs to be non-null if SCS_GIJ is requested.");
ThrowRequireMsg(coordsView != nullptr, "ERROR, coords null but SCS_GIJ requested.");
meSCS->gij(&((*coordsView)(0,0)), &prereqData.gijUpper(0,0,0), &prereqData.gijLower(0,0,0), &prereqData.deriv(0));
break;
case SCV_VOLUME:
ThrowRequireMsg(meSCV != nullptr, "ERROR, meSCV needs to be non-null if SCV_VOLUME is requested.");
ThrowRequireMsg(coordsView != nullptr, "ERROR, coords null but SCV_VOLUME requested.");
meSCV->determinant(1, &((*coordsView)(0,0)), &prereqData.scv_volume(0), &error);
break;
default: break;
}
}
}
//--------------------------------------------------------------------------
//-------- execute ---------------------------------------------------------
//--------------------------------------------------------------------------
void
ComputeMdotElemAlgorithm::execute()
{
stk::mesh::MetaData & meta_data = realm_.meta_data();
const int nDim = meta_data.spatial_dimension();
// 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;
// nodal fields to gather
std::vector<double> ws_vrtm;
std::vector<double> ws_Gpdx;
std::vector<double> ws_coordinates;
std::vector<double> ws_pressure;
std::vector<double> ws_density;
// geometry related to populate
std::vector<double> ws_scs_areav;
std::vector<double> ws_dndx;
std::vector<double> ws_deriv;
std::vector<double> ws_det_j;
std::vector<double> ws_shape_function;
// integration point data that depends on size
std::vector<double> uIp(nDim);
std::vector<double> rho_uIp(nDim);
std::vector<double> GpdxIp(nDim);
std::vector<double> dpdxIp(nDim);
// pointers to everyone...
double *p_uIp = &uIp[0];
double *p_rho_uIp = &rho_uIp[0];
double *p_GpdxIp = &GpdxIp[0];
double *p_dpdxIp = &dpdxIp[0];
// deal with state
ScalarFieldType &densityNp1 = density_->field_of_state(stk::mesh::StateNP1);
// define some common selectors
stk::mesh::Selector s_locally_owned_union = meta_data.locally_owned_part()
&stk::mesh::selectUnion(partVec_);
stk::mesh::BucketVector const& elem_buckets =
realm_.get_buckets( stk::topology::ELEMENT_RANK, s_locally_owned_union );
for ( stk::mesh::BucketVector::const_iterator ib = elem_buckets.begin();
ib != elem_buckets.end() ; ++ib ) {
stk::mesh::Bucket & b = **ib ;
const stk::mesh::Bucket::size_type length = b.size();
// extract master element
MasterElement *meSCS = realm_.get_surface_master_element(b.topology());
// extract master element specifics
const int nodesPerElement = meSCS->nodesPerElement_;
const int numScsIp = meSCS->numIntPoints_;
// algorithm related
ws_vrtm.resize(nodesPerElement*nDim);
ws_Gpdx.resize(nodesPerElement*nDim);
ws_coordinates.resize(nodesPerElement*nDim);
ws_pressure.resize(nodesPerElement);
ws_density.resize(nodesPerElement);
ws_scs_areav.resize(numScsIp*nDim);
ws_dndx.resize(nDim*numScsIp*nodesPerElement);
ws_deriv.resize(nDim*numScsIp*nodesPerElement);
ws_det_j.resize(numScsIp);
ws_shape_function.resize(numScsIp*nodesPerElement);
// pointers
double *p_vrtm = &ws_vrtm[0];
double *p_Gpdx = &ws_Gpdx[0];
double *p_coordinates = &ws_coordinates[0];
double *p_pressure = &ws_pressure[0];
double *p_density = &ws_density[0];
double *p_scs_areav = &ws_scs_areav[0];
double *p_dndx = &ws_dndx[0];
double *p_shape_function = &ws_shape_function[0];
if ( shiftMdot_)
meSCS->shifted_shape_fcn(&p_shape_function[0]);
else
meSCS->shape_fcn(&p_shape_function[0]);
for ( stk::mesh::Bucket::size_type k = 0 ; k < length ; ++k ) {
// pointers to elem data
double * mdot = stk::mesh::field_data(*massFlowRate_, b, k );
//===============================================
// gather nodal data; this is how we do it now..
//===============================================
stk::mesh::Entity const * node_rels = b.begin_nodes(k);
int num_nodes = b.num_nodes(k);
// sanity check on num nodes
ThrowAssert( num_nodes == nodesPerElement );
for ( int ni = 0; ni < num_nodes; ++ni ) {
stk::mesh::Entity node = node_rels[ni];
// pointers to real data
const double * vrtm = stk::mesh::field_data(*velocityRTM_, node);
const double * Gjp = stk::mesh::field_data(*Gpdx_, node);
const double * coords = stk::mesh::field_data(*coordinates_, node);
// gather scalars
p_pressure[ni] = *stk::mesh::field_data(*pressure_, node);
p_density[ni] = *stk::mesh::field_data(densityNp1, node);
// gather vectors
const int offSet = ni*nDim;
for ( int j=0; j < nDim; ++j ) {
p_vrtm[offSet+j] = vrtm[j];
p_Gpdx[offSet+j] = Gjp[j];
p_coordinates[offSet+j] = coords[j];
}
}
// compute geometry
double scs_error = 0.0;
meSCS->determinant(1, &p_coordinates[0], &p_scs_areav[0], &scs_error);
// compute dndx
if (shiftPoisson_)
meSCS->shifted_grad_op(1, &p_coordinates[0], &p_dndx[0], &ws_deriv[0], &ws_det_j[0], &scs_error);
else
meSCS->grad_op(1, &p_coordinates[0], &p_dndx[0], &ws_deriv[0], &ws_det_j[0], &scs_error);
for ( int ip = 0; ip < numScsIp; ++ip ) {
// setup for ip values
for ( int j = 0; j < nDim; ++j ) {
p_uIp[j] = 0.0;
p_rho_uIp[j] = 0.0;
p_GpdxIp[j] = 0.0;
p_dpdxIp[j] = 0.0;
}
double rhoIp = 0.0;
const int offSet = ip*nodesPerElement;
for ( int ic = 0; ic < nodesPerElement; ++ic ) {
const double r = p_shape_function[offSet+ic];
const double nodalPressure = p_pressure[ic];
const double nodalRho = p_density[ic];
rhoIp += r*nodalRho;
const int offSetDnDx = nDim*nodesPerElement*ip + ic*nDim;
for ( int j = 0; j < nDim; ++j ) {
p_GpdxIp[j] += r*p_Gpdx[nDim*ic+j];
p_uIp[j] += r*p_vrtm[nDim*ic+j];
p_rho_uIp[j] += r*nodalRho*p_vrtm[nDim*ic+j];
p_dpdxIp[j] += p_dndx[offSetDnDx+j]*nodalPressure;
}
}
// assemble mdot
double tmdot = 0.0;
for ( int j = 0; j < nDim; ++j ) {
tmdot += (interpTogether*p_rho_uIp[j] + om_interpTogether*rhoIp*p_uIp[j]
- projTimeScale*(p_dpdxIp[j] - p_GpdxIp[j]))*p_scs_areav[ip*nDim+j];
}
mdot[ip] = tmdot;
}
}
}
// check for edge-mdot assembly
if ( assembleMdotToEdge_ )
assemble_edge_mdot();
}
//--------------------------------------------------------------------------
//-------- execute ---------------------------------------------------------
//--------------------------------------------------------------------------
void
ExtrusionMeshDistanceBoundaryAlgorithm::execute()
{
stk::mesh::MetaData & meta_data = realm_.meta_data();
stk::mesh::BulkData & bulk_data = realm_.bulk_data();
const int nDim = meta_data.spatial_dimension();
// extract extrusion factor
const double extrusionCorrectionFac = realm_.solutionOptions_->extrusionCorrectionFac_;
const double om_extrusioneCorrectionFac = 1.0 - extrusionCorrectionFac;
//============================================
// zero out haloNormal and correction factors
//=============================================
VectorFieldType *haloNormal
= meta_data.get_field<VectorFieldType>(stk::topology::NODE_RANK, "halo_normal");
ScalarFieldType *extDistCorrFac
= meta_data.get_field<ScalarFieldType>(stk::topology::NODE_RANK, "extrusion_distance_correct_fac");
ScalarFieldType *extDistCorrCount
= meta_data.get_field<ScalarFieldType>(stk::topology::NODE_RANK, "extrusion_distance_correct_count");
stk::mesh::Selector s_all = stk::mesh::selectUnion(partVec_);
stk::mesh::BucketVector const& all_node_buckets =
realm_.get_buckets( stk::topology::NODE_RANK, s_all );
for ( stk::mesh::BucketVector::const_iterator ib = all_node_buckets.begin();
ib != all_node_buckets.end() ; ++ib ) {
stk::mesh::Bucket & b = **ib ;
const stk::mesh::Bucket::size_type length = b.size();
// pointer to data
double * hNormal = stk::mesh::field_data(*haloNormal, b);
double * extDCF = stk::mesh::field_data(*extDistCorrFac,b);
double * extDCC = stk::mesh::field_data(*extDistCorrCount,b);
for ( stk::mesh::Bucket::size_type k = 0 ; k < length ; ++k ) {
extDCF[k] = 0.0;
extDCC[k] = 0.0;
const size_t offSet = k*nDim;
for ( int j = 0; j < nDim; ++j )
hNormal[offSet+j] = 0.0;
}
}
//=====================================================================
// compute exposed area vector; increment faces touching contact nodes
//=====================================================================
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());
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 master element
MasterElement *meFC = realm_.get_surface_master_element(b.topology());
// extract master element specifics
const int nodesPerElement = meFC->nodesPerElement_;
const int numScsIp = meFC->numIntPoints_;
// define scratch field
std::vector<double > ws_coordinates(nodesPerElement*nDim);
std::vector<double > ws_scs_areav(numScsIp*nDim);
const stk::mesh::Bucket::size_type length = b.size();
for ( stk::mesh::Bucket::size_type k = 0 ; k < length ; ++k ) {
// face data
double * areaVec = stk::mesh::field_data(*exposedAreaVec, b, k);
// face node relations for nodal gather
stk::mesh::Entity const * face_node_rels = b.begin_nodes(k);
//===============================================
// gather nodal data; this is how we do it now..
//===============================================
int num_nodes = b.num_nodes(k);
for ( int ni = 0; ni < num_nodes; ++ni ) {
stk::mesh::Entity node = face_node_rels[ni];
double * coords = stk::mesh::field_data(*coordinates, node);
const int offSet = ni*nDim;
for ( int j=0; j < nDim; ++j ) {
ws_coordinates[offSet+j] = coords[j];
}
}
// compute scs integration point areavec
double scs_error = 0.0;
meFC->determinant(1, &ws_coordinates[0], &ws_scs_areav[0], &scs_error);
for ( int ip = 0; ip < num_nodes; ++ip ) {
// offset for bip area vector
const int faceOffSet = ip*nDim;
double aMag = 0.0;
for ( int j=0; j < nDim; ++j ) {
const double axj = ws_scs_areav[faceOffSet+j];
areaVec[faceOffSet+j] = axj;
aMag += axj*axj;
}
aMag = std::sqrt(aMag);
// extract node; increment count; assemble normal
stk::mesh::Entity node = face_node_rels[ip];
// get nodal fields tocuhing this ip (nearest node); zeroed above
double * extDCC = stk::mesh::field_data(*extDistCorrCount,node);
double * hNormal = stk::mesh::field_data(*haloNormal, node);
// accumulate number of faces that touch this node
*extDCC += 1.0;
// accumulate normal
for ( int j = 0; j < nDim; ++j ) {
hNormal[j] += areaVec[faceOffSet+j]/aMag;
}
}
}
}
// parallel assemble correction count and nodal normals
std::vector<stk::mesh::FieldBase*> sum_halo_vec;
sum_halo_vec.push_back(extDistCorrCount);
sum_halo_vec.push_back(haloNormal);
stk::mesh::parallel_sum(bulk_data, sum_halo_vec);
// normalize hNormal
for ( stk::mesh::BucketVector::const_iterator ib = all_node_buckets.begin();
ib != all_node_buckets.end() ; ++ib ) {
stk::mesh::Bucket & b = **ib ;
const stk::mesh::Bucket::size_type length = b.size();
// pointer to data; to be modified and constant
double * hNormal = stk::mesh::field_data(*haloNormal, b);
for ( stk::mesh::Bucket::size_type k = 0 ; k < length ; ++k ) {
const size_t offSet = k*nDim;
double nMag = 0.0;
for ( int j = 0; j < nDim; ++j ) {
nMag += hNormal[offSet+j]*hNormal[offSet+j];
}
nMag = std::sqrt(nMag);
for ( int j = 0; j < nDim; ++j ) {
hNormal[offSet+j] /= nMag;
}
}
}
//==============================================
// assemble n^nodal_k (dot) n^bip_k
//==============================================
for ( stk::mesh::BucketVector::const_iterator ib = face_buckets.begin();
ib != face_buckets.end() ; ++ib ) {
stk::mesh::Bucket & b = **ib ;
// 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 ) {
// get face
stk::mesh::Entity face = b[k];
// pointer to face data
const double * areaVec = stk::mesh::field_data(*exposedAreaVec, face);
// face node relations for nodal gather
stk::mesh::Entity const* face_node_rels = bulk_data.begin_nodes(face);
// one to one mapping between ips and nodes
for ( int ip = 0; ip < num_face_nodes; ++ip ) {
// offset for bip area vector
const int faceOffSet = ip*nDim;
double aMag = 0.0;
for ( int j = 0; j < nDim; ++j ) {
const double axj = areaVec[faceOffSet+j];
aMag += axj*axj;
}
aMag = std::sqrt(aMag);
stk::mesh::Entity node = face_node_rels[ip];
double *hNormal = stk::mesh::field_data(*haloNormal, node);
double * eDCF = stk::mesh::field_data(*extDistCorrFac, node);
double sum = 0.0;
for ( int j = 0; j < nDim; ++j ) {
const double nj = areaVec[faceOffSet+j]/aMag;
const double nodal_nj = hNormal[j];
sum += nodal_nj*nj;
}
*eDCF += sum;
}
}
}
// parallel assemble correction factor; not yet normalized and in inverse state
std::vector<stk::mesh::FieldBase*> sum_fields(1, extDistCorrFac);
stk::mesh::parallel_sum(bulk_data, sum_fields);
//==============================================
// compute final nodal extrusion distance
//==============================================
VectorFieldType *haloDxj = meta_data.get_field<VectorFieldType>(stk::topology::NODE_RANK, "halo_dxj");
ScalarFieldType *extrusionDistance = meta_data.get_field<ScalarFieldType>(stk::topology::NODE_RANK, "extrusion_distance");
for ( stk::mesh::BucketVector::const_iterator ib = all_node_buckets.begin();
ib != all_node_buckets.end() ; ++ib ) {
stk::mesh::Bucket & b = **ib ;
const stk::mesh::Bucket::size_type length = b.size();
// pointer to data; to be modified and constant
double * hDxj = stk::mesh::field_data(*haloDxj, b);
double * eDCF = stk::mesh::field_data(*extDistCorrFac, b);
const double * extDist = stk::mesh::field_data(*extrusionDistance, b);
const double * eDCC = stk::mesh::field_data(*extDistCorrCount, b);
const double * hNormal = stk::mesh::field_data(*haloNormal, b);
for ( stk::mesh::Bucket::size_type k = 0 ; k < length ; ++k ) {
// choose non-planar correction; user controled to shut it off
const double nonPlanarCorrection
= eDCC[k]/eDCF[k]*extrusionCorrectionFac + om_extrusioneCorrectionFac;
eDCF[k] = nonPlanarCorrection;
const double fac = extDist[k]*nonPlanarCorrection;
const size_t offSet = k*nDim;
for ( int j = 0; j < nDim; ++j ) {
hDxj[offSet+j] = fac*hNormal[offSet+j];
}
}
}
}