//--------------------------------------------------------------------------
//-------- 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
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__);
}
}
}
