/**
* Create workspace to store the structure factor.
* First spectrum is the real part, second spectrum is the imaginary part
* X values are the modulus of the Q-vectors
* @param h5file file identifier
* @param gws pointer to WorkspaceGroup being filled
* @param setName string name of dataset
* @param qvmod vector of Q-vectors' moduli
* @param sorting_indexes permutation of qvmod indexes to render it in increasing order of momemtum transfer
*/
void LoadSassena::loadFQ(const hid_t& h5file, API::WorkspaceGroup_sptr gws, const std::string setName, const MantidVec &qvmod, const std::vector<int> &sorting_indexes)
{
const std::string gwsName = this->getPropertyValue("OutputWorkspace");
int nq = static_cast<int>( qvmod.size() ); //number of q-vectors
DataObjects::Workspace2D_sptr ws = boost::dynamic_pointer_cast<DataObjects::Workspace2D>(API::WorkspaceFactory::Instance().create("Workspace2D", 2, nq, nq));
const std::string wsName = gwsName + std::string("_") + setName;
ws->setTitle(wsName);
double* buf = new double[nq*2];
this->dataSetDouble(h5file,setName,buf);
MantidVec& re = ws->dataY(0); // store the real part
ws->dataX(0) = qvmod; //X-axis values are the modulus of the q vector
MantidVec& im = ws->dataY(1); // store the imaginary part
ws->dataX(1) = qvmod;
double *curr = buf;
for(int iq=0; iq<nq; iq++){
const int index=sorting_indexes[iq];
re[index]=curr[0];
im[index]=curr[1];
curr+=2;
}
delete[] buf;
// Set the Units
ws->getAxis(0)->unit() = Kernel::UnitFactory::Instance().create("MomentumTransfer");
this->registerWorkspace(gws,wsName,ws, "X-axis: Q-vector modulus; Y-axis: intermediate structure factor");
}
/**
* Convenience function to store a detector value into a given spectrum.
* Note that this type of data doesn't use TOD, so that we use a single dummy
* bin in X. Each detector is defined as a spectrum of length 1.
* @param ws: workspace
* @param specID: ID of the spectrum to store the value in
* @param value: value to store [count]
* @param error: error on the value [count]
* @param wavelength: wavelength value [Angstrom]
* @param dwavelength: error on the wavelength [Angstrom]
*/
void store_value(DataObjects::Workspace2D_sptr ws, int specID, double value,
double error, double wavelength, double dwavelength) {
MantidVec &X = ws->dataX(specID);
MantidVec &Y = ws->dataY(specID);
MantidVec &E = ws->dataE(specID);
// The following is mostly to make Mantid happy by defining a histogram with
// a single bin around the neutron wavelength
X[0] = wavelength - dwavelength / 2.0;
X[1] = wavelength + dwavelength / 2.0;
Y[0] = value;
E[0] = error;
ws->getSpectrum(specID)->setSpectrumNo(specID);
}
/** Select background points
*/
void ProcessBackground::selectFromGivenXValues() {
// Get special input properties
std::vector<double> bkgdpoints = getProperty("BackgroundPoints");
string mode = getProperty("BackgroundPointSelectMode");
// Construct background workspace for fit
std::vector<double> realx, realy, reale;
const MantidVec &vecX = m_dataWS->readX(m_wsIndex);
const MantidVec &vecY = m_dataWS->readY(m_wsIndex);
const MantidVec &vecE = m_dataWS->readE(m_wsIndex);
for (size_t i = 0; i < bkgdpoints.size(); ++i) {
// Data range validation
double bkgdpoint = bkgdpoints[i];
if (bkgdpoint < vecX.front()) {
g_log.warning() << "Input background point " << bkgdpoint
<< " is out of lower boundary. "
<< "Use X[0] = " << vecX.front() << " instead."
<< "\n";
bkgdpoint = vecX.front();
} else if (bkgdpoint > vecX.back()) {
g_log.warning() << "Input background point " << bkgdpoint
<< " is out of upper boundary. Use X[-1] = "
<< vecX.back() << " instead."
<< "\n";
bkgdpoint = vecX.back();
}
// Find the index in
std::vector<double>::const_iterator it;
it = std::lower_bound(vecX.begin(), vecX.end(), bkgdpoint);
size_t index = size_t(it - vecX.begin());
g_log.debug() << "DBx502 Background Points " << i << " Index = " << index
<< " For TOF = " << bkgdpoints[i] << " in [" << vecX[0]
<< ", " << vecX.back() << "] "
<< "\n";
// Add to list
realx.push_back(vecX[index]);
realy.push_back(vecY[index]);
reale.push_back(vecE[index]);
} // ENDFOR (i)
DataObjects::Workspace2D_sptr bkgdWS =
boost::dynamic_pointer_cast<DataObjects::Workspace2D>(
API::WorkspaceFactory::Instance().create("Workspace2D", 1,
realx.size(), realy.size()));
for (size_t i = 0; i < realx.size(); ++i) {
bkgdWS->dataX(0)[i] = realx[i];
bkgdWS->dataY(0)[i] = realy[i];
bkgdWS->dataE(0)[i] = reale[i];
}
// Select background points according to mode
if (mode.compare("All Background Points") == 0) {
// Select (possibly) all background points
m_outputWS = autoBackgroundSelection(bkgdWS);
} else if (mode.compare("Input Background Points Only") == 0) {
// Use the input background points only
m_outputWS = bkgdWS;
} else {
stringstream errss;
errss << "Background select mode " << mode
<< " is not supported by ProcessBackground.";
g_log.error(errss.str());
throw runtime_error(errss.str());
}
return;
}
/**
* Load a given period into the workspace
* @param period :: The period number to load (starting from 1)
* @param entry :: The opened root entry node for accessing the monitor and data nodes
* @param local_workspace :: The workspace to place the data in
*/
void LoadISISNexus2::loadPeriodData(int64_t period, NXEntry & entry, DataObjects::Workspace2D_sptr local_workspace)
{
int64_t hist_index = 0;
int64_t period_index(period - 1);
int64_t first_monitor_spectrum = 0;
if( !m_monitors.empty() )
{
first_monitor_spectrum = m_monitors.begin()->first;
hist_index = first_monitor_spectrum - 1;
for(std::map<int64_t,std::string>::const_iterator it = m_monitors.begin();
it != m_monitors.end(); ++it)
{
NXData monitor = entry.openNXData(it->second);
NXInt mondata = monitor.openIntData();
m_progress->report("Loading monitor");
mondata.load(1,static_cast<int>(period-1)); // TODO this is just wrong
MantidVec& Y = local_workspace->dataY(hist_index);
Y.assign(mondata(),mondata() + m_numberOfChannels);
MantidVec& E = local_workspace->dataE(hist_index);
std::transform(Y.begin(), Y.end(), E.begin(), dblSqrt);
local_workspace->getAxis(1)->spectraNo(hist_index) = static_cast<specid_t>(it->first);
NXFloat timeBins = monitor.openNXFloat("time_of_flight");
timeBins.load();
local_workspace->dataX(hist_index).assign(timeBins(),timeBins() + timeBins.dim0());
hist_index++;
}
if (first_monitor_spectrum > 1)
{
hist_index = 0;
}
}
if( m_have_detector )
{
NXData nxdata = entry.openNXData("detector_1");
NXDataSetTyped<int> data = nxdata.openIntData();
data.open();
//Start with thelist members that are lower than the required spectrum
const int * const spec_begin = m_spec.get();
std::vector<int64_t>::iterator min_end = m_spec_list.end();
if( !m_spec_list.empty() )
{
// If we have a list, by now it is ordered so first pull in the range below the starting block range
// Note the reverse iteration as we want the last one
if( m_range_supplied )
{
min_end = std::find_if(m_spec_list.begin(), m_spec_list.end(), std::bind2nd(std::greater<int>(), m_spec_min));
}
for( std::vector<int64_t>::iterator itr = m_spec_list.begin(); itr < min_end; ++itr )
{
// Load each
int64_t spectra_no = (*itr);
// For this to work correctly, we assume that the spectrum list increases monotonically
int64_t filestart = std::lower_bound(spec_begin,m_spec_end,spectra_no) - spec_begin;
m_progress->report("Loading data");
loadBlock(data, static_cast<int64_t>(1), period_index, filestart, hist_index, spectra_no, local_workspace);
}
}
if( m_range_supplied )
{
// When reading in blocks we need to be careful that the range is exactly divisible by the blocksize
// and if not have an extra read of the left overs
const int64_t blocksize = 8;
const int64_t rangesize = (m_spec_max - m_spec_min + 1) - m_monitors.size();
const int64_t fullblocks = rangesize / blocksize;
int64_t read_stop = 0;
int64_t spectra_no = m_spec_min;
if (first_monitor_spectrum == 1)
{// this if crudely checks whether the monitors are at the begining or end of the spectra
spectra_no += static_cast<int>(m_monitors.size());
}
// For this to work correctly, we assume that the spectrum list increases monotonically
int64_t filestart = std::lower_bound(spec_begin,m_spec_end,spectra_no) - spec_begin;
if( fullblocks > 0 )
{
read_stop = (fullblocks * blocksize);// + m_monitors.size(); //RNT: I think monitors are excluded from the data
//for( ; hist_index < read_stop; )
for(int64_t i = 0; i < fullblocks; ++i)
{
loadBlock(data, blocksize, period_index, filestart, hist_index, spectra_no, local_workspace);
filestart += blocksize;
}
}
int64_t finalblock = rangesize - (fullblocks * blocksize);
if( finalblock > 0 )
{
loadBlock(data, finalblock, period_index, filestart, hist_index, spectra_no, local_workspace);
}
}
//Load in the last of the list indices
for( std::vector<int64_t>::iterator itr = min_end; itr < m_spec_list.end(); ++itr )
{
// Load each
int64_t spectra_no = (*itr);
// For this to work correctly, we assume that the spectrum list increases monotonically
int64_t filestart = std::lower_bound(spec_begin,m_spec_end,spectra_no) - spec_begin;
loadBlock(data, 1, period_index, filestart, hist_index, spectra_no, local_workspace);
}
}
try
{
const std::string title = entry.getString("title");
local_workspace->setTitle(title);
// write the title into the log file (run object)
local_workspace->mutableRun().addProperty("run_title", title, true);
}
catch (std::runtime_error &)
{
g_log.debug() << "No title was found in the input file, " << getPropertyValue("Filename") << std::endl;
}
}
/**
* Create one workspace to hold the real part and another to hold the imaginary
* part.
* We symmetrize the structure factor to negative times
* Y-values are structure factor for each Q-value
* X-values are time bins
* @param h5file file identifier
* @param gws pointer to WorkspaceGroup being filled
* @param setName string name of dataset
* @param qvmod vector of Q-vectors' moduli
* @param sorting_indexes permutation of qvmod indexes to render it in increasing
* order of momemtum transfer
*/
void LoadSassena::loadFQT(const hid_t &h5file, API::WorkspaceGroup_sptr gws,
const std::string setName, const MantidVec &qvmod,
const std::vector<int> &sorting_indexes) {
const std::string gwsName = this->getPropertyValue("OutputWorkspace");
int nq = static_cast<int>(qvmod.size()); // number of q-vectors
const double dt =
getProperty("TimeUnit"); // time unit increment, in picoseconds;
hsize_t dims[3];
if (dataSetInfo(h5file, setName, dims) < 0) {
throw Kernel::Exception::FileError(
"Unable to read " + setName + " dataset info:", m_filename);
}
int nnt = static_cast<int>(dims[1]); // number of non-negative time points
int nt = 2 * nnt - 1; // number of time points
int origin = nnt - 1;
double *buf = new double[nq * nnt * 2];
this->dataSetDouble(h5file, setName, buf);
DataObjects::Workspace2D_sptr wsRe =
boost::dynamic_pointer_cast<DataObjects::Workspace2D>(
API::WorkspaceFactory::Instance().create("Workspace2D", nq, nt, nt));
const std::string wsReName =
gwsName + std::string("_") + setName + std::string(".Re");
wsRe->setTitle(wsReName);
DataObjects::Workspace2D_sptr wsIm =
boost::dynamic_pointer_cast<DataObjects::Workspace2D>(
API::WorkspaceFactory::Instance().create("Workspace2D", nq, nt, nt));
const std::string wsImName =
gwsName + std::string("_") + setName + std::string(".Im");
wsIm->setTitle(wsImName);
for (int iq = 0; iq < nq; iq++) {
MantidVec &reX = wsRe->dataX(iq);
MantidVec &imX = wsIm->dataX(iq);
MantidVec &reY = wsRe->dataY(iq);
MantidVec &imY = wsIm->dataY(iq);
const int index = sorting_indexes[iq];
double *curr = buf + index * nnt * 2;
for (int it = 0; it < nnt; it++) {
reX[origin + it] = it * dt; // time point for the real part
reY[origin + it] =
*curr; // real part of the intermediate structure factor
reX[origin - it] = -it * dt; // symmetric negative time
reY[origin - it] = *curr; // symmetric value for the negative time
curr++;
imX[origin + it] = it * dt;
imY[origin + it] = *curr;
imX[origin - it] = -it * dt;
imY[origin - it] = -(*curr); // antisymmetric value for negative times
curr++;
}
}
delete[] buf;
// Set the Time unit for the X-axis
wsRe->getAxis(0)->unit() = Kernel::UnitFactory::Instance().create("Label");
auto unitPtr = boost::dynamic_pointer_cast<Kernel::Units::Label>(
wsRe->getAxis(0)->unit());
unitPtr->setLabel("Time", "picoseconds");
wsIm->getAxis(0)->unit() = Kernel::UnitFactory::Instance().create("Label");
unitPtr = boost::dynamic_pointer_cast<Kernel::Units::Label>(
wsIm->getAxis(0)->unit());
unitPtr->setLabel("Time", "picoseconds");
// Create a numeric axis to replace the default vertical one
API::Axis *const verticalAxisRe = new API::NumericAxis(nq);
API::Axis *const verticalAxisIm = new API::NumericAxis(nq);
wsRe->replaceAxis(1, verticalAxisRe);
wsIm->replaceAxis(1, verticalAxisIm);
// Now set the axis values
for (int i = 0; i < nq; ++i) {
verticalAxisRe->setValue(i, qvmod[i]);
verticalAxisIm->setValue(i, qvmod[i]);
}
// Set the axis units
verticalAxisRe->unit() =
Kernel::UnitFactory::Instance().create("MomentumTransfer");
verticalAxisRe->title() = "|Q|";
verticalAxisIm->unit() =
Kernel::UnitFactory::Instance().create("MomentumTransfer");
verticalAxisIm->title() = "|Q|";
// Set the X axis title (for conversion to MD)
wsRe->getAxis(0)->title() = "Energy transfer";
wsIm->getAxis(0)->title() = "Energy transfer";
// Register the workspaces
registerWorkspace(
gws, wsReName, wsRe,
"X-axis: time; Y-axis: real part of intermediate structure factor");
registerWorkspace(
gws, wsImName, wsIm,
"X-axis: time; Y-axis: imaginary part of intermediate structure factor");
}
/**
* Load a given period into the workspace
* @param period :: The period number to load (starting from 1)
* @param entry :: The opened root entry node for accessing the monitor and data
* nodes
* @param local_workspace :: The workspace to place the data in
* @param update_spectra2det_mapping :: reset spectra-detector map to the one
* calculated earlier. (Warning! -- this map has to be calculated correctly!)
*/
void
LoadISISNexus2::loadPeriodData(int64_t period, NXEntry &entry,
DataObjects::Workspace2D_sptr &local_workspace,
bool update_spectra2det_mapping) {
int64_t hist_index = 0;
int64_t period_index(period - 1);
// int64_t first_monitor_spectrum = 0;
for (auto block = m_spectraBlocks.begin(); block != m_spectraBlocks.end();
++block) {
if (block->isMonitor) {
NXData monitor = entry.openNXData(block->monName);
NXInt mondata = monitor.openIntData();
m_progress->report("Loading monitor");
mondata.load(1, static_cast<int>(period - 1)); // TODO this is just wrong
MantidVec &Y = local_workspace->dataY(hist_index);
Y.assign(mondata(), mondata() + m_monBlockInfo.numberOfChannels);
MantidVec &E = local_workspace->dataE(hist_index);
std::transform(Y.begin(), Y.end(), E.begin(), dblSqrt);
if (update_spectra2det_mapping) {
// local_workspace->getAxis(1)->setValue(hist_index,
// static_cast<specid_t>(it->first));
auto spec = local_workspace->getSpectrum(hist_index);
specid_t specID = m_specInd2specNum_map.at(hist_index);
spec->setDetectorIDs(
m_spec2det_map.getDetectorIDsForSpectrumNo(specID));
spec->setSpectrumNo(specID);
}
NXFloat timeBins = monitor.openNXFloat("time_of_flight");
timeBins.load();
local_workspace->dataX(hist_index)
.assign(timeBins(), timeBins() + timeBins.dim0());
hist_index++;
} else if (m_have_detector) {
NXData nxdata = entry.openNXData("detector_1");
NXDataSetTyped<int> data = nxdata.openIntData();
data.open();
// Start with the list members that are lower than the required spectrum
const int *const spec_begin = m_spec.get();
// When reading in blocks we need to be careful that the range is exactly
// divisible by the block-size
// and if not have an extra read of the left overs
const int64_t blocksize = 8;
const int64_t rangesize = block->last - block->first + 1;
const int64_t fullblocks = rangesize / blocksize;
int64_t spectra_no = block->first;
// For this to work correctly, we assume that the spectrum list increases
// monotonically
int64_t filestart =
std::lower_bound(spec_begin, m_spec_end, spectra_no) - spec_begin;
if (fullblocks > 0) {
for (int64_t i = 0; i < fullblocks; ++i) {
loadBlock(data, blocksize, period_index, filestart, hist_index,
spectra_no, local_workspace);
filestart += blocksize;
}
}
int64_t finalblock = rangesize - (fullblocks * blocksize);
if (finalblock > 0) {
loadBlock(data, finalblock, period_index, filestart, hist_index,
spectra_no, local_workspace);
}
}
}
try {
const std::string title = entry.getString("title");
local_workspace->setTitle(title);
// write the title into the log file (run object)
local_workspace->mutableRun().addProperty("run_title", title, true);
} catch (std::runtime_error &) {
g_log.debug() << "No title was found in the input file, "
<< getPropertyValue("Filename") << std::endl;
}
}