advance Ornl next to qa

.gitignore

@@ -77,6 +77,9 @@ local.properties
 *.sln.docstates
 *.sdf
 
+# User virtual environments
+.venv
+
 #Test results
 *.log
 

.pre-commit-config.yaml

@@ -5,7 +5,7 @@ exclude: ^$|instrument/
 
 ci:
   autofix_prs: true
-  skip: [black,clang-format]
+  skip: [clang-format]
 
 repos:
 
@@ -21,13 +21,17 @@ repos:
       - id: check-xml
       - id: check-yaml
         args: [--allow-multiple-documents]
-        exclude: conda/recipes/mantid/meta.yaml|conda/recipes/mantidqt/meta.yaml|conda/recipes/mantiddocs/meta.yaml|conda/recipes/mantidworkbench/meta.yaml
+        exclude: conda/recipes/mantid/meta.yaml|conda/recipes/mantid-developer/meta.yaml|conda/recipes/mantidqt/meta.yaml|conda/recipes/mantiddocs/meta.yaml|conda/recipes/mantidworkbench/meta.yaml
+
+  - repo: https://github.com/pre-commit/mirrors-clang-format
+    rev: v12.0.1 # updating to a new version should wait until maintenance
+    hooks:
+    - id: clang-format
+      exclude: Testing/Tools/cxxtest|tools
 
   - repo: https://github.com/mantidproject/pre-commit-hooks.git
-    rev: 2f8a4f22629d0d23332f621df9de93751331161b
+    rev: 17c2842277953a4afcbca26bf84e8956f729e765
     hooks:
-      - id: clang-format
-        exclude: Testing/Tools/cxxtest|tools
       - id: cmake-missing-pytest-files
         # Exclude sphinx / template file
         exclude: test_doctest.py|python_export_maker.py
@@ -55,14 +59,10 @@ repos:
           )$
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.5.5
+    rev: v0.6.8
     # ruff must appear before black in the list of hooks
     hooks:
       - id: ruff
         args: [--fix, --exit-non-zero-on-fix]
-
-  - repo: https://github.com/psf/black
-    rev: 24.4.2
-    hooks:
-      - id: black
+      - id: ruff-format
         exclude: scripts/templates/reference/|Testing/Tools/cxxtest

Framework/API/inc/MantidAPI/Column.h

@@ -157,9 +157,13 @@ class MANTID_API_DLL Column {
     return vec;
   }
 
-  virtual bool equals(const Column &, double) const { throw std::runtime_error("equals not implemented"); };
+  virtual bool equals(const Column &, double, bool const = false) const {
+    throw std::runtime_error("equals not implemented");
+  };
 
-  virtual bool equalsRelErr(const Column &, double) const { throw std::runtime_error("equals not implemented"); };
+  virtual bool equalsRelErr(const Column &, double, bool const = false) const {
+    throw std::runtime_error("equals not implemented");
+  };
 
 protected:
   /// Sets the new column size.

Framework/API/inc/MantidAPI/ISISInstrumentDataCache.h

@@ -30,7 +30,7 @@ class MANTID_API_DLL ISISInstrumentDataCache {
   std::pair<Mantid::Kernel::InstrumentInfo, std::string> validateInstrumentAndNumber(const std::string &filename) const;
   std::filesystem::path makeIndexFilePath(const std::string &instrumentName) const;
   std::pair<std::string, std::string> splitIntoInstrumentAndNumber(const std::string &filename) const;
-  [[nodiscard]] std::pair<std::string, Json::Value>
+  [[nodiscard]] std::pair<std::filesystem::path, Json::Value>
   openCacheJsonFile(const Mantid::Kernel::InstrumentInfo &instrument) const;
   [[nodiscard]] Mantid::Kernel::InstrumentInfo getInstrumentFromName(const std::string &instName) const;
   std::string m_dataCachePath;

Framework/API/inc/MantidAPI/MatrixWorkspace.h

@@ -499,7 +499,7 @@ class MANTID_API_DLL MatrixWorkspace : public IMDWorkspace, public ExperimentInf
   /// Flag indicating if the common bins flag is in a valid state
   mutable std::atomic<bool> m_isCommonBinsFlagValid{false};
   /// Flag indicating whether the data has common bins
-  mutable bool m_isCommonBinsFlag{false};
+  mutable std::atomic<bool> m_isCommonBinsFlag{false};
   /// A mutex protecting the update of m_isCommonBinsFlag.
   mutable std::mutex m_isCommonBinsMutex;
 

Framework/API/src/Algorithm.cpp

@@ -1266,7 +1266,7 @@ bool Algorithm::doCallProcessGroups(Mantid::Types::Core::DateAndTime &startTime)
   // In the base implementation of processGroups, this normally calls
   // this->execute() again on each member of the group. Other algorithms may
   // choose to override that behavior (examples: CompareWorkspaces,
-  // CheckWorkspacesMatch, RenameWorkspace)
+  // RenameWorkspace)
 
   startTime = Mantid::Types::Core::DateAndTime::getCurrentTime();
   // Start a timer

Framework/API/src/CompositeFunction.cpp

@@ -797,7 +797,13 @@ void CompositeFunction::clearTies() {
  * @return True if successful
  */
 bool CompositeFunction::removeTie(size_t i) {
-  bool foundAndRemovedTie = IFunction::removeTie(i);
+  bool foundAndRemovedTie = false;
+  // Handle the case when IFunction::removeTie throws a runtime error because it is trying to unfix a tied parameter
+  try {
+    foundAndRemovedTie = IFunction::removeTie(i);
+  } catch (std::runtime_error &) {
+    foundAndRemovedTie = false;
+  }
   if (!foundAndRemovedTie) {
     size_t iFun = functionIndex(i);
     bool res = m_functions[iFun]->removeTie(i - m_paramOffsets[iFun]);

Framework/API/src/FileFinder.cpp

@@ -280,18 +280,10 @@ std::string FileFinderImpl::makeFileName(const std::string &hint, const Kernel::
     filename = shortName + filename;
   }
 
-  std::pair<std::string, std::string> p = toInstrumentAndNumber(filename);
-
-  filename = p.first;
-  if (!delimiter.empty()) {
-    filename += delimiter;
-  }
-  filename += p.second;
-
-  if (!suffix.empty()) {
-    filename += suffix;
-  }
+  auto [instrumentName, runNumber] = toInstrumentAndNumber(filename);
 
+  // delimiter and suffix might be empty strings
+  filename = instrumentName + delimiter + runNumber + suffix;
   return filename;
 }
 
@@ -371,10 +363,22 @@ std::vector<IArchiveSearch_sptr> FileFinderImpl::getArchiveSearch(const Kernel::
   return archs;
 }
 
-const API::Result<std::string> FileFinderImpl::findRun(const std::string &hintstr, const std::vector<std::string> &exts,
-                                                       const bool useExtsOnly) const {
+/**
+ * Find a path to a single file from a hint.
+ * @param hintstr :: hint string to look for filename.
+ * @param extensionsProvided :: Vector of aditional file extensions to consider. Optional.
+ *                  If not provided, facility extensions used.
+ * @param useOnlyExtensionsProvided :: Optional bool.
+ *                  If it's true (and extensionsProvided is not empty),
+ *                  search for the file using extensionsProvided only.
+ *                  If it's false, use extensionsProvided AND facility extensions.
+ * @return A vector of full paths or empty vector
+ */
+const API::Result<std::string> FileFinderImpl::findRun(const std::string &hintstr,
+                                                       const std::vector<std::string> &extensionsProvided,
+                                                       const bool useOnlyExtensionsProvided) const {
   std::string hint = Kernel::Strings::strip(hintstr);
-  g_log.debug() << "vector findRun(\'" << hint << "\', exts[" << exts.size() << "])\n";
+  g_log.debug() << "vector findRun(\'" << hint << "\', exts[" << extensionsProvided.size() << "])\n";
 
   // if partial filename or run number is not supplied, return here
   if (hint.empty())
@@ -406,18 +410,12 @@ const API::Result<std::string> FileFinderImpl::findRun(const std::string &hintst
   const Kernel::InstrumentInfo instrument = this->getInstrument(hint);
   const Kernel::FacilityInfo &facility = instrument.facility();
   // get facility extensions
-  const std::vector<std::string> facility_extensions = facility.extensions();
-  // select allowed extensions
-  std::vector<std::string> extensions;
-
-  g_log.debug() << "Add facility extensions defined in the Facility.xml file"
-                << "\n";
-  extensions.assign(facility_extensions.begin(), facility_extensions.end());
+  const std::vector<std::string> facilityExtensions = facility.extensions();
 
   // Do we need to try and form a filename from our preset rules
   std::string filename(hint);
-  std::string extension = getExtension(hint, extensions);
-  if (!extensions.empty())
+  std::string extension = getExtension(hint, facilityExtensions);
+  if (!facilityExtensions.empty())
     filename = hint.substr(0, hint.rfind(extension));
   if (hintPath.depth() == 0) {
     try {
@@ -453,31 +451,49 @@ const API::Result<std::string> FileFinderImpl::findRun(const std::string &hintst
 
   // Merge the extensions & throw out duplicates
   // On Windows throw out ones that only vary in case
-  std::vector<std::string> uniqueExts;
-  uniqueExts.reserve(1 + exts.size() + extensions.size());
-  if (!extension.empty())
-    uniqueExts.emplace_back(extension);
-
-  // If provided exts are empty, or useExtsOnly is false,
-  // we want to include facility exts as well
-  getUniqueExtensions(exts, uniqueExts);
-  if (exts.empty() || !useExtsOnly) {
-    getUniqueExtensions(extensions, uniqueExts);
+  std::vector<std::string> extensionsToSearch;
+  extensionsToSearch.reserve(1 + extensionsProvided.size() + facilityExtensions.size());
+
+  if (useOnlyExtensionsProvided) {
+    getUniqueExtensions(extensionsProvided, extensionsToSearch);
+
+  } else {
+    if (!extension.empty()) {
+      extensionsToSearch.emplace_back(extension);
+
+    } else {
+      getUniqueExtensions(extensionsProvided, extensionsToSearch);
+      getUniqueExtensions(facilityExtensions, extensionsToSearch);
+    }
   }
 
   // determine which archive search facilities to use
   std::vector<IArchiveSearch_sptr> archs = getArchiveSearch(facility);
 
-  auto path = getPath(archs, filenames, uniqueExts);
+  auto path = getPath(archs, filenames, extensionsToSearch);
   if (path) {
-    g_log.information() << "found path = " << path << '\n';
+    g_log.information() << "Found path = " << path << '\n';
     return path;
-  } else {
-    g_log.information() << "Unable to find run with hint " << hint << "\n";
   }
+  // Path not found
+
+  // If only looked for extension in filename
+  if (!useOnlyExtensionsProvided && extensionsToSearch.size() == 1) {
+
+    extensionsToSearch.pop_back(); // No need to search for missing extension again
+    getUniqueExtensions(extensionsProvided, extensionsToSearch);
+    getUniqueExtensions(facilityExtensions, extensionsToSearch);
 
-  g_log.information() << "Unable to find file path for " << hint << "\n";
+    g_log.warning() << "Extension ['" << extension << "'] not found.\n";
+    g_log.warning() << "Searching for other facility extensions." << std::endl;
 
+    path = getPath(archs, filenames, extensionsToSearch);
+    if (path) {
+      g_log.information() << "Found path = " << path << '\n';
+      return path;
+    }
+  }
+  g_log.information() << "Unable to find run with hint " << hint << "\n";
   return API::Result<std::string>("", path.errors());
 }
 
@@ -521,18 +537,19 @@ std::string FileFinderImpl::validateRuns(const std::string &searchText) const {
  * @param hintstr :: Comma separated list of hints to findRun method.
  *  Can also include ranges of runs, e.g. 123-135 or equivalently 123-35.
  *  Only the beginning of a range can contain an instrument name.
- * @param exts :: Vector of allowed file extensions. Optional.
+ * @param extensionsProvided :: Vector of allowed file extensions. Optional.
  *                If provided, this provides the only extensions searched for.
  *                If not provided, facility extensions used.
- * @param useExtsOnly :: Optional bool. If it's true (and exts is not empty),
+ * @param useOnlyExtensionsProvided:: Optional bool. If it's true (and exts is not empty),
                            search the for the file using exts only.
                            If it's false, use exts AND facility extensions.
  * @return A vector of full paths or empty vector
  * @throw std::invalid_argument if the argument is malformed
  * @throw Exception::NotFoundError if a file could not be found
  */
-std::vector<std::string> FileFinderImpl::findRuns(const std::string &hintstr, const std::vector<std::string> &exts,
-                                                  const bool useExtsOnly) const {
+std::vector<std::string> FileFinderImpl::findRuns(const std::string &hintstr,
+                                                  const std::vector<std::string> &extensionsProvided,
+                                                  const bool useOnlyExtensionsProvided) const {
   auto const error = validateRuns(hintstr);
   if (!error.empty())
     throw std::invalid_argument(error);
@@ -613,9 +630,9 @@ std::vector<std::string> FileFinderImpl::findRuns(const std::string &hintstr, co
 
         std::string path;
         if (boost::algorithm::istarts_with(hint, "PG3")) {
-          path = findRun(instrSName + run, exts, useExtsOnly).result();
+          path = findRun(instrSName + run, extensionsProvided, useOnlyExtensionsProvided).result();
         } else {
-          path = findRun(p1.first + run, exts, useExtsOnly).result();
+          path = findRun(p1.first + run, extensionsProvided, useOnlyExtensionsProvided).result();
         }
 
         if (!path.empty()) {
@@ -634,12 +651,12 @@ std::vector<std::string> FileFinderImpl::findRuns(const std::string &hintstr, co
       if (boost::algorithm::istarts_with(hint, "PG3")) {
         if (h == hints.begin()) {
           instrSName = "PG3";
-          path = findRun(*h, exts, useExtsOnly).result();
+          path = findRun(*h, extensionsProvided, useOnlyExtensionsProvided).result();
         } else {
-          path = findRun(instrSName + *h, exts, useExtsOnly).result();
+          path = findRun(instrSName + *h, extensionsProvided, useOnlyExtensionsProvided).result();
         }
       } else {
-        path = findRun(*h, exts, useExtsOnly).result();
+        path = findRun(*h, extensionsProvided, useOnlyExtensionsProvided).result();
       }
       if (!path.empty()) {
         res.emplace_back(path);
@@ -809,7 +826,8 @@ const API::Result<std::string> FileFinderImpl::getPath(const std::vector<IArchiv
     errors += cacheFilePath.errors();
 
   } else {
-    errors += "Could not find data cache directory: " + cachePathToSearch.string();
+    g_log.debug() << "Data cache directory not found, proceeding with the search." << std::endl;
+    errors += "Could not find data cache directory: " + cachePathToSearch.string() + '\n';
   }
 
   // Search the archive

Framework/API/src/GroupingLoader.cpp

@@ -175,8 +175,7 @@ void GroupingLoader::loadGroupingFromXML(const std::string &filename, Grouping &
       try // ... to convert value to double
       {
         grouping.pairAlphas[ip] = boost::lexical_cast<double>(aElement->getAttribute("val"));
-      }
-      catch (boost::bad_lexical_cast &) {
+      } catch (boost::bad_lexical_cast &) {
         throw Mantid::Kernel::Exception::FileError("Pair alpha value is not a number", filename);
       }
     }

Framework/API/src/ISISInstrumentDataCache.cpp

@@ -24,21 +24,21 @@ std::string ISISInstrumentDataCache::getFileParentDirectoryPath(const std::strin
   g_log.debug() << "ISISInstrumentDataCache::getFileParentDirectoryPath(" << fileName << ")" << std::endl;
 
   auto [instrumentInfo, runNumber] = validateInstrumentAndNumber(fileName);
-  std::string instrName = instrumentInfo.name();
 
   auto const [jsonPath, json] = openCacheJsonFile(instrumentInfo);
 
   std::string relativePath = json[runNumber].asString();
 
   if (relativePath.empty()) {
-    throw std::invalid_argument("Run number " + runNumber + " not found for instrument " + instrName + ".");
+    throw std::invalid_argument("Run number " + runNumber + " not found in index file " + jsonPath.filename().string() +
+                                ".");
   }
 
-  std::string dirPath = m_dataCachePath + "/" + instrName + "/" + relativePath;
+  std::filesystem::path dirPath = jsonPath.parent_path() / relativePath;
+  std::string dirPathString = dirPath.make_preferred().string();
 
-  g_log.debug() << "Opened instrument index file: " << jsonPath << ". Found path to search: " << dirPath << "."
-                << std::endl;
-  return dirPath;
+  g_log.debug() << "Found path to search: " << dirPathString << std::endl;
+  return dirPathString;
 }
 
 /**
@@ -57,7 +57,8 @@ std::vector<std::string> ISISInstrumentDataCache::getRunNumbersInCache(const std
  * @return A pair containing the path and the contents of the json file.
  * @throws std::invalid_argument if the file could not be found.
  */
-std::pair<std::string, Json::Value> ISISInstrumentDataCache::openCacheJsonFile(const InstrumentInfo &instrument) const {
+std::pair<std::filesystem::path, Json::Value>
+ISISInstrumentDataCache::openCacheJsonFile(const InstrumentInfo &instrument) const {
   // Open index json file
   std::filesystem::path jsonPath = makeIndexFilePath(instrument.name());
   std::ifstream ifstrm{jsonPath};
@@ -71,7 +72,8 @@ std::pair<std::string, Json::Value> ISISInstrumentDataCache::openCacheJsonFile(c
   // Read directory path from json file
   Json::Value json;
   ifstrm >> json;
-  return {jsonPath.string(), json};
+  g_log.debug() << "Opened instrument index file: " << jsonPath << std::endl;
+  return {jsonPath, json};
 }
 
 std::pair<InstrumentInfo, std::string>