/** Constructor
*
* @param workspace :: IMDWorkspace to plot
* @param logScale :: true to plot Y in log scale
* @param start :: start point in N-dimensions of the line
* @param end :: end point in N-dimensions of the line
* @param normalize :: method for normalizing the line
* @param isDistribution :: is this a distribution (divide by bin width?)
* @return
*/
MantidQwtIMDWorkspaceData::MantidQwtIMDWorkspaceData(Mantid::API::IMDWorkspace_const_sptr workspace, const bool logScale,
Mantid::Kernel::VMD start, Mantid::Kernel::VMD end,
Mantid::API::MDNormalization normalize,
bool isDistribution)
: m_workspace(workspace),
m_logScale(logScale), m_minPositive(0),
m_preview(false),
m_start(start),
m_end(end),
m_normalization(normalize),
m_isDistribution(isDistribution),
m_transform(NULL),
m_plotAxis(PlotDistance), m_currentPlotAxis(PlotDistance)
{
if (start.getNumDims() == 1 && end.getNumDims() == 1)
{
if (start[0] == 0.0 && end[0] == 0.0)
{
// Default start and end. Find the limits
Mantid::Geometry::VecIMDDimension_const_sptr nonIntegDims = m_workspace->getNonIntegratedDimensions();
std::string alongDim = "";
if (!nonIntegDims.empty())
alongDim = nonIntegDims[0]->getName();
else
alongDim = m_workspace->getDimension(0)->getName();
size_t nd = m_workspace->getNumDims();
m_start = VMD(nd);
m_end = VMD(nd);
for (size_t d=0; d<nd; d++)
{
IMDDimension_const_sptr dim = m_workspace->getDimension(d);
if (dim->getDimensionId() == alongDim)
{
// All the way through in the single dimension
m_start[d] = dim->getMinimum();
m_end[d] = dim->getMaximum();
}
else
{
// Mid point along each dimension
m_start[d] = (dim->getMaximum() + dim->getMinimum()) / 2.0f;
m_end[d] = m_start[d];
}
}
}
}
// Unit direction of the line
m_dir = m_end - m_start;
m_dir.normalize();
// And cache the X/Y values
this->cacheLinePlot();
}
/*
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 true if the point is within the workspace (including the max edges)
* */
bool pointInWorkspace(const MDHistoWorkspace *ws, const VMD &point) {
for (size_t d = 0; d < ws->getNumDims(); d++) {
IMDDimension_const_sptr dim = ws->getDimension(d);
if ((point[d] < dim->getMinimum()) || (point[d] > dim->getMaximum()))
return false;
}
return true;
}
/*
Extract the geometry and function information
@param histoWs : histogram workspace to get the information from.
*/
void MDHWLoadingPresenter::extractMetadata(Mantid::API::IMDHistoWorkspace_sptr 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 << 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;
}
/** 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);
}
