/** * Reads the data (FITS matrix) from a single FITS file into a * workspace (directly into the spectra, using one spectrum per image * row). * * @param fileInfo information on the FITS file to load, including its path * @param cmpp centimeters per pixel, to scale/normalize values * @param ws workspace with the required dimensions * @param buffer pre-allocated buffer to read from file * * @throws std::runtime_error if there are file input issues */ void LoadFITS::readDataToWorkspace(const FITSInfo &fileInfo, double cmpp, Workspace2D_sptr ws, std::vector<char> &buffer) { const size_t bytespp = (fileInfo.bitsPerPixel / 8); const size_t len = m_pixelCount * bytespp; readInBuffer(fileInfo, buffer, len); const size_t nrows(fileInfo.axisPixelLengths[1]), ncols(fileInfo.axisPixelLengths[0]); // Treat buffer as a series of bytes uint8_t *buffer8 = reinterpret_cast<uint8_t *>(buffer.data()); PARALLEL_FOR_NO_WSP_CHECK() for (int i = 0; i < static_cast<int>(nrows); ++i) { auto &xVals = ws->mutableX(i); auto &yVals = ws->mutableY(i); auto &eVals = ws->mutableE(i); xVals = static_cast<double>(i) * cmpp; for (size_t j = 0; j < ncols; ++j) { // Map from 2D->1D index const size_t start = ((i * (bytespp)) * nrows) + (j * (bytespp)); uint8_t const *const buffer8Start = buffer8 + start; // Reverse byte order of current value. Make sure we allocate enough // enough space to hold the size uint8_t byteValue[g_maxBytesPP]; std::reverse_copy(buffer8Start, buffer8Start + bytespp, byteValue); double val = 0; if (fileInfo.bitsPerPixel == 8) { val = toDouble<uint8_t>(byteValue); } else if (fileInfo.bitsPerPixel == 16) { val = toDouble<uint16_t>(byteValue); } else if (fileInfo.bitsPerPixel == 32 && !fileInfo.isFloat) { val = toDouble<uint32_t>(byteValue); } else if (fileInfo.bitsPerPixel == 64 && !fileInfo.isFloat) { val = toDouble<uint32_t>(byteValue); } else if (fileInfo.bitsPerPixel == 32 && fileInfo.isFloat) { val = toDouble<float>(byteValue); } else if (fileInfo.bitsPerPixel == 64 && fileInfo.isFloat) { val = toDouble<double>(byteValue); } val = fileInfo.scale * val - fileInfo.offset; yVals[j] = val; eVals[j] = sqrt(val); } } }
/** Output distributions in order for a better understanding of the log * Result is written to a Workspace2D * * @param timevec :: a vector of time stamps * @param stepsize :: resolution of the delta time count bin */ Workspace2D_sptr GetTimeSeriesLogInformation::calDistributions( std::vector<Kernel::DateAndTime> timevec, double stepsize) { // 1. Get a vector of delta T (in unit of seconds) double dtmin = static_cast<double>(timevec.back().totalNanoseconds() - timevec[0].totalNanoseconds()) * 1.0E-9; double dtmax = 0.0; vector<double> vecdt(timevec.size() - 1, 0.0); for (size_t i = 1; i < timevec.size(); ++i) { vecdt[i - 1] = static_cast<double>(timevec[i].totalNanoseconds() - timevec[i - 1].totalNanoseconds()) * 1.0E-9; if (vecdt[i - 1] < dtmin) dtmin = vecdt[i - 1]; else if (vecdt[i - 1] > dtmax) dtmax = vecdt[i - 1]; } // 2. Create a vector of counts size_t numbins; if (m_ignoreNegativeTime && dtmin < 0) { numbins = static_cast<size_t>(ceil((dtmax) / stepsize)) + 2; } else { numbins = static_cast<size_t>(ceil((dtmax - dtmin) / stepsize)) + 2; } g_log.notice() << "Distribution has " << numbins << " bins. Delta T = (" << dtmin << ", " << dtmax << ")\n"; Workspace2D_sptr distws = boost::dynamic_pointer_cast<Workspace2D>( API::WorkspaceFactory::Instance().create("Workspace2D", 1, numbins, numbins)); auto &vecDeltaT = distws->mutableX(0); auto &vecCount = distws->mutableY(0); double countmin = dtmin; if (m_ignoreNegativeTime && dtmin < 0) countmin = 0; for (size_t i = 0; i < numbins; ++i) vecDeltaT[i] = countmin + (static_cast<double>(i) - 1) * stepsize; for (size_t i = 0; i < numbins; ++i) vecCount[i] = 0; // 3. Count for (double dt : vecdt) { int index; if (dt < 0 && m_ignoreNegativeTime) { index = 0; } else { auto viter = lower_bound(vecDeltaT.begin(), vecDeltaT.end(), dt); index = static_cast<int>(viter - vecDeltaT.begin()); if (index >= static_cast<int>(vecDeltaT.size())) { // Out of upper boundary g_log.error() << "Find index = " << index << " > vecX.size = " << vecDeltaT.size() << ".\n"; } else if (dt < vecDeltaT[index]) { --index; } if (index < 0) throw runtime_error("How can this happen."); } vecCount[index] += 1; } return distws; }