/// Retrieve and check the Start/EndX parameters, if set
void Linear::setRange(const MantidVec& X, const MantidVec& Y)
{
//read in the values that the user selected
double startX = getProperty("StartX");
double endX = getProperty("EndX");
//If the user didn't a start default to the start of the data
if ( isEmpty(startX) ) startX = X.front();
//the default for the end is the end of the data
if ( isEmpty(endX) ) endX = X.back();
// Check the validity of startX
if ( startX < X.front() )
{
g_log.warning("StartX out of range! Set to start of frame.");
startX = X.front();
}
// Now get the corresponding bin boundary that comes before (or coincides with) this value
for (m_minX = 0; X[m_minX+1] < startX; ++m_minX) {}
// Check the validity of endX and get the bin boundary that come after (or coincides with) it
if ( endX >= X.back() || endX < startX )
{
if ( endX != X.back() )
{
g_log.warning("EndX out of range! Set to end of frame");
endX = X.back();
}
m_maxX = static_cast<int>(Y.size());
}
else
{
for (m_maxX = m_minX; X[m_maxX] < endX; ++m_maxX) {}
}
}
/** Calculates the rebin paramters in the case where the two input workspaces do
* not overlap at all.
* @param X1 :: The bin boundaries from the first workspace
* @param X2 :: The bin boundaries from the second workspace
* @param params :: A reference to the vector of rebinning parameters
*/
void MergeRuns::noOverlapParams(const MantidVec &X1, const MantidVec &X2,
std::vector<double> ¶ms) const {
// Add all the bins from the first workspace
for (size_t i = 1; i < X1.size(); ++i) {
params.push_back(X1[i - 1]);
params.push_back(X1[i] - X1[i - 1]);
}
// Put a single bin in the 'gap' (but check first the 'gap' isn't zero)
if (X1.back() < X2.front()) {
params.push_back(X1.back());
params.push_back(X2.front() - X1.back());
}
// Now add all the bins from the second workspace
for (size_t j = 1; j < X2.size(); ++j) {
params.push_back(X2[j - 1]);
params.push_back(X2[j] - X2[j - 1]);
}
params.push_back(X2.back());
}
/** Calculates the overall normalization factor.
* This multiplies result by (bin width * sum of monitor counts) / total frame
* width.
* @param X The X vector
* @param Y The data vector
* @param E The error vector
*/
void NormaliseToMonitor::normalisationFactor(const MantidVec &X, MantidVec *Y,
MantidVec *E) {
const double monitorSum = std::accumulate(Y->begin(), Y->end(), 0.0);
const double range = X.back() - X.front();
MantidVec::size_type specLength = Y->size();
for (MantidVec::size_type j = 0; j < specLength; ++j) {
const double factor = range / ((X[j + 1] - X[j]) * monitorSum);
(*Y)[j] *= factor;
(*E)[j] *= factor;
}
}
/**
* @param tofMin Return value for minimum tof to be masked
* @param tofMax Return value for maximum tof to be masked
* @param tofPeak time-of-flight of the single crystal peak
* @param tof tof-of-flight axis for the spectrum where the peak supposedly
* exists
*/
void MaskPeaksWorkspace::getTofRange(double &tofMin, double &tofMax,
const double tofPeak,
const MantidVec &tof) {
tofMin = tof.front();
tofMax = tof.back() - 1;
if (!isEmpty(m_tofMin)) {
tofMin = tofPeak + m_tofMin;
}
if (!isEmpty(m_tofMax)) {
tofMax = tofPeak + m_tofMax;
}
}
/**
* Get the start and end of the x-interval.
* @param X :: The x-vector of a spectrum.
* @param isHistogram :: Is the x-vector comming form a histogram? If it's true
* the bin
* centres are used.
* @return :: A pair of start x and end x.
*/
std::pair<double, double> WienerSmooth::getStartEnd(const MantidVec &X,
bool isHistogram) const {
const size_t n = X.size();
if (n < 3) {
// 3 is the smallest number for this method to work without breaking
throw std::runtime_error(
"Number of bins/data points cannot be smaller than 3.");
}
if (isHistogram) {
return std::make_pair((X[0] + X[1]) / 2, (X[n - 1] + X[n - 2]) / 2);
}
// else
return std::make_pair(X.front(), X.back());
}
/** Write data in SLOG format
*/
void SaveGSS::writeSLOGdata(const int bank, const bool MultiplyByBinWidth,
std::stringstream &out, const MantidVec &X,
const MantidVec &Y, const MantidVec &E) const {
const size_t datasize = Y.size();
double bc1 = X.front(); // minimum TOF in microseconds
if (bc1 <= 0.) {
throw std::runtime_error(
"Cannot write out logarithmic data starting at zero");
}
double bc2 = 0.5 * (*(X.rbegin()) +
*(X.rbegin() + 1)); // maximum TOF (in microseconds?)
double bc3 = (*(X.begin() + 1) - bc1) / bc1; // deltaT/T
g_log.debug() << "SaveGSS(): Min TOF = " << bc1 << std::endl;
writeBankLine(out, "SLOG", bank, datasize);
out << std::fixed << " " << std::setprecision(0) << std::setw(10) << bc1
<< std::fixed << " " << std::setprecision(0) << std::setw(10) << bc2
<< std::fixed << " " << std::setprecision(7) << std::setw(10) << bc3
<< std::fixed << " 0 FXYE" << std::endl;
for (size_t i = 0; i < datasize; i++) {
double y = Y[i];
double e = E[i];
if (MultiplyByBinWidth) {
// Multiple by bin width as
double delta = X[i + 1] - X[i];
y *= delta;
e *= delta;
}
e = fixErrorValue(e);
out << " " << std::fixed << std::setprecision(9) << std::setw(20)
<< 0.5 * (X[i] + X[i + 1]) << " " << std::fixed << std::setprecision(9)
<< std::setw(20) << y << " " << std::fixed << std::setprecision(9)
<< std::setw(20) << e << std::setw(12) << " "
<< "\n"; // let it flush its own buffer
}
out << std::flush;
return;
}
