Dictionary Curve3D::_get_data() const {
Dictionary dc;
Vector3Array d;
d.resize(points.size()*3);
Vector3Array::Write w = d.write();
RealArray t;
t.resize(points.size());
RealArray::Write wt = t.write();
for(int i=0;i<points.size();i++) {
w[i*3+0]=points[i].in;
w[i*3+1]=points[i].out;
w[i*3+2]=points[i].pos;
wt[i]=points[i].tilt;
}
w=Vector3Array::Write();
wt=RealArray::Write();
dc["points"]=d;
dc["tilts"]=t;
return dc;
}
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;
}
void slamtabs
(const RealArray& energy, const RealArray& parameter,
/*@unused@*/ int spectrum, RealArray& flux, /*@unused@*/ RealArray& fluxError,
/*@unused@*/ const string& init)
{
fluxError.resize (0);
slabAbsorption (energy, parameter, flux, init, true);
return;
}
void hecgauss
(const RealArray& energy, const RealArray& parameter,
/*@unused@*/ int spectrum, RealArray& flux, /*@unused@*/ RealArray& fluxError,
/*@unused@*/ const string& init)
{
fluxError.resize (0);
HeLikeGaussian He (energy, parameter);
He.getFlux (flux);
return;
}
void SharedSurfpackApproxData::
merge_variable_arrays(const RealVector& cv, const IntVector& div,
const RealVector& drv, RealArray& ra)
{
size_t num_cv = cv.length(), num_div = div.length(), num_drv = drv.length(),
num_v = num_cv + num_div + num_drv;
ra.resize(num_v);
if (num_cv) copy_data_partial(cv, ra, 0);
if (num_div) merge_data_partial(div, ra, num_cv);
if (num_drv) copy_data_partial(drv, ra, num_cv+num_div);
}
void vwcloren
(const RealArray& energy, const RealArray& parameter,
/*@unused@*/ int spectrum, RealArray& flux, /*@unused@*/ RealArray& fluxError,
/*@unused@*/ const string& init)
{
fluxError.resize (0);
Real LineEnergy, Gamma;
vwclorenProcessParameter (parameter, LineEnergy, Gamma);
Lorentzian L (energy, LineEnergy, Gamma);
L.getFlux (flux);
return;
}
bool SIMKLShell::getExtLoad (RealArray& extloa, const TimeDomain& time) const
{
extloa.resize(nf[0]);
for (size_t i = 0; i < nf[0]; i++)
extloa[i] = this->extractScalar(i);
for (const PointLoad& load : myLoads)
if (load.ldof.second > 0 && load.ldof.second < nf[0])
extloa[load.ldof.second-1] += (*load.p)(time.t);
return true;
}
void vwcgauss
(const RealArray& energy, const RealArray& parameter,
/*@unused@*/ int spectrum, RealArray& flux, /*@unused@*/ RealArray& fluxError,
/*@unused@*/ const string& init)
{
fluxError.resize (0);
Real LineEnergy, Sigma;
vwcgaussProcessParameter (parameter, LineEnergy, Sigma);
Gaussian G (energy, LineEnergy, Sigma);
G.getFlux (flux);
return;
}
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;
}
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;
}
int getMassFractions (RealArray RelativeAbundances, RealArray& MassFractions)
{
size_t NElements (30);
// should try to replace this with something better
/* char* ElementNames[] =
{"H", "He", "Li", "Be", "B", "C", "N", "O", "F", "Ne",
"Na", "Mg", "Al", "Si", "P", "S", "Cl", "Ar", "K", "Ca",
"Sc", "Ti", "V", "Cr", "Mn", "Fe", "Co", "Ni", "Cu", "Zn"};*/
RealArray AtomicNumber;
RealArray AtomicMass;
RealArray ExplicitRelativeAbundances (1., NElements);
fillAbundanceArray (ExplicitRelativeAbundances, RelativeAbundances);
// Get data directory from XSPEC xset variables
string windtabsDirectory = getXspecVariable ("WINDTABSDIRECTORY", "./");
// Get filename from XSPEC xset variables
string FITSfilename = windtabsDirectory + "/";
FITSfilename += getXspecVariable ("KAPPAZFILENAME", "kappaZ.fits");
try {
int extensionNumber (2);
auto_ptr<FITS> pInfile
(new FITS (FITSfilename, Read, extensionNumber, false));
ExtHDU& table = pInfile->currentExtension ();
size_t NumberOfRows = table.column(1).rows ();
// change column reading
table.column(1).read (AtomicNumber, 1, NumberOfRows);
table.column(2).read (AtomicMass, 1, NumberOfRows);
}
catch (FitsException& issue) {
cerr << "getMassFractions: CCfits / FITSio exception:" << endl;
cerr << issue.message () << endl;
cerr << "(file probably doesn't exist)" << endl;
return 1;
}
MassFractions.resize (NElements, 0.);
Real sum = 0.;
for (size_t i=0; i<NElements; i++) {
// MassFractions[i] = FGABND (ElementNames[i]) * AtomicMass[i] *
// ExplicitRelativeAbundances[i];
size_t Z = i + 1;
MassFractions[i] = FunctionUtility::getAbundance (Z) * AtomicMass[i] *
ExplicitRelativeAbundances[i];
sum += MassFractions[i];
}
// renormalize
if (sum > 0.) {
MassFractions /= sum;
} else {
cerr << "getMassFractions: sum of mass fractions is <= 0" << endl;
return 1;
}
return 0;
}
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;
}
void LR::getGaussPointParameters (const LR::LRSpline* lrspline, RealArray& uGP,
int d, int nGauss, int iel, const double* xi)
{
#ifdef INDEX_CHECK
if (iel < 1 || iel > lrspline->nElements())
{
std::cerr <<" *** getLRGaussPointParameters: Element index "<< iel
<<" out of range [1,"<< lrspline->nElements() <<"]."<< std::endl;
return;
}
#endif
const LR::Element* el = lrspline->getElement(iel-1);
double ustart = el->getParmin(d);
double ustop = el->getParmax(d);
uGP.resize(nGauss);
for (int i = 0; i < nGauss; i++)
uGP[i] = 0.5*((ustop-ustart)*xi[i] + ustop+ustart);
}
Variant _jobject_to_variant(JNIEnv * env, jobject obj) {
jclass c = env->GetObjectClass(obj);
bool array;
String name = _get_class_name(env, c, &array);
//print_line("name is " + name + ", array "+Variant(array));
print_line("ARGNAME: "+name);
if (name == "java.lang.String") {
return String::utf8(env->GetStringUTFChars( (jstring)obj, NULL ));
};
if (name == "[Ljava.lang.String;") {
jobjectArray arr = (jobjectArray)obj;
int stringCount = env->GetArrayLength(arr);
//print_line("String array! " + String::num(stringCount));
DVector<String> sarr;
for (int i=0; i<stringCount; i++) {
jstring string = (jstring) env->GetObjectArrayElement(arr, i);
const char *rawString = env->GetStringUTFChars(string, 0);
sarr.push_back(String(rawString));
env->DeleteLocalRef(string);
}
return sarr;
};
if (name == "java.lang.Boolean") {
jmethodID boolValue = env->GetMethodID(c, "booleanValue", "()Z");
bool ret = env->CallBooleanMethod(obj, boolValue);
return ret;
};
if (name == "java.lang.Integer") {
jclass nclass = env->FindClass("java/lang/Number");
jmethodID intValue = env->GetMethodID(nclass, "intValue", "()I");
int ret = env->CallIntMethod(obj, intValue);
return ret;
};
if (name == "[I") {
jintArray arr = (jintArray)obj;
int fCount = env->GetArrayLength(arr);
DVector<int> sarr;
sarr.resize(fCount);
DVector<int>::Write w = sarr.write();
env->GetIntArrayRegion(arr,0,fCount,w.ptr());
w = DVector<int>::Write();
return sarr;
};
if (name == "[B") {
jbyteArray arr = (jbyteArray)obj;
int fCount = env->GetArrayLength(arr);
DVector<uint8_t> sarr;
sarr.resize(fCount);
DVector<uint8_t>::Write w = sarr.write();
env->GetByteArrayRegion(arr,0,fCount,reinterpret_cast<signed char*>(w.ptr()));
w = DVector<uint8_t>::Write();
return sarr;
};
if (name == "java.lang.Float" || name == "java.lang.Double") {
jclass nclass = env->FindClass("java/lang/Number");
jmethodID doubleValue = env->GetMethodID(nclass, "doubleValue", "()D");
double ret = env->CallDoubleMethod(obj, doubleValue);
return ret;
};
if (name == "[D") {
jdoubleArray arr = (jdoubleArray)obj;
int fCount = env->GetArrayLength(arr);
RealArray sarr;
sarr.resize(fCount);
RealArray::Write w = sarr.write();
for (int i=0; i<fCount; i++) {
double n;
env->GetDoubleArrayRegion(arr, i, 1, &n);
w.ptr()[i] = n;
};
return sarr;
};
if (name == "[F") {
jfloatArray arr = (jfloatArray)obj;
int fCount = env->GetArrayLength(arr);
RealArray sarr;
sarr.resize(fCount);
RealArray::Write w = sarr.write();
for (int i=0; i<fCount; i++) {
float n;
env->GetFloatArrayRegion(arr, i, 1, &n);
w.ptr()[i] = n;
};
return sarr;
};
if (name == "[Ljava.lang.Object;") {
jobjectArray arr = (jobjectArray)obj;
int objCount = env->GetArrayLength(arr);
Array varr(true);
for (int i=0; i<objCount; i++) {
jobject jobj = env->GetObjectArrayElement(arr, i);
Variant v = _jobject_to_variant(env, jobj);
varr.push_back(v);
env->DeleteLocalRef(jobj);
}
return varr;
};
if (name == "java.util.HashMap" || name == "org.godotengine.godot.Dictionary") {
Dictionary ret(true);
jclass oclass = c;
jmethodID get_keys = env->GetMethodID(oclass, "get_keys", "()[Ljava/lang/String;");
jobjectArray arr = (jobjectArray)env->CallObjectMethod(obj, get_keys);
StringArray keys = _jobject_to_variant(env, arr);
env->DeleteLocalRef(arr);
jmethodID get_values = env->GetMethodID(oclass, "get_values", "()[Ljava/lang/Object;");
arr = (jobjectArray)env->CallObjectMethod(obj, get_values);
Array vals = _jobject_to_variant(env, arr);
env->DeleteLocalRef(arr);
//print_line("adding " + String::num(keys.size()) + " to Dictionary!");
for (int i=0; i<keys.size(); i++) {
ret[keys[i]] = vals[i];
};
return ret;
};
env->DeleteLocalRef(c);
return Variant();
};
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 KaiserWindowDesigner::getWindow(RealArray &w)
{
w.resize(size);
Real beta = getBeta();
calculateWindow(w, beta);
}
