//--------------------------------------------------------------------------
//-------- execute ---------------------------------------------------------
//--------------------------------------------------------------------------
void
AssembleElemSolverAlgorithm::execute()
{
stk::mesh::BulkData & bulk_data = realm_.bulk_data();
// set any data
const size_t activeKernelsSize = activeKernels_.size();
for ( size_t i = 0; i < activeKernelsSize; ++i )
activeKernels_[i]->setup(*realm_.timeIntegrator_);
run_algorithm(bulk_data, [&](SharedMemData& smdata)
{
set_zero(smdata.simdrhs.data(), smdata.simdrhs.size());
set_zero(smdata.simdlhs.data(), smdata.simdlhs.size());
// call supplemental; gathers happen inside the elem_execute method
for ( size_t i = 0; i < activeKernelsSize; ++i )
activeKernels_[i]->execute( smdata.simdlhs, smdata.simdrhs, smdata.simdPrereqData );
for(int simdElemIndex=0; simdElemIndex<smdata.numSimdElems; ++simdElemIndex) {
extract_vector_lane(smdata.simdrhs, simdElemIndex, smdata.rhs);
extract_vector_lane(smdata.simdlhs, simdElemIndex, smdata.lhs);
apply_coeff(nodesPerEntity_, smdata.elemNodes[simdElemIndex],
smdata.scratchIds, smdata.sortPermutation, smdata.rhs, smdata.lhs, __FILE__);
}
});
}
//--------------------------------------------------------------------------
//-------- execute ---------------------------------------------------------
//--------------------------------------------------------------------------
void
AssembleNodeSolverAlgorithm::execute()
{
stk::mesh::MetaData & meta_data = realm_.meta_data();
// space for LHS/RHS
const int lhsSize = sizeOfSystem_*sizeOfSystem_;
const int rhsSize = sizeOfSystem_;
std::vector<double> lhs(lhsSize);
std::vector<double> rhs(rhsSize);
std::vector<stk::mesh::Entity> connected_nodes(1);
// pointers
double *p_lhs = &lhs[0];
double *p_rhs = &rhs[0];
// supplemental algorithm size and setup
const size_t supplementalAlgSize = supplementalAlg_.size();
for ( size_t i = 0; i < supplementalAlgSize; ++i )
supplementalAlg_[i]->setup();
// define some common selectors
stk::mesh::Selector s_locally_owned_union = meta_data.locally_owned_part()
& stk::mesh::selectUnion(partVec_)
& !(stk::mesh::selectUnion(realm_.get_slave_part_vector()))
& !(realm_.get_inactive_selector());
stk::mesh::BucketVector const& node_buckets =
realm_.get_buckets( stk::topology::NODE_RANK, s_locally_owned_union );
for ( stk::mesh::BucketVector::const_iterator ib = node_buckets.begin();
ib != node_buckets.end() ; ++ib ) {
stk::mesh::Bucket & b = **ib ;
const stk::mesh::Bucket::size_type length = b.size();
for ( stk::mesh::Bucket::size_type k = 0 ; k < length ; ++k ) {
// get node
stk::mesh::Entity node = b[k];
connected_nodes[0] = node;
for ( int i = 0; i < lhsSize; ++i )
p_lhs[i] = 0.0;
for ( int i = 0; i < rhsSize; ++i )
p_rhs[i] = 0.0;
// call supplemental
for ( size_t i = 0; i < supplementalAlgSize; ++i )
supplementalAlg_[i]->node_execute( &lhs[0], &rhs[0], node);
apply_coeff(connected_nodes, rhs, lhs, __FILE__);
}
}
}
//--------------------------------------------------------------------------
//-------- execute ---------------------------------------------------------
//--------------------------------------------------------------------------
void
AssembleScalarEdgeDiffContactSolverAlgorithm::execute()
{
stk::mesh::MetaData & meta_data = realm_.meta_data();
stk::mesh::BulkData & bulk_data = realm_.bulk_data();
const int nDim = meta_data.spatial_dimension();
// space for LHS/RHS (nodesPerElem+1)*(nodesPerElem+1); nodesPerElem+1
std::vector<double> lhs;
std::vector<double> rhs;
std::vector<int> scratchIds;
std::vector<double> scratchVals;
std::vector<stk::mesh::Entity> connected_nodes;
// deal with state
ScalarFieldType &scalarQNp1 = scalarQ_->field_of_state(stk::mesh::StateNP1);
// space for interpolated right state (halo)
double qNp1R;
double diffFluxCoeffR;
std::vector<double> dqdxR(nDim);
// interpolate nodal values to point-in-elem
const int sizeOfScalarField = 1;
const int sizeOfVectorField = nDim;
// parallel communicate ghosted entities
if ( NULL != realm_.contactManager_->contactGhosting_ )
stk::mesh::communicate_field_data(*(realm_.contactManager_->contactGhosting_), ghostFieldVec_);
// iterate contactInfoVec_
std::vector<ContactInfo *>::iterator ii;
for( ii=realm_.contactManager_->contactInfoVec_.begin();
ii!=realm_.contactManager_->contactInfoVec_.end(); ++ii ) {
// get master element type for this contactInfo
MasterElement *meSCS = (*ii)->meSCS_;
const int nodesPerElement = meSCS->nodesPerElement_;
std::vector <double > elemNodalQ(nodesPerElement);
std::vector <double > elemNodalDiffFluxCoeff(nodesPerElement);
std::vector <double > elemNodalCoords(nDim*nodesPerElement);
std::vector <double > elemNodalDqdx(nDim*nodesPerElement);
std::vector <double > shpfc(nodesPerElement);
// resize some things; matrix related
const int npePlusOne = nodesPerElement+1;
const int lhsSize = npePlusOne*npePlusOne;
const int rhsSize = npePlusOne;
lhs.resize(lhsSize);
rhs.resize(rhsSize);
scratchIds.resize(rhsSize);
scratchVals.resize(rhsSize);
connected_nodes.resize(npePlusOne);
// pointer to lhs/rhs
double *p_lhs = &lhs[0];
double *p_rhs = &rhs[0];
// iterate halo face nodes
std::map<uint64_t, HaloInfo *>::iterator iterHalo;
for (iterHalo = (*ii)->haloInfoMap_.begin();
iterHalo != (*ii)->haloInfoMap_.end();
++iterHalo) {
// halo info object of interest
HaloInfo * infoObject = (*iterHalo).second;
// zeroing of lhs/rhs
for ( int k = 0; k < lhsSize; ++k ) {
p_lhs[k] = 0.0;
}
for ( int k = 0; k < rhsSize; ++k ) {
p_rhs[k] = 0.0;
}
// pointer to edge area vector
const double *p_areaVec = &infoObject->haloEdgeAreaVec_[0];
// extract element mesh object and global id for face node
stk::mesh::Entity elem = infoObject->owningElement_;
stk::mesh::Entity const* elem_node_rels = bulk_data.begin_nodes(elem);
const int num_nodes = bulk_data.num_nodes(elem);
// now load the elemental values for future interpolation; fill in connected nodes
connected_nodes[0] = infoObject->faceNode_;
for ( int ni = 0; ni < num_nodes; ++ni ) {
stk::mesh::Entity node = elem_node_rels[ni];
connected_nodes[ni+1] = node;
elemNodalQ[ni] = *stk::mesh::field_data(*scalarQ_, node);
elemNodalDiffFluxCoeff[ni] = *stk::mesh::field_data(*diffFluxCoeff_, node);
// load up vectors
const double * Gjq = stk::mesh::field_data(*dqdx_, node );
const double * coords = stk::mesh::field_data(*coordinates_, node );
for ( int j = 0; j < nDim; ++j ) {
const int offSet = j*nodesPerElement +ni;
elemNodalDqdx[offSet] = Gjq[j];
elemNodalCoords[offSet] = coords[j];
}
}
// extract nodal fields; right state is Halo and requires inperpolation
const double *coordL = stk::mesh::field_data(*coordinates_, infoObject->faceNode_);
const double *coordR = &infoObject->haloNodalCoords_[0];
const double qNp1L = *stk::mesh::field_data(scalarQNp1, infoObject->faceNode_);
meSCS->interpolatePoint(
sizeOfScalarField,
&(infoObject->isoParCoords_[0]),
&elemNodalQ[0],
&qNp1R);
// possible Hermite polynomial interpolation
if (NULL != hermite_) {
double qNp1H = 0;
hermite_->do_hermite(&elemNodalQ[0], &elemNodalCoords[0], &elemNodalDqdx[0], &coordR[0], qNp1H);
qNp1R = qNp1H;
}
const double diffFluxCoeffL = *stk::mesh::field_data(*diffFluxCoeff_, infoObject->faceNode_);
meSCS->interpolatePoint(
sizeOfScalarField,
&(infoObject->isoParCoords_[0]),
&elemNodalDiffFluxCoeff[0],
&diffFluxCoeffR);
// deal with nodal dqdx
const double *dqdxL = stk::mesh::field_data(*dqdx_, infoObject->faceNode_);
meSCS->interpolatePoint(
sizeOfVectorField,
&(infoObject->isoParCoords_[0]),
&elemNodalDqdx[0],
&(dqdxR[0]));
// ip props
const double viscIp = 0.5*(diffFluxCoeffL + diffFluxCoeffR);
// compute geometry
double axdx = 0.0;
double asq = 0.0;
for (int j = 0; j < nDim; ++j ) {
const double dxj = coordR[j] - coordL[j];
const double axj = p_areaVec[j];
axdx += axj*dxj;
asq += axj*axj;
}
const double inv_axdx = 1.0/axdx;
// NOC
double nonOrth = 0.0;
for ( int j = 0; j < nDim; ++j ) {
const double axj = p_areaVec[j];
const double dxj = coordR[j] - coordL[j];
// now non-orth (over-relaxed procedure of Jasek)
const double kxj = axj - asq*inv_axdx*dxj;
const double GjIp = 0.5*(dqdxL[j] + dqdxR[j]);
nonOrth += -viscIp*kxj*GjIp;
}
// iterate owning element nodes and form pair
meSCS->general_shape_fcn(1, &(infoObject->isoParCoords_[0]), &shpfc[0]);
const double lhsFac = -viscIp*asq*inv_axdx;
const double diffFlux = lhsFac*(qNp1R-qNp1L) + nonOrth;
// setup for LHS; row left is easy - simply zero
// left node (face)
p_rhs[0] = -diffFlux;
p_lhs[0] = -lhsFac;
for ( int ni = 0; ni < num_nodes; ++ni ) {
p_lhs[ni+1] = lhsFac*shpfc[ni];
}
// apply to linear system
apply_coeff(connected_nodes, scratchIds, scratchVals, rhs, lhs, __FILE__);
}
}
}
//--------------------------------------------------------------------------
//-------- execute ---------------------------------------------------------
//--------------------------------------------------------------------------
void
AssembleHeatCondIrradWallSolverAlgorithm::execute()
{
stk::mesh::MetaData & meta_data = realm_.meta_data();
const int nDim = meta_data.spatial_dimension();
const double sigma = realm_.get_stefan_boltzmann();
// space for LHS/RHS; nodesPerFace*nodesPerFace and nodesPerFace
std::vector<double> lhs;
std::vector<double> rhs;
std::vector<stk::mesh::Entity> connected_nodes;
// nodal fields to gather
std::vector<double> ws_irradiation;
std::vector<double> ws_emissivity;
std::vector<double> ws_temperature;
// geometry related to populate
std::vector<double> ws_shape_function;
// setup for buckets; union parts and ask for locally owned
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 specifics
MasterElement *meFC = realm_.get_surface_master_element(b.topology());
const int nodesPerFace = meFC->nodesPerElement_;
const int numScsIp = meFC->numIntPoints_;
// resize some things; matrix related
const int lhsSize = nodesPerFace*nodesPerFace;
const int rhsSize = nodesPerFace;
lhs.resize(lhsSize);
rhs.resize(rhsSize);
connected_nodes.resize(nodesPerFace);
// algorithm related
ws_irradiation.resize(nodesPerFace);
ws_emissivity.resize(nodesPerFace);
ws_temperature.resize(nodesPerFace);
ws_shape_function.resize(numScsIp*nodesPerFace);
// pointers
double *p_lhs = &lhs[0];
double *p_rhs = &rhs[0];
double *p_irradiation = &ws_irradiation[0];
double *p_emissivity = &ws_emissivity[0];
double *p_temperature = &ws_temperature[0];
double *p_shape_function = &ws_shape_function[0];
if ( useShifted_ )
meFC->shifted_shape_fcn(&p_shape_function[0]);
else
meFC->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 ) {
// 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;
// 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);
int num_nodes = b.num_nodes(k);
for ( int ni = 0; ni < num_nodes; ++ni ) {
// get the node and form connected_node
stk::mesh::Entity node = face_node_rels[ni];
connected_nodes[ni] = node;
// gather scalar
p_irradiation[ni] = *stk::mesh::field_data(*irradiation_, node);
p_emissivity[ni] = *stk::mesh::field_data(*emissivity_, node);
p_temperature[ni] = *stk::mesh::field_data(*temperature_, node);
}
// start the assembly
for ( int ip = 0; ip < numScsIp; ++ip ) {
double magA = 0.0;
for ( int j=0; j < nDim; ++j ) {
magA += areaVec[ip*nDim+j]*areaVec[ip*nDim+j];
}
magA = std::sqrt(magA);
const int nn = ip;
const int offSet = ip*nodesPerFace;
// form boundary ip values
double irradiationBip = 0.0;
double emissivityBip = 0.0;
double tBip = 0.0;
for ( int ic = 0; ic < nodesPerFace; ++ic ) {
const double r = p_shape_function[offSet+ic];
irradiationBip += r*p_irradiation[ic];
emissivityBip += r*p_emissivity[ic];
tBip += r*p_temperature[ic];
}
// form rhs contribution
const double radiation = emissivityBip*(irradiationBip - sigma*std::pow(tBip,4))*magA;
p_rhs[nn] += radiation;
// sensitivities
const int rowR = nn*nodesPerFace;
const double lhsFac = 4.0*sigma*emissivityBip*magA*std::pow(tBip,3);
for ( int ic = 0; ic < nodesPerFace; ++ic ) {
const double r = p_shape_function[offSet+ic];
p_lhs[rowR+ic] += r*lhsFac;
}
}
apply_coeff(connected_nodes, rhs, lhs, __FILE__);
}
}
}
//--------------------------------------------------------------------------
//-------- execute ---------------------------------------------------------
//--------------------------------------------------------------------------
void
AssemblePressureForceBCSolverAlgorithm::execute()
{
stk::mesh::BulkData & bulk_data = realm_.bulk_data();
stk::mesh::MetaData & meta_data = realm_.meta_data();
const int nDim = meta_data.spatial_dimension();
// space for LHS/RHS; nodesPerElem*nDim*nodesPerElem*nDim and nodesPerElem*nDim
std::vector<double> lhs;
std::vector<double> rhs;
std::vector<stk::mesh::Entity> connected_nodes;
// nodal fields to gather
std::vector<double> ws_face_coordinates;
std::vector<double> ws_bcScalarQ;
// master element
std::vector<double> ws_face_shape_function;
// define vector of parent topos; should always be UNITY in size
std::vector<stk::topology> parentTopo;
// define some common selectors
stk::mesh::Selector s_locally_owned_union = meta_data.locally_owned_part()
&stk::mesh::selectUnion(partVec_);
stk::mesh::BucketVector const& face_buckets =
realm_.get_buckets( meta_data.side_rank(), s_locally_owned_union );
for ( stk::mesh::BucketVector::const_iterator ib = face_buckets.begin();
ib != face_buckets.end() ; ++ib ) {
stk::mesh::Bucket & b = **ib ;
// extract connected element topology
b.parent_topology(stk::topology::ELEMENT_RANK, parentTopo);
ThrowAssert ( parentTopo.size() == 1 );
stk::topology theElemTopo = parentTopo[0];
// volume master element
MasterElement *meSCS = realm_.get_surface_master_element(theElemTopo);
const int nodesPerElement = meSCS->nodesPerElement_;
// face master element
MasterElement *meFC = realm_.get_surface_master_element(b.topology());
const int nodesPerFace = meFC->nodesPerElement_;
std::vector<int> face_node_ordinal_vec(nodesPerFace);
// resize some things; matrix related
const int lhsSize = nodesPerElement*nDim*nodesPerElement*nDim;
const int rhsSize = nodesPerElement*nDim;
lhs.resize(lhsSize);
rhs.resize(rhsSize);
connected_nodes.resize(nodesPerElement);
// algorithm related; element
ws_face_coordinates.resize(nodesPerFace*nDim);
ws_bcScalarQ.resize(nodesPerFace);
ws_face_shape_function.resize(nodesPerFace*nodesPerFace);
// pointers
double *p_lhs = &lhs[0];
double *p_rhs = &rhs[0];
double *p_face_coordinates = &ws_face_coordinates[0];
double *p_bcScalarQ = &ws_bcScalarQ[0];
double *p_face_shape_function = &ws_face_shape_function[0];
// shape functions
if (use_shifted_integration_)
{
meFC->shifted_shape_fcn(&p_face_shape_function[0]);
}
else{
meFC->shape_fcn(&p_face_shape_function[0]);
}
const size_t length = b.size();
for ( size_t k = 0 ; k < length ; ++k ) {
// zero lhs/rhs
for ( int p = 0; p < lhsSize; ++p )
p_lhs[p] = 0.0;
for ( int p = 0; p < rhsSize; ++p )
p_rhs[p] = 0.0;
// get face
stk::mesh::Entity face = b[k];
//======================================
// gather nodal data off of face
//======================================
stk::mesh::Entity const * face_node_rels = bulk_data .begin_nodes(face);
int num_face_nodes = bulk_data.num_nodes(face);
// sanity check on num nodes
ThrowAssert( num_face_nodes == nodesPerFace );
for ( int ni = 0; ni < num_face_nodes; ++ni ) {
stk::mesh::Entity node = face_node_rels[ni];
p_bcScalarQ[ni] = *stk::mesh::field_data(*bcScalarQ_, node);
// gather vectors
double * coords = stk::mesh::field_data(*coordinates_, node);
const int offSet = ni*nDim;
for ( int i=0; i < nDim; ++i ) {
p_face_coordinates[offSet+i] = coords[i];
}
}
// extract the connected element to this exposed face; should be single in size!
const stk::mesh::Entity* face_elem_rels = bulk_data.begin_elements(face);
ThrowAssert( bulk_data.num_elements(face) == 1 );
// get element; its face ordinal number and populate face_node_ordinal_vec
stk::mesh::Entity element = face_elem_rels[0];
const int face_ordinal = bulk_data.begin_element_ordinals(face)[0];
theElemTopo.side_node_ordinals(face_ordinal, face_node_ordinal_vec.begin());
//==========================================
// gather nodal data off of element; n/a
//==========================================
stk::mesh::Entity const * elem_node_rels = bulk_data.begin_nodes(element);
int num_nodes = bulk_data.num_nodes(element);
// sanity check on num nodes
ThrowAssert( num_nodes == nodesPerElement );
for ( int ni = 0; ni < num_nodes; ++ni ) {
stk::mesh::Entity node = elem_node_rels[ni];
// set connected nodes
connected_nodes[ni] = node;
}
// pointer to face data
double * areaVec = stk::mesh::field_data(*exposedAreaVec_, face);
// loop over face nodes
for ( int ip = 0; ip < num_face_nodes; ++ip ) {
const int nearestNode = face_node_ordinal_vec[ip];
const int offSetSF_face = ip*nodesPerFace;
// interpolate to bip
double fluxBip = 0.0;
for ( int ic = 0; ic < nodesPerFace; ++ic ) {
const double r = p_face_shape_function[offSetSF_face+ic];
fluxBip += r*p_bcScalarQ[ic];
}
// assemble for each of the ith component
for ( int i = 0; i < nDim; ++i ) {
const int indexR = nearestNode*nDim + i;
p_rhs[indexR] -= fluxBip*areaVec[ip*nDim+i];
// RHS only, no need to populate LHS (is zeroed out)
}
}
apply_coeff(connected_nodes, rhs, lhs, __FILE__);
}
}
}
//--------------------------------------------------------------------------
//-------- execute ---------------------------------------------------------
//--------------------------------------------------------------------------
void
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
AssembleMomentumEdgeSolverAlgorithm::execute()
{
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 = "velocity";
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; always edge connectivity
const int nodesPerEdge = 2;
const int lhsSize = nDim*nodesPerEdge*nDim*nodesPerEdge;
const int rhsSize = nDim*nodesPerEdge;
std::vector<double> lhs(lhsSize);
std::vector<double> rhs(rhsSize);
std::vector<stk::mesh::Entity> connected_nodes(2);
// area vector; gather into
std::vector<double> areaVec(nDim);
// pointer for fast access
double *p_lhs = &lhs[0];
double *p_rhs = &rhs[0];
double *p_areaVec = &areaVec[0];
// space for dui/dxj. This variable is the modified gradient with NOC
std::vector<double> duidxj(nDim*nDim);
// extrapolated value from the L/R direction
std::vector<double> uIpL(nDim);
std::vector<double> uIpR(nDim);
// limiter values from the L/R direction, 0:1
std::vector<double> limitL(nDim,1.0);
std::vector<double> limitR(nDim,1.0);
// extrapolated gradient from L/R direction
std::vector<double> duL(nDim);
std::vector<double> duR(nDim);
// pointers for fast access
double *p_duidxj = &duidxj[0];
double *p_uIpL = &uIpL[0];
double *p_uIpR = &uIpR[0];
double *p_limitL = &limitL[0];
double *p_limitR = &limitR[0];
double *p_duL = &duL[0];
double *p_duR = &duR[0];
// deal with state
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_)
& !(realm_.get_inactive_selector());
stk::mesh::BucketVector const& edge_buckets =
realm_.get_buckets( stk::topology::EDGE_RANK, s_locally_owned_union );
for ( stk::mesh::BucketVector::const_iterator ib = edge_buckets.begin();
ib != edge_buckets.end() ; ++ib ) {
stk::mesh::Bucket & b = **ib ;
const stk::mesh::Bucket::size_type length = b.size();
// pointer to edge area vector and mdot
const double * av = stk::mesh::field_data(*edgeAreaVec_, b);
const double * mdot = stk::mesh::field_data(*massFlowRate_, b);
for ( stk::mesh::Bucket::size_type k = 0 ; k < length ; ++k ) {
// zeroing of lhs/rhs
for ( int i = 0; i < lhsSize; ++i ) {
p_lhs[i] = 0.0;
}
for ( int i = 0; i < rhsSize; ++i ) {
p_rhs[i] = 0.0;
}
stk::mesh::Entity const * edge_node_rels = b.begin_nodes(k);
// pointer to edge area vector
for ( int j = 0; j < nDim; ++j )
p_areaVec[j] = av[k*nDim+j];
const double tmdot = mdot[k];
// sanity check on number or nodes
ThrowAssert( b.num_nodes(k) == 2 );
// left and right nodes
stk::mesh::Entity nodeL = edge_node_rels[0];
stk::mesh::Entity nodeR = edge_node_rels[1];
connected_nodes[0] = nodeL;
connected_nodes[1] = nodeR;
// extract nodal fields
const double * coordL = stk::mesh::field_data(*coordinates_, nodeL);
const double * coordR = stk::mesh::field_data(*coordinates_, nodeR);
const double * dudxL = stk::mesh::field_data(*dudx_, nodeL);
const double * dudxR = stk::mesh::field_data(*dudx_, nodeR);
const double * vrtmL = stk::mesh::field_data(*velocityRTM_, nodeL);
const double * vrtmR = stk::mesh::field_data(*velocityRTM_, nodeR);
const double * uNp1L = stk::mesh::field_data(velocityNp1, nodeL);
const double * uNp1R = stk::mesh::field_data(velocityNp1, nodeR);
const double densityL = *stk::mesh::field_data(densityNp1, nodeL);
const double densityR = *stk::mesh::field_data(densityNp1, nodeR);
const double viscosityL = *stk::mesh::field_data(*viscosity_, nodeL);
const double viscosityR = *stk::mesh::field_data(*viscosity_, nodeR);
// copy in extrapolated values
for ( int i = 0; i < nDim; ++i ) {
// extrapolated du
p_duL[i] = 0.0;
p_duR[i] = 0.0;
const int offSet = nDim*i;
for ( int j = 0; j < nDim; ++j ) {
const double dxj = 0.5*(coordR[j] - coordL[j]);
p_duL[i] += dxj*dudxL[offSet+j];
p_duR[i] += dxj*dudxR[offSet+j];
}
}
// compute geometry
double axdx = 0.0;
double asq = 0.0;
double udotx = 0.0;
for ( int j = 0; j < nDim; ++j ) {
const double axj = p_areaVec[j];
const double dxj = coordR[j] - coordL[j];
axdx += axj*dxj;
asq += axj*axj;
udotx += 0.5*dxj*(vrtmL[j] + vrtmR[j]);
}
const double inv_axdx = 1.0/axdx;
// ip props
const double viscIp = 0.5*(viscosityL + viscosityR);
const double diffIp = 0.5*(viscosityL/densityL + viscosityR/densityR);
// Peclet factor
const double pecfac = pecletFunction_->execute(std::abs(udotx)/(diffIp+small));
const double om_pecfac = 1.0-pecfac;
// determine limiter if applicable
if ( useLimiter ) {
for ( int i = 0; i < nDim; ++i ) {
const double dq = uNp1R[i] - uNp1L[i];
const double dqMl = 2.0*2.0*p_duL[i] - dq;
const double dqMr = 2.0*2.0*p_duR[i] - dq;
p_limitL[i] = van_leer(dqMl, dq, small);
p_limitR[i] = van_leer(dqMr, dq, small);
}
}
// final upwind extrapolation; with limiter
for ( int i = 0; i < nDim; ++i ) {
p_uIpL[i] = uNp1L[i] + p_duL[i]*hoUpwind*p_limitL[i];
p_uIpR[i] = uNp1R[i] - p_duR[i]*hoUpwind*p_limitR[i];
}
/*
form duidxj with over-relaxed procedure of Jasak:
dui/dxj = GjUi +[(uiR - uiL) - GlUi*dxl]*Aj/AxDx
where Gp is the interpolated pth nodal gradient for ui
*/
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 = 0.5*(dudxL[offSetIL] + 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 = p_areaVec[j];
const double GjUi = 0.5*(dudxL[offSetIJ] + dudxR[offSetIJ]);
p_duidxj[offSetIJ] = GjUi + (uidiff - GlUidxl)*axj*inv_axdx;
}
}
// lhs diffusion; only -mu*dui/dxj*Aj contribution for now
const double dlhsfac = -viscIp*asq*inv_axdx;
for ( int i = 0; i < nDim; ++i ) {
// 2nd order central
const double uiIp = 0.5*(uNp1R[i] + uNp1L[i]);
// upwind
const double uiUpwind = (tmdot > 0) ? alphaUpw*p_uIpL[i] + om_alphaUpw*uiIp
: alphaUpw*p_uIpR[i] + om_alphaUpw*uiIp;
// generalized central (2nd and 4th order)
const double uiHatL = alpha*p_uIpL[i] + om_alpha*uiIp;
const double uiHatR = alpha*p_uIpR[i] + om_alpha*uiIp;
const double uiCds = 0.5*(uiHatL + uiHatR);
// total advection; pressure contribution in time term expression
const double aflux = tmdot*(pecfac*uiUpwind + om_pecfac*uiCds);
// divU
double divU = 0.0;
for ( int j = 0; j < nDim; ++j)
divU += p_duidxj[j*nDim+j];
// diffusive flux; viscous tensor doted with area vector
double dflux = 2.0/3.0*viscIp*divU*p_areaVec[i]*includeDivU_;
const int offSetI = nDim*i;
for ( int j = 0; j < nDim; ++j ) {
const int offSetTrans = nDim*j+i;
const double axj = p_areaVec[j];
dflux += -viscIp*(p_duidxj[offSetI+j] + p_duidxj[offSetTrans])*axj;
}
// residal for total flux
const double tflux = aflux + dflux;
const int indexL = i;
const int indexR = i + nDim;
// total flux left
p_rhs[indexL] -= tflux;
// total flux right
p_rhs[indexR] += tflux;
// setup for LHS
const int rowL = indexL * nodesPerEdge*nDim;
const int rowR = indexR * nodesPerEdge*nDim;
//==============================
// advection first
//==============================
const int rLiL = rowL+indexL;
const int rLiR = rowL+indexR;
const int rRiL = rowR+indexL;
const int rRiR = rowR+indexR;
// upwind advection (includes 4th); left node
double alhsfac = 0.5*(tmdot+std::abs(tmdot))*pecfac*alphaUpw
+ 0.5*alpha*om_pecfac*tmdot;
p_lhs[rLiL] += alhsfac;
p_lhs[rRiL] -= alhsfac;
// upwind advection (incldues 4th); right node
alhsfac = 0.5*(tmdot-std::abs(tmdot))*pecfac*alphaUpw
+ 0.5*alpha*om_pecfac*tmdot;
p_lhs[rRiR] -= alhsfac;
p_lhs[rLiR] += alhsfac;
// central; left; collect terms on alpha and alphaUpw
alhsfac = 0.5*tmdot*(pecfac*om_alphaUpw + om_pecfac*om_alpha);
p_lhs[rLiL] += alhsfac;
p_lhs[rLiR] += alhsfac;
// central; right
p_lhs[rRiL] -= alhsfac;
p_lhs[rRiR] -= alhsfac;
//==============================
// diffusion second
//==============================
const double axi = p_areaVec[i];
//diffusion; row IL
p_lhs[rLiL] -= dlhsfac;
p_lhs[rLiR] += dlhsfac;
// diffusion; row IR
p_lhs[rRiL] += dlhsfac;
p_lhs[rRiR] -= dlhsfac;
// more diffusion; see theory manual
for ( int j = 0; j < nDim; ++j ) {
const double lhsfacNS = -viscIp*axi*p_areaVec[j]*inv_axdx;
const int colL = j;
const int colR = j + nDim;
// first left; IL,IL; IL,IR
p_lhs[rowL + colL] -= lhsfacNS;
p_lhs[rowL + colR] += lhsfacNS;
// now right, IR,IL; IR,IR
p_lhs[rowR + colL] += lhsfacNS;
p_lhs[rowR + colR] -= lhsfacNS;
}
}
apply_coeff(connected_nodes, rhs, lhs, __FILE__);
}
}
}
//--------------------------------------------------------------------------
//-------- execute ---------------------------------------------------------
//--------------------------------------------------------------------------
void
AssembleScalarElemOpenSolverAlgorithm::execute()
{
stk::mesh::BulkData & bulk_data = realm_.bulk_data();
stk::mesh::MetaData & meta_data = realm_.meta_data();
const int nDim = meta_data.spatial_dimension();
const double small = 1.0e-16;
// extract user advection options (allow to potentially change over time)
const std::string dofName = scalarQ_->name();
const double alphaUpw = realm_.get_alpha_upw_factor(dofName);
const double hoUpwind = realm_.get_upw_factor(dofName);
// one minus flavor..
const double om_alphaUpw = 1.0-alphaUpw;
// space for LHS/RHS; nodesPerElement*nodesPerElement and nodesPerElement
std::vector<double> lhs;
std::vector<double> rhs;
std::vector<int> scratchIds;
std::vector<double> scratchVals;
std::vector<stk::mesh::Entity> connected_nodes;
// ip values; only boundary
std::vector<double> coordBip(nDim);
// pointers to fixed values
double *p_coordBip = &coordBip[0];
// nodal fields to gather
std::vector<double> ws_face_coordinates;
std::vector<double> ws_scalarQNp1;
std::vector<double> ws_bcScalarQ;
// master element
std::vector<double> ws_face_shape_function;
// deal with state
ScalarFieldType &scalarQNp1 = scalarQ_->field_of_state(stk::mesh::StateNP1);
ScalarFieldType &densityNp1 = density_->field_of_state(stk::mesh::StateNP1);
// define vector of parent topos; should always be UNITY in size
std::vector<stk::topology> parentTopo;
// define some common selectors
stk::mesh::Selector s_locally_owned_union = meta_data.locally_owned_part()
&stk::mesh::selectUnion(partVec_);
stk::mesh::BucketVector const& face_buckets =
realm_.get_buckets( meta_data.side_rank(), s_locally_owned_union );
for ( stk::mesh::BucketVector::const_iterator ib = face_buckets.begin();
ib != face_buckets.end() ; ++ib ) {
stk::mesh::Bucket & b = **ib ;
// extract connected element topology
b.parent_topology(stk::topology::ELEMENT_RANK, parentTopo);
ThrowAssert ( parentTopo.size() == 1 );
stk::topology theElemTopo = parentTopo[0];
// volume master element
MasterElement *meSCS = realm_.get_surface_master_element(theElemTopo);
const int nodesPerElement = meSCS->nodesPerElement_;
// face master element
MasterElement *meFC = realm_.get_surface_master_element(b.topology());
const int nodesPerFace = meFC->nodesPerElement_;
const int numScsBip = meFC->numIntPoints_;
std::vector<int> face_node_ordinal_vec(nodesPerFace);
// resize some things; matrix related
const int lhsSize = nodesPerElement*nodesPerElement;
const int rhsSize = nodesPerElement;
lhs.resize(lhsSize);
rhs.resize(rhsSize);
scratchIds.resize(rhsSize);
scratchVals.resize(rhsSize);
connected_nodes.resize(nodesPerElement);
// algorithm related; element
ws_face_coordinates.resize(nodesPerFace*nDim);
ws_scalarQNp1.resize(nodesPerFace);
ws_bcScalarQ.resize(nodesPerFace);
ws_face_shape_function.resize(numScsBip*nodesPerFace);
// pointers
double *p_lhs = &lhs[0];
double *p_rhs = &rhs[0];
double *p_face_coordinates = &ws_face_coordinates[0];
double *p_scalarQNp1 = &ws_scalarQNp1[0];
double *p_bcScalarQ = &ws_bcScalarQ[0];
double *p_face_shape_function = &ws_face_shape_function[0];
// shape functions
meFC->shape_fcn(&p_face_shape_function[0]);
const stk::mesh::Bucket::size_type length = b.size();
for ( stk::mesh::Bucket::size_type k = 0 ; k < length ; ++k ) {
// zero lhs/rhs
for ( int p = 0; p < lhsSize; ++p )
p_lhs[p] = 0.0;
for ( int p = 0; p < rhsSize; ++p )
p_rhs[p] = 0.0;
// get face
stk::mesh::Entity face = b[k];
// pointer to face data
const double * mdot = stk::mesh::field_data(*openMassFlowRate_, face);
//======================================
// gather nodal data off of face
//======================================
stk::mesh::Entity const * face_node_rels = bulk_data.begin_nodes(face);
int num_face_nodes = bulk_data.num_nodes(face);
// sanity check on num nodes
ThrowAssert( num_face_nodes == nodesPerFace );
for ( int ni = 0; ni < num_face_nodes; ++ni ) {
stk::mesh::Entity node = face_node_rels[ni];
// gather scalars
p_scalarQNp1[ni] = *stk::mesh::field_data(scalarQNp1, node);
p_bcScalarQ[ni] = *stk::mesh::field_data(*bcScalarQ_, node);
// gather vectors
double * coords = stk::mesh::field_data(*coordinates_, node);
const int offSet = ni*nDim;
for ( int i=0; i < nDim; ++i ) {
p_face_coordinates[offSet+i] = coords[i];
}
}
// extract the connected element to this exposed face; should be single in size!
const stk::mesh::Entity* face_elem_rels = bulk_data.begin_elements(face);
ThrowAssert( bulk_data.num_elements(face) == 1 );
// get element; its face ordinal number and populate face_node_ordinal_vec
stk::mesh::Entity element = face_elem_rels[0];
const int face_ordinal = bulk_data.begin_element_ordinals(face)[0];
theElemTopo.side_node_ordinals(face_ordinal, face_node_ordinal_vec.begin());
// mapping from ip to nodes for this ordinal
const int *ipNodeMap = meSCS->ipNodeMap(face_ordinal);
//==========================================
// gather nodal data off of element; n/a
//==========================================
stk::mesh::Entity const * elem_node_rels = bulk_data.begin_nodes(element);
int num_nodes = bulk_data.num_nodes(element);
// sanity check on num nodes
ThrowAssert( num_nodes == nodesPerElement );
for ( int ni = 0; ni < num_nodes; ++ni ) {
// set connected nodes
connected_nodes[ni] = elem_node_rels[ni];
}
// loop over face nodes
for ( int ip = 0; ip < numScsBip; ++ip ) {
const int opposingNode = meSCS->opposingNodes(face_ordinal,ip);
const int nearestNode = ipNodeMap[ip];
const int offSetSF_face = ip*nodesPerFace;
// left and right nodes; right is on the face; left is the opposing node
stk::mesh::Entity nodeL = elem_node_rels[opposingNode];
stk::mesh::Entity nodeR = elem_node_rels[nearestNode];
// zero out vector quantities
for ( int j = 0; j < nDim; ++j )
p_coordBip[j] = 0.0;
// interpolate to bip
double qIp = 0.0;
double qIpEntrain = 0.0;
for ( int ic = 0; ic < nodesPerFace; ++ic ) {
const double r = p_face_shape_function[offSetSF_face+ic];
qIp += r*p_scalarQNp1[ic];
qIpEntrain += r*p_bcScalarQ[ic];
const int offSetFN = ic*nDim;
for ( int j = 0; j < nDim; ++j ) {
p_coordBip[j] += r*p_face_coordinates[offSetFN+j];
}
}
// Peclet factor; along the edge is fine
const double densL = *stk::mesh::field_data(densityNp1, nodeL);
const double densR = *stk::mesh::field_data(densityNp1, nodeR);
const double diffCoeffL = *stk::mesh::field_data(*diffFluxCoeff_, nodeL);
const double diffCoeffR = *stk::mesh::field_data(*diffFluxCoeff_, nodeR);
const double scalarQNp1R = *stk::mesh::field_data(scalarQNp1, nodeR);
const double *vrtmL = stk::mesh::field_data(*velocityRTM_, nodeL);
const double *vrtmR = stk::mesh::field_data(*velocityRTM_, nodeR);
const double *coordL = stk::mesh::field_data(*coordinates_, nodeL);
const double *coordR = stk::mesh::field_data(*coordinates_, nodeR);
const double *dqdxR = stk::mesh::field_data(*dqdx_, nodeR);
double udotx = 0.0;
double dqR = 0.0;
for ( int i = 0; i < nDim; ++i ) {
const double dxi = coordR[i] - coordL[i];
udotx += 0.5*dxi*(vrtmL[i] + vrtmR[i]);
// extrapolation
const double dx_bip = coordBip[i] - coordR[i];
dqR += dx_bip*dqdxR[i]*hoUpwind;
}
const double qIpUpw = scalarQNp1R + dqR;
const double diffIp = 0.5*(diffCoeffL/densL + diffCoeffR/densR);
const double pecfac = pecletFunction_->execute(std::abs(udotx)/(diffIp+small));
const double om_pecfac = 1.0-pecfac;
//================================
// advection first (and only)
//================================
const double tmdot = mdot[ip];
const int rowR = nearestNode*nodesPerElement;
// advection; leaving the domain
if ( tmdot > 0.0 ) {
// central; is simply qIp
// upwind
const double qUpwind = alphaUpw*qIpUpw + (om_alphaUpw)*qIp;
// total advection
const double aflux = tmdot*(pecfac*qUpwind+om_pecfac*qIp);
p_rhs[nearestNode] -= aflux;
// upwind lhs
p_lhs[rowR+nearestNode] += tmdot*pecfac*alphaUpw;
// central part
const double fac = tmdot*(pecfac*om_alphaUpw+om_pecfac);
for ( int ic = 0; ic < nodesPerFace; ++ic ) {
const double r = p_face_shape_function[offSetSF_face+ic];
const int nn = face_node_ordinal_vec[ic];
p_lhs[rowR+nn] += r*fac;
}
}
else {
// extrainment; advect in from specified value
const double aflux = tmdot*qIpEntrain;
p_rhs[nearestNode] -= aflux;
}
}
apply_coeff(connected_nodes, scratchIds, scratchVals, rhs, lhs, __FILE__);
}
}
}
//--------------------------------------------------------------------------
//-------- execute ---------------------------------------------------------
//--------------------------------------------------------------------------
void
AssembleContinuityElemOpenSolverAlgorithm::execute()
{
stk::mesh::BulkData & bulk_data = realm_.bulk_data();
stk::mesh::MetaData & meta_data = realm_.meta_data();
const int nDim = meta_data.spatial_dimension();
// extract noc
const std::string dofName = "pressure";
const double includeNOC
= (realm_.get_noc_usage(dofName) == true) ? 1.0 : 0.0;
// space for LHS/RHS; nodesPerElem*nodesPerElem and nodesPerElem
std::vector<double> lhs;
std::vector<double> rhs;
std::vector<stk::mesh::Entity> connected_nodes;
// ip values; both boundary and opposing surface
std::vector<double> uBip(nDim);
std::vector<double> rho_uBip(nDim);
std::vector<double> GpdxBip(nDim);
std::vector<double> coordBip(nDim);
std::vector<double> coordScs(nDim);
// pointers to fixed values
double *p_uBip = &uBip[0];
double *p_rho_uBip = &rho_uBip[0];
double *p_GpdxBip = &GpdxBip[0];
double *p_coordBip = &coordBip[0];
double *p_coordScs = &coordScs[0];
// nodal fields to gather
std::vector<double> ws_coordinates;
std::vector<double> ws_pressure;
std::vector<double> ws_vrtm;
std::vector<double> ws_Gpdx;
std::vector<double> ws_density;
std::vector<double> ws_bcPressure;
// master element
std::vector<double> ws_shape_function;
std::vector<double> ws_shape_function_lhs;
std::vector<double> ws_face_shape_function;
// time step
const double dt = realm_.get_time_step();
const double gamma1 = realm_.get_gamma1();
const double projTimeScale = dt/gamma1;
// deal with interpolation procedure
const double interpTogether = realm_.get_mdot_interp();
const double om_interpTogether = 1.0-interpTogether;
// deal with state
ScalarFieldType &densityNp1 = density_->field_of_state(stk::mesh::StateNP1);
// define vector of parent topos; should always be UNITY in size
std::vector<stk::topology> parentTopo;
// define some common selectors
stk::mesh::Selector s_locally_owned_union = meta_data.locally_owned_part()
&stk::mesh::selectUnion(partVec_);
stk::mesh::BucketVector const& face_buckets =
realm_.get_buckets( meta_data.side_rank(), s_locally_owned_union );
for ( stk::mesh::BucketVector::const_iterator ib = face_buckets.begin();
ib != face_buckets.end() ; ++ib ) {
stk::mesh::Bucket & b = **ib ;
// extract connected element topology
b.parent_topology(stk::topology::ELEMENT_RANK, parentTopo);
ThrowAssert ( parentTopo.size() == 1 );
stk::topology theElemTopo = parentTopo[0];
// volume master element
MasterElement *meSCS = realm_.get_surface_master_element(theElemTopo);
const int nodesPerElement = meSCS->nodesPerElement_;
const int numScsIp = meSCS->numIntPoints_;
// face master element
MasterElement *meFC = realm_.get_surface_master_element(b.topology());
const int nodesPerFace = b.topology().num_nodes();
const int numScsBip = meFC->numIntPoints_;
std::vector<int> face_node_ordinal_vec(nodesPerFace);
// resize some things; matrix related
const int lhsSize = nodesPerElement*nodesPerElement;
const int rhsSize = nodesPerElement;
lhs.resize(lhsSize);
rhs.resize(rhsSize);
connected_nodes.resize(nodesPerElement);
// algorithm related; element
ws_coordinates.resize(nodesPerElement*nDim);
ws_pressure.resize(nodesPerElement);
ws_vrtm.resize(nodesPerFace*nDim);
ws_Gpdx.resize(nodesPerFace*nDim);
ws_density.resize(nodesPerFace);
ws_bcPressure.resize(nodesPerFace);
ws_shape_function.resize(numScsIp*nodesPerElement);
ws_shape_function_lhs.resize(numScsIp*nodesPerElement);
ws_face_shape_function.resize(numScsBip*nodesPerFace);
// pointers
double *p_lhs = &lhs[0];
double *p_rhs = &rhs[0];
double *p_coordinates = &ws_coordinates[0];
double *p_pressure = &ws_pressure[0];
double *p_vrtm = &ws_vrtm[0];
double *p_Gpdx = &ws_Gpdx[0];
double *p_density = &ws_density[0];
double *p_bcPressure = &ws_bcPressure[0];
double *p_shape_function = &ws_shape_function[0];
double *p_shape_function_lhs = shiftPoisson_ ? &ws_shape_function[0] : reducedSensitivities_ ? &ws_shape_function_lhs[0] : &ws_shape_function[0];
double *p_face_shape_function = &ws_face_shape_function[0];
// shape functions; interior
if ( shiftPoisson_ )
meSCS->shifted_shape_fcn(&p_shape_function[0]);
else
meSCS->shape_fcn(&p_shape_function[0]);
if ( !shiftPoisson_ && reducedSensitivities_ )
meSCS->shifted_shape_fcn(&p_shape_function_lhs[0]);
// shape functions; boundary
if ( shiftMdot_ )
meFC->shifted_shape_fcn(&p_face_shape_function[0]);
else
meFC->shape_fcn(&p_face_shape_function[0]);
const stk::mesh::Bucket::size_type length = b.size();
for ( stk::mesh::Bucket::size_type k = 0 ; k < length ; ++k ) {
// zero lhs/rhs
for ( int p = 0; p < lhsSize; ++p )
p_lhs[p] = 0.0;
for ( int p = 0; p < rhsSize; ++p )
p_rhs[p] = 0.0;
// get face
stk::mesh::Entity face = b[k];
//======================================
// gather nodal data off of face
//======================================
stk::mesh::Entity const * face_node_rels = bulk_data.begin_nodes(face);
int num_face_nodes = bulk_data.num_nodes(face);
// sanity check on num nodes
ThrowAssert( num_face_nodes == nodesPerFace );
for ( int ni = 0; ni < num_face_nodes; ++ni ) {
stk::mesh::Entity node = face_node_rels[ni];
// gather scalars
p_density[ni] = *stk::mesh::field_data(densityNp1, node);
p_bcPressure[ni] = *stk::mesh::field_data(*pressureBc_, node);
// gather vectors
const double * vrtm = stk::mesh::field_data(*velocityRTM_, node);
const double * Gjp = stk::mesh::field_data(*Gpdx_, node);
const int offSet = ni*nDim;
for ( int j=0; j < nDim; ++j ) {
p_vrtm[offSet+j] = vrtm[j];
p_Gpdx[offSet+j] = Gjp[j];
}
}
// pointer to face data
const double * areaVec = stk::mesh::field_data(*exposedAreaVec_, face);
// extract the connected element to this exposed face; should be single in size!
const stk::mesh::Entity* face_elem_rels = bulk_data.begin_elements(face);
ThrowAssert( bulk_data.num_elements(face) == 1 );
// get element; its face ordinal number and populate face_node_ordinal_vec
stk::mesh::Entity element = face_elem_rels[0];
const stk::mesh::ConnectivityOrdinal* face_elem_ords = bulk_data.begin_element_ordinals(face);
const int face_ordinal = face_elem_ords[0];
theElemTopo.side_node_ordinals(face_ordinal, face_node_ordinal_vec.begin());
// mapping from ip to nodes for this ordinal
const int *ipNodeMap = meSCS->ipNodeMap(face_ordinal);
//======================================
// gather nodal data off of element
//======================================
stk::mesh::Entity const * elem_node_rels = bulk_data.begin_nodes(element);
int num_nodes = bulk_data.num_nodes(element);
// sanity check on num nodes
ThrowAssert( num_nodes == nodesPerElement );
for ( int ni = 0; ni < num_nodes; ++ni ) {
stk::mesh::Entity node = elem_node_rels[ni];
// set connected nodes
connected_nodes[ni] = node;
// gather scalars
p_pressure[ni] = *stk::mesh::field_data(*pressure_, node);
// gather vectors
const double * coords = stk::mesh::field_data(*coordinates_, node);
const int offSet = ni*nDim;
for ( int j=0; j < nDim; ++j ) {
p_coordinates[offSet+j] = coords[j];
}
}
// loop over boundary ips
for ( int ip = 0; ip < numScsBip; ++ip ) {
const int nearestNode = ipNodeMap[ip];
const int opposingScsIp = meSCS->opposingFace(face_ordinal,ip);
// zero out vector quantities
for ( int j = 0; j < nDim; ++j ) {
p_uBip[j] = 0.0;
p_rho_uBip[j] = 0.0;
p_GpdxBip[j] = 0.0;
p_coordBip[j] = 0.0;
p_coordScs[j] = 0.0;
}
double rhoBip = 0.0;
// interpolate to bip
double pBip = 0.0;
const int offSetSF_face = ip*nodesPerFace;
for ( int ic = 0; ic < nodesPerFace; ++ic ) {
const int fn = face_node_ordinal_vec[ic];
const double r = p_face_shape_function[offSetSF_face+ic];
const double rhoIC = p_density[ic];
rhoBip += r*rhoIC;
pBip += r*p_bcPressure[ic];
const int offSetFN = ic*nDim;
const int offSetEN = fn*nDim;
for ( int j = 0; j < nDim; ++j ) {
p_uBip[j] += r*p_vrtm[offSetFN+j];
p_rho_uBip[j] += r*rhoIC*p_vrtm[offSetFN+j];
p_GpdxBip[j] += r*p_Gpdx[offSetFN+j];
p_coordBip[j] += r*p_coordinates[offSetEN+j];
}
}
// data at interior opposing face
double pScs = 0.0;
const int offSetSF_elem = opposingScsIp*nodesPerElement;
for ( int ic = 0; ic < nodesPerElement; ++ic ) {
const double r = p_shape_function[offSetSF_elem+ic];
pScs += r*p_pressure[ic];
const int offSet = ic*nDim;
for ( int j = 0; j < nDim; ++j ) {
p_coordScs[j] += r*p_coordinates[offSet+j];
}
}
// form axdx, asq and mdot (without dp/dn or noc)
double asq = 0.0;
double axdx = 0.0;
double mdot = 0.0;
for ( int j = 0; j < nDim; ++j ) {
const double dxj = p_coordBip[j] - p_coordScs[j];
const double axj = areaVec[ip*nDim+j];
asq += axj*axj;
axdx += axj*dxj;
mdot += (interpTogether*p_rho_uBip[j] + om_interpTogether*rhoBip*p_uBip[j]
+ projTimeScale*p_GpdxBip[j])*axj;
}
const double inv_axdx = 1.0/axdx;
// deal with noc
double noc = 0.0;
for ( int j = 0; j < nDim; ++j ) {
const double dxj = p_coordBip[j] - p_coordScs[j];
const double axj = areaVec[ip*nDim+j];
const double kxj = axj - asq*inv_axdx*dxj; // NOC
noc += kxj*p_GpdxBip[j];
}
// lhs for pressure system
int rowR = nearestNode*nodesPerElement;
for ( int ic = 0; ic < nodesPerElement; ++ic ) {
const double r = p_shape_function_lhs[offSetSF_elem+ic];
p_lhs[rowR+ic] += r*asq*inv_axdx;
}
// final mdot
mdot += -projTimeScale*((pBip-pScs)*asq*inv_axdx + noc*includeNOC);
// residual
p_rhs[nearestNode] -= mdot/projTimeScale;
}
apply_coeff(connected_nodes, rhs, lhs, __FILE__);
}
}
}
//--------------------------------------------------------------------------
//-------- execute ---------------------------------------------------------
//--------------------------------------------------------------------------
void
AssembleContinuityEdgeSolverAlgorithm::execute()
{
stk::mesh::MetaData & meta_data = realm_.meta_data();
const int nDim = meta_data.spatial_dimension();
// extract noc
const std::string dofName = "pressure";
const double nocFac
= (realm_.get_noc_usage(dofName) == true) ? 1.0 : 0.0;
// 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; always nodesPerEdge*nodesPerEdge and nodesPerEdge
std::vector<double> lhs(4);
std::vector<double> rhs(2);
std::vector<stk::mesh::Entity> connected_nodes(2);
// area vector; gather into
std::vector<double> areaVec(nDim);
// pointers for fast access
double *p_lhs = &lhs[0];
double *p_rhs = &rhs[0];
double *p_areaVec = &areaVec[0];
// mesh motion
std::vector<double> vrtmL(nDim);
std::vector<double> vrtmR(nDim);
double * p_vrtmL = &vrtmL[0];
double * p_vrtmR = &vrtmR[0];
// deal with state
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& edge_buckets =
realm_.get_buckets( stk::topology::EDGE_RANK, s_locally_owned_union );
for ( stk::mesh::BucketVector::const_iterator ib = edge_buckets.begin();
ib != edge_buckets.end() ; ++ib ) {
stk::mesh::Bucket & b = **ib ;
const stk::mesh::Bucket::size_type length = b.size();
// pointer to edge area vector
const double * av = stk::mesh::field_data(*edgeAreaVec_, b);
for ( stk::mesh::Bucket::size_type k = 0 ; k < length ; ++k ) {
// sanity check on number or nodes
ThrowAssert( b.num_nodes(k) == 2 );
stk::mesh::Entity const * edge_node_rels = b.begin_nodes(k);
// pointer to edge area vector
for ( int j = 0; j < nDim; ++j )
p_areaVec[j] = av[k*nDim+j];
// left and right nodes
stk::mesh::Entity nodeL = edge_node_rels[0];
stk::mesh::Entity nodeR = edge_node_rels[1];
connected_nodes[0] = nodeL;
connected_nodes[1] = nodeR;
// extract nodal fields
const double * coordL = stk::mesh::field_data(*coordinates_, nodeL);
const double * coordR = stk::mesh::field_data(*coordinates_, nodeR);
const double * GpdxL = stk::mesh::field_data(*Gpdx_, nodeL);
const double * GpdxR = stk::mesh::field_data(*Gpdx_, nodeR);
const double * velocityNp1L = stk::mesh::field_data(velocityNp1, nodeL);
const double * velocityNp1R = stk::mesh::field_data(velocityNp1, nodeR);
const double pressureL = *stk::mesh::field_data(*pressure_, nodeL);
const double pressureR = *stk::mesh::field_data(*pressure_, nodeR);
const double densityL = *stk::mesh::field_data(densityNp1, nodeL);
const double densityR = *stk::mesh::field_data(densityNp1, nodeR);
// copy to velcoity relative to mesh
for ( int j = 0; j < nDim; ++j ) {
p_vrtmL[j] = velocityNp1L[j];
p_vrtmR[j] = velocityNp1R[j];
}
// deal with mesh motion
if ( meshMotion_ ) {
const double * meshVelocityL = stk::mesh::field_data(*meshVelocity_, nodeL );
const double * meshVelocityR = stk::mesh::field_data(*meshVelocity_, nodeR );
for (int j = 0; j < nDim; ++j ) {
p_vrtmL[j] -= meshVelocityL[j];
p_vrtmR[j] -= meshVelocityR[j];
}
}
// compute geometry
double axdx = 0.0;
double asq = 0.0;
for ( int j = 0; j < nDim; ++j ) {
const double axj = p_areaVec[j];
const double dxj = coordR[j] - coordL[j];
asq += axj*axj;
axdx += axj*dxj;
}
const double inv_axdx = 1.0/axdx;
const double rhoIp = 0.5*(densityR + densityL);
// mdot
double tmdot = -projTimeScale*(pressureR - pressureL)*asq*inv_axdx;
for ( int j = 0; j < nDim; ++j ) {
const double axj = p_areaVec[j];
const double dxj = coordR[j] - coordL[j];
const double kxj = axj - asq*inv_axdx*dxj; // NOC
const double rhoUjIp = 0.5*(densityR*p_vrtmR[j] + densityL*p_vrtmL[j]);
const double ujIp = 0.5*(p_vrtmR[j] + p_vrtmL[j]);
const double GjIp = 0.5*(GpdxR[j] + GpdxL[j]);
tmdot += (interpTogether*rhoUjIp + om_interpTogether*rhoIp*ujIp + projTimeScale*GjIp)*axj
- projTimeScale*kxj*GjIp*nocFac;
}
const double lhsfac = -asq*inv_axdx;
/*
lhs[0] = IL,IL; lhs[1] = IL,IR; IR,IL; IR,IR
*/
// first left
p_lhs[0] = -lhsfac;
p_lhs[1] = +lhsfac;
p_rhs[0] = -tmdot/projTimeScale;
// now right
p_lhs[2] = +lhsfac;
p_lhs[3] = -lhsfac;
p_rhs[1] = tmdot/projTimeScale;
apply_coeff(connected_nodes, rhs, lhs, __FILE__);
}
}
}
//--------------------------------------------------------------------------
//-------- execute ---------------------------------------------------------
//--------------------------------------------------------------------------
void
AssembleMomentumElemSymmetrySolverAlgorithm::execute()
{
stk::mesh::BulkData & bulk_data = realm_.bulk_data();
stk::mesh::MetaData & meta_data = realm_.meta_data();
const int nDim = meta_data.spatial_dimension();
// space for LHS/RHS; nodesPerElem*nDim*nodesPerElem*nDim and nodesPerElem*nDim
std::vector<double> lhs;
std::vector<double> rhs;
std::vector<int> scratchIds;
std::vector<double> scratchVals;
std::vector<stk::mesh::Entity> connected_nodes;
// vectors
std::vector<double> nx(nDim);
// pointers to fixed values
double *p_nx = &nx[0];
// nodal fields to gather
std::vector<double> ws_velocityNp1;
std::vector<double> ws_coordinates;
std::vector<double> ws_viscosity;
// master element
std::vector<double> ws_face_shape_function;
std::vector<double> ws_dndx;
std::vector<double> ws_det_j;
// deal with state
VectorFieldType &velocityNp1 = velocity_->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_;
// 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; element
ws_velocityNp1.resize(nodesPerElement*nDim);
ws_coordinates.resize(nodesPerElement*nDim);
ws_viscosity.resize(nodesPerFace);
ws_face_shape_function.resize(numScsBip*nodesPerFace);
ws_dndx.resize(nDim*numScsBip*nodesPerElement);
ws_det_j.resize(numScsBip);
// pointers
double *p_lhs = &lhs[0];
double *p_rhs = &rhs[0];
double *p_velocityNp1 = &ws_velocityNp1[0];
double *p_coordinates = &ws_coordinates[0];
double *p_viscosity = &ws_viscosity[0];
double *p_face_shape_function = &ws_face_shape_function[0];
double *p_dndx = &ws_dndx[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 ) {
// zero lhs/rhs
for ( int p = 0; p < lhsSize; ++p )
p_lhs[p] = 0.0;
for ( int p = 0; p < rhsSize; ++p )
p_rhs[p] = 0.0;
// get face
stk::mesh::Entity face = b[k];
//======================================
// gather nodal data off of face
//======================================
stk::mesh::Entity const * face_node_rels = bulk_data.begin_nodes(face);
int num_face_nodes = bulk_data.num_nodes(face);
// sanity check on num nodes
ThrowAssert( num_face_nodes == nodesPerFace );
for ( int ni = 0; ni < num_face_nodes; ++ni ) {
stk::mesh::Entity node = face_node_rels[ni];
// gather scalars
p_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!
stk::mesh::Entity const * face_elem_rels = bulk_data.begin_elements(face);
ThrowAssert( bulk_data.num_elements(face) == 1 );
// get element; its face ordinal number
stk::mesh::Entity element = face_elem_rels[0];
const stk::mesh::ConnectivityOrdinal* face_elem_ords = bulk_data.begin_element_ordinals(face);
const int face_ordinal = face_elem_ords[0];
// mapping from ip to nodes for this ordinal
const int *ipNodeMap = meSCS->ipNodeMap(face_ordinal);
//==========================================
// gather nodal data off of element
//==========================================
stk::mesh::Entity const * elem_node_rels = bulk_data.begin_nodes(element);
int num_nodes = bulk_data.num_nodes(element);
// sanity check on num nodes
ThrowAssert( num_nodes == nodesPerElement );
for ( int ni = 0; ni < num_nodes; ++ni ) {
stk::mesh::Entity node = elem_node_rels[ni];
// set connected nodes
connected_nodes[ni] = node;
// gather vectors
double * uNp1 = stk::mesh::field_data(velocityNp1, node);
double * coords = stk::mesh::field_data(*coordinates_, node);
const int offSet = ni*nDim;
for ( int j=0; j < nDim; ++j ) {
p_velocityNp1[offSet+j] = uNp1[j];
p_coordinates[offSet+j] = coords[j];
}
}
// 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);
// loop over boundary ips
for ( int ip = 0; ip < numScsBip; ++ip ) {
const int nearestNode = ipNodeMap[ip];
// offset for bip area vector and types of shape function
const int faceOffSet = ip*nDim;
const int offSetSF_face = ip*nodesPerFace;
// form unit normal
double asq = 0.0;
for ( int j = 0; j < nDim; ++j ) {
const double axj = areaVec[faceOffSet+j];
asq += axj*axj;
}
const double amag = std::sqrt(asq);
for ( int i = 0; i < nDim; ++i ) {
p_nx[i] = areaVec[faceOffSet+i]/amag;
}
// interpolate to bip
double viscBip = 0.0;
for ( int ic = 0; ic < nodesPerFace; ++ic ) {
const double r = p_face_shape_function[offSetSF_face+ic];
viscBip += r*p_viscosity[ic];
}
//================================
// diffusion second
//================================
for ( int ic = 0; ic < nodesPerElement; ++ic ) {
const int offSetDnDx = nDim*nodesPerElement*ip + ic*nDim;
for ( int j = 0; j < nDim; ++j ) {
const double axj = areaVec[faceOffSet+j];
const double dndxj = p_dndx[offSetDnDx+j];
const double uxj = p_velocityNp1[ic*nDim+j];
const double divUstress = 2.0/3.0*viscBip*dndxj*uxj*axj*includeDivU_;
for ( int i = 0; i < nDim; ++i ) {
// matrix entries
int indexR = nearestNode*nDim + i;
int rowR = indexR*nodesPerElement*nDim;
const double dndxi = p_dndx[offSetDnDx+i];
const double uxi = p_velocityNp1[ic*nDim+i];
const double nxi = p_nx[i];
const double nxinxi = nxi*nxi;
// -mu*dui/dxj*Aj*ni*ni; sneak in divU (explicit)
double lhsfac = - viscBip*dndxj*axj*nxinxi;
p_lhs[rowR+ic*nDim+i] += lhsfac;
p_rhs[indexR] -= lhsfac*uxi + divUstress*nxinxi;
// -mu*duj/dxi*Aj*ni*ni
lhsfac = - viscBip*dndxi*axj*nxinxi;
p_lhs[rowR+ic*nDim+j] += lhsfac;
p_rhs[indexR] -= lhsfac*uxj;
// now we need the +nx*ny*Fy + nx*nz*Fz part
for ( int l = 0; l < nDim; ++l ) {
if ( i != l ) {
const double nxinxl = nxi*p_nx[l];
const double uxl = p_velocityNp1[ic*nDim+l];
const double dndxl = p_dndx[offSetDnDx+l];
// -ni*nl*mu*dul/dxj*Aj; sneak in divU (explict)
lhsfac = -viscBip*dndxj*axj*nxinxl;
p_lhs[rowR+ic*nDim+l] += lhsfac;
p_rhs[indexR] -= lhsfac*uxl + divUstress*nxinxl;
// -ni*nl*mu*duj/dxl*Aj
lhsfac = -viscBip*dndxl*axj*nxinxl;
p_lhs[rowR+ic*nDim+j] += lhsfac;
p_rhs[indexR] -= lhsfac*uxj;
}
}
}
}
}
}
apply_coeff(connected_nodes, scratchIds, scratchVals, rhs, lhs, __FILE__);
}
}
}
//--------------------------------------------------------------------------
//-------- execute ---------------------------------------------------------
//--------------------------------------------------------------------------
void
AssembleScalarEdgeSolverAlgorithm::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; always edge connectivity
const int nodesPerEdge = 2;
const int lhsSize = nodesPerEdge*nodesPerEdge;
const int rhsSize = nodesPerEdge;
std::vector<double> lhs(lhsSize);
std::vector<double> rhs(rhsSize);
std::vector<stk::mesh::Entity> connected_nodes(2);
// area vector; gather into
std::vector<double> areaVec(nDim);
// pointer for fast access
double *p_lhs = &lhs[0];
double *p_rhs = &rhs[0];
double *p_areaVec = &areaVec[0];
// deal with state
ScalarFieldType &scalarQNp1 = scalarQ_->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_)
& !(realm_.get_inactive_selector());
stk::mesh::BucketVector const& edge_buckets =
realm_.get_buckets( stk::topology::EDGE_RANK, s_locally_owned_union );
for ( stk::mesh::BucketVector::const_iterator ib = edge_buckets.begin();
ib != edge_buckets.end() ; ++ib ) {
stk::mesh::Bucket & b = **ib ;
const stk::mesh::Bucket::size_type length = b.size();
// pointer to edge area vector and mdot
const double * av = stk::mesh::field_data(*edgeAreaVec_, b);
const double * mdot = stk::mesh::field_data(*massFlowRate_, b);
for ( stk::mesh::Bucket::size_type k = 0 ; k < length ; ++k ) {
// zeroing of lhs/rhs
for ( int i = 0; i < lhsSize; ++i ) {
p_lhs[i] = 0.0;
}
for ( int i = 0; i < rhsSize; ++i ) {
p_rhs[i] = 0.0;
}
// get edge
stk::mesh::Entity edge = b[k];
stk::mesh::Entity const * edge_node_rels = bulk_data.begin_nodes(edge);
// sanity check on number or nodes
ThrowAssert( bulk_data.num_nodes(edge) == 2 );
// pointer to edge area vector
for ( int j = 0; j < nDim; ++j )
p_areaVec[j] = av[k*nDim+j];
const double tmdot = mdot[k];
// left and right nodes
stk::mesh::Entity nodeL = edge_node_rels[0];
stk::mesh::Entity nodeR = edge_node_rels[1];
connected_nodes[0] = nodeL;
connected_nodes[1] = nodeR;
// extract nodal fields
const double * coordL = stk::mesh::field_data(*coordinates_, nodeL);
const double * coordR = stk::mesh::field_data(*coordinates_, nodeR);
const double * dqdxL = stk::mesh::field_data(*dqdx_, nodeL);
const double * dqdxR = stk::mesh::field_data(*dqdx_, nodeR);
const double * vrtmL = stk::mesh::field_data(*velocityRTM_, nodeL);
const double * vrtmR = stk::mesh::field_data(*velocityRTM_, nodeR);
const double qNp1L = *stk::mesh::field_data(scalarQNp1, nodeL);
const double qNp1R = *stk::mesh::field_data(scalarQNp1, nodeR);
const double densityL = *stk::mesh::field_data(densityNp1, nodeL);
const double densityR = *stk::mesh::field_data(densityNp1, nodeR);
const double diffFluxCoeffL = *stk::mesh::field_data(*diffFluxCoeff_, nodeL);
const double diffFluxCoeffR = *stk::mesh::field_data(*diffFluxCoeff_, nodeR);
// compute geometry
double axdx = 0.0;
double asq = 0.0;
double udotx = 0.0;
for ( int j = 0; j < nDim; ++j ) {
const double axj = p_areaVec[j];
const double dxj = coordR[j] - coordL[j];
asq += axj*axj;
axdx += axj*dxj;
udotx += 0.5*dxj*(vrtmL[j] + vrtmR[j]);
}
const double inv_axdx = 1.0/axdx;
// ip props
const double viscIp = 0.5*(diffFluxCoeffL + diffFluxCoeffR);
const double diffIp = 0.5*(diffFluxCoeffL/densityL + diffFluxCoeffR/densityR);
// Peclet factor
double pecfac = hybridFactor*udotx/(diffIp+small);
pecfac = pecfac*pecfac/(5.0 + pecfac*pecfac);
const double om_pecfac = 1.0-pecfac;
// left and right extrapolation; add in diffusion calc
double dqL = 0.0;
double dqR = 0.0;
double nonOrth = 0.0;
for ( int j = 0; j < nDim; ++j ) {
const double dxj = coordR[j] - coordL[j];
dqL += 0.5*dxj*dqdxL[j];
dqR += 0.5*dxj*dqdxR[j];
// now non-orth (over-relaxed procedure of Jasek)
const double axj = p_areaVec[j];
const double kxj = axj - asq*inv_axdx*dxj;
const double GjIp = 0.5*(dqdxL[j] + dqdxR[j]);
nonOrth += -viscIp*kxj*GjIp;
}
// add limiter if appropriate
double limitL = 1.0;
double limitR = 1.0;
const double dq = qNp1R - qNp1L;
if ( useLimiter ) {
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
const double qIpL = qNp1L + dqL*hoUpwind*limitL;
const double qIpR = qNp1R - dqR*hoUpwind*limitR;
//====================================
// diffusive flux
//====================================
double lhsfac = -viscIp*asq*inv_axdx;
double diffFlux = lhsfac*(qNp1R - qNp1L) + nonOrth;
// first left
p_lhs[0] = -lhsfac;
p_lhs[1] = +lhsfac;
p_rhs[0] = -diffFlux;
// now right
p_lhs[2] = +lhsfac;
p_lhs[3] = -lhsfac;
p_rhs[1] = diffFlux;
//====================================
// advective flux
//====================================
// 2nd order central
const double qIp = 0.5*( qNp1L + qNp1R );
// 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);
// upwind advection (includes 4th); left node
double alhsfac = 0.5*(tmdot+std::abs(tmdot))*pecfac*alphaUpw
+ 0.5*alpha*om_pecfac*tmdot;
p_lhs[0] += alhsfac;
p_lhs[2] -= alhsfac;
// upwind advection; right node
alhsfac = 0.5*(tmdot-std::abs(tmdot))*pecfac*alphaUpw
+ 0.5*alpha*om_pecfac*tmdot;
p_lhs[3] -= alhsfac;
p_lhs[1] += alhsfac;
// central; left; collect terms on alpha and alphaUpw
alhsfac = 0.5*tmdot*(pecfac*om_alphaUpw + om_pecfac*om_alpha);
p_lhs[0] += alhsfac;
p_lhs[1] += alhsfac;
// central; right; collect terms on alpha and alphaUpw
p_lhs[2] -= alhsfac;
p_lhs[3] -= alhsfac;
// total flux left
p_rhs[0] -= aflux;
// total flux right
p_rhs[1] += aflux;
apply_coeff(connected_nodes, rhs, lhs, __FILE__);
}
}
}
//--------------------------------------------------------------------------
//-------- execute ---------------------------------------------------------
//--------------------------------------------------------------------------
void
AssembleMomentumEdgeContactSolverAlgorithm::execute()
{
stk::mesh::MetaData & meta_data = realm_.meta_data();
stk::mesh::BulkData & bulk_data = realm_.bulk_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 = "velocity";
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+1)*nDim*(nodesPerElem+1)*nDim; (nodesPerElem+1)*nDim
std::vector<double> lhs;
std::vector<double> rhs;
std::vector<stk::mesh::Entity> connected_nodes;
// space for dui/dxj. This variable is the modifed gradient with NOC
std::vector<double> duidxj(nDim*nDim);
// extrapolated value from the L/R direction
std::vector<double> uIpL(nDim);
std::vector<double> uIpR(nDim);
// limiter values from the L/R direction, 0:1
std::vector<double> limitL(nDim,1.0);
std::vector<double> limitR(nDim,1.0);
// extrapolated gradient from L/R direction
std::vector<double> duL(nDim);
std::vector<double> duR(nDim);
// pointers for fast access
double *p_duidxj = &duidxj[0];
double *p_uIpL = &uIpL[0];
double *p_uIpR = &uIpR[0];
double *p_limitL = &limitL[0];
double *p_limitR = &limitR[0];
double *p_duL = &duL[0];
double *p_duR = &duR[0];
// space for interpolated right state (halo)
double densityR;
double viscosityR;
std::vector<double> uNp1R(nDim);
std::vector<double> dudxR(nDim*nDim);
// interpolate nodal values to point-in-elem
const int sizeOfScalarField = 1;
const int sizeOfVectorField = nDim;
const int sizeOfTensorField = nDim*nDim;
// deal with state
VectorFieldType &velocityNp1 = velocity_->field_of_state(stk::mesh::StateNP1);
ScalarFieldType &densityNp1 = density_->field_of_state(stk::mesh::StateNP1);
// mesh motion
std::vector<double> vrtmL(nDim);
std::vector<double> vrtmR(nDim);
double * p_vrtmL = &vrtmL[0];
double * p_vrtmR = &vrtmR[0];
// parallel communicate ghosted entities
if ( NULL != realm_.contactManager_->contactGhosting_ )
stk::mesh::communicate_field_data(*(realm_.contactManager_->contactGhosting_), ghostFieldVec_);
// iterate contactInfoVec_
std::vector<ContactInfo *>::iterator ii;
for( ii=realm_.contactManager_->contactInfoVec_.begin();
ii!=realm_.contactManager_->contactInfoVec_.end(); ++ii ) {
// get master element type for this contactInfo
MasterElement *meSCS = (*ii)->meSCS_;
const int nodesPerElement = meSCS->nodesPerElement_;
std::vector<double> elemNodalP(nodesPerElement);
std::vector<double> elemNodalUnp1(nDim*nodesPerElement);
std::vector<double> elemNodalVisc(nodesPerElement);
std::vector<double> elemNodalRho(nodesPerElement);
std::vector<double> elemNodalDudx(nDim*nDim*nodesPerElement);
std::vector<double> shpfc(nodesPerElement);
// resize some things; matrix related
const int npePlusOne = nodesPerElement+1;
const int lhsSize = npePlusOne*nDim*npePlusOne*nDim;
const int rhsSize = npePlusOne*nDim;
lhs.resize(lhsSize);
rhs.resize(rhsSize);
connected_nodes.resize(npePlusOne);
// pointer to lhs/rhs
double *p_lhs = &lhs[0];
double *p_rhs = &rhs[0];
// scaling for lhs
const double inv_nodesPerElement = 1.0/double(nodesPerElement);
// iterate halo face nodes
std::map<uint64_t, HaloInfo *>::iterator iterHalo;
for (iterHalo = (*ii)->haloInfoMap_.begin();
iterHalo != (*ii)->haloInfoMap_.end();
++iterHalo) {
// halo info object of interest
HaloInfo * infoObject = (*iterHalo).second;
// zeroing of lhs/rhs
for ( int k = 0; k < lhsSize; ++k ) {
p_lhs[k] = 0.0;
}
for ( int k = 0; k < rhsSize; ++k ) {
p_rhs[k] = 0.0;
}
// pointer to edge area vector and mdot
const double *p_areaVec = &infoObject->haloEdgeAreaVec_[0];
const double tmdot = *stk::mesh::field_data(*haloMdot_, infoObject->faceNode_);
// extract element mesh object and global id for face node
stk::mesh::Entity elem = infoObject->owningElement_;
stk::mesh::Entity const* elem_node_rels = bulk_data.begin_nodes(elem);
const int num_nodes = bulk_data.num_nodes(elem);
// now load the elemental values for future interpolation; fill in connected nodes
connected_nodes[0] = infoObject->faceNode_;
for ( int ni = 0; ni < num_nodes; ++ni ) {
stk::mesh::Entity node = elem_node_rels[ni];
connected_nodes[ni+1] = node;
elemNodalRho[ni] = *stk::mesh::field_data(densityNp1, node);
elemNodalVisc[ni] = *stk::mesh::field_data(*viscosity_, node);
// load up vectors/tensor
const double *uNp1 = stk::mesh::field_data(velocityNp1, node );
const double *dudx = stk::mesh::field_data(*dudx_, node );
for ( int i = 0; i < nDim; ++i ) {
const int offSet = i*nodesPerElement + ni;
elemNodalUnp1[offSet] = uNp1[i];
const int rowI = i*nDim;
const int offSetT = i*nodesPerElement*nDim;
for ( int j = 0; j < nDim; ++j ) {
elemNodalDudx[offSetT+j*nodesPerElement+ni] = dudx[rowI+j];
}
}
}
// extract nodal fields; right state is Halo and requires inperpolation
const double *coordL = stk::mesh::field_data(*coordinates_, infoObject->faceNode_);
const double *coordR = &infoObject->haloNodalCoords_[0];
const double *dudxL = stk::mesh::field_data(*dudx_, infoObject->faceNode_);
meSCS->interpolatePoint(
sizeOfTensorField,
&(infoObject->isoParCoords_[0]),
&elemNodalDudx[0],
&(dudxR[0]));
const double *uNp1L = stk::mesh::field_data(velocityNp1, infoObject->faceNode_);
meSCS->interpolatePoint(
sizeOfVectorField,
&(infoObject->isoParCoords_[0]),
&elemNodalUnp1[0],
&(uNp1R[0]));
const double densityL = *stk::mesh::field_data(densityNp1, infoObject->faceNode_);
meSCS->interpolatePoint(
sizeOfScalarField,
&(infoObject->isoParCoords_[0]),
&elemNodalRho[0],
&densityR);
const double viscosityL = *stk::mesh::field_data(*viscosity_, infoObject->faceNode_);
meSCS->interpolatePoint(
sizeOfScalarField,
&(infoObject->isoParCoords_[0]),
&elemNodalVisc[0],
&viscosityR);
// copy to velocity relative to mesh; squeeze in extrapolated values
for ( int i = 0; i < nDim; ++i ) {
p_vrtmL[i] = uNp1L[i];
p_vrtmR[i] = uNp1R[i];
// extrapolated du
p_duL[i] = 0.0;
p_duR[i] = 0.0;
const int offSet = nDim*i;
for ( int j = 0; j < nDim; ++j ) {
const double dxj = 0.5*(coordR[j] - coordL[j]);
p_duL[i] += dxj*dudxL[offSet+j];
p_duR[i] += dxj*dudxR[offSet+j];
}
}
// deal with mesh motion
if ( meshMotion_ ) {
const double * meshVelocityL = stk::mesh::field_data(*meshVelocity_, infoObject->faceNode_);
const double * meshVelocityR = &(infoObject->haloMeshVelocity_[0]);
for (int j = 0; j < nDim; ++j ) {
p_vrtmL[j] -= meshVelocityL[j];
p_vrtmR[j] -= meshVelocityR[j];
}
}
// compute geometry
double axdx = 0.0;
double asq = 0.0;
double udotx = 0.0;
for (int j = 0; j < nDim; ++j ) {
const double axj = p_areaVec[j];
const double dxj = coordR[j] - coordL[j];
axdx += axj*dxj;
asq += axj*axj;
udotx += 0.5*dxj*(p_vrtmL[j] + p_vrtmR[j]);
}
const double inv_axdx = 1.0/axdx;
// ip props
const double viscIp = 0.5*(viscosityL + viscosityR);
const double diffIp = 0.5*(viscosityL/densityL + viscosityR/densityR);
// Peclet factor
const double pecfac = pecletFunction_->execute(std::abs(udotx)/(diffIp+small));
const double om_pecfac = 1.0-pecfac;
// determine limiter if applicable
if ( useLimiter ) {
for ( int i = 0; i < nDim; ++i ) {
const double dq = uNp1R[i] - uNp1L[i];
const double dqMl = 2.0*2.0*p_duL[i] - dq;
const double dqMr = 2.0*2.0*p_duR[i] - dq;
p_limitL[i] = van_leer(dqMl, dq, small);
p_limitR[i] = van_leer(dqMr, dq, small);
}
}
// final upwind extrapolation; with limiter
for ( int i = 0; i < nDim; ++i ) {
p_uIpL[i] = uNp1L[i] + p_duL[i]*hoUpwind*p_limitL[i];
p_uIpR[i] = uNp1R[i] - p_duR[i]*hoUpwind*p_limitR[i];
}
/*
form duidxj with over-relaxed procedure of Jasak:
dui/dxj = GjUi +[(uiR - uiL) - GlUi*dxl]*Aj/AxDx
where Gp is the interpolated pth nodal gradient for ui
*/
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 = 0.5*(dudxL[offSetIL] + 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 = p_areaVec[j];
const double GjUi = 0.5*(dudxL[offSetIJ] + 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];
// lhs diffusion; only -mu*dui/dxj*Aj contribution for now
const double dlhsfac = -viscIp*asq*inv_axdx;
for ( int i = 0; i < nDim; ++i ) {
// 2nd order central
const double uiIp = 0.5*(uNp1R[i] + uNp1L[i]);
// upwind
const double uiUpwind = (tmdot > 0) ? alphaUpw*p_uIpL[i] + om_alphaUpw*uiIp
: alphaUpw*p_uIpR[i] + om_alphaUpw*uiIp;
// generalized central (2nd and 4th order)
const double uiHatL = alpha*p_uIpL[i] + om_alpha*uiIp;
const double uiHatR = alpha*p_uIpR[i] + om_alpha*uiIp;
const double uiCds = 0.5*(uiHatL + uiHatR);
// total advection; pressure contribution in time term expression
const double aflux = tmdot*(pecfac*uiUpwind + om_pecfac*uiCds);
// diffusive flux; viscous tensor doted with area vector
double dflux = 2.0/3.0*viscIp*divU*p_areaVec[i]*includeDivU_;
const int offSetI = nDim*i;
for ( int j = 0; j < nDim; ++j ) {
const int offSetTrans = nDim*j+i;
const double axj = p_areaVec[j];
dflux += -viscIp*(p_duidxj[offSetI+j] + p_duidxj[offSetTrans])*axj;
}
// residal for total flux
meSCS->general_shape_fcn(1, &(infoObject->isoParCoords_[0]), &shpfc[0]);
const double tflux = aflux + dflux;
const int indexL = i;
// setup for LHS; row left is easy
const int rowL = indexL * npePlusOne * nDim;
const int rLiL = rowL+indexL;
// total flux left
p_rhs[indexL] -= tflux;
// for ease of reading, scale left node by nodesPerElement
for ( int ni = 0; ni < num_nodes; ++ni ) {
const int indexR = i + nDim*(ni+1);
const int rLiR = rowL+indexR;
//==============================
// advection first
//==============================
// upwind advection (includes 4th); left node
double alhsfac = 0.5*(tmdot+std::abs(tmdot))*pecfac*alphaUpw
+ 0.5*alpha*om_pecfac*tmdot;
p_lhs[rLiL] += alhsfac*inv_nodesPerElement;
// upwind advection (incldues 4th); right node
alhsfac = 0.5*(tmdot-std::abs(tmdot))*pecfac*alphaUpw
+ 0.5*alpha*om_pecfac*tmdot;
p_lhs[rLiR] += alhsfac*shpfc[ni];
// central; left; collect terms on alpha and alphaUpw
alhsfac = 0.5*tmdot*(pecfac*om_alphaUpw + om_pecfac*om_alpha);
p_lhs[rLiL] += alhsfac*inv_nodesPerElement;
p_lhs[rLiR] += alhsfac*shpfc[ni];
// central; right n/a
//==============================
// diffusion second
//==============================
const double axi = p_areaVec[i];
//diffusion; row IL
p_lhs[rLiL] -= dlhsfac*inv_nodesPerElement;
p_lhs[rLiR] += dlhsfac*shpfc[ni];
// diffusion; row IR; n/a
// more diffusion; see theory manual
for ( int j = 0; j < nDim; ++j ) {
const double lhsfacNS = -viscIp*axi*p_areaVec[j]*inv_axdx;
const int colL = j;
const int colR = j + nDim*(ni+1);
// first left; IL,IL; IL,IR
p_lhs[rowL + colL] -= lhsfacNS*inv_nodesPerElement;
p_lhs[rowL + colR] += lhsfacNS*shpfc[ni];
// now right, IR,IL; IR,IR; n/a
}
}
}
// apply to linear system
apply_coeff(connected_nodes, rhs, lhs, __FILE__);
}
}
}
//--------------------------------------------------------------------------
//-------- execute ---------------------------------------------------------
//--------------------------------------------------------------------------
void
AssemblePNGBoundarySolverAlgorithm::execute()
{
stk::mesh::MetaData & meta_data = realm_.meta_data();
const int nDim = meta_data.spatial_dimension();
// space for LHS/RHS; nodesPerFace*nDim*nodesPerFace*nDim and nodesPerFace*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_scalarQ;
// master element
std::vector<double> ws_face_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& 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_;
const int numScsBip = meFC->numIntPoints_;
const int *faceIpNodeMap = meFC->ipNodeMap();
// resize some things; matrix related
const int lhsSize = nodesPerFace*nDim*nodesPerFace*nDim;
const int rhsSize = nodesPerFace*nDim;
lhs.resize(lhsSize);
rhs.resize(rhsSize);
scratchIds.resize(rhsSize);
scratchVals.resize(rhsSize);
connected_nodes.resize(nodesPerFace);
// algorithm related; element
ws_scalarQ.resize(nodesPerFace);
ws_face_shape_function.resize(numScsBip*nodesPerFace);
// pointers
double *p_lhs = &lhs[0];
double *p_rhs = &rhs[0];
double *p_scalarQ = &ws_scalarQ[0];
double *p_face_shape_function = &ws_face_shape_function[0];
// zero lhs; always zero
for ( int p = 0; p < lhsSize; ++p )
p_lhs[p] = 0.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 ) {
// zero rhs only since LHS never contributes, never touched
for ( int p = 0; p < rhsSize; ++p )
p_rhs[p] = 0.0;
//======================================
// gather nodal data off of face
//======================================
stk::mesh::Entity const * face_node_rels = b.begin_nodes(k);
int num_face_nodes = b.num_nodes(k);
// sanity check on num nodes
ThrowAssert( num_face_nodes == nodesPerFace );
for ( int ni = 0; ni < num_face_nodes; ++ni ) {
// get the node and form connected_node
stk::mesh::Entity node = face_node_rels[ni];
connected_nodes[ni] = node;
// gather scalars
p_scalarQ[ni] = *stk::mesh::field_data(*scalarQ_, node);
}
// pointer to face data
const double * areaVec = stk::mesh::field_data(*exposedAreaVec_, b, k);
// start the assembly
for ( int ip = 0; ip < numScsBip; ++ip ) {
// nearest node to ip
const int localFaceNode = faceIpNodeMap[ip];
// save off some offsets for this ip
const int nnNdim = localFaceNode*nDim;
const int offSetSF_face = ip*nodesPerFace;
// interpolate to bip
double scalarQBip = 0.0;
for ( int ic = 0; ic < nodesPerFace; ++ic ) {
const double r = p_face_shape_function[offSetSF_face+ic];
scalarQBip += r*p_scalarQ[ic];
}
// assemble to RHS; rhs -= a negative contribution => +=
for ( int i = 0; i < nDim; ++i ) {
p_rhs[nnNdim+i] += scalarQBip*areaVec[ip*nDim+i];
}
}
apply_coeff(connected_nodes, scratchIds, scratchVals, 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
AssembleRadTransEdgeUpwindSolverAlgorithm::execute()
{
stk::mesh::MetaData & meta_data = realm_.meta_data();
const int nDim = meta_data.spatial_dimension();
// 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();
// space for LHS/RHS; always nodesPerEdge*nodesPerEdge and nodesPerEdge
std::vector<double> lhs(4);
std::vector<double> rhs(2);
std::vector<int> scratchIds(2);
std::vector<double> scratchVals(2);
std::vector<stk::mesh::Entity> connected_nodes(2);
// area vector; gather into
std::vector<double> areaVec(nDim);
// pointers for fast access
double *p_lhs = &lhs[0];
double *p_rhs = &rhs[0];
double *p_areaVec = &areaVec[0];
// define some common selectors
stk::mesh::Selector s_locally_owned_union = meta_data.locally_owned_part()
&stk::mesh::selectUnion(partVec_);
stk::mesh::BucketVector const& edge_buckets =
realm_.get_buckets( stk::topology::EDGE_RANK, s_locally_owned_union );
for ( stk::mesh::BucketVector::const_iterator ib = edge_buckets.begin();
ib != edge_buckets.end() ; ++ib ) {
stk::mesh::Bucket & b = **ib ;
const size_t length = b.size();
// pointer to edge area vector
const double * av = stk::mesh::field_data(*edgeAreaVec_, b);
for ( size_t k = 0 ; k < length ; ++k ) {
// set ordinal for edge
unsigned edge_ordinal = k;
// sanity check on number or nodes
ThrowAssert( b.num_nodes(edge_ordinal) == 2 );
stk::mesh::Entity const * edge_node_rels = b.begin_nodes(edge_ordinal);
// pointer to edge area vector
for ( int j = 0; j < nDim; ++j )
p_areaVec[j] = av[k*nDim+j];
// left and right nodes
stk::mesh::Entity nodeL = edge_node_rels[0];
stk::mesh::Entity nodeR = edge_node_rels[1];
connected_nodes[0] = nodeL;
connected_nodes[1] = nodeR;
// extract nodal fields
const double intensityL = *stk::mesh::field_data(*intensity_, nodeL);
const double intensityR = *stk::mesh::field_data(*intensity_, nodeR);
// compute sj*njdS
double sjaj = 0.0;
for ( int j = 0; j < nDim; ++j ) {
sjaj += p_Sk[j]*p_areaVec[j];
}
// upwind; left node
double lhsfac = 0.5*(sjaj+std::abs(sjaj));
p_lhs[0] = +lhsfac;
p_lhs[2] = -lhsfac;
// upwind; right node
lhsfac = 0.5*(sjaj-std::abs(sjaj));
p_lhs[3] = -lhsfac;
p_lhs[1] = +lhsfac;
// residual
const double intensityIp = (sjaj > 0.0) ? intensityL : intensityR;
p_rhs[0] = -sjaj*intensityIp;
p_rhs[1] = +sjaj*intensityIp;
apply_coeff(connected_nodes, scratchIds, scratchVals, rhs, lhs, __FILE__);
}
}
}
//--------------------------------------------------------------------------
//-------- execute ---------------------------------------------------------
//--------------------------------------------------------------------------
void
AssembleOversetSolverConstraintAlgorithm::execute()
{
// first thing to do is to zero out the row (lhs and rhs)
prepare_constraints();
// extract the rank
const int theRank = NaluEnv::self().parallel_rank();
stk::mesh::BulkData & bulkData = realm_.bulk_data();
// space for LHS/RHS (nodesPerElem+1)*numDof*(nodesPerElem+1)*numDof; (nodesPerElem+1)*numDof
std::vector<double> lhs;
std::vector<double> rhs;
std::vector<int> scratchIds;
std::vector<double> scratchVals;
std::vector<stk::mesh::Entity> connected_nodes;
// master element data
std::vector <double > ws_general_shape_function;
// interpolate nodal values to point-in-elem
const int sizeOfDof = eqSystem_->linsys_->numDof();
// size interpolated value
std::vector<double> qNp1Orphan(sizeOfDof, 0.0);
// Parallel communication of ghosted entities has been already handled in
// EquationSystems::pre_iter_work
// iterate oversetInfoVec_
std::vector<OversetInfo *>::iterator ii;
for( ii=realm_.oversetManager_->oversetInfoVec_.begin();
ii!=realm_.oversetManager_->oversetInfoVec_.end(); ++ii ) {
// overset info object of interest
OversetInfo * infoObject = (*ii);
// extract element and node mesh object
stk::mesh::Entity owningElement = infoObject->owningElement_;
stk::mesh::Entity orphanNode = infoObject->orphanNode_;
// extract the owning rank for this node
const int nodeRank = bulkData.parallel_owner_rank(orphanNode);
// check to see if this node is locally owned by this rank; we only want to process locally owned nodes, not shared
if ( theRank != nodeRank )
continue;
// get master element type for this contactInfo
MasterElement *meSCS = infoObject->meSCS_;
const int nodesPerElement = meSCS->nodesPerElement_;
std::vector <double > elemNodalQ(nodesPerElement*sizeOfDof);
std::vector <double > shpfc(nodesPerElement);
// resize some things; matrix related
const int npePlusOne = nodesPerElement+1;
const int lhsSize = npePlusOne*sizeOfDof*npePlusOne*sizeOfDof;
const int rhsSize = npePlusOne*sizeOfDof;
lhs.resize(lhsSize);
rhs.resize(rhsSize);
scratchIds.resize(rhsSize);
scratchVals.resize(rhsSize);
connected_nodes.resize(npePlusOne);
// algorithm related; element
ws_general_shape_function.resize(nodesPerElement);
// pointer to lhs/rhs
double *p_lhs = &lhs[0];
double *p_rhs = &rhs[0];
// zeroing of lhs/rhs
for ( int k = 0; k < lhsSize; ++k ) {
p_lhs[k] = 0.0;
}
for ( int k = 0; k < rhsSize; ++k ) {
p_rhs[k] = 0.0;
}
// extract nodal value for scalarQ
const double *qNp1Nodal = (double *)stk::mesh::field_data(*fieldQ_, orphanNode);
stk::mesh::Entity const* elem_node_rels = bulkData.begin_nodes(owningElement);
const int num_nodes = bulkData.num_nodes(owningElement);
// now load the elemental values for future interpolation; fill in connected nodes; first connected node is orhpan
connected_nodes[0] = orphanNode;
for ( int ni = 0; ni < num_nodes; ++ni ) {
stk::mesh::Entity node = elem_node_rels[ni];
connected_nodes[ni+1] = node;
const double *qNp1 = (double *)stk::mesh::field_data(*fieldQ_, node );
for ( int i = 0; i < sizeOfDof; ++i ) {
elemNodalQ[i*nodesPerElement + ni] = qNp1[i];
}
}
// interpolate dof to elemental ips (assigns qNp1)
meSCS->interpolatePoint(
sizeOfDof,
&(infoObject->isoParCoords_[0]),
&elemNodalQ[0],
&qNp1Orphan[0]);
// lhs; extract general shape function
meSCS->general_shape_fcn(1, &(infoObject->isoParCoords_[0]), &ws_general_shape_function[0]);
// rhs; orphan node is defined to be the zeroth connected node
for ( int i = 0; i < sizeOfDof; ++i) {
const int rowOi = i * npePlusOne * sizeOfDof;
const double residual = qNp1Nodal[i] - qNp1Orphan[i];
p_rhs[i] = -residual;
// row is zero by design (first connected node is the orphan node); assign it fully
p_lhs[rowOi+i] += 1.0;
for ( int ic = 0; ic < nodesPerElement; ++ic ) {
const int indexR = i + sizeOfDof*(ic+1);
const int rOiR = rowOi+indexR;
p_lhs[rOiR] -= ws_general_shape_function[ic];
}
}
// apply to linear system
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
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
AssembleScalarElemDiffSolverAlgorithm::execute()
{
stk::mesh::BulkData & bulk_data = realm_.bulk_data();
stk::mesh::MetaData & meta_data = realm_.meta_data();
const int nDim = meta_data.spatial_dimension();
// space for LHS/RHS; nodesPerElem*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();
// deal with state
ScalarFieldType &scalarQNp1 = scalarQ_->field_of_state(stk::mesh::StateNP1);
ScalarElemDiffusionFunctor * diffusionOperator;
if (useCollocation_){
diffusionOperator = new CollocationScalarElemDiffusionFunctor(bulk_data, meta_data,
scalarQNp1, *diffFluxCoeff_, *coordinates_, nDim);
}
else{
diffusionOperator = new CVFEMScalarElemDiffusionFunctor(bulk_data, meta_data,
scalarQNp1, *diffFluxCoeff_, *coordinates_, 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());
MasterElement *meSCV = realm_.get_volume_master_element(b.topology());
// extract master element specifics
const int nodesPerElement = meSCS->nodesPerElement_;
// resize some things; matrix related
const int lhsSize = nodesPerElement*nodesPerElement;
const int rhsSize = nodesPerElement;
lhs.resize(lhsSize);
rhs.resize(rhsSize);
connected_nodes.resize(nodesPerElement);
// pointer to lhs/rhs
double *p_lhs = &lhs[0];
double *p_rhs = &rhs[0];
diffusionOperator->bind_data(b, *meSCS, p_lhs, p_rhs, connected_nodes);
for ( size_t k = 0 ; k < length ; ++k ) {
//WARNING: do not thread this functor. It is not thread-safe because each element scatters to all of its nodes.
(*diffusionOperator)(k);
// get elem
stk::mesh::Entity elem = b[k];
// 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__);
}
diffusionOperator->release_data();
}
delete diffusionOperator;
}
//--------------------------------------------------------------------------
//-------- 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
AssembleContinuityNonConformalSolverAlgorithm::execute()
{
stk::mesh::BulkData & bulk_data = realm_.bulk_data();
stk::mesh::MetaData & meta_data = realm_.meta_data();
const int nDim = meta_data.spatial_dimension();
// continuity equation scales by projection time scale
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<int> scratchIds;
std::vector<double> scratchVals;
std::vector<stk::mesh::Entity> connected_nodes;
// ip values; both boundary and opposing surface
std::vector<double> currentIsoParCoords(nDim);
std::vector<double> opposingIsoParCoords(nDim);
std::vector<double> cNx(nDim);
std::vector<double> oNx(nDim);
std::vector<double> currentVelocityBip(nDim);
std::vector<double> opposingVelocityBip(nDim);
std::vector<double> currentRhoVelocityBip(nDim);
std::vector<double> opposingRhoVelocityBip(nDim);
std::vector<double> currentMeshVelocityBip(nDim);
std::vector<double> currentRhoMeshVelocityBip(nDim);
// pressure stabilization
std::vector<double> currentGjpBip(nDim);
std::vector<double> opposingGjpBip(nDim);
std::vector<double> currentDpdxBip(nDim);
std::vector<double> opposingDpdxBip(nDim);
// mapping for -1:1 -> -0.5:0.5 volume element
std::vector<double> currentElementIsoParCoords(nDim);
std::vector<double> opposingElementIsoParCoords(nDim);
// interpolate nodal values to point-in-elem
const int sizeOfScalarField = 1;
const int sizeOfVectorField = nDim;
// pointers to fixed values
double *p_cNx = &cNx[0];
double *p_oNx = &oNx[0];
// nodal fields to gather; face
std::vector<double> ws_c_pressure;
std::vector<double> ws_o_pressure;
std::vector<double> ws_c_Gjp;
std::vector<double> ws_o_Gjp;
std::vector<double> ws_c_velocity;
std::vector<double> ws_o_velocity;
std::vector<double> ws_c_meshVelocity; // only require current
std::vector<double> ws_c_density;
std::vector<double> ws_o_density;
std::vector<double> ws_o_coordinates; // only require opposing
// element
std::vector<double> ws_c_elem_pressure;
std::vector<double> ws_o_elem_pressure;
std::vector<double> ws_c_elem_coordinates;
std::vector<double> ws_o_elem_coordinates;
// master element data
std::vector<double> ws_c_dndx;
std::vector<double> ws_o_dndx;
std::vector<double> ws_c_det_j;
std::vector<double> ws_o_det_j;
std::vector <double > ws_c_general_shape_function;
std::vector <double > ws_o_general_shape_function;
// deal with state
ScalarFieldType &pressureNp1 = pressure_->field_of_state(stk::mesh::StateNP1);
// parallel communicate ghosted entities
if ( NULL != realm_.nonConformalManager_->nonConformalGhosting_ )
stk::mesh::communicate_field_data(*(realm_.nonConformalManager_->nonConformalGhosting_), ghostFieldVec_);
// iterate nonConformalManager's dgInfoVec
std::vector<NonConformalInfo *>::iterator ii;
for( ii=realm_.nonConformalManager_->nonConformalInfoVec_.begin();
ii!=realm_.nonConformalManager_->nonConformalInfoVec_.end(); ++ii ) {
// extract vector of DgInfo
std::vector<std::vector<DgInfo *> > &dgInfoVec = (*ii)->dgInfoVec_;
std::vector<std::vector<DgInfo*> >::iterator idg;
for( idg=dgInfoVec.begin(); idg!=dgInfoVec.end(); ++idg ) {
std::vector<DgInfo *> &faceDgInfoVec = (*idg);
// now loop over all the DgInfo objects on this particular exposed face
for ( size_t k = 0; k < faceDgInfoVec.size(); ++k ) {
DgInfo *dgInfo = faceDgInfoVec[k];
// extract current/opposing face/element
stk::mesh::Entity currentFace = dgInfo->currentFace_;
stk::mesh::Entity opposingFace = dgInfo->opposingFace_;
stk::mesh::Entity currentElement = dgInfo->currentElement_;
stk::mesh::Entity opposingElement = dgInfo->opposingElement_;
const int currentFaceOrdinal = dgInfo->currentFaceOrdinal_;
const int opposingFaceOrdinal = dgInfo->opposingFaceOrdinal_;
// master element; face and volume
MasterElement * meFCCurrent = dgInfo->meFCCurrent_;
MasterElement * meFCOpposing = dgInfo->meFCOpposing_;
MasterElement * meSCSCurrent = dgInfo->meSCSCurrent_;
MasterElement * meSCSOpposing = dgInfo->meSCSOpposing_;
// local ip, ordinals, etc
const int currentGaussPointId = dgInfo->currentGaussPointId_;
currentIsoParCoords = dgInfo->currentIsoParCoords_;
opposingIsoParCoords = dgInfo->opposingIsoParCoords_;
// mapping from ip to nodes for this ordinal
const int *ipNodeMap = meSCSCurrent->ipNodeMap(currentFaceOrdinal);
// extract some master element info
const int currentNodesPerFace = meFCCurrent->nodesPerElement_;
const int opposingNodesPerFace = meFCOpposing->nodesPerElement_;
const int currentNodesPerElement = meSCSCurrent->nodesPerElement_;
const int opposingNodesPerElement = meSCSOpposing->nodesPerElement_;
// resize some things; matrix related
const int totalNodes = currentNodesPerElement + opposingNodesPerElement;
const int lhsSize = totalNodes*totalNodes;
const int rhsSize = totalNodes;
lhs.resize(lhsSize);
rhs.resize(rhsSize);
scratchIds.resize(rhsSize);
scratchVals.resize(rhsSize);
connected_nodes.resize(totalNodes);
// algorithm related; face
ws_c_pressure.resize(currentNodesPerFace);
ws_o_pressure.resize(opposingNodesPerFace);
ws_c_Gjp.resize(currentNodesPerFace*nDim);
ws_o_Gjp.resize(opposingNodesPerFace*nDim);
ws_c_velocity.resize(currentNodesPerFace*nDim);
ws_o_velocity.resize(opposingNodesPerFace*nDim);
ws_c_meshVelocity.resize(currentNodesPerFace*nDim);
ws_c_density.resize(currentNodesPerFace);
ws_o_density.resize(opposingNodesPerFace);
ws_o_coordinates.resize(opposingNodesPerFace*nDim);
ws_c_general_shape_function.resize(currentNodesPerFace);
ws_o_general_shape_function.resize(opposingNodesPerFace);
// algorithm related; element; dndx will be at a single gauss point
ws_c_elem_pressure.resize(currentNodesPerElement);
ws_o_elem_pressure.resize(opposingNodesPerElement);
ws_c_elem_coordinates.resize(currentNodesPerElement*nDim);
ws_o_elem_coordinates.resize(opposingNodesPerElement*nDim);
ws_c_dndx.resize(nDim*currentNodesPerElement);
ws_o_dndx.resize(nDim*opposingNodesPerElement);
ws_c_det_j.resize(1);
ws_o_det_j.resize(1);
// pointers
double *p_lhs = &lhs[0];
double *p_rhs = &rhs[0];
// face
double *p_c_pressure = &ws_c_pressure[0];
double *p_o_pressure = &ws_o_pressure[0];
double *p_c_Gjp = &ws_c_Gjp[0];
double *p_o_Gjp = &ws_o_Gjp[0];
double *p_c_velocity = &ws_c_velocity[0];
double *p_o_velocity= &ws_o_velocity[0];
double *p_c_meshVelocity = &ws_c_meshVelocity[0];
double *p_c_density = &ws_c_density[0];
double *p_o_density = &ws_o_density[0];
double *p_o_coordinates = &ws_o_coordinates[0];
// element
double *p_c_elem_pressure = &ws_c_elem_pressure[0];
double *p_o_elem_pressure = &ws_o_elem_pressure[0];
double *p_c_elem_coordinates = &ws_c_elem_coordinates[0];
double *p_o_elem_coordinates = &ws_o_elem_coordinates[0];
// me pointers
double *p_c_general_shape_function = &ws_c_general_shape_function[0];
double *p_o_general_shape_function = &ws_o_general_shape_function[0];
double *p_c_dndx = &ws_c_dndx[0];
double *p_o_dndx = &ws_o_dndx[0];
// populate current face_node_ordinals
const int *c_face_node_ordinals = meSCSCurrent->side_node_ordinals(currentFaceOrdinal);
// gather current face data
stk::mesh::Entity const* current_face_node_rels = bulk_data.begin_nodes(currentFace);
const int current_num_face_nodes = bulk_data.num_nodes(currentFace);
for ( int ni = 0; ni < current_num_face_nodes; ++ni ) {
stk::mesh::Entity node = current_face_node_rels[ni];
// gather; scalar
p_c_pressure[ni] = *stk::mesh::field_data(pressureNp1, node);
p_c_density[ni] = *stk::mesh::field_data(*density_, node);
// gather; vector
const double *velocity = stk::mesh::field_data(*velocity_, node );
const double *meshVelocity = stk::mesh::field_data(*meshVelocity_, node );
const double *Gjp = stk::mesh::field_data(*Gjp_, node );
for ( int i = 0; i < nDim; ++i ) {
const int offSet = i*current_num_face_nodes + ni;
p_c_velocity[offSet] = velocity[i];
p_c_meshVelocity[offSet] = meshVelocity[i];
p_c_Gjp[offSet] = Gjp[i];
}
}
// populate opposing face_node_ordinals
const int *o_face_node_ordinals = meSCSOpposing->side_node_ordinals(opposingFaceOrdinal);
// gather opposing face data
stk::mesh::Entity const* opposing_face_node_rels = bulk_data.begin_nodes(opposingFace);
const int opposing_num_face_nodes = bulk_data.num_nodes(opposingFace);
for ( int ni = 0; ni < opposing_num_face_nodes; ++ni ) {
stk::mesh::Entity node = opposing_face_node_rels[ni];
// gather; scalar
p_o_pressure[ni] = *stk::mesh::field_data(pressureNp1, node);
p_o_density[ni] = *stk::mesh::field_data(*density_, node);
// gather; vector
const double *velocity = stk::mesh::field_data(*velocity_, node );
const double *Gjp = stk::mesh::field_data(*Gjp_, node );
const double *coords = stk::mesh::field_data(*coordinates_, node);
for ( int i = 0; i < nDim; ++i ) {
const int offSet = i*opposing_num_face_nodes + ni;
p_o_velocity[offSet] = velocity[i];
p_o_Gjp[offSet] = Gjp[i];
p_o_coordinates[ni*nDim+i] = coords[i];
}
}
// gather current element data
stk::mesh::Entity const* current_elem_node_rels = bulk_data.begin_nodes(currentElement);
const int current_num_elem_nodes = bulk_data.num_nodes(currentElement);
for ( int ni = 0; ni < current_num_elem_nodes; ++ni ) {
stk::mesh::Entity node = current_elem_node_rels[ni];
// set connected nodes
connected_nodes[ni] = node;
// gather; scalar
p_c_elem_pressure[ni] = *stk::mesh::field_data(pressureNp1, node);
// gather; vector
const double *coords = stk::mesh::field_data(*coordinates_, node);
const int niNdim = ni*nDim;
for ( int i = 0; i < nDim; ++i ) {
p_c_elem_coordinates[niNdim+i] = coords[i];
}
}
// gather opposing element data; sneak in second connected nodes
stk::mesh::Entity const* opposing_elem_node_rels = bulk_data.begin_nodes(opposingElement);
const int opposing_num_elem_nodes = bulk_data.num_nodes(opposingElement);
for ( int ni = 0; ni < opposing_num_elem_nodes; ++ni ) {
stk::mesh::Entity node = opposing_elem_node_rels[ni];
// set connected nodes
connected_nodes[ni+current_num_elem_nodes] = node;
// gather; scalar
p_o_elem_pressure[ni] = *stk::mesh::field_data(pressureNp1, node);
// gather; vector
const double *coords = stk::mesh::field_data(*coordinates_, node);
const int niNdim = ni*nDim;
for ( int i = 0; i < nDim; ++i ) {
p_o_elem_coordinates[niNdim+i] = coords[i];
}
}
// compute opposing normal through master element call, not using oppoing exposed area
meFCOpposing->general_normal(&opposingIsoParCoords[0], &p_o_coordinates[0], &p_oNx[0]);
// pointer to face data
const double * c_areaVec = stk::mesh::field_data(*exposedAreaVec_, currentFace);
double c_amag = 0.0;
for ( int j = 0; j < nDim; ++j ) {
const double c_axj = c_areaVec[currentGaussPointId*nDim+j];
c_amag += c_axj*c_axj;
}
c_amag = std::sqrt(c_amag);
// now compute normal
for ( int i = 0; i < nDim; ++i ) {
p_cNx[i] = c_areaVec[currentGaussPointId*nDim+i]/c_amag;
}
// override opposing normal
if ( useCurrentNormal_ ) {
for ( int i = 0; i < nDim; ++i )
p_oNx[i] = -p_cNx[i];
}
// project from side to element; method deals with the -1:1 isInElement range to the proper underlying CVFEM range
meSCSCurrent->sidePcoords_to_elemPcoords(currentFaceOrdinal, 1, ¤tIsoParCoords[0], ¤tElementIsoParCoords[0]);
meSCSOpposing->sidePcoords_to_elemPcoords(opposingFaceOrdinal, 1, &opposingIsoParCoords[0], &opposingElementIsoParCoords[0]);
// compute dndx
double scs_error = 0.0;
meSCSCurrent->general_face_grad_op(currentFaceOrdinal, ¤tElementIsoParCoords[0],
&p_c_elem_coordinates[0], &p_c_dndx[0], &ws_c_det_j[0], &scs_error);
meSCSOpposing->general_face_grad_op(opposingFaceOrdinal, &opposingElementIsoParCoords[0],
&p_o_elem_coordinates[0], &p_o_dndx[0], &ws_o_det_j[0], &scs_error);
// current inverse length scale; can loop over face nodes to avoid "nodesOnFace" array
double currentInverseLength = 0.0;
for ( int ic = 0; ic < current_num_face_nodes; ++ic ) {
const int faceNodeNumber = c_face_node_ordinals[ic];
const int offSetDnDx = faceNodeNumber*nDim; // single intg. point
for ( int j = 0; j < nDim; ++j ) {
const double nxj = p_cNx[j];
const double dndxj = p_c_dndx[offSetDnDx+j];
currentInverseLength += dndxj*nxj;
}
}
// opposing inverse length scale; can loop over face nodes to avoid "nodesOnFace" array
double opposingInverseLength = 0.0;
for ( int ic = 0; ic < opposing_num_face_nodes; ++ic ) {
const int faceNodeNumber = o_face_node_ordinals[ic];
const int offSetDnDx = faceNodeNumber*nDim; // single intg. point
for ( int j = 0; j < nDim; ++j ) {
const double nxj = p_oNx[j];
const double dndxj = p_o_dndx[offSetDnDx+j];
opposingInverseLength += dndxj*nxj;
}
}
// projected nodal gradient; zero out
for ( int j = 0; j < nDim; ++j ) {
currentDpdxBip[j] = 0.0;
opposingDpdxBip[j] = 0.0;
}
// current pressure gradient
for ( int ic = 0; ic < currentNodesPerElement; ++ic ) {
const int offSetDnDx = ic*nDim; // single intg. point
const double pNp1 = p_c_elem_pressure[ic];
for ( int j = 0; j < nDim; ++j ) {
const double dndxj = p_c_dndx[offSetDnDx+j];
currentDpdxBip[j] += dndxj*pNp1;
}
}
// opposing pressure gradient
for ( int ic = 0; ic < opposingNodesPerElement; ++ic ) {
const int offSetDnDx = ic*nDim; // single intg. point
const double pNp1 = p_o_elem_pressure[ic];
for ( int j = 0; j < nDim; ++j ) {
const double dndxj = p_o_dndx[offSetDnDx+j];
opposingDpdxBip[j] += dndxj*pNp1;
}
}
// interpolate to boundary ips
double currentPressureBip = 0.0;
meFCCurrent->interpolatePoint(
sizeOfScalarField,
&(dgInfo->currentIsoParCoords_[0]),
&ws_c_pressure[0],
¤tPressureBip);
double opposingPressureBip = 0.0;
meFCOpposing->interpolatePoint(
sizeOfScalarField,
&(dgInfo->opposingIsoParCoords_[0]),
&ws_o_pressure[0],
&opposingPressureBip);
// velocity
meFCCurrent->interpolatePoint(
sizeOfVectorField,
&(dgInfo->currentIsoParCoords_[0]),
&ws_c_velocity[0],
¤tVelocityBip[0]);
meFCOpposing->interpolatePoint(
sizeOfVectorField,
&(dgInfo->opposingIsoParCoords_[0]),
&ws_o_velocity[0],
&opposingVelocityBip[0]);
// mesh velocity; only required at current
meFCCurrent->interpolatePoint(
sizeOfVectorField,
&(dgInfo->currentIsoParCoords_[0]),
&ws_c_meshVelocity[0],
¤tMeshVelocityBip[0]);
// projected nodal gradient
meFCCurrent->interpolatePoint(
sizeOfVectorField,
&(dgInfo->currentIsoParCoords_[0]),
&ws_c_Gjp[0],
¤tGjpBip[0]);
meFCOpposing->interpolatePoint(
sizeOfVectorField,
&(dgInfo->opposingIsoParCoords_[0]),
&ws_o_Gjp[0],
&opposingGjpBip[0]);
// density
double currentDensityBip = 0.0;
meFCCurrent->interpolatePoint(
sizeOfScalarField,
&(dgInfo->currentIsoParCoords_[0]),
&ws_c_density[0],
¤tDensityBip);
double opposingDensityBip = 0.0;
meFCOpposing->interpolatePoint(
sizeOfScalarField,
&(dgInfo->opposingIsoParCoords_[0]),
&ws_o_density[0],
&opposingDensityBip);
// product of density and velocity; current (take over previous nodal value for velocity)
for ( int ni = 0; ni < current_num_face_nodes; ++ni ) {
const double density = p_c_density[ni];
for ( int i = 0; i < nDim; ++i ) {
const int offSet = i*current_num_face_nodes + ni;
p_c_velocity[offSet] *= density;
p_c_meshVelocity[offSet] *= density;
}
}
// opposite
for ( int ni = 0; ni < opposing_num_face_nodes; ++ni ) {
const double density = p_o_density[ni];
for ( int i = 0; i < nDim; ++i ) {
const int offSet = i*opposing_num_face_nodes + ni;
p_o_velocity[offSet] *= density;
}
}
// interpolate velocity with density scaling
meFCCurrent->interpolatePoint(
sizeOfVectorField,
&(dgInfo->currentIsoParCoords_[0]),
&ws_c_velocity[0],
¤tRhoVelocityBip[0]);
meFCOpposing->interpolatePoint(
sizeOfVectorField,
&(dgInfo->opposingIsoParCoords_[0]),
&ws_o_velocity[0],
&opposingRhoVelocityBip[0]);
// interpolate mesh velocity with density scaling; only current
meFCCurrent->interpolatePoint(
sizeOfVectorField,
&(dgInfo->currentIsoParCoords_[0]),
&ws_c_meshVelocity[0],
¤tRhoMeshVelocityBip[0]);
// 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;
const double penaltyIp = projTimeScale*0.5*(currentInverseLength + opposingInverseLength);
double ncFlux = 0.0;
double ncPstabFlux = 0.0;
for ( int j = 0; j < nDim; ++j ) {
const double cRhoVelocity = interpTogether*currentRhoVelocityBip[j] + om_interpTogether*currentDensityBip*currentVelocityBip[j];
const double oRhoVelocity = interpTogether*opposingRhoVelocityBip[j] + om_interpTogether*opposingDensityBip*opposingVelocityBip[j];
const double cRhoMeshVelocity = interpTogether*currentRhoMeshVelocityBip[j] + om_interpTogether*currentDensityBip*currentMeshVelocityBip[j];
ncFlux += 0.5*(cRhoVelocity*p_cNx[j] - oRhoVelocity*p_oNx[j]) - meshMotionFac_*cRhoMeshVelocity*p_cNx[j];
const double cPstab = currentDpdxBip[j] - currentGjpBip[j];
const double oPstab = opposingDpdxBip[j] - opposingGjpBip[j];
ncPstabFlux += 0.5*(cPstab*p_cNx[j] - oPstab*p_oNx[j]);
}
const double mdot = (ncFlux - includePstab_*projTimeScale*ncPstabFlux + penaltyIp*(currentPressureBip - opposingPressureBip))*c_amag;
// form residual
const int nn = ipNodeMap[currentGaussPointId];
p_rhs[nn] -= mdot/projTimeScale;
// set-up row for matrix
const int rowR = nn*totalNodes;
double lhsFac = penaltyIp*c_amag/projTimeScale;
// sensitivities; current face (penalty); use general shape function for this single ip
meFCCurrent->general_shape_fcn(1, ¤tIsoParCoords[0], &ws_c_general_shape_function[0]);
for ( int ic = 0; ic < currentNodesPerFace; ++ic ) {
const int icnn = c_face_node_ordinals[ic];
const double r = p_c_general_shape_function[ic];
p_lhs[rowR+icnn] += r*lhsFac;
}
// sensitivities; current element (diffusion)
for ( int ic = 0; ic < currentNodesPerElement; ++ic ) {
const int offSetDnDx = ic*nDim; // single intg. point
double lhscd = 0.0;
for ( int j = 0; j < nDim; ++j ) {
const double nxj = p_cNx[j];
const double dndxj = p_c_dndx[offSetDnDx+j];
lhscd -= dndxj*nxj;
}
p_lhs[rowR+ic] += 0.5*lhscd*c_amag*includePstab_;
}
// sensitivities; opposing face (penalty); use general shape function for this single ip
meFCOpposing->general_shape_fcn(1, &opposingIsoParCoords[0], &ws_o_general_shape_function[0]);
for ( int ic = 0; ic < opposingNodesPerFace; ++ic ) {
const int icnn = o_face_node_ordinals[ic];
const double r = p_o_general_shape_function[ic];
p_lhs[rowR+icnn+currentNodesPerElement] -= r*lhsFac;
}
// sensitivities; opposing element (diffusion)
for ( int ic = 0; ic < opposingNodesPerElement; ++ic ) {
const int offSetDnDx = ic*nDim; // single intg. point
double lhscd = 0.0;
for ( int j = 0; j < nDim; ++j ) {
const double nxj = p_oNx[j];
const double dndxj = p_o_dndx[offSetDnDx+j];
lhscd -= dndxj*nxj;
}
p_lhs[rowR+ic+currentNodesPerElement] -= 0.5*lhscd*c_amag*includePstab_;
}
apply_coeff(connected_nodes, scratchIds, scratchVals, rhs, lhs, __FILE__);
}
}
}
}
//--------------------------------------------------------------------------
//-------- 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
AssembleScalarNonConformalSolverAlgorithm::execute()
{
stk::mesh::BulkData & bulk_data = realm_.bulk_data();
stk::mesh::MetaData & meta_data = realm_.meta_data();
const int nDim = meta_data.spatial_dimension();
// current flux sensitivity is based on Robin
const double robinCurrentFluxFac = robinStyle_ ? 0.0 : 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;
// ip values; both boundary and opposing surface
std::vector<double> currentIsoParCoords(nDim);
std::vector<double> opposingIsoParCoords(nDim);
std::vector<double> cNx(nDim);
std::vector<double> oNx(nDim);
// mapping for -1:1 -> -0.5:0.5 volume element
std::vector<double> currentElementIsoParCoords(nDim);
std::vector<double> opposingElementIsoParCoords(nDim);
// interpolate nodal values to point-in-elem
const int sizeOfScalarField = 1;
// pointers to fixed values
double *p_cNx = &cNx[0];
double *p_oNx = &oNx[0];
// nodal fields to gather
std::vector<double> ws_c_face_scalarQ;
std::vector<double> ws_o_face_scalarQ;
std::vector<double> ws_c_elem_scalarQ;
std::vector<double> ws_o_elem_scalarQ;
std::vector<double> ws_c_elem_coordinates;
std::vector<double> ws_o_elem_coordinates;
std::vector<double> ws_c_diffFluxCoeff;
std::vector<double> ws_o_diffFluxCoeff;
// master element data
std::vector<double> ws_c_dndx;
std::vector<double> ws_o_dndx;
std::vector<double> ws_c_det_j;
std::vector<double> ws_o_det_j;
std::vector <double > ws_c_general_shape_function;
std::vector <double > ws_o_general_shape_function;
std::vector<int> ws_c_face_node_ordinals;
std::vector<int> ws_o_face_node_ordinals;
// deal with state
ScalarFieldType &scalarQNp1 = scalarQ_->field_of_state(stk::mesh::StateNP1);
// parallel communicate ghosted entities
if ( NULL != realm_.nonConformalManager_->nonConformalGhosting_ )
stk::mesh::communicate_field_data(*(realm_.nonConformalManager_->nonConformalGhosting_), ghostFieldVec_);
// iterate nonConformalManager's dgInfoVec
std::vector<NonConformalInfo *>::iterator ii;
for( ii=realm_.nonConformalManager_->nonConformalInfoVec_.begin();
ii!=realm_.nonConformalManager_->nonConformalInfoVec_.end(); ++ii ) {
// extract vector of DgInfo
std::vector<std::vector<DgInfo *> > &dgInfoVec = (*ii)->dgInfoVec_;
std::vector<std::vector<DgInfo*> >::iterator idg;
for( idg=dgInfoVec.begin(); idg!=dgInfoVec.end(); ++idg ) {
std::vector<DgInfo *> &faceDgInfoVec = (*idg);
// now loop over all the DgInfo objects on this particular exposed face
for ( size_t k = 0; k < faceDgInfoVec.size(); ++k ) {
DgInfo *dgInfo = faceDgInfoVec[k];
// extract current/opposing face/element
stk::mesh::Entity currentFace = dgInfo->currentFace_;
stk::mesh::Entity opposingFace = dgInfo->opposingFace_;
stk::mesh::Entity currentElement = dgInfo->currentElement_;
stk::mesh::Entity opposingElement = dgInfo->opposingElement_;
stk::topology currentElementTopo = dgInfo->currentElementTopo_;
stk::topology opposingElementTopo = dgInfo->opposingElementTopo_;
const int currentFaceOrdinal = dgInfo->currentFaceOrdinal_;
const int opposingFaceOrdinal = dgInfo->opposingFaceOrdinal_;
// master element; face and volume
MasterElement * meFCCurrent = dgInfo->meFCCurrent_;
MasterElement * meFCOpposing = dgInfo->meFCOpposing_;
MasterElement * meSCSCurrent = dgInfo->meSCSCurrent_;
MasterElement * meSCSOpposing = dgInfo->meSCSOpposing_;
// local ip, ordinals, etc
const int currentGaussPointId = dgInfo->currentGaussPointId_;
currentIsoParCoords = dgInfo->currentIsoParCoords_;
opposingIsoParCoords = dgInfo->opposingIsoParCoords_;
// extract some master element info
const int currentNodesPerFace = meFCCurrent->nodesPerElement_;
const int opposingNodesPerFace = meFCOpposing->nodesPerElement_;
const int currentNodesPerElement = meSCSCurrent->nodesPerElement_;
const int opposingNodesPerElement = meSCSOpposing->nodesPerElement_;
// resize some things; matrix related
const int totalNodes = currentNodesPerElement + opposingNodesPerElement;
const int lhsSize = totalNodes*totalNodes;
const int rhsSize = totalNodes;
lhs.resize(lhsSize);
rhs.resize(rhsSize);
connected_nodes.resize(totalNodes);
// algorithm related; element; dndx will be at a single gauss point...
ws_c_elem_scalarQ.resize(currentNodesPerElement);
ws_o_elem_scalarQ.resize(opposingNodesPerElement);
ws_c_elem_coordinates.resize(currentNodesPerElement*nDim);
ws_o_elem_coordinates.resize(opposingNodesPerElement*nDim);
ws_c_dndx.resize(nDim*currentNodesPerElement);
ws_o_dndx.resize(nDim*opposingNodesPerElement);
ws_c_det_j.resize(1);
ws_o_det_j.resize(1);
// algorithm related; face
ws_c_face_scalarQ.resize(currentNodesPerFace);
ws_o_face_scalarQ.resize(opposingNodesPerFace);
ws_c_diffFluxCoeff.resize(currentNodesPerFace);
ws_o_diffFluxCoeff.resize(opposingNodesPerFace);
ws_c_general_shape_function.resize(currentNodesPerFace);
ws_o_general_shape_function.resize(opposingNodesPerFace);
// face node identification
ws_c_face_node_ordinals.resize(currentNodesPerFace);
ws_o_face_node_ordinals.resize(opposingNodesPerFace);
// pointers
double *p_lhs = &lhs[0];
double *p_rhs = &rhs[0];
double *p_c_face_scalarQ = &ws_c_face_scalarQ[0];
double *p_o_face_scalarQ = &ws_o_face_scalarQ[0];
double *p_c_elem_scalarQ = &ws_c_elem_scalarQ[0];
double *p_o_elem_scalarQ = &ws_o_elem_scalarQ[0];
double *p_c_elem_coordinates = &ws_c_elem_coordinates[0];
double *p_o_elem_coordinates = &ws_o_elem_coordinates[0];
double *p_c_diffFluxCoeff = &ws_c_diffFluxCoeff[0];
double *p_o_diffFluxCoeff = &ws_o_diffFluxCoeff[0];
// me pointers
double *p_c_general_shape_function = &ws_c_general_shape_function[0];
double *p_o_general_shape_function = &ws_o_general_shape_function[0];
double *p_c_dndx = &ws_c_dndx[0];
double *p_o_dndx = &ws_o_dndx[0];
// populate current face_node_ordinals
currentElementTopo.side_node_ordinals(currentFaceOrdinal, ws_c_face_node_ordinals.begin());
// gather current face data
stk::mesh::Entity const* current_face_node_rels = bulk_data.begin_nodes(currentFace);
const int current_num_face_nodes = bulk_data.num_nodes(currentFace);
for ( int ni = 0; ni < current_num_face_nodes; ++ni ) {
stk::mesh::Entity node = current_face_node_rels[ni];
// gather...
p_c_face_scalarQ[ni] = *stk::mesh::field_data(scalarQNp1, node);
p_c_diffFluxCoeff[ni] = *stk::mesh::field_data(*diffFluxCoeff_, node);
}
// populate opposing face_node_ordinals
opposingElementTopo.side_node_ordinals(opposingFaceOrdinal, ws_o_face_node_ordinals.begin());
// gather opposing face data
stk::mesh::Entity const* opposing_face_node_rels = bulk_data.begin_nodes(opposingFace);
const int opposing_num_face_nodes = bulk_data.num_nodes(opposingFace);
for ( int ni = 0; ni < opposing_num_face_nodes; ++ni ) {
stk::mesh::Entity node = opposing_face_node_rels[ni];
// gather...
p_o_face_scalarQ[ni] = *stk::mesh::field_data(scalarQNp1, node);
p_o_diffFluxCoeff[ni] = *stk::mesh::field_data(*diffFluxCoeff_, node);
}
// gather current element data; sneak in first of connected nodes
stk::mesh::Entity const* current_elem_node_rels = bulk_data.begin_nodes(currentElement);
const int current_num_elem_nodes = bulk_data.num_nodes(currentElement);
for ( int ni = 0; ni < current_num_elem_nodes; ++ni ) {
stk::mesh::Entity node = current_elem_node_rels[ni];
// set connected nodes
connected_nodes[ni] = node;
// gather; scalar
p_c_elem_scalarQ[ni] = *stk::mesh::field_data(scalarQNp1, node);
// gather; vector
const double *coords = stk::mesh::field_data(*coordinates_, node);
const int niNdim = ni*nDim;
for ( int i = 0; i < nDim; ++i ) {
p_c_elem_coordinates[niNdim+i] = coords[i];
}
}
// gather opposing element data; sneak in second connected nodes
stk::mesh::Entity const* opposing_elem_node_rels = bulk_data.begin_nodes(opposingElement);
const int opposing_num_elem_nodes = bulk_data.num_nodes(opposingElement);
for ( int ni = 0; ni < opposing_num_elem_nodes; ++ni ) {
stk::mesh::Entity node = opposing_elem_node_rels[ni];
// set connected nodes
connected_nodes[ni+current_num_elem_nodes] = node;
// gather; scalar
p_o_elem_scalarQ[ni] = *stk::mesh::field_data(scalarQNp1, node);
// gather; vector
const double *coords = stk::mesh::field_data(*coordinates_, node);
const int niNdim = ni*nDim;
for ( int i = 0; i < nDim; ++i ) {
p_o_elem_coordinates[niNdim+i] = coords[i];
}
}
// pointer to face data
const double * c_areaVec = stk::mesh::field_data(*exposedAreaVec_, currentFace);
const double * o_areaVec = stk::mesh::field_data(*exposedAreaVec_, opposingFace);
const double * ncMassFlowRate = stk::mesh::field_data(*ncMassFlowRate_, currentFace);
double c_amag = 0.0;
double o_amag = 0.0;
for ( int j = 0; j < nDim; ++j ) {
const double c_axj = c_areaVec[currentGaussPointId*nDim+j];
c_amag += c_axj*c_axj;
// FIXME: choose first area vector on opposing surface? probably need something better for HO
const double o_axj = o_areaVec[0*nDim+j];
o_amag += o_axj*o_axj;
}
c_amag = std::sqrt(c_amag);
o_amag = std::sqrt(o_amag);
// now compute normal
for ( int i = 0; i < nDim; ++i ) {
p_cNx[i] = c_areaVec[currentGaussPointId*nDim+i]/c_amag;
p_oNx[i] = o_areaVec[0*nDim+i]/o_amag;
}
// project from side to element; method deals with the -1:1 isInElement range to the proper -0.5:0.5 CVFEM range
meSCSCurrent->sidePcoords_to_elemPcoords(currentFaceOrdinal, 1, ¤tIsoParCoords[0], ¤tElementIsoParCoords[0]);
meSCSOpposing->sidePcoords_to_elemPcoords(opposingFaceOrdinal, 1, &opposingIsoParCoords[0], &opposingElementIsoParCoords[0]);
// compute dndx
double scs_error = 0.0;
meSCSCurrent->general_face_grad_op(currentFaceOrdinal, ¤tElementIsoParCoords[0],
&p_c_elem_coordinates[0], &p_c_dndx[0], &ws_c_det_j[0], &scs_error);
meSCSOpposing->general_face_grad_op(opposingFaceOrdinal, &opposingElementIsoParCoords[0],
&p_o_elem_coordinates[0], &p_o_dndx[0], &ws_o_det_j[0], &scs_error);
// current diffusive flux
double currentDiffFluxBip = 0.0;
for ( int ic = 0; ic < currentNodesPerElement; ++ic ) {
const int offSetDnDx = ic*nDim; // single intg. point
const double scalarQIC = p_c_elem_scalarQ[ic];
for ( int j = 0; j < nDim; ++j ) {
const double nxj = p_cNx[j];
const double dndxj = p_c_dndx[offSetDnDx+j];
currentDiffFluxBip += dndxj*nxj*scalarQIC;
}
}
// current inverse length scale; can loop over face nodes to avoid "nodesOnFace" array
double currentInverseLength = 0.0;
for ( int ic = 0; ic < current_num_face_nodes; ++ic ) {
const int faceNodeNumber = ws_c_face_node_ordinals[ic];
const int offSetDnDx = faceNodeNumber*nDim; // single intg. point
for ( int j = 0; j < nDim; ++j ) {
const double nxj = p_cNx[j];
const double dndxj = p_c_dndx[offSetDnDx+j];
currentInverseLength += dndxj*nxj;
}
}
// opposing flux
double opposingDiffFluxBip = 0.0;
for ( int ic = 0; ic < opposingNodesPerElement; ++ic ) {
const int offSetDnDx = ic*nDim; // single intg. point
const double scalarQIC = p_o_elem_scalarQ[ic];
for ( int j = 0; j < nDim; ++j ) {
const double nxj = p_oNx[j];
const double dndxj = p_o_dndx[offSetDnDx+j];
opposingDiffFluxBip += dndxj*nxj*scalarQIC;
}
}
// opposing inverse length scale; can loop over face nodes to avoid "nodesOnFace" array
double opposingInverseLength = 0.0;
for ( int ic = 0; ic < opposing_num_face_nodes; ++ic ) {
const int faceNodeNumber = ws_o_face_node_ordinals[ic];
const int offSetDnDx = faceNodeNumber*nDim; // single intg. point
for ( int j = 0; j < nDim; ++j ) {
const double nxj = p_oNx[j];
const double dndxj = p_o_dndx[offSetDnDx+j];
opposingInverseLength += dndxj*nxj;
}
}
// interpolate face data; current and opposing...
double currentScalarQBip = 0.0;
meFCCurrent->interpolatePoint(
sizeOfScalarField,
&(dgInfo->currentIsoParCoords_[0]),
&ws_c_face_scalarQ[0],
¤tScalarQBip);
double opposingScalarQBip = 0.0;
meFCOpposing->interpolatePoint(
sizeOfScalarField,
&(dgInfo->opposingIsoParCoords_[0]),
&ws_o_face_scalarQ[0],
&opposingScalarQBip);
double currentDiffFluxCoeffBip = 0.0;
meFCCurrent->interpolatePoint(
sizeOfScalarField,
&(dgInfo->currentIsoParCoords_[0]),
&ws_c_diffFluxCoeff[0],
¤tDiffFluxCoeffBip);
double opposingDiffFluxCoeffBip = 0.0;
meFCOpposing->interpolatePoint(
sizeOfScalarField,
&(dgInfo->opposingIsoParCoords_[0]),
&ws_o_diffFluxCoeff[0],
&opposingDiffFluxCoeffBip);
// properly scaled diffusive flux
currentDiffFluxBip *= -currentDiffFluxCoeffBip;
opposingDiffFluxBip *= -opposingDiffFluxCoeffBip;
// 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;
// save mdot
const double tmdot = ncMassFlowRate[currentGaussPointId];
// compute penalty
const double penaltyIp = 0.5*(currentDiffFluxCoeffBip*currentInverseLength + opposingDiffFluxCoeffBip*opposingInverseLength)
+ std::abs(tmdot)/2.0;
// non conformal diffusive flux
const double ncDiffFlux = robinStyle_ ? -opposingDiffFluxBip : 0.5*(currentDiffFluxBip - opposingDiffFluxBip);
// non conformal advection; find upwind (upwind prevails over Robin or DG approach)
const double upwindScalarQBip = tmdot > 0.0 ? currentScalarQBip : opposingScalarQBip;
const double ncAdv = upwindAdvection_ ? tmdot*upwindScalarQBip : robinStyle_ ? tmdot*opposingScalarQBip
: 0.5*tmdot*(currentScalarQBip + opposingScalarQBip);
// form residual
const int nn = ws_c_face_node_ordinals[currentGaussPointId];
p_rhs[nn] -= ((dsFactor_*ncDiffFlux + penaltyIp*(currentScalarQBip-opposingScalarQBip))*c_amag + dsFactor_*ncAdv);
// set-up row for matrix
const int rowR = nn*totalNodes;
double lhsFac = penaltyIp*c_amag;
// sensitivities; current face (penalty and advection); use general shape function for this single ip
meFCCurrent->general_shape_fcn(1, ¤tIsoParCoords[0], &ws_c_general_shape_function[0]);
for ( int ic = 0; ic < currentNodesPerFace; ++ic ) {
const int icnn = ws_c_face_node_ordinals[ic];
const double r = p_c_general_shape_function[ic];
p_lhs[rowR+icnn] += r*(lhsFac+0.5*tmdot);
}
// sensitivities; current element (diffusion)
for ( int ic = 0; ic < currentNodesPerElement; ++ic ) {
const int offSetDnDx = ic*nDim; // single intg. point
double lhscd = 0.0;
for ( int j = 0; j < nDim; ++j ) {
const double nxj = p_cNx[j];
const double dndxj = p_c_dndx[offSetDnDx+j];
lhscd -= dndxj*nxj;
}
p_lhs[rowR+ic] += 0.5*currentDiffFluxCoeffBip*lhscd*c_amag*robinCurrentFluxFac;
}
// sensitivities; opposing face (penalty); use general shape function for this single ip
meFCOpposing->general_shape_fcn(1, &opposingIsoParCoords[0], &ws_o_general_shape_function[0]);
for ( int ic = 0; ic < opposingNodesPerFace; ++ic ) {
const int icnn = ws_o_face_node_ordinals[ic];
const double r = p_o_general_shape_function[ic];
p_lhs[rowR+icnn+currentNodesPerElement] -= r*(lhsFac-0.5*tmdot);
}
// sensitivities; opposing element (diffusion)
for ( int ic = 0; ic < opposingNodesPerElement; ++ic ) {
const int offSetDnDx = ic*nDim; // single intg. point
double lhscd = 0.0;
for ( int j = 0; j < nDim; ++j ) {
const double nxj = p_oNx[j];
const double dndxj = p_o_dndx[offSetDnDx+j];
lhscd -= dndxj*nxj;
}
p_lhs[rowR+ic+currentNodesPerElement] -= 0.5*opposingDiffFluxCoeffBip*lhscd*c_amag;
}
apply_coeff(connected_nodes, rhs, lhs, __FILE__);
}
}
}
}