Re #14613 Use functions that return mask values (0) for MDEWs

Framework/API/inc/MantidAPI/IMDNode.h

@@ -264,6 +264,12 @@ public:
   virtual uint32_t getDepth() const = 0;
   virtual signal_t getSignalNormalized() const = 0;
 
+  virtual signal_t getSignalWithMask() const = 0;
+  virtual signal_t getSignalNormalizedWithMask() const = 0;
+  virtual signal_t getSignalByNEventsWithMask() const {
+    return this->getSignalWithMask() / static_cast<signal_t>(this->getNPoints());
+  }
+
   virtual void calcVolume() = 0;
   virtual void setInverseVolume(const coord_t) = 0;
   virtual void setSignal(const signal_t) = 0;

Framework/DataObjects/inc/MantidDataObjects/MDBoxBase.h

@@ -254,6 +254,16 @@ public:
    */
   virtual signal_t getError() const { return sqrt(m_errorSquared); }
 
+  //-----------------------------------------------------------------------------------------------
+  /** Returns the integrated signal from all points within or mask value.
+   */
+  virtual signal_t getSignalWithMask() const {
+    if (this->getIsMasked()) {
+      return m_maskValue;
+    }
+    return m_signal;
+  }
+
   //-----------------------------------------------------------------------------------------------
   /** Returns the integrated error squared from all points within.
    */
@@ -303,6 +313,17 @@ public:
     return m_errorSquared * m_inverseVolume;
   }
 
+  //-----------------------------------------------------------------------------------------------
+  /** Returns the integrated signal from all points within, normalized for the
+   * cell volume
+   */
+  virtual signal_t getSignalNormalizedWithMask() const {
+    if (this->getIsMasked()) {
+      return m_maskValue;
+    }
+    return m_signal * m_inverseVolume;
+  }
+
   //-----------------------------------------------------------------------------------------------
   /** For testing, mostly: return the recursion depth of this box.
    * 0 is the top-level box, 1 is one deeper, etc.
@@ -367,6 +388,9 @@ protected:
   /// Mutex for modifying the event list or box averages
   Mantid::Kernel::Mutex m_dataMutex;
 
+  // Value to be returned for masked data when plotting
+  static constexpr signal_t m_maskValue = 0.0;
+
 private:
   MDBoxBase(const MDBoxBase<MDE, nd> &box);
 

Vates/VatesAPI/inc/MantidVatesAPI/Normalization.h

@@ -41,7 +41,8 @@ Determine which normalization function will be called on an IMDNode
 */
 NormFuncIMDNodePtr makeMDEventNormalizationFunction(
     VisualNormalization normalizationOption,
-    Mantid::API::IMDEventWorkspace const *const ws);
+    Mantid::API::IMDEventWorkspace const *const ws,
+    const bool hasMask);
 
 /**
 Determine which normalization function will be called on an IMDIterator of an IMDWorkspace

Vates/VatesAPI/src/Normalization.cpp

@@ -14,9 +14,10 @@ This is used for visualisation of IMDEventWorkspaces.
 @param ws : workspace to fetch defaults from if needed
 @return member function to use on IMDNodes
 */
-NormFuncIMDNodePtr makeMDEventNormalizationFunction(
-    VisualNormalization normalizationOption,
-    Mantid::API::IMDEventWorkspace const *const ws) {
+NormFuncIMDNodePtr
+makeMDEventNormalizationFunction(VisualNormalization normalizationOption,
+                                 Mantid::API::IMDEventWorkspace const *const ws,
+                                 const bool hasMask) {
 
   using namespace Mantid::API;
 
@@ -29,12 +30,24 @@ NormFuncIMDNodePtr makeMDEventNormalizationFunction(
 
   NormFuncIMDNodePtr normalizationFunction;
 
-  if (normalizationOption == Mantid::VATES::NumEventsNormalization) {
-    normalizationFunction = &IMDNode::getSignalByNEvents;
-  } else if (normalizationOption == Mantid::VATES::NoNormalization) {
-    normalizationFunction = &IMDNode::getSignal;
+  // Avoid checking every box for a mask if there is no mask in the workspace
+  // by using different functions
+  if (hasMask) {
+    if (normalizationOption == Mantid::VATES::NumEventsNormalization) {
+      normalizationFunction = &IMDNode::getSignalByNEventsWithMask;
+    } else if (normalizationOption == Mantid::VATES::NoNormalization) {
+      normalizationFunction = &IMDNode::getSignalWithMask;
+    } else {
+      normalizationFunction = &IMDNode::getSignalNormalizedWithMask;
+    }
   } else {
-    normalizationFunction = &IMDNode::getSignalNormalized;
+    if (normalizationOption == Mantid::VATES::NumEventsNormalization) {
+      normalizationFunction = &IMDNode::getSignalByNEvents;
+    } else if (normalizationOption == Mantid::VATES::NoNormalization) {
+      normalizationFunction = &IMDNode::getSignal;
+    } else {
+      normalizationFunction = &IMDNode::getSignalNormalized;
+    }
   }
 
   return normalizationFunction;
@@ -57,21 +70,17 @@ createIteratorWithNormalization(const VisualNormalization normalizationOption,
   if (normalizationOption == AutoSelect) {
     // enum to enum.
     targetNormalization =
-      static_cast<MDNormalization>(ws->displayNormalization());
-  }
-  else {
+        static_cast<MDNormalization>(ws->displayNormalization());
+  } else {
     targetNormalization = static_cast<MDNormalization>(normalizationOption);
   }
 
   // Create the iterator
-  IMDIterator * iterator = ws->createIterator();
+  IMDIterator *iterator = ws->createIterator();
   // Set normalization
   iterator->setNormalization(targetNormalization);
   // Return it
   return iterator;
 }
-
-
-
 }
 }
\ No newline at end of file

Vates/VatesAPI/src/vtkMDHexFactory.cpp

@@ -25,7 +25,6 @@ namespace Mantid {
 
 namespace VATES {
 
-
 /*Constructor
   @param thresholdRange : Threshold range strategy
   @param normalizationOption : Info object setting how normalization should be
@@ -103,7 +102,8 @@ void vtkMDHexFactory::doCreate(
   vtkIdList *hexPointList = vtkIdList::New();
   hexPointList->SetNumberOfIds(8);
 
-  NormFuncIMDNodePtr normFunction = makeMDEventNormalizationFunction(m_normalizationOption, ws.get());
+  NormFuncIMDNodePtr normFunction = makeMDEventNormalizationFunction(
+      m_normalizationOption, ws.get(), ws.get()->hasMask());
 
   // This can be parallelized
   // cppcheck-suppress syntaxError
@@ -112,7 +112,7 @@ void vtkMDHexFactory::doCreate(
       // Get the box here
       size_t i = size_t(ii);
       API::IMDNode *box = boxes[i];
-      Mantid::signal_t signal_normalized = (box->*normFunction)(); 
+      Mantid::signal_t signal_normalized = (box->*normFunction)();
 
       if (!isSpecial(signal_normalized) &&
           m_thresholdRange->inRange(signal_normalized)) {

Vates/VatesAPI/src/vtkMDLineFactory.cpp

@@ -111,7 +111,7 @@ namespace Mantid
         {
           progressUpdating.eventRaised(double(iBox)*progressFactor);
 
-          Mantid::signal_t signal_normalized= it->getNormalizedSignal();
+          Mantid::signal_t signal_normalized= it->getNormalizedSignalWithMask();
           if (!isSpecial( signal_normalized ) && m_thresholdRange->inRange(signal_normalized))
           {
             useBox[iBox] = true;

Vates/VatesAPI/src/vtkMDQuadFactory.cpp

@@ -107,7 +107,7 @@ namespace Mantid
         {
           progressUpdating.eventRaised(progressFactor * double(iBox));
 
-          Mantid::signal_t signal = it->getNormalizedSignal();
+          Mantid::signal_t signal = it->getNormalizedSignalWithMask();
           if (!isSpecial( signal ) && m_thresholdRange->inRange(signal))
           {
             useBox[iBox] = true;