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