/*
Extract the geometry and function information
This implementation is an override of the base-class method, which deals with
the more common event based route. However the SQW files will provide complete
dimensions with ranges already set. Less work needs to be done here than for
event workspaces where the extents of each dimension need to be individually
extracted.
@param eventWs : event workspace to get the information from.
*/
void SQWLoadingPresenter::extractMetadata(
const Mantid::API::IMDEventWorkspace &eventWs) {
using namespace Mantid::Geometry;
MDGeometryBuilderXML<NoDimensionPolicy> refresh;
this->xmlBuilder = refresh; // Reassign.
std::vector<IMDDimension_sptr> dimensions;
size_t nDimensions = eventWs.getNumDims();
for (size_t d = 0; d < nDimensions; d++) {
IMDDimension_const_sptr inDim = eventWs.getDimension(d);
axisLabels.push_back(makeAxisTitle(*inDim));
// Copy the dimension, but set the ID and name to be the same. This is an
// assumption in bintohistoworkspace.
dimensions.push_back(boost::make_shared<MDHistoDimension>(
inDim->getName(), inDim->getName(), inDim->getMDFrame(),
inDim->getMinimum(), inDim->getMaximum(), size_t{10}));
}
// Configuring the geometry xml builder allows the object panel associated
// with this reader to later
// determine how to display all geometry related properties.
if (nDimensions > 0) {
this->xmlBuilder.addXDimension(dimensions[0]);
}
if (nDimensions > 1) {
this->xmlBuilder.addYDimension(dimensions[1]);
}
if (nDimensions > 2) {
this->xmlBuilder.addZDimension(dimensions[2]);
}
if (nDimensions > 3) {
this->tDimension = dimensions[3];
this->xmlBuilder.addTDimension(this->tDimension);
}
this->m_isSetup = true;
}
//-----------------------------------------------------------------------------
/// @return the label for the X axis
QString MantidQwtIMDWorkspaceData::getXAxisLabel() const
{
QString xLabel;
if ( m_originalWorkspace.expired() )
return xLabel; // Empty string
if (m_currentPlotAxis >= 0)
{
// One of the dimensions of the original
IMDDimension_const_sptr dim = m_originalWorkspace.lock()->getDimension(m_currentPlotAxis);
xLabel = QString::fromStdString(dim->getName()) + " (" + QString::fromStdWString(dim->getUnits().utf8()) + ")";
}
else
{
// Distance
// Distance, or not set.
xLabel = "Distance from start";
// if (dimX->getUnits() == dimY->getUnits())
// xLabel += " (" + dimX->getUnits() + ")";
// else
// xLabel += " (undefined units)";
// break;
}
return xLabel;
}
/*
Extract the geometry and function information
@param eventWs : event workspace to get the information from.
*/
void MDEWLoadingPresenter::extractMetadata(Mantid::API::IMDEventWorkspace_sptr eventWs)
{
using namespace Mantid::Geometry;
MDGeometryBuilderXML<NoDimensionPolicy> refresh;
xmlBuilder= refresh; //Reassign.
std::vector<MDDimensionExtents<coord_t> > ext = eventWs->getMinimumExtents(5);
std::vector<IMDDimension_sptr> dimensions;
size_t nDimensions = eventWs->getNumDims();
for (size_t d=0; d<nDimensions; d++)
{
IMDDimension_const_sptr inDim = eventWs->getDimension(d);
coord_t min = ext[d].getMin();
coord_t max = ext[d].getMax();
if (min > max)
{
min = 0.0;
max = 1.0;
}
//std::cout << "dim " << d << min << " to " << max << std::endl;
axisLabels.push_back(makeAxisTitle(inDim));
MDHistoDimension_sptr dim(new MDHistoDimension(inDim->getName(), inDim->getName(), inDim->getUnits(), min, max, inDim->getNBins()));
dimensions.push_back(dim);
}
//Configuring the geometry xml builder allows the object panel associated with this reader to later
//determine how to display all geometry related properties.
if(nDimensions > 0)
{
xmlBuilder.addXDimension( dimensions[0] );
}
if(nDimensions > 1)
{
xmlBuilder.addYDimension( dimensions[1] );
}
if(nDimensions > 2)
{
xmlBuilder.addZDimension( dimensions[2] );
}
if(nDimensions > 3)
{
tDimension = dimensions[3];
xmlBuilder.addTDimension(tDimension);
}
m_isSetup = true;
}
/** Set the original workspace, to show the axes plot choice */
void LinePlotOptions::setOriginalWorkspace(Mantid::API::IMDWorkspace_sptr ws) {
if (!ws)
return;
for (size_t d = 0; d < (ws->getNumDims()); d++) {
IMDDimension_const_sptr dim = ws->getDimension(d);
std::string text = dim->getName();
std::string tooltip =
"Use the " + dim->getName() + " dimension as the X plot axis.";
const bool bIntegrated = dim->getIsIntegrated();
// Index into the radio buttons array
int index = int(d) + 2;
if (m_radPlots.size() > index) {
m_radPlots[index]->setText(QString::fromStdString(text));
m_radPlots[index]->setToolTip(QString::fromStdString(tooltip));
} else
addPlotRadioButton(text, tooltip, bIntegrated);
}
}
/*
Extract the geometry and function information
@param histoWs : histogram workspace to get the information from.
*/
void MDHWLoadingPresenter::extractMetadata(
const Mantid::API::IMDHistoWorkspace &histoWs) {
using namespace Mantid::Geometry;
MDGeometryBuilderXML<NoDimensionPolicy> refresh;
xmlBuilder = refresh; // Reassign.
std::vector<IMDDimension_sptr> dimensions;
size_t nDimensions = histoWs.getNumDims();
for (size_t d = 0; d < nDimensions; d++) {
IMDDimension_const_sptr inDim = histoWs.getDimension(d);
coord_t min = inDim->getMinimum();
coord_t max = inDim->getMaximum();
if (min > max) {
min = 0.0;
max = 1.0;
}
// std::cout << "dim " << d << min << " to " << max << '\n';
axisLabels.push_back(makeAxisTitle(*inDim));
dimensions.push_back(boost::make_shared<MDHistoDimension>(
inDim->getName(), inDim->getName(), inDim->getMDFrame(), min, max,
inDim->getNBins()));
}
// Configuring the geometry xml builder allows the object panel associated
// with this reader to later
// determine how to display all geometry related properties.
if (nDimensions > 0) {
xmlBuilder.addXDimension(dimensions[0]);
}
if (nDimensions > 1) {
xmlBuilder.addYDimension(dimensions[1]);
}
if (nDimensions > 2) {
xmlBuilder.addZDimension(dimensions[2]);
}
if (nDimensions > 3) {
tDimension = dimensions[3];
xmlBuilder.addTDimension(tDimension);
}
m_isSetup = true;
}
/** Execute the algorithm.
*/
void BinaryOperationMD::exec() {
// Get the properties
m_lhs = getProperty(inputPropName1());
m_rhs = getProperty(inputPropName2());
m_out = getProperty(outputPropName());
// Flip LHS and RHS if commutative and :
// 1. A = B + A -> becomes -> A += B
// 1. C = 1 + A -> becomes -> C = A + 1 (number is always on RHS if
// possible)
if (this->commutative() &&
((m_out == m_rhs) ||
boost::dynamic_pointer_cast<WorkspaceSingleValue>(m_lhs))) {
// So we flip RHS/LHS
Mantid::API::IMDWorkspace_sptr temp = m_lhs;
m_lhs = m_rhs;
m_rhs = temp;
}
// Do not compare conventions if one is single value
if (!boost::dynamic_pointer_cast<WorkspaceSingleValue>(m_rhs)) {
if (m_lhs->getConvention() != m_rhs->getConvention()) {
throw std::runtime_error(
"Workspaces have different conventions for Q. "
"Use algorithm ChangeQConvention on one workspace. ");
}
}
// Can't do A = 1 / B
if (boost::dynamic_pointer_cast<MatrixWorkspace>(m_lhs))
throw std::invalid_argument("BinaryOperationMD: can't have a "
"MatrixWorkspace (e.g. WorkspaceSingleValue) "
"as the LHS argument of " +
this->name() + ".");
// Check the inputs. First cast to everything
m_lhs_event = boost::dynamic_pointer_cast<IMDEventWorkspace>(m_lhs);
m_lhs_histo = boost::dynamic_pointer_cast<MDHistoWorkspace>(m_lhs);
m_lhs_scalar = boost::dynamic_pointer_cast<WorkspaceSingleValue>(m_lhs);
m_rhs_event = boost::dynamic_pointer_cast<IMDEventWorkspace>(m_rhs);
m_rhs_histo = boost::dynamic_pointer_cast<MDHistoWorkspace>(m_rhs);
m_rhs_scalar = boost::dynamic_pointer_cast<WorkspaceSingleValue>(m_rhs);
// MDEventWorkspaces only:
// If you have to clone any WS, and the operation is commutative, and is NOT
// in-place, then clone the one that is file-backed.
if (this->commutative() && (m_lhs_event && m_rhs_event) && (m_out != m_lhs)) {
if (m_rhs_event->isFileBacked() && !m_lhs_event->isFileBacked()) {
// So we flip RHS/LHS
Mantid::API::IMDWorkspace_sptr temp = m_lhs;
m_lhs = m_rhs;
m_rhs = temp;
m_lhs_event = boost::dynamic_pointer_cast<IMDEventWorkspace>(m_lhs);
m_rhs_event = boost::dynamic_pointer_cast<IMDEventWorkspace>(m_rhs);
}
}
this->checkInputs();
if (m_out == m_lhs) {
// A = A * B. -> we will do A *= B
} else {
// C = A + B. -> So first we clone A (lhs) into C
IAlgorithm_sptr clone =
this->createChildAlgorithm("CloneMDWorkspace", 0.0, 0.5, true);
clone->setProperty("InputWorkspace", m_lhs);
clone->executeAsChildAlg();
m_out = clone->getProperty("OutputWorkspace");
}
// Okay, at this point we are ready to do, e.g.,
// "m_out /= m_rhs"
if (!m_out)
throw std::runtime_error("Error creating the output workspace");
if (!m_rhs)
throw std::runtime_error("No RHS workspace specified!");
m_operand_event = boost::dynamic_pointer_cast<IMDEventWorkspace>(m_rhs);
m_operand_histo = boost::dynamic_pointer_cast<MDHistoWorkspace>(m_rhs);
m_operand_scalar = boost::dynamic_pointer_cast<WorkspaceSingleValue>(m_rhs);
m_out_event = boost::dynamic_pointer_cast<IMDEventWorkspace>(m_out);
m_out_histo = boost::dynamic_pointer_cast<MDHistoWorkspace>(m_out);
if (m_out_event) {
// Call the templated virtual function for this type of MDEventWorkspace
this->execEvent();
} else if (m_out_histo) {
// MDHistoWorkspace as the output
if (m_operand_histo) {
if (m_out_histo->getNumDims() != m_operand_histo->getNumDims())
throw std::invalid_argument(
"Cannot perform " + this->name() +
" on MDHistoWorkspace's with a different number of dimensions.");
if (m_out_histo->getNPoints() != m_operand_histo->getNPoints())
throw std::invalid_argument(
"Cannot perform " + this->name() +
" on MDHistoWorkspace's with a different number of points.");
// Check that the dimensions span the same size, warn if they don't
for (size_t d = 0; d < m_out_histo->getNumDims(); d++) {
IMDDimension_const_sptr dimA = m_out_histo->getDimension(0);
IMDDimension_const_sptr dimB = m_operand_histo->getDimension(0);
if (dimA->getMinimum() != dimB->getMinimum() ||
dimA->getMaximum() != dimB->getMaximum())
g_log.warning() << "Dimension " << d << " (" << dimA->getName()
<< ") has different extents in the two "
"MDHistoWorkspaces. The operation may not make "
"sense!" << std::endl;
}
this->execHistoHisto(m_out_histo, m_operand_histo);
} else if (m_operand_scalar)
this->execHistoScalar(m_out_histo, m_operand_scalar);
else
throw std::runtime_error(
"Unexpected operand workspace type. Expected MDHistoWorkspace or "
"WorkspaceSingleValue, got " +
m_rhs->id());
// When operating on MDHistoWorkspaces, add a simple flag
// that will be checked in BinMD to avoid binning a modified workspace
if (m_out_histo->getNumExperimentInfo() == 0) // Create a run if needed
m_out_histo->addExperimentInfo(ExperimentInfo_sptr(new ExperimentInfo()));
m_out_histo->getExperimentInfo(0)->mutableRun().addProperty(
new PropertyWithValue<std::string>("mdhisto_was_modified", "1"), true);
} else {
throw std::runtime_error(
"Unexpected output workspace type. Expected MDEventWorkspace or "
"MDHistoWorkspace, got " +
m_out->id());
}
// Give the output
setProperty("OutputWorkspace", m_out);
}
