// calculate time from sample to detector
void ModeratorTzeroLinear::calculateTfLi(MatrixWorkspace_const_sptr inputWS,
size_t i, double &t_f, double &L_i) {
static const double convFact = 1.0e-6 * sqrt(2 * PhysicalConstants::meV /
PhysicalConstants::NeutronMass);
static const double TfError = -1.0; // signal error when calculating final
// time
// Get detector position
IDetector_const_sptr det;
try {
det = inputWS->getDetector(i);
} catch (Exception::NotFoundError &) {
t_f = TfError;
return;
}
if (det->isMonitor()) {
L_i = m_instrument->getSource()->getDistance(*det);
t_f = 0.0; // t_f=0.0 since there is no sample to detector path
} else {
IComponent_const_sptr sample = m_instrument->getSample();
try {
L_i = m_instrument->getSource()->getDistance(*sample);
} catch (Exception::NotFoundError &) {
g_log.error("Unable to calculate source-sample distance");
throw Exception::InstrumentDefinitionError(
"Unable to calculate source-sample distance", inputWS->getTitle());
}
// Get final energy E_f, final velocity v_f
std::vector<double> wsProp = det->getNumberParameter("Efixed");
if (!wsProp.empty()) {
double E_f = wsProp.at(0); //[E_f]=meV
double v_f = convFact * sqrt(E_f); //[v_f]=meter/microsec
try {
// obtain L_f, calculate t_f
double L_f = det->getDistance(*sample);
t_f = L_f / v_f;
// g_log.debug() << "detector: " << i << " L_f=" << L_f << " t_f=" <<
// t_f << '\n';
} catch (Exception::NotFoundError &) {
g_log.error("Unable to calculate detector-sample distance");
throw Exception::InstrumentDefinitionError(
"Unable to calculate detector-sample distance",
inputWS->getTitle());
}
} else {
g_log.debug() << "Efixed not found for detector " << i << '\n';
t_f = TfError;
}
}
} // end of CalculateTf(const MatrixWorkspace_sptr inputWS, size_t i)
/** Initialise a workspace from its parent
* This sets values such as title, instrument, units, sample, spectramap.
* This does NOT copy any data.
*
* @param parent :: the parent workspace
* @param child :: the child workspace
* @param differentSize :: A flag to indicate if the two workspace will be different sizes
*/
void WorkspaceFactoryImpl::initializeFromParent(const MatrixWorkspace_const_sptr parent,
const MatrixWorkspace_sptr child, const bool differentSize) const
{
child->setTitle(parent->getTitle());
child->setComment(parent->getComment());
child->setInstrument(parent->getInstrument()); // This call also copies the SHARED POINTER to the parameter map
// This call will (should) perform a COPY of the parameter map.
child->instrumentParameters();
child->m_sample = parent->m_sample;
child->m_run = parent->m_run;
child->setYUnit(parent->m_YUnit);
child->setYUnitLabel(parent->m_YUnitLabel);
child->isDistribution(parent->isDistribution());
// Only copy the axes over if new sizes are not given
if ( !differentSize )
{
// Only copy mask map if same size for now. Later will need to check continued validity.
child->m_masks = parent->m_masks;
}
// Same number of histograms = copy over the spectra data
if (parent->getNumberHistograms() == child->getNumberHistograms())
{
for (size_t wi=0; wi<parent->getNumberHistograms(); wi++)
{
ISpectrum * childSpec = child->getSpectrum(wi);
const ISpectrum * parentSpec = parent->getSpectrum(wi);
// Copy spectrum number and detector IDs
childSpec->copyInfoFrom(*parentSpec);
}
}
// deal with axis
for (size_t i = 0; i < parent->m_axes.size(); ++i)
{
const size_t newAxisLength = child->getAxis(i)->length();
const size_t oldAxisLength = parent->getAxis(i)->length();
if ( !differentSize || newAxisLength == oldAxisLength )
{
// Need to delete the existing axis created in init above
delete child->m_axes[i];
// Now set to a copy of the parent workspace's axis
child->m_axes[i] = parent->m_axes[i]->clone(child.get());
}
else
{
if (! parent->getAxis(i)->isSpectra()) // WHY???
{
delete child->m_axes[i];
// Call the 'different length' clone variant
child->m_axes[i] = parent->m_axes[i]->clone(newAxisLength,child.get());
}
}
}
return;
}
/**
* Construct an SpectrumView for the specified matrix workspace
*/
MatrixWSSpectrumView::MatrixWSSpectrumView( MatrixWorkspace_const_sptr mat_ws )
{
/* This is the QMainWindow for the viewer. */
/* It is deleted when the window is closed. */
spectrum_view = new SpectrumView();
std::string title = "SpectrumView (" + mat_ws->getTitle() + ")";
QString qtitle = QString::fromStdString(title);
spectrum_view->setCaption( qtitle );
spectrum_view->renderWorkspace(mat_ws);
std::cerr << "MatrixWSSpectrumView?" << std::endl;
}
/**
* Execute the algorithm
*/
void ExtractMask::exec()
{
MatrixWorkspace_const_sptr inputWS = getProperty("InputWorkspace");
Geometry::Instrument_const_sptr instr = inputWS->getInstrument();
// convert input to a mask workspace
DataObjects::MaskWorkspace_const_sptr inputMaskWS
= boost::dynamic_pointer_cast<const DataObjects::MaskWorkspace>(inputWS);
bool inputWSIsSpecial = bool(inputMaskWS);
if (inputWSIsSpecial)
{
g_log.notice() << "Input workspace is a MaskWorkspace.\n";
}
DataObjects::MaskWorkspace_sptr maskWS;
// List masked of detector IDs
std::vector<detid_t> detectorList;
if (instr)
{
const int nHist = static_cast<int>(inputWS->getNumberHistograms());
// Create a new workspace for the results, copy from the input to ensure that we copy over the instrument and current masking
maskWS = DataObjects::MaskWorkspace_sptr(new DataObjects::MaskWorkspace(inputWS));
maskWS->setTitle(inputWS->getTitle());
Progress prog(this,0.0,1.0,nHist);
MantidVecPtr xValues;
xValues.access() = MantidVec(1, 0.0);
PARALLEL_FOR2(inputWS, maskWS)
for( int i = 0; i < nHist; ++i )
{
PARALLEL_START_INTERUPT_REGION
bool inputIsMasked(false);
IDetector_const_sptr inputDet;
try
{
inputDet = inputWS->getDetector(i);
if (inputWSIsSpecial) {
inputIsMasked = inputMaskWS->isMaskedIndex(i);
}
// special workspaces can mysteriously have the mask bit set
// but only check if we haven't already decided to mask the spectrum
if( !inputIsMasked && inputDet->isMasked() )
{
inputIsMasked = true;
}
if (inputIsMasked)
{
detid_t id = inputDet->getID();
PARALLEL_CRITICAL(name)
{
detectorList.push_back(id);
}
}
}
catch(Kernel::Exception::NotFoundError &)
{
inputIsMasked = false;
}
maskWS->setMaskedIndex(i, inputIsMasked);
prog.report();
PARALLEL_END_INTERUPT_REGION
}
PARALLEL_CHECK_INTERUPT_REGION
// Clear all the "masked" bits on the output masked workspace
Geometry::ParameterMap & pmap = maskWS->instrumentParameters();
pmap.clearParametersByName("masked");
}
else // no instrument
{
// TODO should fill this in
throw std::runtime_error("No instrument");
void SofQWCentre::exec() {
using namespace Geometry;
MatrixWorkspace_const_sptr inputWorkspace = getProperty("InputWorkspace");
// Do the full check for common binning
if (!WorkspaceHelpers::commonBoundaries(*inputWorkspace)) {
g_log.error(
"The input workspace must have common binning across all spectra");
throw std::invalid_argument(
"The input workspace must have common binning across all spectra");
}
std::vector<double> verticalAxis;
MatrixWorkspace_sptr outputWorkspace = setUpOutputWorkspace(
inputWorkspace, getProperty("QAxisBinning"), verticalAxis);
setProperty("OutputWorkspace", outputWorkspace);
// Holds the spectrum-detector mapping
std::vector<specnum_t> specNumberMapping;
std::vector<detid_t> detIDMapping;
m_EmodeProperties.initCachedValues(*inputWorkspace, this);
int emode = m_EmodeProperties.m_emode;
// Get a pointer to the instrument contained in the workspace
Instrument_const_sptr instrument = inputWorkspace->getInstrument();
// Get the distance between the source and the sample (assume in metres)
IComponent_const_sptr source = instrument->getSource();
IComponent_const_sptr sample = instrument->getSample();
V3D beamDir = sample->getPos() - source->getPos();
beamDir.normalize();
try {
double l1 = source->getDistance(*sample);
g_log.debug() << "Source-sample distance: " << l1 << '\n';
} catch (Exception::NotFoundError &) {
g_log.error("Unable to calculate source-sample distance");
throw Exception::InstrumentDefinitionError(
"Unable to calculate source-sample distance",
inputWorkspace->getTitle());
}
// Conversion constant for E->k. k(A^-1) = sqrt(energyToK*E(meV))
const double energyToK = 8.0 * M_PI * M_PI * PhysicalConstants::NeutronMass *
PhysicalConstants::meV * 1e-20 /
(PhysicalConstants::h * PhysicalConstants::h);
// Loop over input workspace bins, reassigning data to correct bin in output
// qw workspace
const size_t numHists = inputWorkspace->getNumberHistograms();
const size_t numBins = inputWorkspace->blocksize();
Progress prog(this, 0.0, 1.0, numHists);
for (int64_t i = 0; i < int64_t(numHists); ++i) {
try {
// Now get the detector object for this histogram
IDetector_const_sptr spectrumDet = inputWorkspace->getDetector(i);
if (spectrumDet->isMonitor())
continue;
const double efixed = m_EmodeProperties.getEFixed(*spectrumDet);
// For inelastic scattering the simple relationship q=4*pi*sinTheta/lambda
// does not hold. In order to
// be completely general we must calculate the momentum transfer by
// calculating the incident and final
// wave vectors and then use |q| = sqrt[(ki - kf)*(ki - kf)]
DetectorGroup_const_sptr detGroup =
boost::dynamic_pointer_cast<const DetectorGroup>(spectrumDet);
std::vector<IDetector_const_sptr> detectors;
if (detGroup) {
detectors = detGroup->getDetectors();
} else {
detectors.push_back(spectrumDet);
}
const size_t numDets = detectors.size();
// cache to reduce number of static casts
const double numDets_d = static_cast<double>(numDets);
const auto &Y = inputWorkspace->y(i);
const auto &E = inputWorkspace->e(i);
const auto &X = inputWorkspace->x(i);
// Loop over the detectors and for each bin calculate Q
for (size_t idet = 0; idet < numDets; ++idet) {
IDetector_const_sptr det = detectors[idet];
// Calculate kf vector direction and then Q for each energy bin
V3D scatterDir = (det->getPos() - sample->getPos());
scatterDir.normalize();
for (size_t j = 0; j < numBins; ++j) {
const double deltaE = 0.5 * (X[j] + X[j + 1]);
// Compute ki and kf wave vectors and therefore q = ki - kf
double ei(0.0), ef(0.0);
if (emode == 1) {
ei = efixed;
ef = efixed - deltaE;
if (ef < 0) {
std::string mess =
"Energy transfer requested in Direct mode exceeds incident "
"energy.\n Found for det ID: " +
std::to_string(idet) + " bin No " + std::to_string(j) +
" with Ei=" + boost::lexical_cast<std::string>(efixed) +
" and energy transfer: " +
boost::lexical_cast<std::string>(deltaE);
throw std::runtime_error(mess);
}
} else {
ei = efixed + deltaE;
ef = efixed;
if (ef < 0) {
std::string mess =
"Incident energy of a neutron is negative. Are you trying to "
"process Direct data in Indirect mode?\n Found for det ID: " +
std::to_string(idet) + " bin No " + std::to_string(j) +
" with efied=" + boost::lexical_cast<std::string>(efixed) +
" and energy transfer: " +
boost::lexical_cast<std::string>(deltaE);
throw std::runtime_error(mess);
}
}
if (ei < 0)
throw std::runtime_error(
"Negative incident energy. Check binning.");
const V3D ki = beamDir * sqrt(energyToK * ei);
const V3D kf = scatterDir * (sqrt(energyToK * (ef)));
const double q = (ki - kf).norm();
// Test whether it's in range of the Q axis
if (q < verticalAxis.front() || q > verticalAxis.back())
continue;
// Find which q bin this point lies in
const MantidVec::difference_type qIndex =
std::upper_bound(verticalAxis.begin(), verticalAxis.end(), q) -
verticalAxis.begin() - 1;
// Add this spectra-detector pair to the mapping
specNumberMapping.push_back(
outputWorkspace->getSpectrum(qIndex).getSpectrumNo());
detIDMapping.push_back(det->getID());
// And add the data and it's error to that bin, taking into account
// the number of detectors contributing to this bin
outputWorkspace->mutableY(qIndex)[j] += Y[j] / numDets_d;
// Standard error on the average
outputWorkspace->mutableE(qIndex)[j] =
sqrt((pow(outputWorkspace->e(qIndex)[j], 2) + pow(E[j], 2)) /
numDets_d);
}
}
} catch (Exception::NotFoundError &) {
// Get to here if exception thrown when calculating distance to detector
// Presumably, if we get to here the spectrum will be all zeroes anyway
// (from conversion to E)
continue;
}
prog.report();
}
// If the input workspace was a distribution, need to divide by q bin width
if (inputWorkspace->isDistribution())
this->makeDistribution(outputWorkspace, verticalAxis);
// Set the output spectrum-detector mapping
SpectrumDetectorMapping outputDetectorMap(specNumberMapping, detIDMapping);
outputWorkspace->updateSpectraUsing(outputDetectorMap);
// Replace any NaNs in outputWorkspace with zeroes
if (this->getProperty("ReplaceNaNs")) {
auto replaceNans = this->createChildAlgorithm("ReplaceSpecialValues");
replaceNans->setChild(true);
replaceNans->initialize();
replaceNans->setProperty("InputWorkspace", outputWorkspace);
replaceNans->setProperty("OutputWorkspace", outputWorkspace);
replaceNans->setProperty("NaNValue", 0.0);
replaceNans->setProperty("InfinityValue", 0.0);
replaceNans->setProperty("BigNumberThreshold", DBL_MAX);
replaceNans->execute();
}
}
