diff --git a/Framework/MDAlgorithms/inc/MantidMDAlgorithms/MaskMD.h b/Framework/MDAlgorithms/inc/MantidMDAlgorithms/MaskMD.h
index 1236616f67638c55c874ea309bb1f5804383c8e9..5959cff0c111e487924a9d91bc897afb94a0bc97 100644
--- a/Framework/MDAlgorithms/inc/MantidMDAlgorithms/MaskMD.h
+++ b/Framework/MDAlgorithms/inc/MantidMDAlgorithms/MaskMD.h
@@ -3,10 +3,23 @@
 
 #include "MantidKernel/System.h"
 #include "MantidAPI/Algorithm.h"
+#include "MantidMDAlgorithms/DllConfig.h"
 
 namespace Mantid {
 namespace MDAlgorithms {
 
+std::vector<std::string> MANTID_MDALGORITHMS_DLL
+splitByCommas(const std::string &names_string);
+
+std::vector<std::string> MANTID_MDALGORITHMS_DLL
+findNamesInBrackets(const std::string &names_string);
+
+std::vector<std::string> MANTID_MDALGORITHMS_DLL
+parseDimensionNames(const std::string &names_string);
+
+std::vector<std::string> MANTID_MDALGORITHMS_DLL
+removeBracketedNames(const std::string &names_string);
+
 /** MaskMD : Mask an MDWorkspace. Can provide complex masking shapes over an
   exisitng MDWorkspace. Operates on a MDWorkspace in-situ.
 
@@ -30,10 +43,11 @@ namespace MDAlgorithms {
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-  File change history is stored at: <https://github.com/mantidproject/mantid>
+  File change history is stored at:
+  <https://github.com/mantidproject/mantid>
   Code Documentation is available at: <http://doxygen.mantidproject.org>
 */
-class DLLExport MaskMD : public API::Algorithm {
+class MANTID_MDALGORITHMS_DLL MaskMD : public API::Algorithm {
 public:
   MaskMD();
   virtual ~MaskMD();
diff --git a/Framework/MDAlgorithms/src/MaskMD.cpp b/Framework/MDAlgorithms/src/MaskMD.cpp
index 019e3e10b7bad3144fcdd0b22d683fe73408b129..243a9cacfe55b13d6a12feefb46975439afcc48a 100644
--- a/Framework/MDAlgorithms/src/MaskMD.cpp
+++ b/Framework/MDAlgorithms/src/MaskMD.cpp
@@ -4,14 +4,106 @@
 #include "MantidKernel/ArrayProperty.h"
 #include "MantidKernel/MandatoryValidator.h"
 #include <algorithm>
+#include <boost/algorithm/string.hpp>
+#include <boost/regex.hpp>
 
 using namespace Mantid::Kernel;
 using namespace Mantid::API;
 using namespace Mantid::Geometry;
+using boost::regex;
 
 namespace Mantid {
 namespace MDAlgorithms {
 
+static const std::string REGEX_STR = "\\[[^\\[\\]]*\\]";
+
+/*
+ * Split the input string on commas and trim leading and trailing whitespace
+ * from the results
+ */
+std::vector<std::string> splitByCommas(const std::string &names_string) {
+  std::vector<std::string> names_split_by_commas;
+  boost::split(names_split_by_commas, names_string, boost::is_any_of(","));
+
+  // Remove leading/trailing whitespace from potential dimension name
+  for (auto &name : names_split_by_commas) {
+    boost::trim(name);
+  }
+  return names_split_by_commas;
+}
+
+/*
+ * Return a vector of only those names from the input string which are within
+ * brackets
+ */
+std::vector<std::string> findNamesInBrackets(const std::string &names_string) {
+  std::vector<std::string> names_result;
+
+  regex re(REGEX_STR);
+  boost::sregex_token_iterator iter(names_string.begin(), names_string.end(),
+                                    re, 0);
+  boost::sregex_token_iterator end;
+  std::ostringstream ss;
+  for (; iter != end; ++iter) {
+    ss.str(std::string());
+    ss << *iter;
+    names_result.push_back(ss.str());
+  }
+
+  return names_result;
+}
+
+/*
+ * Return a vector of names from the string, but with names in brackets reduced
+ * to '[]'
+ */
+std::vector<std::string> removeBracketedNames(const std::string &names_string) {
+  regex re(REGEX_STR);
+  const std::string names_string_reduced =
+      regex_replace(names_string, re, "[]");
+
+  std::vector<std::string> remainder_split =
+      splitByCommas(names_string_reduced);
+
+  return remainder_split;
+}
+
+/*
+ * The list of dimension names often looks like "[H,0,0],[0,K,0]" with "[H,0,0]"
+ * being the first dimension but getProperty returns a vector of
+ * the string split on every comma
+ * This function parses the string, and does not split on commas within brackets
+ */
+std::vector<std::string> parseDimensionNames(const std::string &names_string) {
+
+  // If there are no brackets then simply split the string on commas
+  if (!boost::contains(names_string, "[")) {
+    // Split input string by commas
+    return splitByCommas(names_string);
+  }
+
+  std::vector<std::string> names_result = findNamesInBrackets(names_string);
+  std::vector<std::string> remainder_split = removeBracketedNames(names_string);
+
+  // Insert these into results vector if they are not "[]"
+  // if they are "[]" then skip a position in the vector instead
+  // This preserves the original order of the names,
+  // it is also inefficient, but the name list is expected to be short
+  size_t names_position = 0;
+  auto begin_it = names_result.begin();
+  for (std::string name : remainder_split) {
+    if (name != "[]") {
+      if (names_position == names_result.size()) {
+        names_result.push_back(name);
+      } else {
+        names_result.insert(begin_it + names_position, name);
+      }
+    }
+    ++names_position;
+  }
+  return names_result;
+}
+
 // Register the algorithm into the AlgorithmFactory
 DECLARE_ALGORITHM(MaskMD)
 
@@ -21,7 +113,7 @@ struct InputArgument {
   size_t index;
 };
 
-/// Comparitor to allow sorting by dimension index.
+/// Comparator to allow sorting by dimension index.
 struct LessThanIndex
     : std::binary_function<InputArgument, InputArgument, bool> {
   bool operator()(const InputArgument &a, const InputArgument &b) const {
@@ -110,9 +202,19 @@ size_t tryFetchDimensionIndex(Mantid::API::IMDWorkspace_sptr ws,
  */
 void MaskMD::exec() {
   IMDWorkspace_sptr ws = getProperty("Workspace");
-  std::vector<std::string> dimensions = getProperty("Dimensions");
+  std::string dimensions_string = getPropertyValue("Dimensions");
   std::vector<double> extents = getProperty("Extents");
 
+  // Dimension names may contain brackets with commas (i.e. [H,0,0])
+  // so getProperty would return an incorrect vector of names
+  // instead get the string and parse it here
+  std::vector<std::string> dimensions = parseDimensionNames(dimensions_string);
+  // Report what dimension names were found
+  g_log.notice() << "Dimension names parsed as: " << std::endl;
+  for (const auto &name : dimensions) {
+    g_log.notice() << name << std::endl;
+  }
+
   size_t nDims = ws->getNumDims();
   size_t nDimensionIds = dimensions.size();
 
@@ -169,9 +271,9 @@ void MaskMD::exec() {
     }
 
     // Sort all the inputs by the dimension index. Without this it will not be
-    // possible to construct the MDImplicit function propertly.
-    LessThanIndex comparitor;
-    std::sort(arguments.begin(), arguments.end(), comparitor);
+    // possible to construct the MDImplicit function property.
+    LessThanIndex comparator;
+    std::sort(arguments.begin(), arguments.end(), comparator);
 
     // Create inputs for a box implicit function
     VMD mins(nDims);
diff --git a/Framework/MDAlgorithms/test/MaskMDTest.h b/Framework/MDAlgorithms/test/MaskMDTest.h
index 9fc97b278154e7922ba0d604502a1f96d34e3f68..be3ed513a1ee8599d17a01a6c180ac315097f3ef 100644
--- a/Framework/MDAlgorithms/test/MaskMDTest.h
+++ b/Framework/MDAlgorithms/test/MaskMDTest.h
@@ -59,6 +59,62 @@ public:
   static MaskMDTest *createSuite() { return new MaskMDTest(); }
   static void destroySuite(MaskMDTest *suite) { delete suite; }
 
+  void test_split_by_commas() {
+    std::string test_string = "a, b,c ,d,e ";
+    std::vector<std::string> split_test_string = splitByCommas(test_string);
+
+    // String should be split on commas and whitespace trimmed off to result in:
+    TS_ASSERT_EQUALS(split_test_string[0], "a");
+    TS_ASSERT_EQUALS(split_test_string[1], "b");
+    TS_ASSERT_EQUALS(split_test_string[2], "c");
+    TS_ASSERT_EQUALS(split_test_string[3], "d");
+    TS_ASSERT_EQUALS(split_test_string[4], "e");
+  }
+
+  void test_find_names_in_brackets() {
+    std::string test_string = "[a,b,c], [d,e], f, g";
+    std::vector<std::string> names_in_brackets =
+        findNamesInBrackets(test_string);
+
+    TS_ASSERT_EQUALS(names_in_brackets[0], "[a,b,c]");
+    TS_ASSERT_EQUALS(names_in_brackets[1], "[d,e]");
+    TS_ASSERT_EQUALS(names_in_brackets.size(), 2);
+  }
+
+  void test_parse_dimension_names() {
+    // These are default dimension names from CreateMD
+    std::string test_string = "[H,0,0],[0,K,0],[0,0,L],DeltaE";
+    std::vector<std::string> names_result = parseDimensionNames(test_string);
+
+    TS_ASSERT_EQUALS(names_result[0], "[H,0,0]");
+    TS_ASSERT_EQUALS(names_result[1], "[0,K,0]");
+    TS_ASSERT_EQUALS(names_result[2], "[0,0,L]");
+    TS_ASSERT_EQUALS(names_result[3], "DeltaE");
+  }
+
+  void test_remove_bracketed_names() {
+    std::string test_string = "[a,b] , c, [d,e], f";
+    std::vector<std::string> names_result = removeBracketedNames(test_string);
+
+    TS_ASSERT_EQUALS(names_result[0], "[]");
+    TS_ASSERT_EQUALS(names_result[1], "c");
+    TS_ASSERT_EQUALS(names_result[2], "[]");
+    TS_ASSERT_EQUALS(names_result[3], "f");
+  }
+
+  void test_parse_dimension_names_retains_order() {
+
+    std::string test_string = "[a,b],c,[d,e],f";
+    std::vector<std::string> names_result = parseDimensionNames(test_string);
+
+    // Check that order in the vector is the same as order in the original
+    // string
+    TS_ASSERT_EQUALS(names_result[0], "[a,b]");
+    TS_ASSERT_EQUALS(names_result[1], "c");
+    TS_ASSERT_EQUALS(names_result[2], "[d,e]");
+    TS_ASSERT_EQUALS(names_result[3], "f");
+  }
+
   void test_Init() {
     MaskMD alg;
     TS_ASSERT_THROWS_NOTHING(alg.initialize())