TEST(TestASMu3D, TransferGaussPtVarsN)
{
SIM3D sim(1), sim2(1);
sim.opt.discretization = sim2.opt.discretization = ASM::LRSpline;
sim.createDefaultModel();
sim2.createDefaultModel();
ASMu3D* pch = static_cast<ASMu3D*>(sim.getPatch(1));
ASMu3D* pchNew = static_cast<ASMu3D*>(sim2.getPatch(1));
pchNew->uniformRefine(0, 1);
RealArray oldAr(3*3*3), newAr;
std::iota(oldAr.begin(), oldAr.end(), 1);
pchNew->transferGaussPtVarsN(pch->getVolume(), oldAr, newAr, 3);
static RealArray refAr = {{ 1.0, 1.0, 2.0,
4.0, 4.0, 5.0,
7.0, 7.0, 8.0,
10.0, 10.0, 11.0,
13.0, 13.0, 14.0,
16.0, 16.0, 17.0,
19.0, 19.0, 20.0,
22.0, 22.0, 23.0,
25.0, 25.0, 26.0,
2.0, 3.0, 3.0,
5.0, 6.0, 6.0,
8.0, 9.0, 9.0,
11.0, 12.0, 12.0,
14.0, 15.0, 15.0,
17.0, 18.0, 18.0,
20.0, 21.0, 21.0,
23.0, 24.0, 24.0,
26.0, 27.0, 27.0}};
EXPECT_EQ(refAr.size(), newAr.size());
for (size_t i = 0; i < refAr.size(); ++i)
EXPECT_FLOAT_EQ(refAr[i], newAr[i]);
}
bool ASMs1D::tesselate (ElementBlock& grid, const int* npe) const
{
// Compute parameter values of the nodal points
RealArray gpar;
if (!this->getGridParameters(gpar,npe[0]-1))
return false;
// Evaluate the spline curve at all points
size_t nx = gpar.size();
RealArray XYZ(curv->dimension()*nx);
curv->gridEvaluator(XYZ,gpar);
// Establish the block grid coordinates
size_t i, j, l;
grid.resize(nx);
for (i = l = 0; i < grid.getNoNodes(); i++, l += curv->dimension())
for (j = 0; j < nsd; j++)
grid.setCoor(i,j,XYZ[l+j]);
// Establish the block grid topology
int nse1 = npe[0] - 1;
int n[2], ie = 1, ip = 0;
n[0] = 0;
n[1] = n[0] + 1;
for (i = 1; i < nx; i++)
{
for (l = 0; l < 2; l++)
grid.setNode(ip++,n[l]++);
grid.setElmId(i,ie);
if (i%nse1 == 0) ie++;
}
return true;
}
bool ASMs1D::refine (const RealArray& xi)
{
if (!curv || xi.empty()) return false;
if (xi.front() < 0.0 || xi.back() > 1.0) return false;
if (shareFE) return true;
RealArray extraKnots;
RealArray::const_iterator uit = curv->basis().begin();
double ucurr, uprev = *(uit++);
while (uit != curv->basis().end())
{
ucurr = *(uit++);
if (ucurr > uprev)
for (size_t i = 0; i < xi.size(); i++)
if (i > 0 && xi[i] < xi[i-1])
return false;
else
extraKnots.push_back(ucurr*xi[i] + uprev*(1.0-xi[i]));
uprev = ucurr;
}
curv->insertKnot(extraKnots);
return true;
}
void slabAbsorption (const RealArray& energy, const RealArray& parameter,
RealArray& flux, const string& init,
bool MassColumnDensity)
{
size_t energySize = energy.size ();
size_t fluxSize = energySize - 1;
flux.resize (fluxSize);
size_t i = 0;
Real Sigma = 0.;
Real Column = parameter[i++]; // units depend on calling function
// load kappa
RealArray kappa;
RealArray kappaWavelength;
Real mu;
LoadKappa (kappa, kappaWavelength, mu);
// determine units of column parameter
if (MassColumnDensity) {
Sigma = Column;
} else {
Sigma = Column * CONST_NH_SIGMA_CONVERSION * mu;
}
for (i = 0; i < fluxSize; i++) {
Real responseWavelength = 2. * CONST_HC_KEV_A / (energy[i] + energy[i+1]);
size_t j = BinarySearch (kappaWavelength, responseWavelength);
Real Tau = Sigma * kappa[j];
flux[i] = exp (-1. * Tau);
}
return;
}
LagrangeFields2D::LagrangeFields2D (const ASMs2DLag* patch,
const RealArray& v,
char basis,
const char* name) : Fields(name)
{
patch->getNodalCoordinates(coord);
patch->getSize(n1,n2);
patch->getOrder(p1,p2);
nno = n1*n2;
nelm = (n1-1)*(n2-1)/(p1*p2);
nf = v.size()/nno;
// Ensure the values array has compatible length, pad with zeros if necessary
values.resize(nf*nno);
RealArray::const_iterator end = v.size() > nf*nno ? v.begin()+nf*nno:v.end();
std::copy(v.begin(),end,values.begin());
}
void FIRFilter::kaiser (RealArray &w, Real beta)
{
size_t n = (1 + w.size()) / 2, ieo = w.size() % 2;
Real bes = in0 (beta);
Real xind = pow ((w.size() - 1.0), 2);
for (size_t ii = 0; ii < n; ii++)
{
Real xi = ii;
if (ieo == 0)
xi += 0.5;
size_t jj = n + ii - ieo;
w[n - 1 - ii] =
w[jj] = in0 (beta * sqrt(1.0 - 4.0 * xi * xi / xind)) / bes;
}
} // end kaiser
SplineFields2D::SplineFields2D (const ASMs2D* patch,
const RealArray& v, char nbasis,
const char* name)
: Fields(name), basis(patch->getBasis(nbasis)), surf(patch->getSurface())
{
const int n1 = basis->numCoefs_u();
const int n2 = basis->numCoefs_v();
nno = n1*n2;
const int p1 = basis->order_u();
const int p2 = basis->order_v();
nelm = (n1-p1+1)*(n2-p2+1);
// Ensure the values array has compatible length, pad with zeros if necessary
nf = v.size()/nno;
values.resize(nf*nno);
RealArray::const_iterator end = v.size() > nf*nno ? v.begin()+nf*nno:v.end();
std::copy(v.begin(),end,values.begin());
}
bool NonlinearDriver::solutionNorms (const TimeDomain& time,
double zero_tol, std::streamsize outPrec)
{
if (msgLevel < 0 || solution.empty()) return true;
const size_t nsd = model.getNoSpaceDim();
size_t iMax[nsd];
double dMax[nsd];
double normL2 = model.solutionNorms(solution.front(),dMax,iMax);
RealArray RF;
bool haveReac = model.getCurrentReactions(RF,solution.front());
Vectors gNorm;
if (calcEn)
{
model.setMode(SIM::RECOVERY);
model.setQuadratureRule(opt.nGauss[1]);
if (!model.solutionNorms(time,solution,gNorm))
gNorm.clear();
}
if (myPid > 0) return true;
std::streamsize stdPrec = outPrec > 0 ? IFEM::cout.precision(outPrec) : 0;
double old_tol = utl::zero_print_tol;
utl::zero_print_tol = zero_tol;
IFEM::cout <<" Primary solution summary: L2-norm : "
<< utl::trunc(normL2);
for (unsigned char d = 0; d < nsd; d++)
if (utl::trunc(dMax[d]) != 0.0)
IFEM::cout <<"\n Max "<< char('X'+d)
<<"-displacement : "<< dMax[d] <<" node "<< iMax[d];
if (haveReac)
{
IFEM::cout <<"\n Total reaction forces: Sum(R) =";
for (size_t i = 1; i < RF.size(); i++)
IFEM::cout <<" "<< utl::trunc(RF[i]);
if (utl::trunc(RF.front()) != 0.0)
IFEM::cout <<"\n displacement*reactions: (R,u) = "<< RF.front();
}
if (!gNorm.empty())
this->printNorms(gNorm.front(),IFEM::cout);
IFEM::cout << std::endl;
utl::zero_print_tol = old_tol;
if (stdPrec > 0) IFEM::cout.precision(stdPrec);
return true;
}
bool ASMs2D::getGrevilleParameters (RealArray& prm, int dir, int basisNum) const
{
if (dir < 0 || dir > 1) return false;
const Go::BsplineBasis& basis = this->getBasis(basisNum)->basis(dir);
prm.resize(basis.numCoefs());
for (size_t i = 0; i < prm.size(); i++)
prm[i] = basis.grevilleParameter(i);
return true;
}
bool ASMs1D::getGrevilleParameters (RealArray& prm) const
{
if (!curv) return false;
const Go::BsplineBasis& basis = curv->basis();
prm.resize(basis.numCoefs());
for (size_t i = 0; i < prm.size(); i++)
prm[i] = basis.grevilleParameter(i);
return true;
}
void SIMKLShell::printStep (int istep, const TimeDomain& time) const
{
adm.cout <<"\n step="<< istep <<" time="<< time.t;
RealArray extLo;
if (myProblem->getMode() == SIM::ARCLEN && this->getExtLoad(extLo,time))
{
adm.cout <<" Sum(Fex) =";
for (size_t d = 0; d < extLo.size(); d++)
adm.cout <<" "<< utl::trunc(extLo[d]);
}
adm.cout << std::endl;
}
void KaiserWindowDesigner::calculateWindow (RealArray &w, Real beta)
{
size_t n = (1 + w.size()) / 2;
size_t ieo = w.size() % 2;
Real bes = in0 (beta);
Real xind = pow ((w.size() - 1.0), 2);
Real arg;
for (size_t ii = 0; ii < n; ii++)
{
Real xi = ii;
if (ieo == 0)
xi += 0.5;
size_t jj = n + ii - ieo;
// there is a case do to floating point error when you end up with a very small negative number
// therefore - ensure that the number is always non-negative so we can take the square root of it
arg=std::max(1.0 - 4.0 * xi * xi / xind,0.0);
w[n - 1 - ii] =
w[jj] = in0 (beta * sqrt(arg)) / bes;
}
} // end calculateWindow
void hegauss
(const RealArray& energy, const RealArray& parameter,
/*@unused@*/ int spectrum, RealArray& flux, /*@unused@*/ RealArray& fluxError,
/*@unused@*/ const string& init)
{
fluxError.resize (0);
size_t Nparameters (parameter.size ());
RealArray NewParameter (Nparameters + 1);
for (size_t i = 0; i < Nparameters - 1; i++)
NewParameter[i] = parameter[i];
NewParameter[Nparameters] = parameter[Nparameters - 1];
/* Leave NewParameter[Nparameters-1] initialized to zero
for zero calibration shift. */
HeLikeGaussian He (energy, NewParameter);
He.getFlux (flux);
return;
}
bool ASMs1D::evalSolution (Matrix& sField, const IntegrandBase& integrand,
const int* npe, char project) const
{
if (npe)
{
// Compute parameter values of the result sampling points
RealArray gpar;
if (this->getGridParameters(gpar,npe[0]-1))
if (project)
{
// Project the secondary solution onto the spline basis
Go::SplineCurve* c = this->projectSolution(integrand);
if (c)
{
// Evaluate the projected field at the result sampling points
const Vector& svec = sField; // using utl::matrix cast operator
sField.resize(c->dimension(),gpar.size());
c->gridEvaluator(const_cast<Vector&>(svec),gpar);
delete c;
return true;
}
}
else
// Evaluate the secondary solution directly at all sampling points
return this->evalSolution(sField,integrand,&gpar);
}
else
{
// Project the secondary solution onto the spline basis
Go::SplineCurve* c = this->projectSolution(integrand);
if (c)
{
// Extract control point values from the spline object
sField.resize(c->dimension(),c->numCoefs());
sField.fill(&(*c->coefs_begin()));
delete c;
return true;
}
}
std::cerr <<" *** ASMs1D::evalSolution: Failure!"<< std::endl;
return false;
}
static void assemSparse (const RealArray& V, SparseMatrix& SM, size_t col,
const IntVec& mnen, const int* meqn,
const int* mpmceq, const int* mmceq, const Real* ttcc)
{
for (size_t d = 0; d < mnen.size(); d++, col++)
{
Real vd = d < V.size() ? V[d] : V.back();
int ieq = mnen[d];
int ceq = -ieq;
if (ieq > 0)
SM(ieq,col) += vd;
else if (ceq > 0)
for (int ip = mpmceq[ceq-1]; ip < mpmceq[ceq]-1; ip++)
{
ieq = meqn[mmceq[ip]-1];
SM(ieq,col) += vd;
}
}
}
int LoadKappaZ (RealArray& kappa, RealArray& kappaEnergy, RealArray abundances)
{
// Get data directory from XSPEC xset variables
string windtabsDirectory = getXspecVariable ("WINDTABSDIRECTORY", "./");
// Get filename from XSPEC xset variables
string FITSfilename = windtabsDirectory + "/";
FITSfilename += getXspecVariable ("KAPPAZFILENAME", "kappa.fits");
// string KeywordNameMu ("mu");
// Set up load of 2D array kappaZ;
// dimensions are Z and energyx
RealArray kappaZ; // this gets appropriately resized when it is loaded
size_t ax1 (0);
size_t ax2 (0);
try {
auto_ptr<FITS> pInfile
(new FITS (FITSfilename, Read, true)); // Primary HDU - Image
PHDU& image = pInfile->pHDU ();
image.read (kappaZ); // this is a 1D representation of a 2D array
ax1 = image.axis (0);
ax2 = image.axis (1);
}
catch (FitsException& issue) {
cerr << "LoadKappaZ: CCfits / FITSio exception:" << endl;
cerr << issue.message () << endl;
cerr << "(failed reading KappaZ)" << endl;
return 1;
}
// Load energy axis for kappa table:
try {
int extensionNumber (1);
auto_ptr<FITS> pInfile
(new FITS (FITSfilename, Read, extensionNumber, false));
ExtHDU& table = pInfile->currentExtension ();
size_t NumberOfRows = table.column(1).rows ();
table.column(1).read (kappaEnergy, 1, NumberOfRows);
// table.column(2).read (kappaZ, 1, NumberOfRows); // see if this works???
}
catch (FitsException& issue) {
cerr << "LoadKappa: CCfits / FITSio exception:" << endl;
cerr << issue.message () << endl;
cerr << "(file probably doesn't exist)" << endl;
return 1;
}
kappaEnergy *= 1.e-3; // convert from eV to keV
// get mass fractions based on xspec abund, model abund parameter,
// and atomic masses
RealArray massFractions;
getMassFractions (abundances, massFractions);
// sum kappas weighted by mass fractions
size_t NEnergies (kappaEnergy.size ());
size_t NZ (massFractions.size ());
kappa.resize (NEnergies, 0.);
// It would be better if there was a vectorized way to do this,
// but I don't know what it is.
for (size_t i=0; i<NZ; i++) {
for (size_t j=0; j<NEnergies; j++){
size_t k = i*ax1 + j; // this is the 1d representation of the 2d array
kappa[j] += kappaZ[k] * massFractions[i];
}
}
return 0;
}
//------------------------------------------------------------------------------
void Estimator::PlotResiduals()
{
#ifdef DEBUG_RESIDUAL_PLOTS
MessageInterface::ShowMessage("Entered PlotResiduals\n");
MessageInterface::ShowMessage("Processing plot with %d Residuals\n",
measurementResiduals.size());
#endif
std::vector<RealArray*> dataBlast;
RealArray epochs;
RealArray values;
RealArray hiErrors;
RealArray lowErrors;
RealArray *hi = NULL, *low = NULL;
for (UnsignedInt i = 0; i < residualPlots.size(); ++i)
{
dataBlast.clear();
epochs.clear();
values.clear();
if (showErrorBars)
{
hiErrors.clear();
lowErrors.clear();
if (hiLowData.size() > 0)
{
hi = hiLowData[0];
if (hiLowData.size() > 1)
{
low = hiLowData[1];
}
}
}
// Collect residuals by plot
for (UnsignedInt j = 0; j < measurementResiduals.size(); ++j)
{
if (residualPlots[i]->UsesData(measurementResidualID[j]) >= 0)
{
epochs.push_back(measurementEpochs[j]);
values.push_back(measurementResiduals[j]);
if (hi && showErrorBars)
{
hiErrors.push_back((*hi)[j]);
}
if (low && showErrorBars)
lowErrors.push_back((*low)[j]);
}
}
if (epochs.size() > 0)
{
dataBlast.push_back(&epochs);
dataBlast.push_back(&values);
residualPlots[i]->TakeAction("ClearData");
residualPlots[i]->Deactivate();
residualPlots[i]->SetData(dataBlast, hiErrors, lowErrors);
residualPlots[i]->TakeAction("Rescale");
residualPlots[i]->Activate();
}
#ifdef DEBUG_RESIDUALS
// Dump the data to screen
MessageInterface::ShowMessage("DataDump for residuals plot %d:\n", i);
for (UnsignedInt k = 0; k < epochs.size(); ++k)
{
MessageInterface::ShowMessage(" %.12lf %.12lf", epochs[k], values[k]);
if (hi)
if (hi->size() > k)
if (low)
MessageInterface::ShowMessage(" + %.12lf", (*hi)[k]);
else
MessageInterface::ShowMessage(" +/- %.12lf", (*hi)[k]);
if (low)
if (low->size() > k)
MessageInterface::ShowMessage(" - %.12lf", (*low)[k]);
MessageInterface::ShowMessage("\n");
}
#endif
}
}
