/**
* 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;
}
