/**
* Execute the algorithm
*/
void LoadRKH::exec() {
using namespace Mantid::Kernel;
using namespace Mantid::API;
// Retrieve filename and try to open the file
std::string filename = getPropertyValue("Filename");
m_fileIn.open(filename.c_str());
if (!m_fileIn) {
g_log.error("Unable to open file " + filename);
throw Exception::FileError("Unable to open File: ", filename);
}
g_log.information() << "Opened file \"" << filename << "\" for reading\n";
std::string line;
// The first line contains human readable information about the original
// workspace that we don't need
getline(m_fileIn, line);
getline(m_fileIn, line);
// Use one line of the file to diagnose if it is 1D or 2D, this line contains
// some data required by the 2D data reader
MatrixWorkspace_sptr result = is2D(line) ? read2D(line) : read1D();
// all RKH files contain distribution data
result->setDistribution(true);
// Set the output workspace
setProperty("OutputWorkspace", result);
}
/**
* This function gets the input workspace. In the case for a RebinnedOutput
* workspace, it must be cleaned before proceeding. Other workspaces are
* untouched.
* @return the input workspace, cleaned if necessary
*/
MatrixWorkspace_sptr Integration::getInputWorkspace() {
MatrixWorkspace_sptr temp = getProperty("InputWorkspace");
if (temp->id() == "RebinnedOutput") {
// Clean the input workspace in the RebinnedOutput case for nan's and
// inf's in order to treat the data correctly later.
IAlgorithm_sptr alg = this->createChildAlgorithm("ReplaceSpecialValues");
alg->setProperty<MatrixWorkspace_sptr>("InputWorkspace", temp);
std::string outName = "_" + temp->getName() + "_clean";
alg->setProperty("OutputWorkspace", outName);
alg->setProperty("NaNValue", 0.0);
alg->setProperty("NaNError", 0.0);
alg->setProperty("InfinityValue", 0.0);
alg->setProperty("InfinityError", 0.0);
alg->executeAsChildAlg();
temp = alg->getProperty("OutputWorkspace");
}
// To integrate point data it will be converted to histograms
if (!temp->isHistogramData()) {
auto alg = this->createChildAlgorithm("ConvertToHistogram");
alg->setProperty<MatrixWorkspace_sptr>("InputWorkspace", temp);
std::string outName = "_" + temp->getName() + "_histogram";
alg->setProperty("OutputWorkspace", outName);
alg->executeAsChildAlg();
temp = alg->getProperty("OutputWorkspace");
temp->setDistribution(true);
}
return temp;
}
/**
* Creates the output workspace for this algorithm
* @param inputWorkspace A parent workspace to initialize from.
* @return A pointer to the output workspace.
*/
API::MatrixWorkspace_sptr Transpose::createOutputWorkspace(
API::MatrixWorkspace_const_sptr inputWorkspace) {
Mantid::API::Axis *yAxis = getVerticalAxis(inputWorkspace);
const size_t oldNhist = inputWorkspace->getNumberHistograms();
const auto &inX = inputWorkspace->x(0);
const size_t oldYlength = inputWorkspace->blocksize();
const size_t oldVerticalAxislength = yAxis->length();
// The input Y axis may be binned so the new X data should be too
size_t newNhist(oldYlength), newXsize(oldVerticalAxislength),
newYsize(oldNhist);
MatrixWorkspace_sptr outputWorkspace = inputWorkspace->cloneEmpty();
outputWorkspace->initialize(newNhist, newXsize, newYsize);
outputWorkspace->setTitle(inputWorkspace->getTitle());
outputWorkspace->setComment(inputWorkspace->getComment());
outputWorkspace->copyExperimentInfoFrom(inputWorkspace.get());
outputWorkspace->setYUnit(inputWorkspace->YUnit());
outputWorkspace->setYUnitLabel(inputWorkspace->YUnitLabel());
outputWorkspace->setDistribution(inputWorkspace->isDistribution());
// Create a new numeric axis for Y the same length as the old X array
// Values come from input X
API::NumericAxis *newYAxis(nullptr);
if (inputWorkspace->isHistogramData()) {
newYAxis = new API::BinEdgeAxis(inX.rawData());
} else {
newYAxis = new API::NumericAxis(inX.rawData());
}
newYAxis->unit() = inputWorkspace->getAxis(0)->unit();
outputWorkspace->getAxis(0)->unit() = inputWorkspace->getAxis(1)->unit();
outputWorkspace->replaceAxis(1, newYAxis);
setProperty("OutputWorkspace", outputWorkspace);
return outputWorkspace;
}
MatrixWorkspace_sptr MonteCarloAbsorption::createOutputWorkspace(
const MatrixWorkspace &inputWS) const {
MatrixWorkspace_sptr outputWS = inputWS.clone();
// The algorithm computes the signal values at bin centres so they should
// be treated as a distribution
outputWS->setDistribution(true);
outputWS->setYUnit("");
outputWS->setYUnitLabel("Attenuation factor");
return outputWS;
}
MatrixWorkspace_sptr CalculateCarpenterSampleCorrection::createOutputWorkspace(
const MatrixWorkspace_sptr &inputWksp, const std::string ylabel) const {
MatrixWorkspace_sptr outputWS = create<HistoWorkspace>(*inputWksp);
// The algorithm computes the signal values at bin centres so they should
// be treated as a distribution
outputWS->setDistribution(true);
outputWS->setYUnit("");
outputWS->setYUnitLabel(ylabel);
return outputWS;
}
/** Initialize 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->setDistribution(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++) {
auto &childSpec = child->getSpectrum(wi);
const auto &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;
}
MatrixWorkspace_sptr
JoinISISPolarizationEfficiencies::interpolateHistogramWorkspace(
MatrixWorkspace_sptr ws, size_t const maxSize) {
ws->setDistribution(true);
auto const &x = ws->x(0);
auto const dX = (x.back() - x.front()) / double(maxSize);
std::vector<double> params(2 * maxSize + 1);
for (size_t i = 0; i < maxSize; ++i) {
params[2 * i] = x.front() + dX * double(i);
params[2 * i + 1] = dX;
}
params.back() = x.back();
auto alg = createChildAlgorithm("InterpolatingRebin");
alg->setProperty("InputWorkspace", ws);
alg->setProperty("Params", params);
alg->setProperty("OutputWorkspace", "dummy");
alg->execute();
MatrixWorkspace_sptr interpolatedWS = alg->getProperty("OutputWorkspace");
assert(interpolatedWS->y(0).size() == maxSize);
assert(interpolatedWS->x(0).size() == maxSize + 1);
return interpolatedWS;
}
/** Creates the output workspace, its size, units, etc.
* @param binParams the bin boundary specification using the same same syntax as
* param the Rebin algorithm
* @return A pointer to the newly-created workspace
*/
API::MatrixWorkspace_sptr
Q1D2::setUpOutputWorkspace(const std::vector<double> &binParams) const {
// Calculate the output binning
HistogramData::BinEdges XOut(0);
size_t sizeOut = static_cast<size_t>(VectorHelper::createAxisFromRebinParams(
binParams, XOut.mutableRawData()));
// Now create the output workspace
MatrixWorkspace_sptr outputWS =
WorkspaceFactory::Instance().create(m_dataWS, 1, sizeOut, sizeOut - 1);
outputWS->getAxis(0)->unit() =
UnitFactory::Instance().create("MomentumTransfer");
outputWS->setYUnitLabel("1/cm");
// Set the X vector for the output workspace
outputWS->setBinEdges(0, XOut);
outputWS->setDistribution(true);
outputWS->getSpectrum(0).clearDetectorIDs();
outputWS->getSpectrum(0).setSpectrumNo(1);
return outputWS;
}
void SANSSolidAngleCorrection::exec() {
// Reduction property manager
const std::string reductionManagerName = getProperty("ReductionProperties");
boost::shared_ptr<PropertyManager> reductionManager;
if (PropertyManagerDataService::Instance().doesExist(reductionManagerName)) {
reductionManager =
PropertyManagerDataService::Instance().retrieve(reductionManagerName);
} else {
reductionManager = boost::make_shared<PropertyManager>();
PropertyManagerDataService::Instance().addOrReplace(reductionManagerName,
reductionManager);
}
// If the solid angle algorithm isn't in the reduction properties, add it
if (!reductionManager->existsProperty("SolidAngleAlgorithm")) {
auto algProp = make_unique<AlgorithmProperty>("SolidAngleAlgorithm");
algProp->setValue(toString());
reductionManager->declareProperty(std::move(algProp));
}
MatrixWorkspace_const_sptr inputWS = getProperty("InputWorkspace");
DataObjects::EventWorkspace_const_sptr inputEventWS =
boost::dynamic_pointer_cast<const EventWorkspace>(inputWS);
if (inputEventWS)
return execEvent();
// Now create the output workspace
MatrixWorkspace_sptr outputWS = getProperty("OutputWorkspace");
if (outputWS != inputWS) {
outputWS = WorkspaceFactory::Instance().create(inputWS);
outputWS->setDistribution(true);
outputWS->setYUnit("");
outputWS->setYUnitLabel("Steradian");
setProperty("OutputWorkspace", outputWS);
}
const int numHists = static_cast<int>(inputWS->getNumberHistograms());
Progress progress(this, 0.0, 1.0, numHists);
// Number of X bins
const int xLength = static_cast<int>(inputWS->readY(0).size());
PARALLEL_FOR2(outputWS, inputWS)
for (int i = 0; i < numHists; ++i) {
PARALLEL_START_INTERUPT_REGION
outputWS->dataX(i) = inputWS->readX(i);
IDetector_const_sptr det;
try {
det = inputWS->getDetector(i);
} catch (Exception::NotFoundError &) {
g_log.warning() << "Workspace index " << i
<< " has no detector assigned to it - discarding\n";
// Catch if no detector. Next line tests whether this happened - test
// placed
// outside here because Mac Intel compiler doesn't like 'continue' in a
// catch
// in an openmp block.
}
// If no detector found, skip onto the next spectrum
if (!det)
continue;
// Skip if we have a monitor or if the detector is masked.
if (det->isMonitor() || det->isMasked())
continue;
const MantidVec &YIn = inputWS->readY(i);
const MantidVec &EIn = inputWS->readE(i);
MantidVec &YOut = outputWS->dataY(i);
MantidVec &EOut = outputWS->dataE(i);
// Compute solid angle correction factor
const bool is_tube = getProperty("DetectorTubes");
const bool is_wing = getProperty("DetectorWing");
const double tanTheta = tan(inputWS->detectorTwoTheta(*det));
const double theta_term = sqrt(tanTheta * tanTheta + 1.0);
double corr;
if (is_tube || is_wing) {
const double tanAlpha = tan(getYTubeAngle(det, inputWS));
const double alpha_term = sqrt(tanAlpha * tanAlpha + 1.0);
if (is_tube)
corr = alpha_term * theta_term * theta_term;
else // if (is_wing) {
corr = alpha_term;
} else {
corr = theta_term * theta_term * theta_term;
}
// Correct data for all X bins
for (int j = 0; j < xLength; j++) {
YOut[j] = YIn[j] * corr;
EOut[j] = fabs(EIn[j] * corr);
}
progress.report("Solid Angle Correction");
PARALLEL_END_INTERUPT_REGION
}
PARALLEL_CHECK_INTERUPT_REGION
setProperty("OutputMessage", "Solid angle correction applied");
}
Workspace_sptr SeqDomainSpectrumCreator::createOutputWorkspace(
const std::string &baseName, IFunction_sptr function,
boost::shared_ptr<FunctionDomain> domain,
boost::shared_ptr<FunctionValues> values,
const std::string &outputWorkspacePropertyName) {
// don't need values, since the values need to be calculated spectrum by
// spectrum (see loop below).
UNUSED_ARG(values);
boost::shared_ptr<SeqDomain> seqDomain =
boost::dynamic_pointer_cast<SeqDomain>(domain);
if (!seqDomain) {
throw std::invalid_argument("CreateOutputWorkspace requires SeqDomain.");
}
if (!m_matrixWorkspace) {
throw std::invalid_argument("No MatrixWorkspace assigned. Cannot construct "
"proper output workspace.");
}
MatrixWorkspace_sptr outputWs = boost::dynamic_pointer_cast<MatrixWorkspace>(
WorkspaceFactory::Instance().create(m_matrixWorkspace));
// Assign y-values, taking into account masked detectors
for (size_t i = 0; i < seqDomain->getNDomains(); ++i) {
FunctionDomain_sptr localDomain;
FunctionValues_sptr localValues;
seqDomain->getDomainAndValues(i, localDomain, localValues);
function->function(*localDomain, *localValues);
boost::shared_ptr<FunctionDomain1DSpectrum> spectrumDomain =
boost::dynamic_pointer_cast<FunctionDomain1DSpectrum>(localDomain);
if (spectrumDomain) {
size_t wsIndex = spectrumDomain->getWorkspaceIndex();
auto &yValues = outputWs->mutableY(wsIndex);
for (size_t j = 0; j < yValues.size(); ++j) {
yValues[j] = localValues->getCalculated(j);
}
}
}
// Assign x-values on all histograms
for (size_t i = 0; i < m_matrixWorkspace->getNumberHistograms(); ++i) {
outputWs->setSharedX(i, m_matrixWorkspace->sharedX(i));
}
if (m_manager && !outputWorkspacePropertyName.empty()) {
declareProperty(
new WorkspaceProperty<MatrixWorkspace>(outputWorkspacePropertyName, "",
Kernel::Direction::Output),
"Result workspace");
m_manager->setPropertyValue(outputWorkspacePropertyName,
baseName + "Workspace");
m_manager->setProperty(outputWorkspacePropertyName, outputWs);
}
// If the input is a not an EventWorkspace and is a distrubution, then convert
// the output also to a distribution
if (!boost::dynamic_pointer_cast<Mantid::API::IEventWorkspace>(
m_matrixWorkspace)) {
if (m_matrixWorkspace->isDistribution()) {
outputWs->setDistribution(true);
}
}
return outputWs;
}
