Beispiel #1
0
  /** Set the workspace
   * @param ws :: A shared pointer to a workspace.
   */
  void IFunctionMD::setWorkspace(boost::shared_ptr<const Workspace> ws)
  {
    try
    {
      IMDWorkspace_const_sptr workspace = boost::dynamic_pointer_cast<const IMDWorkspace>(ws);
      if (!workspace)
      {
        throw std::invalid_argument("Workspace has a wrong type (not a IMDWorkspace)");
      }

      if (m_dimensionIndexMap.empty())
      {
        useAllDimensions(workspace);
      }

      m_dimensions.resize(m_dimensionIndexMap.size());
      std::map<std::string,size_t>::const_iterator it = m_dimensionIndexMap.begin();
      std::map<std::string,size_t>::const_iterator end = m_dimensionIndexMap.end();
      for(; it != end; ++it)
      {
        boost::shared_ptr<const Mantid::Geometry::IMDDimension> dim = workspace->getDimensionWithId(it->first);
        if (!dim)
        {
          throw std::invalid_argument("Dimension "+it->first+" dos not exist in workspace "+ws->getName());
        }
        m_dimensions[it->second] = dim;
      }

    }
    catch(std::exception&)
    {
      throw;
    }

  }
Beispiel #2
0
 /**
   * This method is called if a function does not call to useDimension at all. 
   * It adds all the dimensions in the workspace in the order they are in in that workspace
   * then calls init(). 
   */
 void IFunctionMD::useAllDimensions(IMDWorkspace_const_sptr workspace)
 {
   if (!workspace)
   {
     throw std::runtime_error("Method IFunctionMD::useAllDimensions() can only be called after setting the workspace");
   }
   for(size_t i = 0; i < workspace->getNumDims(); ++ i)
   {
     useDimension(workspace->getDimension(i)->getDimensionId());
   }
   this->initDimensions();
 }
Beispiel #3
0
/**
 *  @param g :: The Graph widget which will display the curve
 *  @param distr :: True if this is a distribution,
 *  not applicable here.
 *  @param style :: The graph style to use
 *  @param multipleSpectra :: True if there are multiple spectra,
 *  not applicable here.
 */
void MantidMDCurve::init(Graph *g, bool distr, GraphOptions::CurveType style,
                         bool multipleSpectra) {
  UNUSED_ARG(distr);
  UNUSED_ARG(multipleSpectra);
  IMDWorkspace_const_sptr ws = boost::dynamic_pointer_cast<IMDWorkspace>(
      AnalysisDataService::Instance().retrieve(m_wsName.toStdString()));
  if (!ws) {
    std::string message =
        "Could not extract IMDWorkspace of name: " + m_wsName.toStdString();
    throw std::runtime_error(message);
  }
  if (ws->getNonIntegratedDimensions().size() != 1) {
    std::string message = "This plot only applies to MD Workspaces with a "
                          "single expanded dimension";
    throw std::invalid_argument(message);
  }

  this->setTitle(m_wsName + "-signal");

  const bool log = g->isLog(QwtPlot::yLeft);
  MantidQwtIMDWorkspaceData data(ws, log);
  setData(data);

  int lineWidth = 1;
  MultiLayer *ml = dynamic_cast<MultiLayer *>(g->parent()->parent()->parent());
  if (ml && (style == GraphOptions::Unspecified ||
             ml->applicationWindow()->applyCurveStyleToMantid)) {
    // FIXME: Style HorizontalSteps does NOT seem to be applied
    applyStyleChoice(style, ml, lineWidth);
  } else {
    setStyle(QwtPlotCurve::Lines);
  }
  g->insertCurve(this, lineWidth);

  // set the option to draw all error bars from the global settings
  if (hasErrorBars()) {
    setErrorBars(true, g->multiLayer()->applicationWindow()->drawAllErrors);
  }
  // Initialise error bar colour to match curve colour
  m_errorSettings->m_color = pen().color();
  m_errorSettings->setWidth(pen().widthF());

  connect(g, SIGNAL(axisScaleChanged(int, bool)), this,
          SLOT(axisScaleChanged(int, bool)));
  observePostDelete();
  connect(this, SIGNAL(resetData(const QString &)), this,
          SLOT(dataReset(const QString &)));
  observeAfterReplace();
  observeADSClear();
}
/** Automatically choose which coordinate to use as the X axis,
 * if we selected it to be automatic
 */
void MantidQwtIMDWorkspaceData::choosePlotAxis()
{
  if (m_plotAxis == MantidQwtIMDWorkspaceData::PlotAuto)
  {
    if (m_transform)
    {
      // Find the start and end points in the original workspace
      VMD originalStart = m_transform->applyVMD(m_start);
      VMD originalEnd = m_transform->applyVMD(m_end);
      VMD diff = originalEnd - originalStart;

      // Now we find the dimension with the biggest change
      double largest = -1e30;
      // Default to 0
      m_currentPlotAxis = 0;
      IMDWorkspace_const_sptr originalWS = m_originalWorkspace.lock();

      bool regularBinnedMDWorkspace = false;
      if(auto mdew = boost::dynamic_pointer_cast<const Mantid::API::IMDEventWorkspace>(m_workspace))
      {
        Mantid::API::BoxController_const_sptr controller = mdew->getBoxController();
        bool atLeastOneDimNotIntegrated = false;
        for(size_t i = 0; i < mdew->getNumDims(); ++i)
        {
          if( mdew->getDimension(i)->getNBins() ==  controller->getSplitInto(i))
          {
            if(!mdew->getDimension(i)->getIsIntegrated())
            {
              atLeastOneDimNotIntegrated = true;
            }
          }
        }
        regularBinnedMDWorkspace = atLeastOneDimNotIntegrated;
      }

      if(NULL != boost::dynamic_pointer_cast<const Mantid::API::IMDHistoWorkspace>(originalWS) || regularBinnedMDWorkspace)
      {
        for (size_t d=0; d<diff.getNumDims(); d++)
        {
          if (fabs(diff[d]) > largest || ( originalWS && originalWS->getDimension(m_currentPlotAxis)->getIsIntegrated() ) )
          {
            //Skip over any integrated dimensions
            if( originalWS && !originalWS->getDimension(d)->getIsIntegrated() )
            {
              largest = fabs(diff[d]);
              m_currentPlotAxis = int(d);
            }
          }
        }
      }
      else
      {
        for (size_t d=0; d<diff.getNumDims(); d++)
        {
          if (fabs(diff[d]) > largest)
          {
            largest = fabs(diff[d]);
            m_currentPlotAxis = int(d);
          }
        }
      }
    }
    else
      // Drop to distance if the transform does not exist
      m_currentPlotAxis = MantidQwtIMDWorkspaceData::PlotDistance;
  }
  else
  {
    // Pass-through the value.
    m_currentPlotAxis = m_plotAxis;
  }
}