diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md
index cb76fa46d12f841d1b5ee2f6f599720d197b6446..b9bbbac114cf4398acf75cbfec18f6bd9d203c4a 100644
--- a/.github/CONTRIBUTING.md
+++ b/.github/CONTRIBUTING.md
@@ -1,8 +1,8 @@
-The [developer documentation](http://www.mantidproject.org/Category:Development) has information on how to participate in the mantid project as a developer. This document is meant to outline the steps for contributing to mantid without becomming a developer. We aspire to have similar guidelines as [github](https://github.com/blog/1943-how-to-write-the-perfect-pull-request).
+The [developer documentation](http://developer.mantidproject.org/) has information on how to participate in the mantid project as a developer. This document is meant to outline the steps for contributing to mantid without becomming a developer. We aspire to have similar guidelines as [github](https://github.com/blog/1943-how-to-write-the-perfect-pull-request).
1. [Fork](https://help.github.com/articles/fork-a-repo) the repository. *recommended:* Delete all branches other than `master`. This makes it easier to see what is in your fork later.
2. Clone the repository with the remotes `origin` pointing at your fork as `origin` and `mantidproject/mantid` as `upstream`. This is a [common setup](https://help.github.com/articles/configuring-a-remote-for-a-fork/).
- 3. Make changes as you see fit. Please still follow the guidelines for [running the unit tests](http://www.mantidproject.org/Running_the_unit_tests) and the [build servers](http://www.mantidproject.org/The_automated_build_process).
+ 3. Make changes as you see fit. Please still follow the guidelines for [running the unit tests](http://developer.mantidproject.org/RunningTheUnitTests.html) and the [build servers](http://developer.mantidproject.org/AutomatedBuildProcess.html).
4. Submit a [pull request](https://help.github.com/articles/using-pull-requests) to this branch. This is a start to the conversation.
7. (Optional) email mantid-help@mantidproject.org requests to.
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index f2a9331c7f867a4fc927dc4208dc5c038d649701..e229daad59c9b3566f585415c8178d10e1510a2f 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -19,7 +19,7 @@ Fixes #xxxx. <!-- and fix #xxxx or close #xxxx xor resolves #xxxx -->
#### Reviewer ####
-Please comment on the following ([full description](http://www.mantidproject.org/Individual_Ticket_Testing)):
+Please comment on the following ([full description](http://developer.mantidproject.org/IndividualTicketTesting/)):
##### Code Review #####
diff --git a/.gitignore b/.gitignore
index 07c6b866b6a40cebb9a12c58a6095cde08701e0e..0bf82370fc12d12d98df4433da272ee489769c11 100644
--- a/.gitignore
+++ b/.gitignore
@@ -177,7 +177,8 @@ Desktop.ini
#Dynamically created files
Framework/Kernel/inc/MantidKernel/GitHubApiHelper.h
Vates/VatesSimpleGui/ViewWidgets/inc/MantidVatesSimpleGuiViewWidgets/LibHelper.h
-
+qt/applications/workbench/setup.py
+qt/python/setup.py
# Make sure Third_Party doesn't get checked into the main repository
Third_Party/
diff --git a/CMakeLists.txt b/CMakeLists.txt
index cbf238f3ac687378183395e565d967e9bc5d3bd6..ccade423d537682f25e723a062a5cbd298eec9c6 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -17,17 +17,19 @@ if (POLICY CMP0072)
endif ()
# System package target is important for the windows builds as it allows us to package only the dlls and exes and exclude libs. Defaults to empty for other platforms.
-set ( SYSTEM_PACKAGE_TARGET "")
+set ( SYSTEM_PACKAGE_TARGET "" )
# Add the path to our custom 'find' modules
set ( CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/buildconfig/CMake")
-set ( ENABLE_MANTIDPLOT ON CACHE BOOL "Switch for compiling the Qt4-based gui & components")
-# TODO: Switch this on by default when the builders all have Qt5 installed
-set ( ENABLE_WORKBENCH OFF CACHE BOOL "Switch for compiling the Qt5-based gui & components")
+set ( ENABLE_MANTIDPLOT ON CACHE BOOL "Enable Qt4-based gui & components" )
+set ( ENABLE_WORKBENCH OFF CACHE BOOL "Enable Qt5-based gui & components" )
+set ( PACKAGE_WORKBENCH OFF CACHE BOOL "If packaging is enabled then include the Qt-5 workbench in the package" )
+if ( PACKAGE_WORKBENCH AND NOT ENABLE_WORKBENCH )
+ message ( FATAL_ERROR "Packaging workbench requested but workbench build is disabled!" )
+endif ()
-set ( CPACK_INSTALL_CMAKE_PROJECTS
- "${CMAKE_BINARY_DIR}" "Mantid" "ALL" "/" )
+set ( CPACK_INSTALL_CMAKE_PROJECTS "${CMAKE_BINARY_DIR}" "Mantid" "ALL" "/" )
###########################################################################
# Quick exit if we only want data targets
@@ -304,6 +306,9 @@ if ( ENABLE_CPACK )
# scipy
set ( CPACK_RPM_PACKAGE_REQUIRES "${CPACK_RPM_PACKAGE_REQUIRES},scipy" )
set ( CPACK_RPM_PACKAGE_REQUIRES "${CPACK_RPM_PACKAGE_REQUIRES},mxml,hdf,hdf5,jsoncpp >= 0.7.0" )
+ if (ENABLE_WORKBENCH)
+ set ( CPACK_RPM_PACKAGE_REQUIRES "${CPACK_RPM_PACKAGE_REQUIRES},python-qt5" )
+ endif()
if( "${UNIX_CODENAME}" MATCHES "Santiago" ) # RHEL6
# On RHEL6 we have to use an updated qscintilla to fix an auto complete bug
@@ -371,6 +376,13 @@ if ( ENABLE_CPACK )
list (REMOVE_ITEM DEPENDS_LIST "python-nxs (>= 4.3),")
string ( REPLACE "python-" "python3-" DEPENDS_LIST ${DEPENDS_LIST} )
string ( REPLACE "python3-qt4" "python3-pyqt4" DEPENDS_LIST ${DEPENDS_LIST} )
+ if (ENABLE_WORKBENCH)
+ set ( APPEND DEPENDS_LIST ",python3-qt5" )
+ endif()
+ else()
+ if (ENABLE_WORKBENCH)
+ set ( APPEND DEPENDS_LIST ",pyqt5" )
+ endif()
endif ()
# parse list to string required for deb package
string ( REPLACE ";" "" CPACK_DEBIAN_PACKAGE_DEPENDS ${DEPENDS_LIST} )
diff --git a/Framework/API/CMakeLists.txt b/Framework/API/CMakeLists.txt
index 3fa7bdf8ff6ad8ad41ae13c977defe2ce4c8d3d3..78facd863b5900e0b3421ebd50e7b08a7b11d097 100644
--- a/Framework/API/CMakeLists.txt
+++ b/Framework/API/CMakeLists.txt
@@ -111,6 +111,7 @@ set ( SRC_FILES
src/NullCoordTransform.cpp
src/NumericAxis.cpp
src/NumericAxisValidator.cpp
+ src/OrientedLatticeValidator.cpp
src/ParallelAlgorithm.cpp
src/ParamFunction.cpp
src/ParameterReference.cpp
@@ -310,6 +311,7 @@ set ( INC_FILES
inc/MantidAPI/NullCoordTransform.h
inc/MantidAPI/NumericAxis.h
inc/MantidAPI/NumericAxisValidator.h
+ inc/MantidAPI/OrientedLatticeValidator.h
inc/MantidAPI/ParallelAlgorithm.h
inc/MantidAPI/ParamFunction.h
inc/MantidAPI/ParameterReference.h
@@ -435,6 +437,7 @@ set ( TEST_FILES
NotebookWriterTest.h
NumericAxisTest.h
NumericAxisValidatorTest.h
+ OrientedLatticeValidatorTest.h
ParamFunctionAttributeHolderTest.h
ParameterReferenceTest.h
ParameterTieTest.h
diff --git a/Framework/API/inc/MantidAPI/AnalysisDataService.h b/Framework/API/inc/MantidAPI/AnalysisDataService.h
index f428b8e7bc631d93e16bc7b2c49684219c43ebbe..b50402509a2393a9c2996f6d6ed36a6e7b8f5295 100644
--- a/Framework/API/inc/MantidAPI/AnalysisDataService.h
+++ b/Framework/API/inc/MantidAPI/AnalysisDataService.h
@@ -23,9 +23,8 @@ class WorkspaceGroup;
/** The Analysis data service stores instances of the Workspace objects and
anything that derives from template class
- DynamicFactory<Mantid::Kernel::IAlgorithm>.
- This is the primary data service that
- the users will interact with either through writing scripts or directly
+ DynamicFactory<Mantid::Kernel::IAlgorithm>. This is the primary data service
+ that the users will interact with either through writing scripts or directly
through the API. It is implemented as a singleton class.
This is the manager/owner of Workspace* when registered.
@@ -35,8 +34,8 @@ class WorkspaceGroup;
@author L C Chapon, ISIS, Rutherford Appleton Laboratory
Modified to inherit from DataService
- Copyright © 2007-9 ISIS Rutherford Appleton Laboratory, NScD Oak Ridge
- National Laboratory & European Spallation Source
+ Copyright © 2007-9 ISIS Rutherford Appleton Laboratory, NScD Oak
+ Ridge National Laboratory & European Spallation Source
This file is part of Mantid.
@@ -53,7 +52,8 @@ class WorkspaceGroup;
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 AnalysisDataServiceImpl final
@@ -78,8 +78,7 @@ public:
};
/// UnGroupingWorkspace notification is sent from UnGroupWorkspace algorithm
- /// before the WorkspaceGroup is removed from the
- /// DataService
+ /// before the WorkspaceGroup is removed from the DataService
class UnGroupingWorkspaceNotification : public DataServiceNotification {
public:
/// Constructor
@@ -88,8 +87,8 @@ public:
: DataServiceNotification(name, obj) {}
};
- /// GroupWorkspaces notification is send when a group is updated by adding or
- /// removing members.
+ /// GroupWorkspaces notification is send when a group is updated by adding
+ /// or removing members.
/// Disable observing the ADS by a group
/// (WorkspaceGroup::observeADSNotifications(false))
/// to prevent sending this notification.
@@ -110,12 +109,12 @@ public:
void setIllegalCharacterList(const std::string &);
/// Is the given name a valid name for an object in the ADS
const std::string isValid(const std::string &name) const;
- /// Overridden add member to attach the name to the workspace when a workspace
- /// object is added to the service
+ /// Overridden add member to attach the name to the workspace when a
+ /// workspace object is added to the service
void add(const std::string &name,
const boost::shared_ptr<API::Workspace> &workspace) override;
- /// Overridden addOrReplace member to attach the name to the workspace when a
- /// workspace object is added to the service
+ /// Overridden addOrReplace member to attach the name to the workspace when
+ /// a workspace object is added to the service
void
addOrReplace(const std::string &name,
const boost::shared_ptr<API::Workspace> &workspace) override;
@@ -128,26 +127,27 @@ public:
/** Retrieve a workspace and cast it to the given WSTYPE
*
* @param name :: name of the workspace
- * @tparam WSTYPE :: type of workspace to cast to. Should sub-class Workspace
+ * @tparam WSTYPE :: type of workspace to cast to. Should sub-class
+ * Workspace
* @return a shared pointer of WSTYPE
*/
template <typename WSTYPE>
boost::shared_ptr<WSTYPE> retrieveWS(const std::string &name) const {
// Get as a bare workspace
try {
- boost::shared_ptr<Mantid::API::Workspace> workspace =
- Kernel::DataService<API::Workspace>::retrieve(name);
// Cast to the desired type and return that.
- return boost::dynamic_pointer_cast<WSTYPE>(workspace);
+ return boost::dynamic_pointer_cast<WSTYPE>(
+ Kernel::DataService<API::Workspace>::retrieve(name));
} catch (Kernel::Exception::NotFoundError &) {
- throw Kernel::Exception::NotFoundError(
- "Unable to find workspace type with name '" + name +
- "': data service ",
- name);
+ throw;
}
}
+ std::vector<Workspace_sptr>
+ retrieveWorkspaces(const std::vector<std::string> &names,
+ bool unrollGroups = false) const;
+
/** @name Methods to work with workspace groups */
//@{
void sortGroupByName(const std::string &groupName);
diff --git a/Framework/API/inc/MantidAPI/OrientedLatticeValidator.h b/Framework/API/inc/MantidAPI/OrientedLatticeValidator.h
new file mode 100644
index 0000000000000000000000000000000000000000..edceaeb05f25b2c0d5a10cc5c54c976266b4bf43
--- /dev/null
+++ b/Framework/API/inc/MantidAPI/OrientedLatticeValidator.h
@@ -0,0 +1,52 @@
+#ifndef MANTID_API_ORIENTEDLATTICEVALIDATOR_H
+#define MANTID_API_ORIENTEDLATTICEVALIDATOR_H
+
+#include "MantidAPI/DllConfig.h"
+#include "MantidAPI/ExperimentInfo.h"
+#include "MantidKernel/TypedValidator.h"
+
+/**
+ A validator which checks that a workspace has an oriented lattice attached to
+ it.
+
+ Copyright © 2015 ISIS Rutherford Appleton Laboratory, NScD Oak Ridge
+ National Laboratory & European Spallation Source
+
+ This file is part of Mantid.
+
+ Mantid is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ Mantid is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ 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>
+ Code Documentation is available at: <http://doxygen.mantidproject.org>
+*/
+namespace Mantid {
+namespace API {
+class MANTID_API_DLL OrientedLatticeValidator
+ : public Kernel::TypedValidator<ExperimentInfo_sptr> {
+public:
+ /// Gets the type of the validator
+ std::string getType() const { return "orientedlattice"; }
+ /// Clone the current state
+ Kernel::IValidator_sptr clone() const override;
+
+private:
+ /// Check for validity.
+ std::string
+ checkValidity(const ExperimentInfo_sptr &workspace) const override;
+};
+
+} // namespace API
+} // namespace Mantid
+
+#endif // MANTID_API_ORIENTEDLATTICEVALIDATOR_H
diff --git a/Framework/API/inc/MantidAPI/Workspace.h b/Framework/API/inc/MantidAPI/Workspace.h
index c777780aec4348e837cd40f4a7c9f80178c13604..8b6c0a0366cda1ad5c07b598bc2b963431a581e5 100644
--- a/Framework/API/inc/MantidAPI/Workspace.h
+++ b/Framework/API/inc/MantidAPI/Workspace.h
@@ -89,6 +89,7 @@ public:
const std::string &getComment() const;
const std::string &getName() const override;
bool isDirty(const int n = 1) const;
+ virtual bool isGroup() const { return false; }
/// Get the footprint in memory in bytes.
virtual size_t getMemorySize() const = 0;
/// Returns the memory footprint in sensible units
diff --git a/Framework/API/inc/MantidAPI/WorkspaceGroup.h b/Framework/API/inc/MantidAPI/WorkspaceGroup.h
index bd9dbf8a5b77774749c9059ca2dce12f20243ef5..057f4035f52281b6fcfd8eb9ffa7ffabce5ed371 100644
--- a/Framework/API/inc/MantidAPI/WorkspaceGroup.h
+++ b/Framework/API/inc/MantidAPI/WorkspaceGroup.h
@@ -82,6 +82,7 @@ public:
void removeItem(const size_t index);
/// Remove all names from the group but do not touch the ADS
void removeAll();
+ bool isGroup() const override { return true; }
/// This method returns true if the group is empty (no member workspace)
bool isEmpty() const;
bool areNamesSimilar() const;
diff --git a/Framework/API/src/AnalysisDataService.cpp b/Framework/API/src/AnalysisDataService.cpp
index 529ee2dbc80b8fd6abbd1b1bc5830610c72d9c99..6b0d242cedca100eef6adec679de26dd1ca58468 100644
--- a/Framework/API/src/AnalysisDataService.cpp
+++ b/Framework/API/src/AnalysisDataService.cpp
@@ -1,5 +1,6 @@
#include "MantidAPI/AnalysisDataService.h"
#include "MantidAPI/WorkspaceGroup.h"
+#include <iterator>
#include <sstream>
namespace Mantid {
@@ -164,6 +165,46 @@ void AnalysisDataServiceImpl::remove(const std::string &name) {
}
}
+/**
+ * @brief Given a list of names retrieve the corresponding workspace handles
+ * @param names A list of names of workspaces, if any does not exist then
+ * a Kernel::Exception::NotFoundError is thrown.
+ * @param unrollGroups If true flatten groups into the list of members.
+ * @return A vector of pointers to Workspaces
+ * @throws std::invalid_argument if no names are provided
+ * @throws Mantid::Kernel::Exception::NotFoundError if a workspace does not
+ * exist within the ADS
+ */
+std::vector<Workspace_sptr> AnalysisDataServiceImpl::retrieveWorkspaces(
+ const std::vector<std::string> &names, bool unrollGroups) const {
+ using WorkspacesVector = std::vector<Workspace_sptr>;
+ WorkspacesVector workspaces;
+ workspaces.reserve(names.size());
+ std::transform(
+ std::begin(names), std::end(names), std::back_inserter(workspaces),
+ [this](const std::string &name) { return this->retrieve(name); });
+ assert(names.size() == workspaces.size());
+ if (unrollGroups) {
+ using IteratorDifference =
+ std::iterator_traits<WorkspacesVector::iterator>::difference_type;
+ for (size_t i = 0; i < workspaces.size(); ++i) {
+ if (auto group =
+ boost::dynamic_pointer_cast<WorkspaceGroup>(workspaces.at(i))) {
+ const auto groupLength(group->size());
+ workspaces.erase(std::next(std::begin(workspaces),
+ static_cast<IteratorDifference>(i)));
+ for (size_t j = 0; j < groupLength; ++j) {
+ workspaces.insert(std::next(std::begin(workspaces),
+ static_cast<IteratorDifference>(i + j)),
+ group->getItem(j));
+ }
+ i += groupLength;
+ }
+ }
+ }
+ return workspaces;
+}
+
/**
* Sort members by Workspace name. The group must be in the ADS.
* @param groupName :: A group name.
diff --git a/Framework/API/src/OrientedLatticeValidator.cpp b/Framework/API/src/OrientedLatticeValidator.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2aedef2bb82b5b591af75d7508c55c779e8e852c
--- /dev/null
+++ b/Framework/API/src/OrientedLatticeValidator.cpp
@@ -0,0 +1,34 @@
+#include "MantidAPI/OrientedLatticeValidator.h"
+#include "MantidAPI/ExperimentInfo.h"
+#include "MantidAPI/Sample.h"
+#include "MantidKernel/IValidator.h"
+#include <boost/make_shared.hpp>
+
+using Mantid::Kernel::IValidator_sptr;
+
+namespace Mantid {
+namespace API {
+
+/**
+ * Clone the current state
+ */
+Kernel::IValidator_sptr OrientedLatticeValidator::clone() const {
+ return boost::make_shared<OrientedLatticeValidator>(*this);
+}
+
+/** Checks that workspace has an oriented lattice.
+ *
+ * @param info :: The experiment info to check for an oriented lattice.
+ * @return A user level description of the error or "" for no error
+ */
+std::string
+OrientedLatticeValidator::checkValidity(const ExperimentInfo_sptr &info) const {
+ if (!info->sample().hasOrientedLattice()) {
+ return "Workspace must have a sample with an orientation matrix defined.";
+ } else {
+ return "";
+ }
+}
+
+} // namespace API
+} // namespace Mantid
diff --git a/Framework/API/test/AnalysisDataServiceTest.h b/Framework/API/test/AnalysisDataServiceTest.h
index e3e7dbcf66afc2758229448b0fc018420e2a1289..cbb2cbfce64e98b527d2e5372a7408560cefbf0e 100644
--- a/Framework/API/test/AnalysisDataServiceTest.h
+++ b/Framework/API/test/AnalysisDataServiceTest.h
@@ -5,6 +5,7 @@
#include "MantidAPI/AnalysisDataService.h"
#include "MantidAPI/WorkspaceGroup.h"
+#include <boost/make_shared.hpp>
using namespace Mantid::Kernel;
using namespace Mantid::API;
@@ -75,6 +76,61 @@ public:
TS_ASSERT_THROWS(ads.retrieve("z"), Exception::NotFoundError);
}
+ void test_retrieveWorkspaces_with_empty_list_returns_empty_list() {
+ std::vector<Workspace_sptr> empty;
+ TS_ASSERT_EQUALS(empty, ads.retrieveWorkspaces({}));
+ }
+
+ void test_retrieveWorkspaces_with_all_missing_items_throws_exception() {
+ TS_ASSERT_THROWS(ads.retrieveWorkspaces({"a"}), Exception::NotFoundError);
+ TS_ASSERT_THROWS(ads.retrieveWorkspaces({"a", "b"}),
+ Exception::NotFoundError);
+ }
+
+ void test_retrieveWorkspaces_with_some_missing_items_throws_exception() {
+ const std::string name("test_some_missing_items");
+ addToADS(name);
+ TS_ASSERT_THROWS(ads.retrieveWorkspaces({"a", "b"}),
+ Exception::NotFoundError);
+ ads.remove(name);
+ }
+
+ void test_retrieveWorkspaces_with_all_items_present_and_no_group_unrolling() {
+ const std::vector<std::string> names{"test_all_items_present_1",
+ "test_all_items_present_2"};
+ std::vector<Workspace_sptr> expected;
+ for (const auto &name : names) {
+ expected.push_back(addToADS(name));
+ }
+ std::vector<Workspace_sptr> items;
+ TS_ASSERT_THROWS_NOTHING(items = ads.retrieveWorkspaces(names));
+ TS_ASSERT_EQUALS(expected, expected);
+
+ for (const auto &name : names) {
+ ads.remove(name);
+ }
+ }
+
+ void test_retrieveWorkspaces_with_group_unrolling() {
+ const std::vector<std::string> names{"test_all_items_present_unroll_1",
+ "test_all_items_present_unroll_2"};
+ std::vector<Workspace_sptr> expected;
+ expected.push_back(addToADS(names[0]));
+ const size_t nitems{4u};
+ WorkspaceGroup_sptr groupWS{addGroupToADS(names[1], nitems)};
+ for (auto i = 0u; i < nitems; ++i) {
+ expected.push_back(groupWS->getItem(i));
+ }
+ std::vector<Workspace_sptr> items;
+ TS_ASSERT_THROWS_NOTHING(items = ads.retrieveWorkspaces(names, true));
+ TS_ASSERT_EQUALS(expected.size(), items.size());
+ TS_ASSERT_EQUALS(expected, items);
+
+ for (const auto &name : names) {
+ ads.remove(name);
+ }
+ }
+
void test_Add_With_Name_That_Has_No_Special_Chars_Is_Accpeted() {
const std::string name = "MySpace";
TS_ASSERT_THROWS_NOTHING(addToADS(name));
@@ -479,11 +535,13 @@ private:
return space;
}
- /// Add a group with 2 simple workspaces to the ADS
- WorkspaceGroup_sptr addGroupToADS(const std::string &name) {
- WorkspaceGroup_sptr group(new WorkspaceGroup);
- group->addWorkspace(MockWorkspace_sptr(new MockWorkspace));
- group->addWorkspace(MockWorkspace_sptr(new MockWorkspace));
+ /// Add a group with N simple workspaces to the ADS
+ WorkspaceGroup_sptr addGroupToADS(const std::string &name,
+ const size_t nitems = 2) {
+ auto group(boost::make_shared<WorkspaceGroup>());
+ for (auto i = 0u; i < nitems; ++i) {
+ group->addWorkspace(boost::make_shared<MockWorkspace>());
+ }
ads.add(name, group);
return group;
}
diff --git a/Framework/API/test/FrameworkManagerTest.h b/Framework/API/test/FrameworkManagerTest.h
index 5c947c209e6c06da71e56f533927214c38866ab4..1909115d4d38fe5c2f4feb7c2b007d11181bc7a5 100644
--- a/Framework/API/test/FrameworkManagerTest.h
+++ b/Framework/API/test/FrameworkManagerTest.h
@@ -37,6 +37,12 @@ using namespace Mantid;
class FrameworkManagerTest : public CxxTest::TestSuite {
public:
+ // This means the constructor isn't called when running other tests
+ static FrameworkManagerTest *createSuite() {
+ return new FrameworkManagerTest();
+ }
+ static void destroySuite(FrameworkManagerTest *suite) { delete suite; }
+
#ifdef MPI_EXPERIMENTAL
// Make sure FrameworkManager is always instantiated. This is needed to
// initialize the MPI environment.
diff --git a/Framework/API/test/MatrixWorkspaceTest.h b/Framework/API/test/MatrixWorkspaceTest.h
index 73a74dc9f39622807b139e9e818a02158c22e81b..7ad7a0397491d269b7ece4ebb7f1ab4fb4f443e2 100644
--- a/Framework/API/test/MatrixWorkspaceTest.h
+++ b/Framework/API/test/MatrixWorkspaceTest.h
@@ -2036,6 +2036,11 @@ public:
ws->hasOrientedLattice(), false);
}
+ void test_isGroup() {
+ boost::shared_ptr<MatrixWorkspace> ws(makeWorkspaceWithDetectors(3, 1));
+ TS_ASSERT_EQUALS(ws->isGroup(), false);
+ }
+
private:
WorkspaceTester m_workspace;
WorkspaceTester m_workspaceSans;
diff --git a/Framework/API/test/OrientedLatticeValidatorTest.h b/Framework/API/test/OrientedLatticeValidatorTest.h
new file mode 100644
index 0000000000000000000000000000000000000000..15056f1f8b37447ece1a6d9533cece0635007f95
--- /dev/null
+++ b/Framework/API/test/OrientedLatticeValidatorTest.h
@@ -0,0 +1,47 @@
+#ifndef MANTID_ORIENTEDLATTICEVALIDATOR_TEST_H
+#define MANTID_ORIENTEDLATTICEVALIDATOR_TEST_H
+
+#include <boost/make_shared.hpp>
+#include <cxxtest/TestSuite.h>
+
+#include "MantidAPI/ExperimentInfo.h"
+#include "MantidAPI/OrientedLatticeValidator.h"
+#include "MantidAPI/Sample.h"
+#include "MantidGeometry/Crystal/OrientedLattice.h"
+#include "MantidTestHelpers/FakeObjects.h"
+
+class OrientedLatticeValidatorTest : public CxxTest::TestSuite {
+public:
+ // This pair of boilerplate methods prevent the suite being created statically
+ // This means the constructor isn't called when running other tests
+ static OrientedLatticeValidatorTest *createSuite() {
+ return new OrientedLatticeValidatorTest();
+ }
+ static void destroySuite(OrientedLatticeValidatorTest *suite) {
+ delete suite;
+ }
+
+ void test_getType() {
+ OrientedLatticeValidator validator;
+ TS_ASSERT_EQUALS(validator.getType(), "orientedlattice")
+ }
+
+ void test_isValid_is_valid_when_latticeDefined() {
+ OrientedLattice lattice;
+ auto info = boost::make_shared<ExperimentInfo>();
+ info->mutableSample().setOrientedLattice(&lattice);
+
+ OrientedLatticeValidator validator;
+ TS_ASSERT_EQUALS(validator.isValid(info), "");
+ };
+
+ void test_isValid_is_invalid_when_latticeUndefined() {
+ auto info = boost::make_shared<ExperimentInfo>();
+ OrientedLatticeValidator validator;
+ TS_ASSERT_EQUALS(
+ validator.isValid(info),
+ "Workspace must have a sample with an orientation matrix defined.");
+ };
+};
+
+#endif // MANTID_ORIENTEDLATTICEVALIDATOR_TEST_H
diff --git a/Framework/API/test/WorkspaceGroupTest.h b/Framework/API/test/WorkspaceGroupTest.h
index 5d70069b2a6cba9a272096f806e473004182e053..9f33eab56ef920462ea1e8d8009af34e671b9603 100644
--- a/Framework/API/test/WorkspaceGroupTest.h
+++ b/Framework/API/test/WorkspaceGroupTest.h
@@ -347,6 +347,11 @@ public:
TS_ASSERT(group->isMultiperiod());
}
+ void test_isGroup() {
+ WorkspaceGroup_sptr group = makeGroup();
+ TS_ASSERT_EQUALS(group->isGroup(), true);
+ }
+
void test_isInGroup() {
WorkspaceGroup_sptr group = makeGroup();
auto ws1 = group->getItem(1);
diff --git a/Framework/Algorithms/CMakeLists.txt b/Framework/Algorithms/CMakeLists.txt
index 58aa32a3fb06c768a2e238dde168179f6517b0c0..0b5acd6d29d89a4a6312c48bbd3b1a40963daa4f 100644
--- a/Framework/Algorithms/CMakeLists.txt
+++ b/Framework/Algorithms/CMakeLists.txt
@@ -280,6 +280,7 @@ set ( SRC_FILES
src/SofQWPolygon.cpp
src/SolidAngle.cpp
src/SortEvents.cpp
+ src/SortXAxis.cpp
src/SpatialGrouping.cpp
src/SpectrumAlgorithm.cpp
src/SpecularReflectionAlgorithm.cpp
@@ -609,6 +610,7 @@ set ( INC_FILES
inc/MantidAlgorithms/SofQWPolygon.h
inc/MantidAlgorithms/SolidAngle.h
inc/MantidAlgorithms/SortEvents.h
+ inc/MantidAlgorithms/SortXAxis.h
inc/MantidAlgorithms/SpatialGrouping.h
inc/MantidAlgorithms/SpectrumAlgorithm.h
inc/MantidAlgorithms/SpecularReflectionAlgorithm.h
@@ -928,6 +930,7 @@ set ( TEST_FILES
SofQWTest.h
SolidAngleTest.h
SortEventsTest.h
+ SortXAxisTest.h
SparseInstrumentTest.h
SpatialGroupingTest.h
SpecularReflectionCalculateTheta2Test.h
diff --git a/Framework/Algorithms/inc/MantidAlgorithms/SortXAxis.h b/Framework/Algorithms/inc/MantidAlgorithms/SortXAxis.h
new file mode 100644
index 0000000000000000000000000000000000000000..33c3be72324c993c3a4ccd8e65a742a1c77d40c7
--- /dev/null
+++ b/Framework/Algorithms/inc/MantidAlgorithms/SortXAxis.h
@@ -0,0 +1,81 @@
+#ifndef MANTID_ALGORITHMS_SORTXAXIS_H_
+#define MANTID_ALGORITHMS_SORTXAXIS_H_
+
+#include "MantidAPI/Algorithm.h"
+
+namespace Mantid {
+namespace Algorithms {
+
+/**
+ Copyright © 2018 ISIS Rutherford Appleton Laboratory, NScD Oak Ridge
+ National Laboratory & European Spallation Source
+
+ This file is part of Mantid.
+
+ Mantid is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ Mantid is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ 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>
+ Code Documentation is available at: <http://doxygen.mantidproject.org>
+*/
+
+/**
+ * @brief SortXAxis will take Histogram or Point data and reorder it based on
+ * the X Axis' values, whilst maintaining it's Dx, Y and E axis relative values.
+ * @author Samuel Jones
+ * @version 2.0
+ * @date 07-2018
+ * @copyright GNU General Public License
+ */
+
+class DLLExport SortXAxis : public API::Algorithm {
+public:
+ const std::string name() const override;
+ int version() const override;
+ const std::string category() const override;
+ const std::string summary() const override;
+
+private:
+ void init() override;
+ void exec() override;
+ std::vector<std::size_t> createIndexes(const size_t);
+
+ void sortIndicesByX(std::vector<std::size_t> &workspaceIndecies,
+ std::string order,
+ const Mantid::API::MatrixWorkspace &inputWorkspace,
+ unsigned int specNum);
+
+ void
+ copyYandEToOutputWorkspace(std::vector<std::size_t> &workspaceIndecies,
+ const Mantid::API::MatrixWorkspace &inputWorkspace,
+ Mantid::API::MatrixWorkspace &outputWorkspace,
+ unsigned int SpecNum, bool isAProperHistogram);
+
+ void copyXandDxToOutputWorkspace(
+ std::vector<std::size_t> &workspaceIndecies,
+ const Mantid::API::MatrixWorkspace &inputWorkspace,
+ Mantid::API::MatrixWorkspace &outputWorkspace, unsigned int specNum);
+
+ void copyToOutputWorkspace(std::vector<std::size_t> &workspaceIndecies,
+ const Mantid::API::MatrixWorkspace &inputWorkspace,
+ Mantid::API::MatrixWorkspace &outputWorkspace,
+ unsigned int specNum, bool isAProperHistogram);
+
+ bool determineIfHistogramIsValid(
+ const Mantid::API::MatrixWorkspace &inputWorkspace);
+};
+
+} // namespace Algorithms
+} // namespace Mantid
+
+#endif /* MANTID_ALGORITHMS_SORTXAXIS_H_ */
diff --git a/Framework/Algorithms/inc/MantidAlgorithms/WorkspaceJoiners.h b/Framework/Algorithms/inc/MantidAlgorithms/WorkspaceJoiners.h
index 1b9165ba8c114e0a54014a92082a98f429ef8f96..e662c06aad1f4e044d3cc6bd770eaaed4583a4e3 100644
--- a/Framework/Algorithms/inc/MantidAlgorithms/WorkspaceJoiners.h
+++ b/Framework/Algorithms/inc/MantidAlgorithms/WorkspaceJoiners.h
@@ -52,8 +52,9 @@ public:
protected:
API::MatrixWorkspace_sptr execWS2D(const API::MatrixWorkspace &ws1,
const API::MatrixWorkspace &ws2);
- API::MatrixWorkspace_sptr execEvent();
-
+ DataObjects::EventWorkspace_sptr
+ execEvent(const DataObjects::EventWorkspace &eventWs1,
+ const DataObjects::EventWorkspace &eventWs2);
using Mantid::API::Algorithm::validateInputs;
void validateInputs(const API::MatrixWorkspace &ws1,
const API::MatrixWorkspace &ws2, const bool checkBinning);
@@ -66,10 +67,6 @@ protected:
API::MatrixWorkspace &output) = 0;
API::Progress *m_progress; ///< Progress reporting object
- DataObjects::EventWorkspace_const_sptr
- event_ws1; ///< First event workspace input.
- DataObjects::EventWorkspace_const_sptr
- event_ws2; ///< Second event workspace input.
};
} // namespace Algorithms
diff --git a/Framework/Algorithms/src/AppendSpectra.cpp b/Framework/Algorithms/src/AppendSpectra.cpp
index 6400881d9d21d6696e7349cd05e5cc38e8a3943f..9907957643a72de0ed100950a959d4327305179d 100644
--- a/Framework/Algorithms/src/AppendSpectra.cpp
+++ b/Framework/Algorithms/src/AppendSpectra.cpp
@@ -43,8 +43,7 @@ void AppendSpectra::init() {
declareProperty("Number", 1,
boost::make_shared<BoundedValidator<int>>(1, EMPTY_INT()),
- "Append the spectra from InputWorkspace2 multiple times (for "
- "MatrixWorkspaces only)");
+ "Append the spectra from InputWorkspace2 multiple times.");
declareProperty(make_unique<WorkspaceProperty<>>("OutputWorkspace", "",
Direction::Output),
@@ -60,12 +59,14 @@ void AppendSpectra::exec() {
// Retrieve the input workspaces
MatrixWorkspace_const_sptr ws1 = getProperty("InputWorkspace1");
MatrixWorkspace_const_sptr ws2 = getProperty("InputWorkspace2");
- event_ws1 = boost::dynamic_pointer_cast<const EventWorkspace>(ws1);
- event_ws2 = boost::dynamic_pointer_cast<const EventWorkspace>(ws2);
+ DataObjects::EventWorkspace_const_sptr eventWs1 =
+ boost::dynamic_pointer_cast<const EventWorkspace>(ws1);
+ DataObjects::EventWorkspace_const_sptr eventWs2 =
+ boost::dynamic_pointer_cast<const EventWorkspace>(ws2);
// Make sure that we are not mis-matching EventWorkspaces and other types of
// workspaces
- if (((event_ws1) && (!event_ws2)) || ((!event_ws1) && (event_ws2))) {
+ if (((eventWs1) && (!eventWs2)) || ((!eventWs1) && (eventWs2))) {
const std::string message("Only one of the input workspaces are of type "
"EventWorkspace; please use matching workspace "
"types (both EventWorkspace's or both "
@@ -82,28 +83,28 @@ void AppendSpectra::exec() {
const bool mergeLogs = getProperty("MergeLogs");
const int number = getProperty("Number");
+ MatrixWorkspace_sptr output;
- if (event_ws1 && event_ws2) {
+ if (eventWs1 && eventWs2) {
// Both are event workspaces. Use the special method
- MatrixWorkspace_sptr output = this->execEvent();
- if (number > 1)
- g_log.warning("Number property is ignored for event workspaces");
- if (mergeLogs)
- combineLogs(ws1->run(), ws2->run(), output->mutableRun());
- // Set the output workspace
- setProperty("OutputWorkspace", output);
- return;
+ DataObjects::EventWorkspace_sptr eOutput =
+ this->execEvent(*eventWs1, *eventWs2);
+ for (int i = 1; i < number; i++) {
+ eOutput = this->execEvent(*eOutput, *eventWs2);
+ }
+ output = boost::static_pointer_cast<MatrixWorkspace>(eOutput);
+ } else { // So it is a workspace 2D.
+ // The only restriction, even with ValidateInputs=false
+ if (ws1->blocksize() != ws2->blocksize())
+ throw std::runtime_error(
+ "Workspace2D's must have the same number of bins.");
+
+ output = execWS2D(*ws1, *ws2);
+ for (int i = 1; i < number; i++) {
+ output = execWS2D(*output, *ws2);
+ }
}
- // So it is a workspace 2D.
-
- // The only restriction, even with ValidateInputs=false
- if (ws1->blocksize() != ws2->blocksize())
- throw std::runtime_error(
- "Workspace2D's must have the same number of bins.");
- MatrixWorkspace_sptr output = execWS2D(*ws1, *ws2);
- for (int i = 1; i < number; i++)
- output = execWS2D(*output, *ws2);
if (mergeLogs)
combineLogs(ws1->run(), ws2->run(), output->mutableRun());
diff --git a/Framework/Algorithms/src/ConjoinWorkspaces.cpp b/Framework/Algorithms/src/ConjoinWorkspaces.cpp
index 37f2fd807fc2a21ea73407fefea9ea6780037e09..cf39d7d45a6cb3c08ed30e00e0e5f0882a27b89a 100644
--- a/Framework/Algorithms/src/ConjoinWorkspaces.cpp
+++ b/Framework/Algorithms/src/ConjoinWorkspaces.cpp
@@ -46,12 +46,14 @@ void ConjoinWorkspaces::exec() {
// Retrieve the input workspaces
MatrixWorkspace_const_sptr ws1 = getProperty("InputWorkspace1");
MatrixWorkspace_const_sptr ws2 = getProperty("InputWorkspace2");
- event_ws1 = boost::dynamic_pointer_cast<const EventWorkspace>(ws1);
- event_ws2 = boost::dynamic_pointer_cast<const EventWorkspace>(ws2);
+ DataObjects::EventWorkspace_const_sptr eventWs1 =
+ boost::dynamic_pointer_cast<const EventWorkspace>(ws1);
+ DataObjects::EventWorkspace_const_sptr eventWs2 =
+ boost::dynamic_pointer_cast<const EventWorkspace>(ws2);
// Make sure that we are not mis-matching EventWorkspaces and other types of
// workspaces
- if (((event_ws1) && (!event_ws2)) || ((!event_ws1) && (event_ws2))) {
+ if (((eventWs1) && (!eventWs2)) || ((!eventWs1) && (eventWs2))) {
const std::string message("Only one of the input workspaces are of type "
"EventWorkspace; please use matching workspace "
"types (both EventWorkspace's or both "
@@ -60,9 +62,9 @@ void ConjoinWorkspaces::exec() {
throw std::invalid_argument(message);
}
- if (event_ws1 && event_ws2) {
- this->validateInputs(*event_ws1, *event_ws2, false);
- auto output = conjoinEvents(*event_ws1, *event_ws2);
+ if (eventWs1 && eventWs2) {
+ this->validateInputs(*eventWs1, *eventWs2, false);
+ auto output = conjoinEvents(*eventWs1, *eventWs2);
setYUnitAndLabel(*output);
// Set the result workspace to the first input
setProperty("InputWorkspace1", output);
@@ -150,7 +152,7 @@ ConjoinWorkspaces::conjoinEvents(const DataObjects::EventWorkspace &ws1,
}
// Both are event workspaces. Use the special method
- auto output = this->execEvent();
+ auto output = this->execEvent(ws1, ws2);
// Copy the history from the original workspace
output->history().addHistory(ws1.getHistory());
diff --git a/Framework/Algorithms/src/SortXAxis.cpp b/Framework/Algorithms/src/SortXAxis.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..aa4640a7a12e34c5e94c01cb7673d38de5e2e9d0
--- /dev/null
+++ b/Framework/Algorithms/src/SortXAxis.cpp
@@ -0,0 +1,265 @@
+#include "MantidAlgorithms/SortXAxis.h"
+#include "MantidAPI/Algorithm.h"
+#include "MantidAPI/MatrixWorkspace.h"
+#include "MantidAPI/WorkspaceProperty.h"
+#include "MantidHistogramData/Histogram.h"
+#include "MantidKernel/ListValidator.h"
+#include "MantidKernel/System.h"
+#include "MantidKernel/make_unique.h"
+using namespace Mantid;
+using namespace Mantid::API;
+using namespace Mantid::Kernel;
+using namespace Mantid::Algorithms;
+using namespace Mantid::DataObjects;
+using namespace Mantid::HistogramData;
+
+namespace Mantid {
+namespace Algorithms {
+
+DECLARE_ALGORITHM(SortXAxis)
+
+const std::string SortXAxis::name() const { return "SortXAxis"; }
+
+int SortXAxis::version() const { return 1; }
+
+const std::string SortXAxis::category() const {
+ return "Transforms\\Axes;Utility\\Sorting";
+}
+
+const std::string SortXAxis::summary() const {
+ return "Clones the input MatrixWorkspace(s) and orders the x-axis in an "
+ "ascending or descending fashion.";
+}
+
+void SortXAxis::init() {
+ declareProperty(make_unique<WorkspaceProperty<MatrixWorkspace>>(
+ "InputWorkspace", "", Direction::Input),
+ "Input Workspace");
+
+ declareProperty(make_unique<WorkspaceProperty<MatrixWorkspace>>(
+ "OutputWorkspace", "", Direction::Output),
+ "Sorted Output Workspace");
+
+ auto orderingValues = std::vector<std::string>({"Ascending", "Descending"});
+ auto orderingValidator =
+ boost::make_shared<StringListValidator>(orderingValues);
+ declareProperty("Ordering", orderingValues[0], orderingValidator,
+ "Ascending or descending sorting", Direction::Input);
+}
+
+void SortXAxis::exec() {
+
+ MatrixWorkspace_const_sptr inputWorkspace = getProperty("InputWorkspace");
+ MatrixWorkspace_sptr outputWorkspace = inputWorkspace->clone();
+
+ // Check if it is a valid histogram here
+ bool isAProperHistogram = determineIfHistogramIsValid(*inputWorkspace);
+
+ // Define everything you can outside of the for loop
+ // Assume that all spec are the same size
+ const auto sizeOfX = inputWorkspace->x(0).size();
+
+ PARALLEL_FOR_IF(Kernel::threadSafe(*inputWorkspace, *outputWorkspace))
+ for (int specNum = 0u; specNum < (int)inputWorkspace->getNumberHistograms();
+ specNum++) {
+ PARALLEL_START_INTERUPT_REGION
+ auto workspaceIndicies = createIndexes(sizeOfX);
+
+ sortIndicesByX(workspaceIndicies, getProperty("Ordering"), *inputWorkspace,
+ specNum);
+
+ copyToOutputWorkspace(workspaceIndicies, *inputWorkspace, *outputWorkspace,
+ specNum, isAProperHistogram);
+ PARALLEL_END_INTERUPT_REGION
+ }
+ PARALLEL_CHECK_INTERUPT_REGION
+
+ setProperty("OutputWorkspace", outputWorkspace);
+}
+
+/**
+ * @brief Gets a vector of numbers from 0 to the sizeOfX-1 and returns it
+ *
+ * @param sizeOfX The size of the Spectrum's X axis
+ * @return std::vector<std::size_t>
+ */
+std::vector<std::size_t> SortXAxis::createIndexes(const size_t sizeOfX) {
+ std::vector<std::size_t> workspaceIndicies;
+ workspaceIndicies.reserve(sizeOfX);
+ for (auto workspaceIndex = 0u; workspaceIndex < sizeOfX; workspaceIndex++) {
+ workspaceIndicies.emplace_back(workspaceIndex);
+ }
+ return workspaceIndicies;
+}
+
+/**
+ * @brief A template for sorting the values given a comparator
+ *
+ * @tparam Comparator
+ * @param workspaceIndicies the vector of indicies values
+ * @param inputWorkspace the original workspace
+ * @param specNum the Spectrum number to be sorted
+ * @param compare std::less<double> for Ascending order std::greater<double>
+ * for descending order
+ */
+template <typename Comparator>
+void sortByXValue(std::vector<std::size_t> &workspaceIndicies,
+ const Mantid::API::MatrixWorkspace &inputWorkspace,
+ unsigned int specNum, Comparator const &compare) {
+ std::sort(workspaceIndicies.begin(), workspaceIndicies.end(),
+ [&](std::size_t lhs, std::size_t rhs) -> bool {
+ return compare(inputWorkspace.x(specNum)[lhs],
+ inputWorkspace.x(specNum)[rhs]);
+ });
+}
+
+void SortXAxis::sortIndicesByX(
+ std::vector<std::size_t> &workspaceIndicies, std::string order,
+ const Mantid::API::MatrixWorkspace &inputWorkspace, unsigned int specNum) {
+ if (order == "Ascending") {
+ sortByXValue(workspaceIndicies, inputWorkspace, specNum,
+ std::less<double>());
+ } else if (order == "Descending") {
+ sortByXValue(workspaceIndicies, inputWorkspace, specNum,
+ std::greater<double>());
+ }
+}
+
+/**
+ * @brief Copies the sorted inputworkspace into the output workspace without
+ * using clone because of how histograms are supported, for the X Axis and the
+ * Dx Axis.
+ *
+ * @param workspaceIndicies the sorted vector of indecies
+ * @param inputWorkspace the unsorted initial workspace
+ * @param outputWorkspace the emptry output workspace
+ * @param specNum the Spectrum it is currently copying over
+ */
+void SortXAxis::copyXandDxToOutputWorkspace(
+ std::vector<std::size_t> &workspaceIndicies,
+ const Mantid::API::MatrixWorkspace &inputWorkspace,
+ Mantid::API::MatrixWorkspace &outputWorkspace, unsigned int specNum) {
+ // Move an ordered X to the output workspace
+ for (auto workspaceIndex = 0u;
+ workspaceIndex < inputWorkspace.x(specNum).size(); workspaceIndex++) {
+ outputWorkspace.mutableX(specNum)[workspaceIndex] =
+ inputWorkspace.x(specNum)[workspaceIndicies[workspaceIndex]];
+ }
+
+ // If Dx's are present, move Dx's to the output workspace
+ // If Dx's are present, move Dx's to the output workspace
+ if (inputWorkspace.hasDx(specNum)) {
+ for (auto workspaceIndex = 0u;
+ workspaceIndex < inputWorkspace.dx(specNum).size(); workspaceIndex++) {
+ outputWorkspace.mutableDx(specNum)[workspaceIndex] =
+ inputWorkspace.dx(specNum)[workspaceIndicies[workspaceIndex]];
+ }
+ }
+}
+
+/**
+ * @brief Copies the sorted inputworkspace into the output workspace without
+ * using clone because of how histograms are supported, for the Y Axis and the E
+ * Axis.
+ *
+ * @param workspaceIndicies the sorted vector of indicies
+ * @param inputWorkspace the unsorted input workspaces
+ * @param outputWorkspace the empty output workspace
+ * @param specNum the spectrum number being copied into
+ * @param isAProperHistogram whether or not it has been determined to be a valid
+ * histogram earlier on.
+ */
+void SortXAxis::copyYandEToOutputWorkspace(
+ std::vector<std::size_t> &workspaceIndicies,
+ const Mantid::API::MatrixWorkspace &inputWorkspace,
+ Mantid::API::MatrixWorkspace &outputWorkspace, unsigned int specNum,
+ bool isAProperHistogram) {
+ // If Histogram data find the biggest index value and remove it from
+ // workspaceIndicies
+ if (isAProperHistogram) {
+ auto lastIndexIt =
+ std::find(workspaceIndicies.begin(), workspaceIndicies.end(),
+ inputWorkspace.y(specNum).size());
+ workspaceIndicies.erase(lastIndexIt);
+ }
+
+ auto &inSpaceY = inputWorkspace.y(specNum);
+ for (auto workspaceIndex = 0u;
+ workspaceIndex < inputWorkspace.y(specNum).size(); workspaceIndex++) {
+ outputWorkspace.mutableY(specNum)[workspaceIndex] =
+ inSpaceY[workspaceIndicies[workspaceIndex]];
+ }
+
+ auto &inSpaceE = inputWorkspace.e(specNum);
+ for (auto workspaceIndex = 0u;
+ workspaceIndex < inputWorkspace.e(specNum).size(); workspaceIndex++) {
+ outputWorkspace.mutableE(specNum)[workspaceIndex] =
+ inSpaceE[workspaceIndicies[workspaceIndex]];
+ }
+}
+
+void SortXAxis::copyToOutputWorkspace(
+ std::vector<std::size_t> &workspaceIndicies,
+ const Mantid::API::MatrixWorkspace &inputWorkspace,
+ Mantid::API::MatrixWorkspace &outputWorkspace, unsigned int specNum,
+ bool isAProperHistogram) {
+ copyXandDxToOutputWorkspace(workspaceIndicies, inputWorkspace,
+ outputWorkspace, specNum);
+ copyYandEToOutputWorkspace(workspaceIndicies, inputWorkspace, outputWorkspace,
+ specNum, isAProperHistogram);
+}
+
+/**
+ * @brief determines whether or not a given spectrum is sorted based on a passed
+ * comparator
+ *
+ * @tparam Comparator
+ * @param compare std::less<double> for descending and std::greater<double> for
+ * ascending
+ * @param inputWorkspace the unsorted input workspace
+ * @return true if it is sorted
+ * @return false if it is not sorted
+ */
+template <typename Comparator>
+bool isItSorted(Comparator const &compare,
+ const Mantid::API::MatrixWorkspace &inputWorkspace) {
+ for (auto specNum = 0u; specNum < inputWorkspace.getNumberHistograms();
+ specNum++) {
+ if (!std::is_sorted(inputWorkspace.x(specNum).begin(),
+ inputWorkspace.x(specNum).end(),
+ [&](double lhs, double rhs) -> bool {
+ return compare(lhs, rhs);
+ })) {
+ return false;
+ }
+ }
+ return true;
+}
+
+/**
+ * @brief Determines whether it is a valid histogram or not.
+ *
+ * @param inputWorkspace the unsorted input workspace
+ * @return true if it is a valid histogram else produce a runtime_error
+ * @return false if it is not a histogram, and is thus point data
+ */
+bool SortXAxis::determineIfHistogramIsValid(
+ const Mantid::API::MatrixWorkspace &inputWorkspace) {
+ // Assuming all X and Ys are the same, if X is not the same size as y, assume
+ // it is a histogram
+ if (inputWorkspace.x(0).size() != inputWorkspace.y(0).size()) {
+ // The only way to guarantee that a histogram is a proper histogram, is to
+ // check whether each data value is in the correct order.
+ if (!isItSorted(std::greater<double>(), inputWorkspace)) {
+ if (!isItSorted(std::less<double>(), inputWorkspace)) {
+ throw std::runtime_error("Data entered looks like a histogram, but is "
+ "not a valid histogram");
+ }
+ }
+ return true;
+ }
+ return false;
+}
+
+} // namespace Algorithms
+} // namespace Mantid
diff --git a/Framework/Algorithms/src/WorkspaceJoiners.cpp b/Framework/Algorithms/src/WorkspaceJoiners.cpp
index f2483b3c7432688297a386ccbd3127d36640060b..ff4ec7e077d76bc1c78b3559af55230dafdef003 100644
--- a/Framework/Algorithms/src/WorkspaceJoiners.cpp
+++ b/Framework/Algorithms/src/WorkspaceJoiners.cpp
@@ -118,44 +118,46 @@ MatrixWorkspace_sptr WorkspaceJoiners::execWS2D(const MatrixWorkspace &ws1,
* @throw std::invalid_argument If the input workspaces do not meet the
* requirements of this algorithm
*/
-MatrixWorkspace_sptr WorkspaceJoiners::execEvent() {
+DataObjects::EventWorkspace_sptr
+WorkspaceJoiners::execEvent(const DataObjects::EventWorkspace &eventWs1,
+ const DataObjects::EventWorkspace &eventWs2) {
// Create the output workspace
const size_t totalHists =
- event_ws1->getNumberHistograms() + event_ws2->getNumberHistograms();
+ eventWs1.getNumberHistograms() + eventWs2.getNumberHistograms();
auto output =
- create<EventWorkspace>(*event_ws1, totalHists, event_ws1->binEdges(0));
+ create<EventWorkspace>(eventWs1, totalHists, eventWs1.binEdges(0));
// Initialize the progress reporting object
m_progress = new API::Progress(this, 0.0, 1.0, totalHists);
- const int64_t &nhist1 = event_ws1->getNumberHistograms();
+ const int64_t &nhist1 = eventWs1.getNumberHistograms();
for (int64_t i = 0; i < nhist1; ++i) {
- output->getSpectrum(i) = event_ws1->getSpectrum(i);
+ output->getSpectrum(i) = eventWs1.getSpectrum(i);
m_progress->report();
}
// For second loop we use the offset from the first
- const int64_t &nhist2 = event_ws2->getNumberHistograms();
- const auto &spectrumInfo = event_ws2->spectrumInfo();
+ const int64_t &nhist2 = eventWs2.getNumberHistograms();
+ const auto &spectrumInfo = eventWs2.spectrumInfo();
auto &outSpectrumInfo = output->mutableSpectrumInfo();
for (int64_t j = 0; j < nhist2; ++j) {
// This is the workspace index at which we assign in the output
- int64_t output_wi = j + nhist1;
- output->getSpectrum(output_wi) = event_ws2->getSpectrum(j);
+ int64_t outputWi = j + nhist1;
+ output->getSpectrum(outputWi) = eventWs2.getSpectrum(j);
// Propagate spectrum masking. First workspace will have been done by the
// factory
if (spectrumInfo.hasDetectors(j) && spectrumInfo.isMasked(j)) {
- output->getSpectrum(output_wi).clearData();
+ output->getSpectrum(outputWi).clearData();
PARALLEL_CRITICAL(setMaskedEvent) {
- outSpectrumInfo.setMasked(output_wi, true);
+ outSpectrumInfo.setMasked(outputWi, true);
}
}
m_progress->report();
}
- fixSpectrumNumbers(*event_ws1, *event_ws2, *output);
+ fixSpectrumNumbers(eventWs1, eventWs2, *output);
return std::move(output);
}
diff --git a/Framework/Algorithms/test/AppendSpectraTest.h b/Framework/Algorithms/test/AppendSpectraTest.h
index bdf76d8bb2498ba35fc46c279ebc108e8bce12cc..2b43a0d444ae5b0ddf7af9746d3bc4e5c6d42cea 100644
--- a/Framework/Algorithms/test/AppendSpectraTest.h
+++ b/Framework/Algorithms/test/AppendSpectraTest.h
@@ -178,7 +178,7 @@ public:
}
//----------------------------------------------------------------------------------------------
- void doTest(bool event, bool combineLogs = false) {
+ void doTest(bool event, bool combineLogs = false, int number = 1) {
MatrixWorkspace_sptr ws1, ws2, out;
int numBins = 20;
@@ -212,6 +212,7 @@ public:
TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("InputWorkspace1", ws1Name));
TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("InputWorkspace2", ws2Name));
TS_ASSERT_THROWS_NOTHING(alg.setPropertyValue("OutputWorkspace", ws1Name));
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("Number", number));
if (combineLogs)
alg.setProperty("MergeLogs", true);
TS_ASSERT_THROWS_NOTHING(alg.execute();)
@@ -224,7 +225,7 @@ public:
if (!out)
return;
- TS_ASSERT_EQUALS(out->getNumberHistograms(), 15);
+ TS_ASSERT_EQUALS(out->getNumberHistograms(), 10 + 5 * number);
TS_ASSERT_EQUALS(out->blocksize(), numBins);
for (size_t wi = 0; wi < out->getNumberHistograms(); wi++) {
@@ -246,6 +247,8 @@ public:
void test_events() { doTest(true); }
+ void test_number_events() { doTest(true, true, 3); }
+
void test_2D() { doTest(false); }
void test_events_mergeLogs() { doTest(true, true); }
diff --git a/Framework/Algorithms/test/ConvertSpectrumAxis2Test.h b/Framework/Algorithms/test/ConvertSpectrumAxis2Test.h
index 32a575b45b822ea907d273ae4452b9aebea9103c..e489b3a8f1c96a9c158195165c75b0d2c98eb339 100644
--- a/Framework/Algorithms/test/ConvertSpectrumAxis2Test.h
+++ b/Framework/Algorithms/test/ConvertSpectrumAxis2Test.h
@@ -10,7 +10,6 @@
#include "MantidAPI/SpectrumInfo.h"
#include "MantidAlgorithms/CreateSampleWorkspace.h"
#include "MantidKernel/Unit.h"
-#include "MantidTestHelpers/HistogramDataTestHelper.h"
#include "MantidTestHelpers/WorkspaceCreationHelper.h"
using namespace Mantid::API;
diff --git a/Framework/Algorithms/test/ConvertSpectrumAxisTest.h b/Framework/Algorithms/test/ConvertSpectrumAxisTest.h
index 7599829a79d571dbd97a7aba96fab733178a567f..548463d7ccfa86f1e710070cea0dca4239bd2844 100644
--- a/Framework/Algorithms/test/ConvertSpectrumAxisTest.h
+++ b/Framework/Algorithms/test/ConvertSpectrumAxisTest.h
@@ -6,7 +6,6 @@
#include "MantidAlgorithms/ConvertSpectrumAxis.h"
#include "MantidDataHandling/LoadRaw3.h"
#include "MantidKernel/Unit.h"
-#include "MantidTestHelpers/HistogramDataTestHelper.h"
#include "MantidTestHelpers/WorkspaceCreationHelper.h"
#include <cxxtest/TestSuite.h>
diff --git a/Framework/Algorithms/test/ConvertToMatrixWorkspaceTest.h b/Framework/Algorithms/test/ConvertToMatrixWorkspaceTest.h
index 365e7922a9c5e7aa9fccf05fc18df0a10e0c359c..1a7300a4329c493310b22c4784aa813166633841 100644
--- a/Framework/Algorithms/test/ConvertToMatrixWorkspaceTest.h
+++ b/Framework/Algorithms/test/ConvertToMatrixWorkspaceTest.h
@@ -8,7 +8,6 @@
#include "MantidAlgorithms/ConvertToMatrixWorkspace.h"
#include "MantidDataObjects/EventWorkspace.h"
#include "MantidGeometry/Instrument.h"
-#include "MantidTestHelpers/HistogramDataTestHelper.h"
#include "MantidTestHelpers/WorkspaceCreationHelper.h"
using namespace Mantid;
diff --git a/Framework/Algorithms/test/InterpolationOptionTest.h b/Framework/Algorithms/test/InterpolationOptionTest.h
index 8efed012ff50008822ed9af32b16838aba76557d..8da20ed54e9d36cd88a539702d8426ad0ed743d1 100644
--- a/Framework/Algorithms/test/InterpolationOptionTest.h
+++ b/Framework/Algorithms/test/InterpolationOptionTest.h
@@ -9,7 +9,6 @@
#include "MantidHistogramData/LinearGenerator.h"
#include "MantidHistogramData/Points.h"
#include "MantidKernel/PropertyWithValue.h"
-#include "MantidTestHelpers/HistogramDataTestHelper.h"
using Mantid::Algorithms::InterpolationOption;
using namespace Mantid::HistogramData;
diff --git a/Framework/Algorithms/test/Rebin2DTest.h b/Framework/Algorithms/test/Rebin2DTest.h
index 7bef27e8d98e1c05f2b9350b364abc481c0b8815..fd1b7c0d6689647c8d7f65a4ea1f469e22ceb0ea 100644
--- a/Framework/Algorithms/test/Rebin2DTest.h
+++ b/Framework/Algorithms/test/Rebin2DTest.h
@@ -81,6 +81,10 @@ MatrixWorkspace_sptr runAlgorithm(MatrixWorkspace_sptr inputWS,
class Rebin2DTest : public CxxTest::TestSuite {
public:
+ // This means the constructor isn't called when running other tests
+ static Rebin2DTest *createSuite() { return new Rebin2DTest(); }
+ static void destroySuite(Rebin2DTest *suite) { delete suite; }
+
void test_Init() {
Rebin2D alg;
TS_ASSERT_THROWS_NOTHING(alg.initialize())
@@ -212,6 +216,13 @@ private:
class Rebin2DTestPerformance : public CxxTest::TestSuite {
public:
+ // This pair of boilerplate methods prevent the suite being created statically
+ // This means the constructor isn't called when running other tests
+ static Rebin2DTestPerformance *createSuite() {
+ return new Rebin2DTestPerformance();
+ }
+ static void destroySuite(Rebin2DTestPerformance *suite) { delete suite; }
+
Rebin2DTestPerformance() {
m_inputWS = makeInputWS(distribution, perf_test, small_bins);
}
diff --git a/Framework/Algorithms/test/SortXAxisTest.h b/Framework/Algorithms/test/SortXAxisTest.h
new file mode 100644
index 0000000000000000000000000000000000000000..616a1137dc1cd4f96c2fbaa5270f55f7964b19ec
--- /dev/null
+++ b/Framework/Algorithms/test/SortXAxisTest.h
@@ -0,0 +1,380 @@
+#ifndef MANTID_ALGORITHMS_SORTXAXISTEST_H_
+#define MANTID_ALGORITHMS_SORTXAXISTEST_H_
+
+#include "MantidAPI/AnalysisDataService.h"
+#include "MantidAPI/MatrixWorkspace.h"
+#include "MantidAlgorithms/SortXAxis.h"
+#include "MantidDataObjects/Workspace2D.h"
+#include "MantidDataObjects/WorkspaceCreation.h"
+#include "MantidHistogramData/Histogram.h"
+#include <cxxtest/TestSuite.h>
+
+/**
+ Copyright © 2018 ISIS Rutherford Appleton Laboratory, NScD Oak Ridge
+ National Laboratory & European Spallation Source
+ This file is part of Mantid.
+ Mantid is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+ Mantid is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ 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>
+ Code Documentation is available at: <http://doxygen.mantidproject.org>
+*/
+
+using namespace Mantid;
+using namespace Mantid::API;
+using namespace Mantid::Kernel;
+using namespace Mantid::Algorithms;
+using namespace Mantid::DataObjects;
+using namespace Mantid::HistogramData;
+
+namespace {
+MatrixWorkspace_sptr createWorkspaceE(const std::vector<double> xData,
+ const std::vector<double> yData,
+ const std::vector<double> eData,
+ const int nSpec = 1) {
+
+ Workspace2D_sptr outputWorkspace = create<DataObjects::Workspace2D>(
+ nSpec, Mantid::HistogramData::Histogram(
+ Mantid::HistogramData::Points(xData.size())));
+ for (int i = 0; i < nSpec; ++i) {
+ outputWorkspace->mutableY(i) = yData;
+ outputWorkspace->mutableE(i) = eData;
+ outputWorkspace->mutableX(i) = xData;
+ }
+ return outputWorkspace;
+}
+
+MatrixWorkspace_sptr createHistoWorkspaceE(const std::vector<double> xData,
+ const std::vector<double> yData,
+ const std::vector<double> eData,
+ const int nSpec = 1) {
+
+ Workspace2D_sptr outputWorkspace = create<DataObjects::Workspace2D>(
+ nSpec, Mantid::HistogramData::Histogram(
+ Mantid::HistogramData::BinEdges(xData.size())));
+ for (int i = 0; i < nSpec; ++i) {
+ outputWorkspace->mutableY(i) = yData;
+ outputWorkspace->mutableE(i) = eData;
+ outputWorkspace->mutableX(i) = xData;
+ }
+ return outputWorkspace;
+}
+
+MatrixWorkspace_sptr createWorkspaceDx(const std::vector<double> xData,
+ const std::vector<double> yData,
+ const std::vector<double> dxData,
+ const int nSpec = 1) {
+
+ Workspace2D_sptr outputWorkspace = create<DataObjects::Workspace2D>(
+ nSpec, Mantid::HistogramData::Histogram(
+ Mantid::HistogramData::Points(xData.size())));
+ for (int i = 0; i < nSpec; ++i) {
+ outputWorkspace->mutableY(i) = yData;
+ outputWorkspace->mutableX(i) = xData;
+ outputWorkspace->setPointStandardDeviations(i, dxData);
+ }
+ return outputWorkspace;
+}
+
+MatrixWorkspace_sptr createHistoWorkspaceDx(const std::vector<double> xData,
+ const std::vector<double> yData,
+ const std::vector<double> dxData,
+ const int nSpec = 1) {
+
+ Workspace2D_sptr outputWorkspace = create<DataObjects::Workspace2D>(
+ nSpec, Mantid::HistogramData::Histogram(
+ Mantid::HistogramData::BinEdges(xData.size())));
+ for (int i = 0; i < nSpec; ++i) {
+ outputWorkspace->mutableY(i) = yData;
+ outputWorkspace->mutableX(i) = xData;
+ outputWorkspace->setPointStandardDeviations(i, dxData);
+ }
+ return outputWorkspace;
+}
+
+MatrixWorkspace_sptr createHistoWorkspace(const std::vector<double> xData,
+ const std::vector<double> yData,
+ const int nSpec = 1) {
+
+ Workspace2D_sptr outputWorkspace = create<DataObjects::Workspace2D>(
+ nSpec, Mantid::HistogramData::Histogram(
+ Mantid::HistogramData::BinEdges(xData.size())));
+ for (int i = 0; i < nSpec; ++i) {
+ outputWorkspace->mutableY(i) = yData;
+ outputWorkspace->mutableX(i) = xData;
+ }
+ return outputWorkspace;
+}
+} // namespace
+
+class SortXAxisTest : public CxxTest::TestSuite {
+public:
+ // This pair of boilerplate methods prevent the suite being created statically
+ // This means the constructor isn't called when running other tests
+ static SortXAxisTest *createSuite() { return new SortXAxisTest(); }
+ static void destroySuite(SortXAxisTest *suite) { delete suite; }
+
+ void testXAscending() {
+ std::vector<double> xData = {1, 2, 3};
+ std::vector<double> yData = {1, 2, 3};
+ std::vector<double> eData = {1, 2, 3};
+
+ MatrixWorkspace_sptr unsortedws = createWorkspaceE(xData, yData, eData);
+
+ SortXAxis alg;
+ TS_ASSERT_THROWS_NOTHING(alg.initialize())
+ TS_ASSERT(alg.isInitialized())
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("InputWorkspace", unsortedws));
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("OutputWorkspace", "sortedws"));
+ TS_ASSERT_THROWS_NOTHING(alg.execute());
+
+ MatrixWorkspace_sptr sortedws;
+ TS_ASSERT_THROWS_NOTHING(
+ sortedws = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
+ "sortedws"));
+ TS_ASSERT(sortedws);
+
+ TS_ASSERT_EQUALS(sortedws->x(0).rawData(), xData);
+ TS_ASSERT_EQUALS(sortedws->y(0).rawData(), yData);
+ TS_ASSERT_EQUALS(sortedws->e(0).rawData(), eData);
+
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("unsortedws"));
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("sortedws"));
+ }
+
+ void testXDescending() {
+ std::vector<double> xData = {3, 2, 1};
+ std::vector<double> sortedXData = {1, 2, 3};
+ std::vector<double> yData = {1, 2, 3};
+ std::vector<double> reverseYData = {3, 2, 1};
+ std::vector<double> eData = {1, 2, 3};
+ std::vector<double> reverseEData = {3, 2, 1};
+
+ MatrixWorkspace_sptr unsortedws = createWorkspaceE(xData, yData, eData);
+
+ SortXAxis alg;
+ TS_ASSERT_THROWS_NOTHING(alg.initialize())
+ TS_ASSERT(alg.isInitialized())
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("InputWorkspace", unsortedws));
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("OutputWorkspace", "sortedws"));
+ TS_ASSERT_THROWS_NOTHING(alg.execute());
+
+ MatrixWorkspace_sptr sortedws;
+ TS_ASSERT_THROWS_NOTHING(
+ sortedws = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
+ "sortedws"));
+ TS_ASSERT(sortedws);
+
+ TS_ASSERT_EQUALS(sortedws->x(0).rawData(), sortedXData);
+ TS_ASSERT_EQUALS(sortedws->y(0).rawData(), reverseYData);
+ TS_ASSERT_EQUALS(sortedws->e(0).rawData(), reverseEData);
+
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("unsortedws"));
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("sortedws"));
+ }
+
+ void testOnMultipleSpectrum() {
+ std::vector<double> xData = {3, 2, 1};
+ std::vector<double> sortedXData = {1, 2, 3};
+ std::vector<double> yData = {1, 2, 3};
+ std::vector<double> reverseYData = {3, 2, 1};
+ std::vector<double> eData = {1, 2, 3};
+ std::vector<double> reverseEData = {3, 2, 1};
+
+ MatrixWorkspace_sptr unsortedws = createWorkspaceE(xData, yData, eData, 2);
+
+ SortXAxis alg;
+ TS_ASSERT_THROWS_NOTHING(alg.initialize())
+ TS_ASSERT(alg.isInitialized())
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("InputWorkspace", unsortedws));
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("OutputWorkspace", "sortedws"));
+ TS_ASSERT_THROWS_NOTHING(alg.execute());
+
+ MatrixWorkspace_sptr sortedws;
+ TS_ASSERT_THROWS_NOTHING(
+ sortedws = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
+ "sortedws"));
+ TS_ASSERT(sortedws);
+
+ TS_ASSERT_EQUALS(sortedws->x(0).rawData(), sortedXData);
+ TS_ASSERT_EQUALS(sortedws->y(0).rawData(), reverseYData);
+ TS_ASSERT_EQUALS(sortedws->e(0).rawData(), reverseEData);
+
+ TS_ASSERT_EQUALS(sortedws->x(1).rawData(), sortedXData);
+ TS_ASSERT_EQUALS(sortedws->y(1).rawData(), reverseYData);
+ TS_ASSERT_EQUALS(sortedws->e(1).rawData(), reverseEData);
+
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("unsortedws"));
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("sortedws"));
+ }
+
+ void testSortsXHistogramAscending() {
+ std::vector<double> xData = {1, 2, 3, 4};
+ std::vector<double> yData = {1, 2, 3};
+ std::vector<double> eData = {1, 2, 3};
+
+ MatrixWorkspace_sptr unsortedws =
+ createHistoWorkspaceE(xData, yData, eData);
+
+ SortXAxis alg;
+ TS_ASSERT_THROWS_NOTHING(alg.initialize())
+ TS_ASSERT(alg.isInitialized())
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("InputWorkspace", unsortedws));
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("OutputWorkspace", "sortedws"));
+ TS_ASSERT_THROWS_NOTHING(alg.execute());
+
+ MatrixWorkspace_sptr sortedws;
+ TS_ASSERT_THROWS_NOTHING(
+ sortedws = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
+ "sortedws"));
+ TS_ASSERT(sortedws);
+
+ TS_ASSERT_EQUALS(sortedws->x(0).rawData(), xData);
+ TS_ASSERT_EQUALS(sortedws->y(0).rawData(), yData);
+ TS_ASSERT_EQUALS(sortedws->e(0).rawData(), eData);
+
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("unsortedws"));
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("sortedws"));
+ }
+
+ void testSortsXHistogramDescending() {
+ std::vector<double> xData = {4, 3, 2, 1};
+ std::vector<double> sortedXData = {1, 2, 3, 4};
+ std::vector<double> yData = {1, 2, 3};
+ std::vector<double> reverseYData = {3, 2, 1};
+ std::vector<double> eData = {1, 2, 3};
+ std::vector<double> reverseEData = {3, 2, 1};
+
+ MatrixWorkspace_sptr unsortedws =
+ createHistoWorkspaceE(xData, yData, eData);
+
+ SortXAxis alg;
+ TS_ASSERT_THROWS_NOTHING(alg.initialize())
+ TS_ASSERT(alg.isInitialized())
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("InputWorkspace", unsortedws));
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("OutputWorkspace", "sortedws"));
+ TS_ASSERT_THROWS_NOTHING(alg.execute());
+
+ MatrixWorkspace_sptr sortedws;
+ TS_ASSERT_THROWS_NOTHING(
+ sortedws = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
+ "sortedws"));
+ TS_ASSERT(sortedws);
+
+ TS_ASSERT_EQUALS(sortedws->x(0).rawData(), sortedXData);
+ TS_ASSERT_EQUALS(sortedws->y(0).rawData(), reverseYData);
+ TS_ASSERT_EQUALS(sortedws->e(0).rawData(), reverseEData);
+
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("unsortedws"));
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("sortedws"));
+ }
+
+ void testDxMultipleSpectrum() {
+ std::vector<double> xData = {3, 2, 1};
+ std::vector<double> yData = {1, 2, 3};
+ std::vector<double> dxData = {1, 2, 3};
+ std::vector<double> reverseDxData = {3, 2, 1};
+
+ MatrixWorkspace_sptr unsortedws =
+ createWorkspaceDx(xData, yData, dxData, 2);
+
+ SortXAxis alg;
+ TS_ASSERT_THROWS_NOTHING(alg.initialize())
+ TS_ASSERT(alg.isInitialized())
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("InputWorkspace", unsortedws));
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("OutputWorkspace", "sortedws"));
+ TS_ASSERT_THROWS_NOTHING(alg.execute());
+
+ MatrixWorkspace_sptr sortedws;
+ TS_ASSERT_THROWS_NOTHING(
+ sortedws = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
+ "sortedws"));
+ TS_ASSERT(sortedws);
+
+ TS_ASSERT_EQUALS(sortedws->dx(0).rawData(), reverseDxData);
+ TS_ASSERT_EQUALS(sortedws->dx(1).rawData(), reverseDxData);
+
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("unsortedws"));
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("sortedws"));
+ }
+
+ void testDxHistogramAscending() {
+ std::vector<double> xData = {1, 2, 3, 4};
+ std::vector<double> yData = {1, 2, 3};
+ std::vector<double> dxData = {1, 2, 3};
+
+ MatrixWorkspace_sptr unsortedws =
+ createHistoWorkspaceDx(xData, yData, dxData, 2);
+
+ SortXAxis alg;
+ TS_ASSERT_THROWS_NOTHING(alg.initialize())
+ TS_ASSERT(alg.isInitialized())
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("InputWorkspace", unsortedws));
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("OutputWorkspace", "sortedws"));
+ TS_ASSERT_THROWS_NOTHING(alg.execute());
+
+ MatrixWorkspace_sptr sortedws;
+ TS_ASSERT_THROWS_NOTHING(
+ sortedws = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
+ "sortedws"));
+ TS_ASSERT(sortedws);
+
+ TS_ASSERT_EQUALS(sortedws->dx(0).rawData(), dxData);
+
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("unsortedws"));
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("sortedws"));
+ }
+
+ void testSortDescending() {
+ std::vector<double> xData = {1, 2, 3, 4};
+ std::vector<double> reverseXData = {4, 3, 2, 1};
+ std::vector<double> yData = {1, 2, 3};
+ std::vector<double> reverseYData = {3, 2, 1};
+
+ MatrixWorkspace_sptr unsortedws = createHistoWorkspace(xData, yData, 2);
+
+ SortXAxis alg;
+ TS_ASSERT_THROWS_NOTHING(alg.initialize())
+ TS_ASSERT(alg.isInitialized())
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("InputWorkspace", unsortedws));
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("OutputWorkspace", "sortedws"));
+ TS_ASSERT_THROWS_NOTHING(alg.setProperty("Ordering", "Descending"));
+ TS_ASSERT_THROWS_NOTHING(alg.execute());
+
+ MatrixWorkspace_sptr sortedws;
+ TS_ASSERT_THROWS_NOTHING(
+ sortedws = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
+ "sortedws"));
+ TS_ASSERT(sortedws);
+
+ TS_ASSERT_EQUALS(sortedws->x(0).rawData(), reverseXData);
+ TS_ASSERT_EQUALS(sortedws->y(0).rawData(), reverseYData);
+
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("unsortedws"));
+ TS_ASSERT_THROWS_NOTHING(
+ AnalysisDataService::Instance().remove("sortedws"));
+ }
+};
+#endif /*MANTID_ALGORITHMS_SORTXAXISTEST_H_*/
diff --git a/Framework/Algorithms/test/SpecularReflectionAlgorithmTest.h b/Framework/Algorithms/test/SpecularReflectionAlgorithmTest.h
index 8c5a18ffa91d966cff05461b9a799492a98545fb..061729e970b71e42b0782cc66494e4adcf05276b 100644
--- a/Framework/Algorithms/test/SpecularReflectionAlgorithmTest.h
+++ b/Framework/Algorithms/test/SpecularReflectionAlgorithmTest.h
@@ -25,6 +25,15 @@ using namespace Mantid::Kernel;
using VerticalHorizontalOffsetType = boost::tuple<double, double>;
class SpecularReflectionAlgorithmTest {
+public:
+ // This means the constructor isn't called when running other tests
+ static SpecularReflectionAlgorithmTest *createSuite() {
+ return new SpecularReflectionAlgorithmTest();
+ }
+ static void destroySuite(SpecularReflectionAlgorithmTest *suite) {
+ delete suite;
+ }
+
protected:
MatrixWorkspace_sptr pointDetectorWS;
diff --git a/Framework/CurveFitting/test/Algorithms/SeqDomainSpectrumCreatorTest.h b/Framework/CurveFitting/test/Algorithms/SeqDomainSpectrumCreatorTest.h
index a0878686c324274a47d726165d47d03235e7a1a3..c77d6e31b9d71f8644b5310543c822a8b190c9aa 100644
--- a/Framework/CurveFitting/test/Algorithms/SeqDomainSpectrumCreatorTest.h
+++ b/Framework/CurveFitting/test/Algorithms/SeqDomainSpectrumCreatorTest.h
@@ -19,8 +19,6 @@
#include "MantidAPI/FrameworkManager.h"
#include "MantidAPI/SpectrumInfo.h"
-#include "MantidTestHelpers/HistogramDataTestHelper.h"
-
using namespace Mantid::Kernel;
using namespace Mantid::API;
using namespace Mantid::CurveFitting;
diff --git a/Framework/DataHandling/src/SaveGSS.cpp b/Framework/DataHandling/src/SaveGSS.cpp
index e0553f416d692b38d431ceb1e0761c50fc62ec84..ed411a29fc9d03ef67682d7ae4c75e0577bf29ef 100644
--- a/Framework/DataHandling/src/SaveGSS.cpp
+++ b/Framework/DataHandling/src/SaveGSS.cpp
@@ -9,6 +9,7 @@
#include "MantidKernel/ArrayLengthValidator.h"
#include "MantidKernel/ArrayProperty.h"
#include "MantidKernel/CompositeValidator.h"
+#include "MantidKernel/Exception.h"
#include "MantidKernel/ListValidator.h"
#include "MantidKernel/PhysicalConstants.h"
#include "MantidKernel/TimeSeriesProperty.h"
@@ -668,13 +669,11 @@ void SaveGSS::openFileStream(const std::string &outFilePath,
// Have to wrap this in a unique pointer as GCC 4.x (RHEL 7) does
// not support the move operator on iostreams
outStream.open(outFilePath, mode);
-
if (outStream.fail()) {
// Get the error message from library and log before throwing
const std::string error = strerror(errno);
- g_log.error("Failed to open file. Error was: " + error);
- throw std::runtime_error("Could not open the file at the following path: " +
- outFilePath);
+ throw Kernel::Exception::FileError(
+ "Failed to open file. Error was: " + error, outFilePath);
}
// Stream is good at this point
@@ -751,21 +750,6 @@ std::map<std::string, std::string> SaveGSS::validateInputs() {
return result;
}
-namespace { // anonymous
-// throw an exception if file cannot be written
-void checkWritable(const std::string &filename) {
- const auto fileobj = Poco::File(filename);
- if (fileobj.exists()) {
- if (!fileobj.canWrite())
- throw std::runtime_error("Cannot write to " + filename);
- } else {
- const auto pathobj = Poco::Path(filename).makeAbsolute().parent();
- if (!Poco::File(pathobj.toString()).canWrite())
- throw std::runtime_error("Cannot write to " + pathobj.toString());
- }
-}
-} // namespace
-
/**
* Writes all the spectra to the file(s) from the buffer to the
* list of output file paths.
@@ -782,13 +766,10 @@ void SaveGSS::writeBufferToFile(size_t numOutFiles, size_t numSpectra) {
const auto numOutFilesInt64 = static_cast<int64_t>(numOutFiles);
- // verify that all paths can be written to
- for (const auto &filename : m_outFileNames) {
- checkWritable(filename);
- }
-
PARALLEL_FOR_NO_WSP_CHECK()
for (int64_t fileIndex = 0; fileIndex < numOutFilesInt64; fileIndex++) {
+ PARALLEL_START_INTERUPT_REGION
+
// Open each file when there are multiple
std::ofstream fileStream;
openFileStream(m_outFileNames[fileIndex], fileStream);
@@ -807,7 +788,9 @@ void SaveGSS::writeBufferToFile(size_t numOutFiles, size_t numSpectra) {
"Failed to close the file at " + m_outFileNames[fileIndex] +
" - this file may be empty, corrupted or incorrect.");
}
+ PARALLEL_END_INTERUPT_REGION
}
+ PARALLEL_CHECK_INTERUPT_REGION
}
void SaveGSS::writeRALFHeader(std::stringstream &out, int bank,
@@ -850,7 +833,6 @@ void SaveGSS::writeRALF_ALTdata(std::stringstream &out, const int bank,
std::vector<std::unique_ptr<std::stringstream>> outLines;
outLines.resize(numberOfOutLines);
- PARALLEL_FOR_NO_WSP_CHECK()
for (int64_t i = 0; i < numberOfOutLines; i++) {
outLines[i] = makeStringStream();
auto &outLine = *outLines[i];
diff --git a/Framework/DataHandling/src/SaveNexusProcessed.cpp b/Framework/DataHandling/src/SaveNexusProcessed.cpp
index 04f5e45932330d4044da107983af2017ed8c523f..fdd8cd6ec3f3815b026b77e00347175c0ec3d937 100644
--- a/Framework/DataHandling/src/SaveNexusProcessed.cpp
+++ b/Framework/DataHandling/src/SaveNexusProcessed.cpp
@@ -220,7 +220,7 @@ void SaveNexusProcessed::doExec(
nexusFile->openNexusWrite(m_filename, entryNumber);
// Equivalent C++ API handle
- auto cppFile = new ::NeXus::File(nexusFile->fileID);
+ ::NeXus::File cppFile(nexusFile->fileID);
prog_init.reportIncrement(1, "Opening file");
if (nexusFile->writeNexusProcessedHeader(m_title, wsName) != 0)
@@ -231,7 +231,7 @@ void SaveNexusProcessed::doExec(
// write instrument data, if present and writer enabled
if (matrixWorkspace) {
// Save the instrument names, ParameterMap, sample, run
- matrixWorkspace->saveExperimentInfoNexus(cppFile);
+ matrixWorkspace->saveExperimentInfoNexus(&cppFile);
prog_init.reportIncrement(1, "Writing sample and instrument");
// check if all X() are in fact the same array
@@ -256,23 +256,21 @@ void SaveNexusProcessed::doExec(
spec, "workspace", true);
}
- cppFile->openGroup("instrument", "NXinstrument");
- saveSpectraMapNexus(*matrixWorkspace, cppFile, spec, ::NeXus::LZW);
- cppFile->closeGroup();
+ cppFile.openGroup("instrument", "NXinstrument");
+ saveSpectraMapNexus(*matrixWorkspace, &cppFile, spec, ::NeXus::LZW);
+ cppFile.closeGroup();
} // finish matrix workspace specifics
if (peaksWorkspace) {
// Save the instrument names, ParameterMap, sample, run
- peaksWorkspace->saveExperimentInfoNexus(cppFile);
+ peaksWorkspace->saveExperimentInfoNexus(&cppFile);
prog_init.reportIncrement(1, "Writing sample and instrument");
}
// peaks workspace specifics
if (peaksWorkspace) {
- // g_log.information("Peaks Workspace saving to Nexus would be done");
- // int pNum = peaksWorkspace->getNumberPeaks();
- peaksWorkspace->saveNexus(cppFile);
+ peaksWorkspace->saveNexus(&cppFile);
} // finish peaks workspace specifics
else if (tableWorkspace) // Table workspace specifics
@@ -294,7 +292,7 @@ void SaveNexusProcessed::doExec(
}
}
- inputWorkspace->history().saveNexus(cppFile);
+ inputWorkspace->history().saveNexus(&cppFile);
nexusFile->closeGroup();
}
diff --git a/Framework/DataHandling/test/GroupDetectors2Test.h b/Framework/DataHandling/test/GroupDetectors2Test.h
index fc800954fd162cd9f63334809df6678ee87bdc08..1831741c3c0df759fcdbd5743b9530aed69d0c8a 100644
--- a/Framework/DataHandling/test/GroupDetectors2Test.h
+++ b/Framework/DataHandling/test/GroupDetectors2Test.h
@@ -22,7 +22,6 @@
#include "MantidIndexing/IndexInfo.h"
#include "MantidKernel/DateAndTime.h"
#include "MantidKernel/UnitFactory.h"
-#include "MantidTestHelpers/HistogramDataTestHelper.h"
#include "MantidTypes/SpectrumDefinition.h"
#include <Poco/Path.h>
diff --git a/Framework/DataHandling/test/GroupDetectorsTest.h b/Framework/DataHandling/test/GroupDetectorsTest.h
index 4da716c2a9fb427d43d7f6b475cb003da6fdd4ff..e251e2f21f2909097ca3f33f77233e4128debe60 100644
--- a/Framework/DataHandling/test/GroupDetectorsTest.h
+++ b/Framework/DataHandling/test/GroupDetectorsTest.h
@@ -16,7 +16,6 @@
#include "MantidHistogramData/LinearGenerator.h"
#include "MantidKernel/ArrayProperty.h"
#include "MantidKernel/UnitFactory.h"
-#include "MantidTestHelpers/HistogramDataTestHelper.h"
using Mantid::DataHandling::GroupDetectors;
using Mantid::MantidVecPtr;
diff --git a/Framework/DataHandling/test/LoadMuonNexus1Test.h b/Framework/DataHandling/test/LoadMuonNexus1Test.h
index c48808ceb798b1664b3f8f60afc8b5e0d77fd7cf..e5b18522e92552b7d98d3958200a5052d788ec6b 100644
--- a/Framework/DataHandling/test/LoadMuonNexus1Test.h
+++ b/Framework/DataHandling/test/LoadMuonNexus1Test.h
@@ -24,7 +24,6 @@
#include "MantidKernel/ConfigService.h"
#include "MantidKernel/TimeSeriesProperty.h"
#include "MantidKernel/Unit.h"
-#include "MantidTestHelpers/HistogramDataTestHelper.h"
#include <Poco/Path.h>
diff --git a/Framework/DataHandling/test/LoadMuonNexus2Test.h b/Framework/DataHandling/test/LoadMuonNexus2Test.h
index b3f2d184e37f7d2f917361bb25781a98f9ba6dc4..378dbab2fe1d5491414a6cf1bdb9b61c0b4004f6 100644
--- a/Framework/DataHandling/test/LoadMuonNexus2Test.h
+++ b/Framework/DataHandling/test/LoadMuonNexus2Test.h
@@ -19,7 +19,6 @@
#include "MantidKernel/ConfigService.h"
#include "MantidKernel/TimeSeriesProperty.h"
#include "MantidKernel/Unit.h"
-#include "MantidTestHelpers/HistogramDataTestHelper.h"
using namespace Mantid::API;
using namespace Mantid::Kernel;
diff --git a/Framework/DataHandling/test/LoadNexusProcessedTest.h b/Framework/DataHandling/test/LoadNexusProcessedTest.h
index 3dd7f36a307cbf1deba66b45d0a5d5077ac0e048..8c6ae9e995087765cb8381fe7514de0ff7ad25fd 100644
--- a/Framework/DataHandling/test/LoadNexusProcessedTest.h
+++ b/Framework/DataHandling/test/LoadNexusProcessedTest.h
@@ -30,7 +30,6 @@
#include <string>
-#include "MantidTestHelpers/HistogramDataTestHelper.h"
#include "MantidTestHelpers/WorkspaceCreationHelper.h"
using namespace Mantid::Geometry;
diff --git a/Framework/DataHandling/test/LoadPreNexusMonitorsTest.h b/Framework/DataHandling/test/LoadPreNexusMonitorsTest.h
index ccc628500938eb24992d59426336f4d539d93e11..7084bfd13f1f3fc122d3e28f2e2e2da9c0cfa194 100644
--- a/Framework/DataHandling/test/LoadPreNexusMonitorsTest.h
+++ b/Framework/DataHandling/test/LoadPreNexusMonitorsTest.h
@@ -6,7 +6,6 @@
#include "MantidAPI/AnalysisDataService.h"
#include "MantidAPI/MatrixWorkspace.h"
#include "MantidDataHandling/LoadPreNexusMonitors.h"
-#include "MantidTestHelpers/HistogramDataTestHelper.h"
#include <Poco/Path.h>
diff --git a/Framework/DataHandling/test/LoadRawSaveNxsLoadNxsTest.h b/Framework/DataHandling/test/LoadRawSaveNxsLoadNxsTest.h
index 345dca29bbb3070e42382931a26ab9baae222d71..e961b3336a03a1add21ef7197348b47b2e9892e1 100644
--- a/Framework/DataHandling/test/LoadRawSaveNxsLoadNxsTest.h
+++ b/Framework/DataHandling/test/LoadRawSaveNxsLoadNxsTest.h
@@ -174,7 +174,7 @@ public:
TS_ASSERT_DELTA(detectorInfo.position(detectorIndex).Z(), 12.403, 0.01);
TS_ASSERT_DELTA(detectorInfo.position(detectorIndex).Y(), 0.1164, 0.01);
const auto d = detectorInfo.l2(detectorIndex);
- TS_ASSERT_DELTA(d, 2.1561, 0.0001);
+ TS_ASSERT_DELTA(d, 2.1477, 0.0001);
}
}
diff --git a/Framework/DataHandling/test/XMLInstrumentParameterTest.h b/Framework/DataHandling/test/XMLInstrumentParameterTest.h
index 105a6a4487d188cde565ee00ab7b9b39a08df8b8..d828b19a477b661c9efb01f299bea53256a656b4 100644
--- a/Framework/DataHandling/test/XMLInstrumentParameterTest.h
+++ b/Framework/DataHandling/test/XMLInstrumentParameterTest.h
@@ -59,7 +59,7 @@ public:
TS_ASSERT_EQUALS(static_cast<int>(ret1.size()), 0);
TS_ASSERT_DELTA(pos1.Z(), 12.113, 0.0001);
TS_ASSERT_DELTA(pos1.X(), 0.0, 0.0001);
- TS_ASSERT_DELTA(pos1.Y(), 0.0081, 0.0001);
+ TS_ASSERT_DELTA(pos1.Y(), 0.0162, 0.0001);
// linear-detector is composite, i.e., not a detector and thus not stored in
// DetectorInfo but in ComponentInfo
const auto &componentInfo = output1->componentInfo();
diff --git a/Framework/DataObjects/src/TableWorkspace.cpp b/Framework/DataObjects/src/TableWorkspace.cpp
index 17f38f934a9b053605b68380d5c717d30611a298..037b250a1839be72a6e9e0840fc49a7c3fbdf4db 100644
--- a/Framework/DataObjects/src/TableWorkspace.cpp
+++ b/Framework/DataObjects/src/TableWorkspace.cpp
@@ -86,6 +86,7 @@ API::Column_sptr TableWorkspace::addColumn(const std::string &type,
ss << e.what() << '\n';
throw std::invalid_argument(ss.str());
}
+ modified();
return c;
}
@@ -153,6 +154,7 @@ void TableWorkspace::removeColumn(const std::string &name) {
}
m_columns.erase(ci);
}
+ modified();
}
/** @param index :: Points where to insert the new row.
@@ -164,6 +166,7 @@ size_t TableWorkspace::insertRow(size_t index) {
for (auto &column : m_columns)
insertInColumn(column.get(), index);
++m_rowCount;
+ modified();
return index;
}
@@ -178,6 +181,7 @@ void TableWorkspace::removeRow(size_t index) {
for (auto &column : m_columns)
removeFromColumn(column.get(), index);
--m_rowCount;
+ modified();
}
std::vector<std::string> TableWorkspace::getColumnNames() const {
@@ -196,6 +200,7 @@ void TableWorkspace::addColumn(boost::shared_ptr<API::Column> column) {
ss << "Column with name " << column->name() << " already exists.\n";
throw std::invalid_argument(ss.str());
} else {
+ modified();
m_columns.push_back(column);
}
}
@@ -272,6 +277,7 @@ void TableWorkspace::sort(std::vector<std::pair<std::string, bool>> &criteria) {
for (size_t i = 0; i < nCols; ++i) {
getColumn(i)->sortValues(indexVec);
}
+ modified();
}
/// Clone the workspace keeping only selected columns.
diff --git a/Framework/DataObjects/test/WorkspaceValidatorsTest.h b/Framework/DataObjects/test/WorkspaceValidatorsTest.h
index f54126de447492575f5f8dee6b214831e3f23ca1..4fea1646dd445dd74c067f07d727fd60e71d6050 100644
--- a/Framework/DataObjects/test/WorkspaceValidatorsTest.h
+++ b/Framework/DataObjects/test/WorkspaceValidatorsTest.h
@@ -5,12 +5,14 @@
#include "MantidAPI/CommonBinsValidator.h"
#include "MantidAPI/HistogramValidator.h"
#include "MantidAPI/InstrumentValidator.h"
+#include "MantidAPI/OrientedLatticeValidator.h"
#include "MantidAPI/RawCountValidator.h"
#include "MantidAPI/Sample.h"
#include "MantidAPI/SampleValidator.h"
#include "MantidAPI/WorkspaceProperty.h"
#include "MantidAPI/WorkspaceUnitValidator.h"
#include "MantidDataObjects/Workspace2D.h"
+#include "MantidGeometry/Crystal/OrientedLattice.h"
#include "MantidKernel/Material.h"
#include "MantidKernel/NeutronAtom.h"
#include "MantidKernel/UnitFactory.h"
@@ -218,6 +220,22 @@ public:
}
}
+ void testOrientedLatticeValidator() {
+ using Mantid::API::OrientedLatticeValidator;
+ using Mantid::DataObjects::Workspace2D;
+ using Mantid::Geometry::OrientedLattice;
+ OrientedLatticeValidator validator;
+ auto ws = boost::make_shared<Workspace2D>();
+ TS_ASSERT_EQUALS(
+ validator.isValid(ws),
+ "Workspace must have a sample with an orientation matrix defined.");
+
+ OrientedLattice lattice;
+ ws->mutableSample().setOrientedLattice(&lattice);
+
+ TS_ASSERT_EQUALS(validator.isValid(ws), "");
+ }
+
void testSampleValidator() {
using Mantid::Geometry::CSGObject;
using Mantid::Kernel::Material;
diff --git a/Framework/HistogramData/inc/MantidHistogramData/FixedLengthVector.h b/Framework/HistogramData/inc/MantidHistogramData/FixedLengthVector.h
index 86d789a25bd5496e3268565b2b0fcebee0a785ca..53cb5f7dc9b564ea7f6104a00a589ad8651e1c46 100644
--- a/Framework/HistogramData/inc/MantidHistogramData/FixedLengthVector.h
+++ b/Framework/HistogramData/inc/MantidHistogramData/FixedLengthVector.h
@@ -105,6 +105,10 @@ public:
return *this;
}
+ bool operator==(const FixedLengthVector<T> &rhs) const {
+ return this->rawData() == rhs.rawData();
+ }
+
bool empty() const { return m_data.empty(); }
size_t size() const { return m_data.size(); }
diff --git a/Framework/HistogramData/inc/MantidHistogramData/HistogramDx.h b/Framework/HistogramData/inc/MantidHistogramData/HistogramDx.h
index c907569b6cbab43d3f4c8024f0a212f1de636ae2..3d682287b4552e188f8f52bc7c9b6d70e29b3ec3 100644
--- a/Framework/HistogramData/inc/MantidHistogramData/HistogramDx.h
+++ b/Framework/HistogramData/inc/MantidHistogramData/HistogramDx.h
@@ -50,7 +50,6 @@ public:
HistogramDx(HistogramDx &&) = default;
HistogramDx &operator=(const HistogramDx &) & = default;
HistogramDx &operator=(HistogramDx &&) & = default;
-
// These classes are friends, such that they can modify the length.
friend class Histogram;
friend class detail::VectorOf<PointVariances, HistogramDx>;
diff --git a/Framework/HistogramData/inc/MantidHistogramData/HistogramE.h b/Framework/HistogramData/inc/MantidHistogramData/HistogramE.h
index 74728cc922d3e704254f3ede9a117102d9a2afa4..8ae619c9ffd5b5be9ac4d8c68e713ab2d16498f3 100644
--- a/Framework/HistogramData/inc/MantidHistogramData/HistogramE.h
+++ b/Framework/HistogramData/inc/MantidHistogramData/HistogramE.h
@@ -66,7 +66,6 @@ public:
HistogramE(HistogramE &&) = default;
HistogramE &operator=(const HistogramE &) & = default;
HistogramE &operator=(HistogramE &&) & = default;
-
// These classes are friends, such that they can modify the length.
friend class Histogram;
friend class detail::VectorOf<CountStandardDeviations, HistogramE>;
diff --git a/Framework/HistogramData/inc/MantidHistogramData/HistogramItem.h b/Framework/HistogramData/inc/MantidHistogramData/HistogramItem.h
index ef05f8655b3cae45df206c063be329864b239311..6213e0526b59ddc171338260c0ccf2d16d23fd18 100644
--- a/Framework/HistogramData/inc/MantidHistogramData/HistogramItem.h
+++ b/Framework/HistogramData/inc/MantidHistogramData/HistogramItem.h
@@ -137,29 +137,6 @@ public:
}
}
- void advance(int64_t delta) {
- m_index = delta < 0 ? std::max(static_cast<uint64_t>(0),
- static_cast<uint64_t>(m_index) + delta)
- : std::min(m_histogram.size(),
- m_index + static_cast<size_t>(delta));
- }
-
- void incrementIndex() {
- if (m_index < m_histogram.size()) {
- ++m_index;
- }
- }
-
- void decrementIndex() {
- if (m_index > 0) {
- --m_index;
- }
- }
-
- size_t getIndex() const { return m_index; }
-
- void setIndex(const size_t index) { m_index = index; }
-
private:
friend class HistogramIterator;
diff --git a/Framework/HistogramData/inc/MantidHistogramData/HistogramIterator.h b/Framework/HistogramData/inc/MantidHistogramData/HistogramIterator.h
index 927fe6491b0bc2e78f3622a855c99c3cf1409186..cd2379d28040bbfb98a419c465035fa21e61a0dc 100644
--- a/Framework/HistogramData/inc/MantidHistogramData/HistogramIterator.h
+++ b/Framework/HistogramData/inc/MantidHistogramData/HistogramIterator.h
@@ -54,21 +54,39 @@ public:
private:
friend class boost::iterator_core_access;
- void increment() { m_item.incrementIndex(); }
+ void advance(int64_t delta) {
+ m_item.m_index =
+ delta < 0 ? std::max(static_cast<uint64_t>(0),
+ static_cast<uint64_t>(m_item.m_index) + delta)
+ : std::min(m_item.m_histogram.size(),
+ m_item.m_index + static_cast<size_t>(delta));
+ }
- bool equal(const HistogramIterator &other) const {
- return m_item.getIndex() == other.m_item.getIndex();
+ void increment() {
+ if (m_item.m_index < m_item.m_histogram.size()) {
+ ++m_item.m_index;
+ }
}
- const HistogramItem &dereference() const { return m_item; }
+ void decrement() {
+ if (m_item.m_index > 0) {
+ --m_item.m_index;
+ }
+ }
+
+ size_t getIndex() const { return m_item.m_index; }
- void decrement() { m_item.decrementIndex(); }
+ void setIndex(const size_t index) { m_item.m_index = index; }
- void advance(int64_t delta) { m_item.advance(delta); }
+ bool equal(const HistogramIterator &other) const {
+ return getIndex() == other.getIndex();
+ }
+
+ const HistogramItem &dereference() const { return m_item; }
uint64_t distance_to(const HistogramIterator &other) const {
- return static_cast<uint64_t>(other.m_item.getIndex()) -
- static_cast<uint64_t>(m_item.getIndex());
+ return static_cast<uint64_t>(other.getIndex()) -
+ static_cast<uint64_t>(getIndex());
}
HistogramItem m_item;
diff --git a/Framework/HistogramData/inc/MantidHistogramData/HistogramX.h b/Framework/HistogramData/inc/MantidHistogramData/HistogramX.h
index 7006427eb5960c90361dd76ea62c7311af065ca2..3405461106d5fbd8949ab2ddb19c40435063cbe8 100644
--- a/Framework/HistogramData/inc/MantidHistogramData/HistogramX.h
+++ b/Framework/HistogramData/inc/MantidHistogramData/HistogramX.h
@@ -62,7 +62,6 @@ public:
HistogramX(HistogramX &&) = default;
HistogramX &operator=(const HistogramX &) & = default;
HistogramX &operator=(HistogramX &&) & = default;
-
// These classes are friends, such that they can modify the length.
friend class Histogram;
friend class detail::VectorOf<BinEdges, HistogramX>;
diff --git a/Framework/HistogramData/test/InterpolateTest.h b/Framework/HistogramData/test/InterpolateTest.h
index 8f5c0c07a9bb95a1f23a09e47087b82bdb8f4797..1ac447765b977404e4d667884a110ccdce0277ae 100644
--- a/Framework/HistogramData/test/InterpolateTest.h
+++ b/Framework/HistogramData/test/InterpolateTest.h
@@ -6,7 +6,6 @@
#include "MantidHistogramData/Histogram.h"
#include "MantidHistogramData/Interpolate.h"
#include "MantidHistogramData/LinearGenerator.h"
-#include "MantidTestHelpers/HistogramDataTestHelper.h"
using namespace Mantid::HistogramData;
diff --git a/Framework/HistogramData/test/RebinTest.h b/Framework/HistogramData/test/RebinTest.h
index 61aa1a04e8b2b6f09988b81da61ae6def4c13147..0491b2791d9a0a80a2b561d2b7f9a846ad10d005 100644
--- a/Framework/HistogramData/test/RebinTest.h
+++ b/Framework/HistogramData/test/RebinTest.h
@@ -7,7 +7,6 @@
#include "MantidHistogramData/Histogram.h"
#include "MantidHistogramData/LinearGenerator.h"
#include "MantidHistogramData/Rebin.h"
-#include "MantidTestHelpers/HistogramDataTestHelper.h"
#include <algorithm>
#include <random>
diff --git a/Framework/HistogramData/test/SliceTest.h b/Framework/HistogramData/test/SliceTest.h
index 2e2d0f66bde9ddbf8ddc2ee1726f62f5f72bb841..60bb2ed19ab88f8d4d401319f8b6566ae4ba6ab9 100644
--- a/Framework/HistogramData/test/SliceTest.h
+++ b/Framework/HistogramData/test/SliceTest.h
@@ -4,7 +4,6 @@
#include <cxxtest/TestSuite.h>
#include "MantidHistogramData/Slice.h"
-#include "MantidTestHelpers/HistogramDataTestHelper.h"
using namespace Mantid::HistogramData;
diff --git a/Framework/ICat/test/CatalogDownloadDataFilesTest.h b/Framework/ICat/test/CatalogDownloadDataFilesTest.h
index 59f43ada6069b057128b574a877f14c24dd4e665..8b821b27f90f0a8ebfdf4c53fd7720b6b62e60bc 100644
--- a/Framework/ICat/test/CatalogDownloadDataFilesTest.h
+++ b/Framework/ICat/test/CatalogDownloadDataFilesTest.h
@@ -3,6 +3,7 @@
#include "ICatTestHelper.h"
#include "MantidAPI/AnalysisDataService.h"
+#include "MantidAPI/FrameworkManager.h"
#include "MantidDataObjects/WorkspaceSingleValue.h"
#include "MantidICat/CatalogDownloadDataFiles.h"
#include "MantidICat/CatalogGetDataFiles.h"
@@ -18,34 +19,21 @@
using namespace Mantid;
using namespace Mantid::ICat;
using namespace Mantid::API;
+
class CatalogDownloadDataFilesTest : public CxxTest::TestSuite {
public:
- /** Ping the download.mantidproject.org and
- * skip all tests if internet/server is down.
- */
- bool skipTests() override {
-#ifdef _WIN32
- // I don't know how to get exit status from windows.
- return false;
-#else
- // Ping once, with a 1 second wait.
- std::string cmdstring = "ping download.mantidproject.org -c 1 -w 1";
-
- int status;
- status = system(cmdstring.c_str());
- if (status == -1) {
- // Some kind of system() failure
- } else
- // Get the exit code
- status = WEXITSTATUS(status);
-
- if (status != 0) {
- std::cout << "Skipping test since '" << cmdstring << "' FAILED!\n";
- return true;
- }
- return false;
-#endif
+ // This means the constructor isn't called when running other tests
+ static CatalogDownloadDataFilesTest *createSuite() {
+ return new CatalogDownloadDataFilesTest();
}
+ static void destroySuite(CatalogDownloadDataFilesTest *suite) {
+ delete suite;
+ }
+
+ /// Skip all unit tests if ICat server is down
+ bool skipTests() override { return ICatTestHelper::skipTests(); }
+
+ CatalogDownloadDataFilesTest() { FrameworkManager::Instance(); }
void testInit() {
TS_ASSERT_THROWS_NOTHING(downloadobj.initialize());
diff --git a/Framework/ICat/test/CatalogGetDataFilesTest.h b/Framework/ICat/test/CatalogGetDataFilesTest.h
index 856812b8118efc39cc27a1e8897e3e35383e60fa..aafcfb86dda9129c08b691e90823c1d8e3e04747 100644
--- a/Framework/ICat/test/CatalogGetDataFilesTest.h
+++ b/Framework/ICat/test/CatalogGetDataFilesTest.h
@@ -2,6 +2,7 @@
#define GETINVESTIGATION_H_
#include "ICatTestHelper.h"
+#include "MantidAPI/FrameworkManager.h"
#include "MantidDataObjects/WorkspaceSingleValue.h"
#include "MantidICat/CatalogGetDataFiles.h"
#include "MantidICat/CatalogLogin.h"
@@ -13,9 +14,17 @@ using namespace Mantid::ICat;
class CatalogGetDataFilesTest : public CxxTest::TestSuite {
public:
+ // This means the constructor isn't called when running other tests
+ static CatalogGetDataFilesTest *createSuite() {
+ return new CatalogGetDataFilesTest();
+ }
+ static void destroySuite(CatalogGetDataFilesTest *suite) { delete suite; }
+
/// Skip all unit tests if ICat server is down
bool skipTests() override { return ICatTestHelper::skipTests(); }
+ CatalogGetDataFilesTest() { API::FrameworkManager::Instance(); }
+
void testInit() {
Mantid::Kernel::ConfigService::Instance().setString("default.facility",
"ISIS");
diff --git a/Framework/ICat/test/CatalogGetDataSetsTest.h b/Framework/ICat/test/CatalogGetDataSetsTest.h
index 0670ab8561bc05fc27561d7379e49ac436c90e78..fc90ca305c6716c21d4454c4368018a16e1db248 100644
--- a/Framework/ICat/test/CatalogGetDataSetsTest.h
+++ b/Framework/ICat/test/CatalogGetDataSetsTest.h
@@ -2,6 +2,7 @@
#define GETIDATASETS_H_
#include "ICatTestHelper.h"
+#include "MantidAPI/FrameworkManager.h"
#include "MantidDataObjects/WorkspaceSingleValue.h"
#include "MantidICat/CatalogGetDataSets.h"
#include "MantidICat/CatalogLogin.h"
@@ -13,9 +14,17 @@ using namespace Mantid::ICat;
class CatalogGetDataSetsTest : public CxxTest::TestSuite {
public:
+ // This means the constructor isn't called when running other tests
+ static CatalogGetDataSetsTest *createSuite() {
+ return new CatalogGetDataSetsTest();
+ }
+ static void destroySuite(CatalogGetDataSetsTest *suite) { delete suite; }
+
/// Skip all unit tests if ICat server is down
bool skipTests() override { return ICatTestHelper::skipTests(); }
+ CatalogGetDataSetsTest() { API::FrameworkManager::Instance(); }
+
void testInit() {
Mantid::Kernel::ConfigService::Instance().setString("default.facility",
"ISIS");
diff --git a/Framework/ICat/test/CatalogListInstrumentsTest.h b/Framework/ICat/test/CatalogListInstrumentsTest.h
index cc851d767ca82a0065398d1dfb712d6b746e5388..64557dfe385b60eb3678161846ae72bbed18643c 100644
--- a/Framework/ICat/test/CatalogListInstrumentsTest.h
+++ b/Framework/ICat/test/CatalogListInstrumentsTest.h
@@ -12,6 +12,12 @@ using namespace Mantid::ICat;
class CatalogListInstrumentsTest : public CxxTest::TestSuite {
public:
+ // This means the constructor isn't called when running other tests
+ static CatalogListInstrumentsTest *createSuite() {
+ return new CatalogListInstrumentsTest();
+ }
+ static void destroySuite(CatalogListInstrumentsTest *suite) { delete suite; }
+
/// Skip all unit tests if ICat server is down
bool skipTests() override { return ICatTestHelper::skipTests(); }
diff --git a/Framework/ICat/test/CatalogListInvestigationTypesTest.h b/Framework/ICat/test/CatalogListInvestigationTypesTest.h
index 4c99d004bb7b8b080de7f33d19d885c54cd36b19..6b7502dd38dcaf49e7eddcd3d18300f26f2f2943 100644
--- a/Framework/ICat/test/CatalogListInvestigationTypesTest.h
+++ b/Framework/ICat/test/CatalogListInvestigationTypesTest.h
@@ -12,6 +12,14 @@ using namespace Mantid::ICat;
class CatalogListInvestigationTypesTest : public CxxTest::TestSuite {
public:
+ // This means the constructor isn't called when running other tests
+ static CatalogListInvestigationTypesTest *createSuite() {
+ return new CatalogListInvestigationTypesTest();
+ }
+ static void destroySuite(CatalogListInvestigationTypesTest *suite) {
+ delete suite;
+ }
+
/// Skip all unit tests if ICat server is down
bool skipTests() override { return ICatTestHelper::skipTests(); }
diff --git a/Framework/ICat/test/CatalogLoginTest.h b/Framework/ICat/test/CatalogLoginTest.h
index b8f8d93e890fb3c0a82f380c7c42561a966440f5..d13295459568397807362979a63fcc8492c83271 100644
--- a/Framework/ICat/test/CatalogLoginTest.h
+++ b/Framework/ICat/test/CatalogLoginTest.h
@@ -8,6 +8,10 @@
using namespace Mantid::ICat;
class CatalogLoginTest : public CxxTest::TestSuite {
public:
+ // This means the constructor isn't called when running other tests
+ static CatalogLoginTest *createSuite() { return new CatalogLoginTest(); }
+ static void destroySuite(CatalogLoginTest *suite) { delete suite; }
+
/// Skip all unit tests if ICat server is down
bool skipTests() override { return ICatTestHelper::skipTests(); }
diff --git a/Framework/ICat/test/CatalogMyDataSearchTest.h b/Framework/ICat/test/CatalogMyDataSearchTest.h
index 767b73483282b29d2a2d3160ce2dc0260a0f9325..24b1c49240bd4ba38f482a2c83f7e9a314e2edf3 100644
--- a/Framework/ICat/test/CatalogMyDataSearchTest.h
+++ b/Framework/ICat/test/CatalogMyDataSearchTest.h
@@ -2,6 +2,7 @@
#define MYDATASEARCH_H_
#include "ICatTestHelper.h"
+#include "MantidAPI/FrameworkManager.h"
#include "MantidDataObjects/WorkspaceSingleValue.h"
#include "MantidICat/CatalogLogin.h"
#include "MantidICat/CatalogMyDataSearch.h"
@@ -12,9 +13,17 @@ using namespace Mantid::ICat;
class CatalogMyDataSearchTest : public CxxTest::TestSuite {
public:
+ // This means the constructor isn't called when running other tests
+ static CatalogMyDataSearchTest *createSuite() {
+ return new CatalogMyDataSearchTest();
+ }
+ static void destroySuite(CatalogMyDataSearchTest *suite) { delete suite; }
+
/// Skip all unit tests if ICat server is down
bool skipTests() override { return ICatTestHelper::skipTests(); }
+ CatalogMyDataSearchTest() { API::FrameworkManager::Instance(); }
+
void testInit() {
Mantid::Kernel::ConfigService::Instance().setString("default.facility",
"ISIS");
diff --git a/Framework/ICat/test/CatalogSearchTest.h b/Framework/ICat/test/CatalogSearchTest.h
index 79238ca16ed4618b8dcb9a449bc6b883affee7af..b9b3a57493b3e19815958999138874e97f3c3ef8 100644
--- a/Framework/ICat/test/CatalogSearchTest.h
+++ b/Framework/ICat/test/CatalogSearchTest.h
@@ -12,6 +12,10 @@ using namespace Mantid;
using namespace Mantid::ICat;
class CatalogSearchTest : public CxxTest::TestSuite {
public:
+ // This means the constructor isn't called when running other tests
+ static CatalogSearchTest *createSuite() { return new CatalogSearchTest(); }
+ static void destroySuite(CatalogSearchTest *suite) { delete suite; }
+
/// Skip all unit tests if ICat server is down
bool skipTests() override { return ICatTestHelper::skipTests(); }
diff --git a/Framework/ICat/test/CompositeCatalogTest.h b/Framework/ICat/test/CompositeCatalogTest.h
index 96af4e207b201903e5b3efc3fa7269900ac1a57a..967f50fa7151e147597282a2a753b501fcfea9f2 100644
--- a/Framework/ICat/test/CompositeCatalogTest.h
+++ b/Framework/ICat/test/CompositeCatalogTest.h
@@ -1,9 +1,11 @@
#ifndef MANTID_ICAT_COMPOSITECATALOGTEST_H_
#define MANTID_ICAT_COMPOSITECATALOGTEST_H_
+#include "ICatTestHelper.h"
#include <cxxtest/TestSuite.h>
#include "MantidAPI/CompositeCatalog.h"
+#include "MantidAPI/FrameworkManager.h"
#include "MantidAPI/ITableWorkspace.h"
#include "MantidAPI/WorkspaceFactory.h"
#include "MantidICat/CatalogSearchParam.h"
@@ -80,6 +82,17 @@ int DummyCatalog::m_counter(0);
class CompositeCatalogTest : public CxxTest::TestSuite {
public:
+ // This means the constructor isn't called when running other tests
+ static CompositeCatalogTest *createSuite() {
+ return new CompositeCatalogTest();
+ }
+ static void destroySuite(CompositeCatalogTest *suite) { delete suite; }
+
+ /// Skip all unit tests if ICat server is down
+ bool skipTests() override { return ICatTestHelper::skipTests(); }
+
+ CompositeCatalogTest() { Mantid::API::FrameworkManager::Instance(); }
+
/// Verifies that multiple catalogs are being logged in to.
void testLogin() {
std::string temp = "";
diff --git a/Framework/Kernel/inc/MantidKernel/Strings.h b/Framework/Kernel/inc/MantidKernel/Strings.h
index 8ae51d40e152b1146ed674024fce08669d1d6b22..a98fc5e178ba860d692e13e22a4cfa9ef662ef47 100644
--- a/Framework/Kernel/inc/MantidKernel/Strings.h
+++ b/Framework/Kernel/inc/MantidKernel/Strings.h
@@ -5,6 +5,7 @@
// Includes
//----------------------------------------------------------------------
#include "MantidKernel/DllConfig.h"
+#include "MantidKernel/MultiThreaded.h"
#include "MantidKernel/StringTokenizer.h"
#include "MantidKernel/System.h"
@@ -56,14 +57,17 @@ namespace Strings {
* For example, join a vector of strings with commas with:
* out = join(v.begin(), v.end(), ", ");
*
+ * This is a simple default version that works in all cases but is potentially
+ * slow.
+ *
* @param begin :: iterator at the start
* @param end :: iterator at the end
* @param separator :: string to append.
* @return
*/
template <typename ITERATOR_TYPE>
-DLLExport std::string join(ITERATOR_TYPE begin, ITERATOR_TYPE end,
- const std::string &separator) {
+DLLExport std::string simpleJoin(ITERATOR_TYPE begin, ITERATOR_TYPE end,
+ const std::string &separator) {
std::ostringstream output;
ITERATOR_TYPE it;
for (it = begin; it != end;) {
@@ -75,6 +79,124 @@ DLLExport std::string join(ITERATOR_TYPE begin, ITERATOR_TYPE end,
return output.str();
}
+//------------------------------------------------------------------------------------------------
+/** Join a set or vector of (something that turns into a string) together
+ * into one string, separated by a string.
+ * Returns an empty string if the range is null.
+ * Does not add the separator after the LAST item.
+ *
+ * For example, join a vector of strings with commas with:
+ * out = join(v.begin(), v.end(), ", ");
+ *
+ * This version is used for random access iterators (e.g. map, set), and
+ * it calls simpleJoin().
+ *
+ * @param begin :: iterator at the start
+ * @param end :: iterator at the end
+ * @param separator :: string to append.
+ * @return
+ */
+template <typename ITERATOR_TYPE>
+DLLExport std::string
+join(ITERATOR_TYPE begin, ITERATOR_TYPE end, const std::string &separator,
+ typename std::enable_if<
+ !(std::is_same<
+ typename std::iterator_traits<ITERATOR_TYPE>::iterator_category,
+ std::random_access_iterator_tag>::value)>::type * = nullptr) {
+ return simpleJoin(begin, end, separator);
+}
+
+//------------------------------------------------------------------------------------------------
+/** Join a set or vector of (something that turns into a string) together
+ * into one string, separated by a string.
+ * Returns an empty string if the range is null.
+ * Does not add the separator after the LAST item.
+ *
+ * For example, join a vector of strings with commas with:
+ * out = join(v.begin(), v.end(), ", ");
+ *
+ * This is a faster threaded version of the join() function above.
+ * It is used only if the iterators are not random access (e.g. vector), as it
+ * needs to be able to determine the distance between begin and end.
+ * It reverts to calling simpleJoin() if the input array is small.
+ *
+ * @param begin :: iterator at the start
+ * @param end :: iterator at the end
+ * @param separator :: string to append.
+ * @return
+ */
+template <typename ITERATOR_TYPE>
+DLLExport std::string
+join(ITERATOR_TYPE begin, ITERATOR_TYPE end, const std::string &separator,
+ typename std::enable_if<
+ (std::is_same<
+ typename std::iterator_traits<ITERATOR_TYPE>::iterator_category,
+ std::random_access_iterator_tag>::value)>::type * = nullptr) {
+
+ // Get max number of threads
+ int nmaxThreads = static_cast<int>(PARALLEL_GET_MAX_THREADS);
+
+ // Define minimum size for using threading
+ int min_size = 500 * nmaxThreads;
+
+ // Get the distance between begining and end
+ int dist = static_cast<int>(std::distance(begin, end));
+
+ if (dist < min_size) {
+
+ // If the input array is small, use the simpler function to avoid
+ // unnecessary overhead from generating the parallel section
+ return simpleJoin(begin, end, separator);
+
+ } else {
+
+ // Allocate vector space
+ std::vector<std::string> output(nmaxThreads);
+ size_t stream_size = 0;
+
+ // Actual number of threads in the current region
+ int nThreads = 1;
+#pragma omp parallel reduction(+ : stream_size)
+ {
+ nThreads = static_cast<int>(PARALLEL_NUMBER_OF_THREADS);
+ int idThread = static_cast<int>(PARALLEL_THREAD_NUMBER);
+ ITERATOR_TYPE it;
+
+ // Initialise ostringstream
+ std::ostringstream thread_stream;
+
+/* To make sure the loop is done in the right order, we use schedule(static).
+
+ From the OpenMP documentation:
+ "When schedule(static, chunk_size) is specified, iterations are divided into
+ chunks of size chunk_size, and the chunks are assigned to the threads in the
+ team in a round-robin fashion **in the order of the thread number**."
+
+ "When no chunk_size is specified, the iteration space is divided into chunks
+ that are approximately equal in size, and at most one chunk is distributed
+ to each thread."
+*/
+#pragma omp for schedule(static)
+ for (int i = 0; i < dist; i++) {
+ thread_stream << separator << *(begin + i);
+ }
+ output[idThread] = thread_stream.str();
+ stream_size += output[idThread].length();
+ }
+
+ // Reserve space in memory for output string
+ std::string master_string = output[0].erase(0, separator.length());
+ master_string.reserve(stream_size - separator.length());
+
+ // Concatenate the contributions from the remaning threads
+ for (int i = 1; i < nThreads; i++) {
+ master_string += output[i];
+ }
+
+ return master_string;
+ }
+}
+
//------------------------------------------------------------------------------------------------
/** Join a set or vector of (something that turns into a string) together
* into one string, separated by a separator,
diff --git a/Framework/Kernel/test/InterpolationTest.h b/Framework/Kernel/test/InterpolationTest.h
index aabbc4711a2fb17d71635ce3fad0fde9a269edeb..d9fb5ecac94ac27409fdacd4ed075347115c7971 100644
--- a/Framework/Kernel/test/InterpolationTest.h
+++ b/Framework/Kernel/test/InterpolationTest.h
@@ -9,6 +9,10 @@ using namespace Mantid::Kernel;
class InterpolationTest : public CxxTest::TestSuite {
public:
+ // This means the constructor isn't called when running other tests
+ static InterpolationTest *createSuite() { return new InterpolationTest(); }
+ static void destroySuite(InterpolationTest *suite) { delete suite; }
+
/* In the constructor some vectors with values are setup,
* which make the tests easier later on.
*
diff --git a/Framework/Kernel/test/LiveListenerInfoTest.h b/Framework/Kernel/test/LiveListenerInfoTest.h
index 9ad4cf426fefbee81543ca83d03f9a2bf9cf2301..660fce9eafc9c2a8b97d659d3e0a0249f7b2f877 100644
--- a/Framework/Kernel/test/LiveListenerInfoTest.h
+++ b/Framework/Kernel/test/LiveListenerInfoTest.h
@@ -6,6 +6,7 @@
#include "MantidKernel/Exception.h"
#include "MantidKernel/FacilityInfo.h"
#include "MantidKernel/LiveListenerInfo.h"
+#include "MantidKernel/make_unique.h"
#include <Poco/AutoPtr.h>
#include <Poco/DOM/DOMParser.h>
@@ -25,7 +26,7 @@ public:
"<connection />"
"</livedata>";
- FacilityInfo *fac = nullptr;
+ std::unique_ptr<FacilityInfo> fac;
TS_ASSERT_THROWS_NOTHING(fac = createMinimalFacility(xml));
InstrumentInfo inst = fac->instruments().front();
@@ -41,7 +42,7 @@ public:
"<connection name='n' address='a' listener='l' />"
"</livedata>";
- FacilityInfo *fac = nullptr;
+ std::unique_ptr<FacilityInfo> fac;
TS_ASSERT_THROWS_NOTHING(fac = createMinimalFacility(xml));
InstrumentInfo inst = fac->instruments().front();
@@ -58,7 +59,7 @@ public:
"<connection name='n2' address='A' listener='L' />"
"</livedata>";
- FacilityInfo *fac = nullptr;
+ std::unique_ptr<FacilityInfo> fac;
TS_ASSERT_THROWS_NOTHING(fac = createMinimalFacility(xml));
InstrumentInfo inst = fac->instruments().front();
@@ -88,7 +89,7 @@ public:
"<connection name='n2' address='A' listener='L' />"
"</livedata>";
- FacilityInfo *fac = nullptr;
+ std::unique_ptr<FacilityInfo> fac = nullptr;
TS_ASSERT_THROWS_NOTHING(fac = createMinimalFacility(xml));
InstrumentInfo inst = fac->instruments().front();
@@ -150,7 +151,8 @@ public:
}
private:
- FacilityInfo *createMinimalFacility(const std::string &livedataXml) {
+ std::unique_ptr<FacilityInfo>
+ createMinimalFacility(const std::string &livedataXml) {
const std::string xmlStr =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
"<facilities>"
@@ -165,13 +167,13 @@ private:
return createFacility(xmlStr);
}
- FacilityInfo *createFacility(const std::string &xml) {
+ std::unique_ptr<FacilityInfo> createFacility(const std::string &xml) {
Poco::XML::DOMParser parser;
Poco::AutoPtr<Poco::XML::Document> pDoc = parser.parseString(xml);
Poco::XML::Element *pRootElem = pDoc->documentElement();
Poco::XML::Element *elem = pRootElem->getChildElement("facility");
- return new FacilityInfo(elem);
+ return Mantid::Kernel::make_unique<FacilityInfo>(elem);
}
};
diff --git a/Framework/Kernel/test/NearestNeighboursTest.h b/Framework/Kernel/test/NearestNeighboursTest.h
index 450dbe96e7baa457dd337331f1509358bd64ee66..7cbc98f705e34bab178d68a760adaea328dc655f 100644
--- a/Framework/Kernel/test/NearestNeighboursTest.h
+++ b/Framework/Kernel/test/NearestNeighboursTest.h
@@ -9,6 +9,12 @@ using namespace Eigen;
class NearestNeighboursTest : public CxxTest::TestSuite {
public:
+ // This means the constructor isn't called when running other tests
+ static NearestNeighboursTest *createSuite() {
+ return new NearestNeighboursTest();
+ }
+ static void destroySuite(NearestNeighboursTest *suite) { delete suite; }
+
NearestNeighboursTest() {}
void test_construct() {
diff --git a/Framework/Kernel/test/StringsTest.h b/Framework/Kernel/test/StringsTest.h
index f0805ab7127c49d7aea9aacc083e05bc76060851..e65782ae72eb1faaf2fbc04f4846605987818543 100644
--- a/Framework/Kernel/test/StringsTest.h
+++ b/Framework/Kernel/test/StringsTest.h
@@ -267,6 +267,44 @@ public:
TS_ASSERT_EQUALS(out, "Help,Me,I'm,Stuck,Inside,A,Test");
}
+ void test_joinSet() {
+ std::set<std::string> v;
+ std::string out;
+
+ out = join(v.begin(), v.end(), ",");
+ TS_ASSERT_EQUALS(out, "");
+
+ v.insert("Help");
+ v.insert("Me");
+ v.insert("I'm");
+ v.insert("Stuck");
+ v.insert("Inside");
+ v.insert("A");
+ v.insert("Test");
+
+ out = join(v.begin(), v.end(), ",");
+ TS_ASSERT_EQUALS(out, "A,Help,I'm,Inside,Me,Stuck,Test");
+ }
+
+ void test_joinLong() {
+ std::vector<std::string> v;
+ std::string out;
+ std::string ans;
+
+ out = join(v.begin(), v.end(), ",");
+ TS_ASSERT_EQUALS(out, "");
+
+ int n = 100000;
+ for (int i = 0; i < n; i++) {
+ v.emplace_back(std::to_string(i));
+ ans += std::to_string(i) + ",";
+ }
+
+ out = join(v.begin(), v.end(), ",");
+ ans.pop_back();
+ TS_ASSERT_EQUALS(out, ans);
+ }
+
void test_joinCompress() {
std::vector<std::vector<int>> inputList{
@@ -590,4 +628,20 @@ public:
}
};
+class StringsTestPerformance : public CxxTest::TestSuite {
+public:
+ static StringsTestPerformance *createSuite() {
+ return new StringsTestPerformance();
+ }
+ static void destroySuite(StringsTestPerformance *suite) { delete suite; }
+ void setUp() override { input = std::vector<double>(50000000, 0.123456); }
+ void test_join_double() {
+ auto result = join(input.begin(), input.end(), separator);
+ }
+
+private:
+ std::vector<double> input;
+ std::string separator{","};
+};
+
#endif // MANTID_SUPPORTTEST_H_
diff --git a/Framework/Kernel/test/TimeSeriesPropertyTest.h b/Framework/Kernel/test/TimeSeriesPropertyTest.h
index 1681ab64967382a5d416f9a986b0bb94ed82cd08..b28bc9f179c116b61aeae82d5dfe28bbda11769e 100644
--- a/Framework/Kernel/test/TimeSeriesPropertyTest.h
+++ b/Framework/Kernel/test/TimeSeriesPropertyTest.h
@@ -835,8 +835,7 @@ public:
// Initialze the 4 splitters
std::vector<TimeSeriesProperty<int> *> outputs;
for (int itarget = 0; itarget < 4; ++itarget) {
- TimeSeriesProperty<int> *tsp = new TimeSeriesProperty<int>("target");
- outputs.push_back(tsp);
+ outputs.push_back(new TimeSeriesProperty<int>("target"));
}
log.splitByTimeVector(split_time_vec, split_target_vec, outputs);
@@ -845,6 +844,8 @@ public:
for (int i = 0; i < 4; ++i) {
TimeSeriesProperty<int> *out_i = outputs[i];
TS_ASSERT_EQUALS(out_i->size(), 0);
+ delete out_i;
+ outputs[i] = nullptr;
}
return;
@@ -889,8 +890,7 @@ public:
// Initialze the 4 splitters
std::vector<TimeSeriesProperty<int> *> outputs;
for (int itarget = 0; itarget < 4; ++itarget) {
- TimeSeriesProperty<int> *tsp = new TimeSeriesProperty<int>("target");
- outputs.push_back(tsp);
+ outputs.emplace_back(new TimeSeriesProperty<int>("target"));
}
log.splitByTimeVector(split_time_vec, split_target_vec, outputs);
@@ -899,6 +899,8 @@ public:
for (int i = 0; i < 4; ++i) {
TimeSeriesProperty<int> *out_i = outputs[i];
TS_ASSERT_EQUALS(out_i->size(), 1);
+ delete out_i;
+ outputs[i] = nullptr;
}
}
@@ -941,39 +943,18 @@ public:
// Initialze the 10 splitters
std::vector<TimeSeriesProperty<int> *> outputs;
for (int itarget = 0; itarget < 10; ++itarget) {
- TimeSeriesProperty<int> *tsp = new TimeSeriesProperty<int>("target");
- outputs.push_back(tsp);
+ outputs.push_back(new TimeSeriesProperty<int>("target"));
}
- /*
- size_t num_splits = vec_split_target.size();
- for (size_t i = 0; i < num_splits; ++i) {
- std::cout << "s[" << i << "] start = " << vec_split_times[i]
- << ", stop = " << vec_split_times[i + 1]
- << ": target = " << vec_split_target[i] << "\n";
- }
- */
-
// split time series property
log.splitByTimeVector(vec_split_times, vec_split_target, outputs);
- // TODO/FIXME/ - continue to debug from here!
- /*
- TimeSeriesProperty<int> *out0 = outputs[0];
- for (int i = 0; i < out0->size(); ++i) {
- std::cout << i << "-th: " << out0->nthTime(i) << ", " << out0->nthValue(i)
- << "\n";
- }
- */
-
// test
- for (auto it : outputs) {
+ for (auto &it : outputs) {
TS_ASSERT_EQUALS(it->size(), 2);
- }
-
- // cleanup
- for (auto &it : outputs)
delete it;
+ it = nullptr;
+ }
}
//----------------------------------------------------------------------------
@@ -1005,19 +986,27 @@ public:
// create the target vector
std::vector<int> split_target_vec(5);
- for (size_t i = 0; i < 5; ++i)
+ for (size_t i = 0; i < 5; ++i) {
split_target_vec[i] = (i + 1) % 2;
+ }
// Initialze the 2 splitters
std::vector<TimeSeriesProperty<int> *> outputs;
for (int itarget = 0; itarget < 2; ++itarget) {
- TimeSeriesProperty<int> *tsp = new TimeSeriesProperty<int>("target");
- outputs.push_back(tsp);
+ outputs.push_back(new TimeSeriesProperty<int>("target"));
}
// split
int_log.splitByTimeVector(split_time_vec, split_target_vec, outputs);
+ // check
+ for (int i = 0; i < 2; ++i) {
+ TimeSeriesProperty<int> *out_i = outputs[i];
+ TS_ASSERT_EQUALS(out_i->size(), 1);
+ delete out_i;
+ outputs[i] = nullptr;
+ }
+
return;
}
diff --git a/Framework/MDAlgorithms/inc/MantidMDAlgorithms/MDNormDirectSC.h b/Framework/MDAlgorithms/inc/MantidMDAlgorithms/MDNormDirectSC.h
index 8239e46772954ab534e42e4523f88c232dd0c18a..a345739aa656f3f570c8bc382eb3c6ca328caf09 100644
--- a/Framework/MDAlgorithms/inc/MantidMDAlgorithms/MDNormDirectSC.h
+++ b/Framework/MDAlgorithms/inc/MantidMDAlgorithms/MDNormDirectSC.h
@@ -55,13 +55,15 @@ private:
DataObjects::MDHistoWorkspace_sptr binInputWS();
void createNormalizationWS(const DataObjects::MDHistoWorkspace &dataWS);
std::vector<coord_t>
- getValuesFromOtherDimensions(bool &skipNormalization) const;
+ getValuesFromOtherDimensions(bool &skipNormalization,
+ uint16_t expInfoIndex = 0) const;
Kernel::Matrix<coord_t>
findIntergratedDimensions(const std::vector<coord_t> &otherDimValues,
bool &skipNormalization);
void cacheDimensionXValues();
void calculateNormalization(const std::vector<coord_t> &otherValues,
- const Kernel::Matrix<coord_t> &affineTrans);
+ const Kernel::Matrix<coord_t> &affineTrans,
+ uint16_t expInfoIndex);
void calculateIntersections(std::vector<std::array<double, 4>> &intersections,
const double theta, const double phi);
@@ -88,7 +90,10 @@ private:
Kernel::V3D m_beamDir;
/// ki-kf for Inelastic convention; kf-ki for Crystallography convention
std::string convention;
+ /// internal flag to accumulate to an existing workspace
bool m_accumulate{false};
+ /// number of experiment infos
+ uint16_t m_numExptInfos;
};
} // namespace MDAlgorithms
diff --git a/Framework/MDAlgorithms/src/MDNormDirectSC.cpp b/Framework/MDAlgorithms/src/MDNormDirectSC.cpp
index 2feb1ff6a126e39b27eea151c0dc5bcb4043bba2..b2ab47cf1982924176231635032a001c611e14e6 100644
--- a/Framework/MDAlgorithms/src/MDNormDirectSC.cpp
+++ b/Framework/MDAlgorithms/src/MDNormDirectSC.cpp
@@ -142,20 +142,27 @@ void MDNormDirectSC::exec() {
m_normWS->setDisplayNormalization(Mantid::API::NoNormalization);
setProperty("OutputNormalizationWorkspace", m_normWS);
- // Check for other dimensions if we could measure anything in the original
- // data
- bool skipNormalization = false;
- const std::vector<coord_t> otherValues =
- getValuesFromOtherDimensions(skipNormalization);
- const auto affineTrans =
- findIntergratedDimensions(otherValues, skipNormalization);
- cacheDimensionXValues();
-
- if (!skipNormalization) {
- calculateNormalization(otherValues, affineTrans);
- } else {
- g_log.warning("Binning limits are outside the limits of the MDWorkspace. "
- "Not applying normalization.");
+ m_numExptInfos = outputWS->getNumExperimentInfo();
+ // loop over all experiment infos
+ for (uint16_t expInfoIndex = 0; expInfoIndex < m_numExptInfos;
+ expInfoIndex++) {
+ // Check for other dimensions if we could measure anything in the original
+ // data
+ bool skipNormalization = false;
+ const std::vector<coord_t> otherValues =
+ getValuesFromOtherDimensions(skipNormalization, expInfoIndex);
+ const auto affineTrans =
+ findIntergratedDimensions(otherValues, skipNormalization);
+ cacheDimensionXValues();
+
+ if (!skipNormalization) {
+ calculateNormalization(otherValues, affineTrans, expInfoIndex);
+ } else {
+ g_log.warning("Binning limits are outside the limits of the MDWorkspace. "
+ "Not applying normalization.");
+ }
+ // if more than one experiment info, keep accumulating
+ m_accumulate = true;
}
// Set the display normalization based on the input workspace
@@ -295,12 +302,14 @@ void MDNormDirectSC::createNormalizationWS(const MDHistoWorkspace &dataWS) {
* Retrieve logged values from non-HKL dimensions
* @param skipNormalization [InOut] Updated to false if any values are outside
* range measured by input workspace
+ * @param expInfoIndex current experiment info index
* @return A vector of values from other dimensions to be include in normalized
* MD position calculation
*/
std::vector<coord_t>
-MDNormDirectSC::getValuesFromOtherDimensions(bool &skipNormalization) const {
- const auto &runZero = m_inputWS->getExperimentInfo(0)->run();
+MDNormDirectSC::getValuesFromOtherDimensions(bool &skipNormalization,
+ uint16_t expInfoIndex) const {
+ const auto ¤tRun = m_inputWS->getExperimentInfo(expInfoIndex)->run();
std::vector<coord_t> otherDimValues;
for (size_t i = 4; i < m_inputWS->getNumDims(); i++) {
@@ -308,7 +317,7 @@ MDNormDirectSC::getValuesFromOtherDimensions(bool &skipNormalization) const {
float dimMin = static_cast<float>(dimension->getMinimum());
float dimMax = static_cast<float>(dimension->getMaximum());
auto *dimProp = dynamic_cast<Kernel::TimeSeriesProperty<double> *>(
- runZero.getProperty(dimension->getName()));
+ currentRun.getProperty(dimension->getName()));
if (dimProp) {
coord_t value = static_cast<coord_t>(dimProp->firstValue());
otherDimValues.push_back(value);
@@ -396,7 +405,8 @@ Kernel::Matrix<coord_t> MDNormDirectSC::findIntergratedDimensions(
}
/**
- * Stores the X values from each H,K,L dimension as member variables
+ * Stores the X values from each H,K,L,E dimension as member variables
+ * Energy dimension is transformed to final wavevector.
*/
void MDNormDirectSC::cacheDimensionXValues() {
constexpr double energyToK = 8.0 * M_PI * M_PI *
@@ -439,20 +449,21 @@ void MDNormDirectSC::cacheDimensionXValues() {
/**
* Computed the normalization for the input workspace. Results are stored in
* m_normWS
- * @param otherValues
- * @param affineTrans
+ * @param otherValues non HKLE dimensions
+ * @param affineTrans affine matrix
+ * @param expInfoIndex current experiment info index
*/
void MDNormDirectSC::calculateNormalization(
const std::vector<coord_t> &otherValues,
- const Kernel::Matrix<coord_t> &affineTrans) {
+ const Kernel::Matrix<coord_t> &affineTrans, uint16_t expInfoIndex) {
constexpr double energyToK = 8.0 * M_PI * M_PI *
PhysicalConstants::NeutronMass *
PhysicalConstants::meV * 1e-20 /
(PhysicalConstants::h * PhysicalConstants::h);
- const auto &exptInfoZero = *(m_inputWS->getExperimentInfo(0));
+ const auto ¤tExptInfo = *(m_inputWS->getExperimentInfo(expInfoIndex));
using VectorDoubleProperty = Kernel::PropertyWithValue<std::vector<double>>;
- auto *rubwLog =
- dynamic_cast<VectorDoubleProperty *>(exptInfoZero.getLog("RUBW_MATRIX"));
+ auto *rubwLog = dynamic_cast<VectorDoubleProperty *>(
+ currentExptInfo.getLog("RUBW_MATRIX"));
if (!rubwLog) {
throw std::runtime_error(
"Wokspace does not contain a log entry for the RUBW matrix."
@@ -460,12 +471,12 @@ void MDNormDirectSC::calculateNormalization(
} else {
Kernel::DblMatrix rubwValue(
(*rubwLog)()); // includes the 2*pi factor but not goniometer for now :)
- m_rubw = exptInfoZero.run().getGoniometerMatrix() * rubwValue;
+ m_rubw = currentExptInfo.run().getGoniometerMatrix() * rubwValue;
m_rubw.Invert();
}
- const double protonCharge = exptInfoZero.run().getProtonCharge();
+ const double protonCharge = currentExptInfo.run().getProtonCharge();
- const auto &spectrumInfo = exptInfoZero.spectrumInfo();
+ const auto &spectrumInfo = currentExptInfo.spectrumInfo();
// Mapping
const int64_t ndets = static_cast<int64_t>(spectrumInfo.size());
@@ -482,7 +493,10 @@ void MDNormDirectSC::calculateNormalization(
std::vector<std::atomic<signal_t>> signalArray(m_normWS->getNPoints());
std::vector<std::array<double, 4>> intersections;
std::vector<coord_t> pos, posNew;
- auto prog = make_unique<API::Progress>(this, 0.3, 1.0, ndets);
+ double progStep = 0.7 / m_numExptInfos;
+ auto prog =
+ make_unique<API::Progress>(this, 0.3 + progStep * expInfoIndex,
+ 0.3 + progStep * (expInfoIndex + 1.), ndets);
// cppcheck-suppress syntaxError
PRAGMA_OMP(parallel for private(intersections, pos, posNew))
for (int64_t i = 0; i < ndets; i++) {
diff --git a/Framework/MDAlgorithms/test/IntegratePeaksMDHKLTest.h b/Framework/MDAlgorithms/test/IntegratePeaksMDHKLTest.h
index d9e4f462e9e7c2a8aaef7c10073e81d706c01547..78c9358bd50f3f884b9c9be6193640253ac32ff3 100644
--- a/Framework/MDAlgorithms/test/IntegratePeaksMDHKLTest.h
+++ b/Framework/MDAlgorithms/test/IntegratePeaksMDHKLTest.h
@@ -31,6 +31,12 @@ using Mantid::Kernel::V3D;
class IntegratePeaksMDHKLTest : public CxxTest::TestSuite {
public:
+ // This means the constructor isn't called when running other tests
+ static IntegratePeaksMDHKLTest *createSuite() {
+ return new IntegratePeaksMDHKLTest();
+ }
+ static void destroySuite(IntegratePeaksMDHKLTest *suite) { delete suite; }
+
IntegratePeaksMDHKLTest() { Mantid::API::FrameworkManager::Instance(); }
~IntegratePeaksMDHKLTest() override {}
diff --git a/Framework/Muon/src/CalculateMuonAsymmetry.cpp b/Framework/Muon/src/CalculateMuonAsymmetry.cpp
index 6b85662dbad5878846cd9f3fcc5298eee627d3da..15f6af64f6797c63a769c9944860f57069a87646 100644
--- a/Framework/Muon/src/CalculateMuonAsymmetry.cpp
+++ b/Framework/Muon/src/CalculateMuonAsymmetry.cpp
@@ -80,6 +80,7 @@ void CalculateMuonAsymmetry::init() {
"MaxIterations", 500, mustBePositive->clone(),
"Stop after this number of iterations if a good fit is not found");
declareProperty("OutputStatus", "", Kernel::Direction::Output);
+ declareProperty("ChiSquared", 0.0, Kernel::Direction::Output);
declareProperty(make_unique<API::FunctionProperty>("OutputFunction",
Kernel::Direction::Output),
"The fitting function after fit.");
@@ -251,7 +252,8 @@ std::vector<double> CalculateMuonAsymmetry::getNormConstants(
fit->execute();
auto status = fit->getPropertyValue("OutputStatus");
setProperty("OutputStatus", status);
-
+ double chi2 = std::stod(fit->getPropertyValue("OutputChi2overDoF"));
+ setProperty("ChiSquared", chi2);
API::IFunction_sptr tmp = fit->getProperty("Function");
setProperty("OutputFunction", tmp);
try {
diff --git a/Framework/Muon/test/RRFMuonTest.h b/Framework/Muon/test/RRFMuonTest.h
index 65811ebf23274b604d19b1575b206c61d30c3472..96b05c18d346968260248583880c7d8c330c7db8 100644
--- a/Framework/Muon/test/RRFMuonTest.h
+++ b/Framework/Muon/test/RRFMuonTest.h
@@ -7,7 +7,6 @@
#include "MantidAPI/WorkspaceFactory.h"
#include "MantidKernel/UnitFactory.h"
#include "MantidMuon/RRFMuon.h"
-#include "MantidTestHelpers/HistogramDataTestHelper.h"
#include <cxxtest/TestSuite.h>
using namespace Mantid::Algorithms;
diff --git a/Framework/PythonInterface/inc/MantidPythonInterface/kernel/Converters/ContainerDtype.h b/Framework/PythonInterface/inc/MantidPythonInterface/kernel/Converters/ContainerDtype.h
index ba5428819b01be68143c591c6cb625844f89cbd9..a356083e3d1e290aad15b542d17bcc4b50121993 100644
--- a/Framework/PythonInterface/inc/MantidPythonInterface/kernel/Converters/ContainerDtype.h
+++ b/Framework/PythonInterface/inc/MantidPythonInterface/kernel/Converters/ContainerDtype.h
@@ -8,7 +8,7 @@
ContainerDtype Header File
A helper free function to allow identification of data type being used by
- providing a numpy friendly string.
+ providing a numpy friendly string (using the numpy array interface).
@author Lamar Moore STFC, Bhuvan Bezawada STFC
@date 21/06/2018
@@ -43,29 +43,13 @@ namespace Converters {
template <template <class> class Container, typename HeldType>
std::string dtype(const Container<HeldType> &) {
if (std::is_same<HeldType, bool>::value) {
- return "bool_";
- } else if (std::is_same<HeldType, short>::value) {
- return "int16";
- } else if (std::is_same<HeldType, std::int8_t>::value) {
- return "int8";
- } else if (std::is_same<HeldType, std::int16_t>::value) {
- return "int16";
- } else if (std::is_same<HeldType, std::int32_t>::value) {
- return "int32";
- } else if (std::is_same<HeldType, std::int64_t>::value) {
- return "int64";
- } else if (std::is_same<HeldType, long>::value) {
- return "int_";
- } else if (std::is_same<HeldType, long long>::value) {
- return "int64";
- } else if (std::is_same<HeldType, float>::value) {
- return "float32";
- } else if (std::is_same<HeldType, double>::value) {
- return "float64";
- } else if (std::is_same<HeldType, std::string>::value) {
- return "string_";
+ return "b";
+ } else if (std::is_integral<HeldType>::value) {
+ return "i";
+ } else if (std::is_floating_point<HeldType>::value) {
+ return "f";
} else {
- return "object_";
+ return "O";
}
}
diff --git a/Framework/PythonInterface/inc/MantidPythonInterface/kernel/Converters/ToPyList.h b/Framework/PythonInterface/inc/MantidPythonInterface/kernel/Converters/ToPyList.h
new file mode 100644
index 0000000000000000000000000000000000000000..b5e0b0e8e7e010d4468debd54770ca25b3b3d8df
--- /dev/null
+++ b/Framework/PythonInterface/inc/MantidPythonInterface/kernel/Converters/ToPyList.h
@@ -0,0 +1,57 @@
+#ifndef MANTID_PYTHONINTERFACE_TOPYLIST_H_
+#define MANTID_PYTHONINTERFACE_TOPYLIST_H_
+/**
+ Copyright © 2012 ISIS Rutherford Appleton Laboratory, NScD Oak Ridge
+ National Laboratory & European Spallation Source
+
+ This file is part of Mantid.
+
+ Mantid is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ Mantid is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ 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>
+ Code Documentation is available at: <http://doxygen.mantidproject.org>
+ */
+#include <boost/python/list.hpp>
+#include <vector>
+
+namespace Mantid {
+namespace PythonInterface {
+namespace Converters {
+//-----------------------------------------------------------------------
+// Converter implementation
+//-----------------------------------------------------------------------
+/**
+ * Converter that takes a std::vector and converts it into a python list.
+ * It is able to convert anything for which a converter is already registered
+ */
+template <typename ElementType> struct ToPyList {
+ /**
+ * Converts a cvector to a numpy array
+ * @param cdata :: A const reference to a vector
+ * @returns A new python list object
+ */
+ inline boost::python::list
+ operator()(const std::vector<ElementType> &cdata) const {
+ boost::python::list result;
+ for (const auto &item : cdata) {
+ result.append(item);
+ }
+ return result;
+ }
+};
+} // namespace Converters
+} // namespace PythonInterface
+} // namespace Mantid
+
+#endif /* MANTID_PYTHONINTERFACE_TOPYLIST_H_ */
diff --git a/Framework/PythonInterface/inc/MantidPythonInterface/kernel/Converters/VectorToNDArray.h b/Framework/PythonInterface/inc/MantidPythonInterface/kernel/Converters/VectorToNDArray.h
index d8a5d366dd5fedc926d4319e774d96b2b513006d..43b3d4089d31d78011536c46b722b77060a0a57b 100644
--- a/Framework/PythonInterface/inc/MantidPythonInterface/kernel/Converters/VectorToNDArray.h
+++ b/Framework/PythonInterface/inc/MantidPythonInterface/kernel/Converters/VectorToNDArray.h
@@ -37,7 +37,7 @@ namespace Converters {
* Converter that takes a std::vector and converts it into a flat numpy array.
*
* The type of conversion is specified by another struct/class that
- * contains a static member create.
+ * contains a static member create1D.
*/
template <typename ElementType, typename ConversionPolicy>
struct VectorToNDArray {
diff --git a/Framework/PythonInterface/inc/MantidPythonInterface/kernel/Environment/ReleaseGlobalInterpreterLock.h b/Framework/PythonInterface/inc/MantidPythonInterface/kernel/Environment/ReleaseGlobalInterpreterLock.h
new file mode 100644
index 0000000000000000000000000000000000000000..c1f45931c66f02c8eb85548a111f042f50274070
--- /dev/null
+++ b/Framework/PythonInterface/inc/MantidPythonInterface/kernel/Environment/ReleaseGlobalInterpreterLock.h
@@ -0,0 +1,36 @@
+#ifndef MANTID_PYTHONINTERFACE_RELEASEGLOBALINTERPRETERLOCK_H_
+#define MANTID_PYTHONINTERFACE_RELEASEGLOBALINTERPRETERLOCK_H_
+
+#include "MantidPythonInterface/kernel/DllConfig.h"
+#include <boost/python/detail/wrap_python.hpp>
+
+namespace Mantid {
+namespace PythonInterface {
+namespace Environment {
+
+/**
+ * Defines a structure for releaseing the Python GIL
+ * using the RAII pattern. This releases the Python GIL
+ * for the duration of the current scope.
+ */
+class PYTHON_KERNEL_DLL ReleaseGlobalInterpreterLock {
+public:
+ /// Default constructor
+ ReleaseGlobalInterpreterLock();
+ /// Destructor
+ ~ReleaseGlobalInterpreterLock();
+
+private:
+ // Stores the current python trace used to track where in
+ // a python script you are.
+ Py_tracefunc m_tracefunc;
+ PyObject *m_tracearg;
+ /// Saved thread state
+ PyThreadState *m_saved;
+};
+
+} // namespace Environment
+} // namespace PythonInterface
+} // namespace Mantid
+
+#endif /* MANTID_PYTHONINTERFACE_RELEASEGLOBALINTERPRETERLock_H_ */
diff --git a/Framework/PythonInterface/inc/MantidPythonInterface/kernel/PropertyWithValueExporter.h b/Framework/PythonInterface/inc/MantidPythonInterface/kernel/PropertyWithValueExporter.h
index 6254785d87f458ef42cfe257b964a9627b3896c2..2270d5c0425acaf2d5e954bfe6fa0397f26c4aa4 100644
--- a/Framework/PythonInterface/inc/MantidPythonInterface/kernel/PropertyWithValueExporter.h
+++ b/Framework/PythonInterface/inc/MantidPythonInterface/kernel/PropertyWithValueExporter.h
@@ -37,6 +37,15 @@
// Call the dtype helper function
template <typename HeldType>
std::string dtype(Mantid::Kernel::PropertyWithValue<HeldType> &self) {
+ // Check for the special case of a string
+ if (std::is_same<HeldType, std::string>::value) {
+ std::stringstream ss;
+ std::string val = self.value();
+ ss << "S" << val.size();
+ std::string ret_val = ss.str();
+ return ret_val;
+ }
+
return Mantid::PythonInterface::Converters::dtype(self);
}
diff --git a/Framework/PythonInterface/inc/MantidPythonInterface/kernel/Registry/PropertyWithValueFactory.h b/Framework/PythonInterface/inc/MantidPythonInterface/kernel/Registry/PropertyWithValueFactory.h
index 9b4f222e2ca53a3f888f68abb26f377aaefd5f60..b591c6c6c0b67b51a67f4aae0197d0a4797b6d3a 100644
--- a/Framework/PythonInterface/inc/MantidPythonInterface/kernel/Registry/PropertyWithValueFactory.h
+++ b/Framework/PythonInterface/inc/MantidPythonInterface/kernel/Registry/PropertyWithValueFactory.h
@@ -1,5 +1,5 @@
-#ifndef MANTID_PYTHONINTERFACE_PROEPRTYWITHVALUEFACTORY_H_
-#define MANTID_PYTHONINTERFACE_PROEPRTYWITHVALUEFACTORY_H_
+#ifndef MANTID_PYTHONINTERFACE_PROPERTYWITHVALUEFACTORY_H_
+#define MANTID_PYTHONINTERFACE_PROPERTYWITHVALUEFACTORY_H_
/**
Copyright © 2011 ISIS Rutherford Appleton Laboratory, NScD Oak Ridge
National Laboratory & European Spallation Source
@@ -26,8 +26,8 @@
// Includes
//-----------------------------------------------------------------------------
#include "MantidPythonInterface/kernel/Registry/PropertyValueHandler.h"
+#include <boost/python/list.hpp>
#include <memory>
-#include <string>
namespace Mantid {
//---------------------------------------------------------------------------
@@ -53,6 +53,10 @@ public:
create(const std::string &name, const boost::python::object &defaultValue,
const unsigned int direction);
+ static std::unique_ptr<Kernel::Property>
+ createTimeSeries(const std::string &name,
+ const boost::python::list &defaultValue);
+
private:
/// Return a handler that maps the python type to a C++ type
static const PropertyValueHandler &lookup(PyObject *const object);
@@ -63,4 +67,4 @@ private:
} // namespace PythonInterface
} // namespace Mantid
-#endif // MANTID_PYTHONINTERFACE_PROEPRTYWITHVALUEFACTORY_H_
+#endif // MANTID_PYTHONINTERFACE_PROPERTYWITHVALUEFACTORY_H_
diff --git a/Framework/PythonInterface/mantid/api/CMakeLists.txt b/Framework/PythonInterface/mantid/api/CMakeLists.txt
index 24ff964957acfb3dd44d5545badca601b126f1d6..0d348eb21b5e3e4e902f1875778ff416516657b8 100644
--- a/Framework/PythonInterface/mantid/api/CMakeLists.txt
+++ b/Framework/PythonInterface/mantid/api/CMakeLists.txt
@@ -54,6 +54,7 @@ set ( EXPORT_FILES
src/Exports/WorkspaceValidators.cpp
src/Exports/ADSValidator.cpp
src/Exports/InstrumentValidator.cpp
+ src/Exports/OrientedLatticeValidator.cpp
src/Exports/Axis.cpp
src/Exports/IPeak.cpp
src/Exports/BoxController.cpp
@@ -76,6 +77,7 @@ set ( EXPORT_FILES
src/Exports/FunctionProperty.cpp
src/Exports/AlgorithmProperty.cpp
src/Exports/MultiDomainFunction.cpp
+ src/Exports/SpectrumDefinition.cpp
)
set ( MODULE_DEFINITION ${CMAKE_CURRENT_BINARY_DIR}/api.cpp )
diff --git a/Framework/PythonInterface/mantid/api/src/Exports/AnalysisDataService.cpp b/Framework/PythonInterface/mantid/api/src/Exports/AnalysisDataService.cpp
index cd0d53f6d1aeb541d0b2be56be91c9f6597699a0..008c2544fa19b17b54e46fe7c85b672ab6847682 100644
--- a/Framework/PythonInterface/mantid/api/src/Exports/AnalysisDataService.cpp
+++ b/Framework/PythonInterface/mantid/api/src/Exports/AnalysisDataService.cpp
@@ -1,7 +1,14 @@
+#include "MantidAPI/AnalysisDataService.h"
+#include "MantidKernel/WarningSuppressions.h"
+#include "MantidPythonInterface/kernel/Converters/PySequenceToVector.h"
+#include "MantidPythonInterface/kernel/Converters/ToPyList.h"
#include "MantidPythonInterface/kernel/DataServiceExporter.h"
#include "MantidPythonInterface/kernel/GetPointer.h"
-#include "MantidAPI/AnalysisDataService.h"
+#include <boost/python/enum.hpp>
+#include <boost/python/list.hpp>
+#include <boost/python/overloads.hpp>
+#include <boost/python/return_value_policy.hpp>
using namespace Mantid::API;
using namespace Mantid::Kernel;
@@ -10,6 +17,23 @@ using namespace boost::python;
GET_POINTER_SPECIALIZATION(AnalysisDataServiceImpl)
+namespace {
+list retrieveWorkspaces(AnalysisDataServiceImpl &self, const list &names,
+ bool unrollGroups = false) {
+ return Converters::ToPyList<Workspace_sptr>()(self.retrieveWorkspaces(
+ Converters::PySequenceToVector<std::string>(names)(), unrollGroups));
+}
+
+GNU_DIAG_OFF("unused-local-typedef")
+// Ignore -Wconversion warnings coming from boost::python
+// Seen with GCC 7.1.1 and Boost 1.63.0
+GNU_DIAG_OFF("conversion")
+BOOST_PYTHON_FUNCTION_OVERLOADS(AdsRetrieveWorkspacesOverloads,
+ retrieveWorkspaces, 2, 3)
+GNU_DIAG_ON("conversion")
+GNU_DIAG_ON("unused-local-typedef")
+} // namespace
+
void export_AnalysisDataService() {
using ADSExporter =
DataServiceExporter<AnalysisDataServiceImpl, Workspace_sptr>;
@@ -18,5 +42,9 @@ void export_AnalysisDataService() {
.def("Instance", &AnalysisDataService::Instance,
return_value_policy<reference_existing_object>(),
"Return a reference to the singleton instance")
- .staticmethod("Instance");
+ .staticmethod("Instance")
+ .def("retrieveWorkspaces", retrieveWorkspaces,
+ AdsRetrieveWorkspacesOverloads(
+ "Retrieve a list of workspaces by name",
+ (arg("self"), arg("names"), arg("unrollGroups") = false)));
}
diff --git a/Framework/PythonInterface/mantid/api/src/Exports/ExperimentInfo.cpp b/Framework/PythonInterface/mantid/api/src/Exports/ExperimentInfo.cpp
index 459a987c54318dffd3c2f2436c93ded403f5b046..25410e307f83443b5bf1006969973da3a1ae713e 100644
--- a/Framework/PythonInterface/mantid/api/src/Exports/ExperimentInfo.cpp
+++ b/Framework/PythonInterface/mantid/api/src/Exports/ExperimentInfo.cpp
@@ -3,6 +3,7 @@
#include "MantidAPI/Sample.h"
#include "MantidAPI/SpectrumInfo.h"
#include "MantidGeometry/IDTypes.h"
+#include "MantidGeometry/Instrument/ComponentInfo.h"
#include "MantidGeometry/Instrument/DetectorInfo.h"
#include "MantidKernel/WarningSuppressions.h"
#include "MantidPythonInterface/kernel/GetPointer.h"
@@ -81,5 +82,10 @@ void export_ExperimentInfo() {
.def("spectrumInfo", &ExperimentInfo::spectrumInfo,
return_value_policy<reference_existing_object>(), args("self"),
"Return a const reference to the :class:`~mantid.api.SpectrumInfo` "
+ "object.")
+ .def("componentInfo", &ExperimentInfo::componentInfo,
+ return_value_policy<reference_existing_object>(), args("self"),
+ "Return a const reference to the "
+ ":class:`~mantid.geometry.ComponentInfo` "
"object.");
}
diff --git a/Framework/PythonInterface/mantid/api/src/Exports/FileFinder.cpp b/Framework/PythonInterface/mantid/api/src/Exports/FileFinder.cpp
index 9ffe5c56308b8252b13c0a48c63092fdf839b221..73b769c2b9d66da22484a14cf7aaa7757f30725f 100644
--- a/Framework/PythonInterface/mantid/api/src/Exports/FileFinder.cpp
+++ b/Framework/PythonInterface/mantid/api/src/Exports/FileFinder.cpp
@@ -1,5 +1,6 @@
#include "MantidAPI/FileFinder.h"
#include "MantidKernel/WarningSuppressions.h"
+#include "MantidPythonInterface/kernel/Environment/ReleaseGlobalInterpreterLock.h"
#include <boost/python/class.hpp>
#include <boost/python/overloads.hpp>
#include <boost/python/reference_existing_object.hpp>
@@ -20,6 +21,23 @@ GNU_DIAG_ON("conversion")
GNU_DIAG_ON("unused-local-typedef")
} // namespace
+/**
+ * Runs FileFinder.findRuns after releasing the python GIL.
+ * @param self :: A reference to the calling object
+ * @param hinstr :: A string containing the run number and possibly instrument
+ * to search for
+ */
+std::vector<std::string> runFinderProxy(FileFinderImpl &self,
+ std::string hinstr) {
+ // Before calling the function we need to release the GIL,
+ // drop the Python threadstate and reset anything installed
+ // via PyEval_SetTrace while we execute the C++ code -
+ // ReleaseGlobalInterpreter does this for us
+ Mantid::PythonInterface::Environment::ReleaseGlobalInterpreterLock
+ releaseGlobalInterpreterLock;
+ return self.findRuns(hinstr);
+}
+
void export_FileFinder() {
class_<FileFinderImpl, boost::noncopyable>("FileFinderImpl", no_init)
.def("getFullPath", &FileFinderImpl::getFullPath,
@@ -28,7 +46,7 @@ void export_FileFinder() {
"Return a full path to the given file if it can be found within "
"datasearch.directories paths. Directories can be ignored with "
"ignoreDirs=True. An empty string is returned otherwise."))
- .def("findRuns", &FileFinderImpl::findRuns, (arg("self"), arg("hintstr")),
+ .def("findRuns", &runFinderProxy, (arg("self"), arg("hintstr")),
"Find a list of files file given a hint. "
"The hint can be a comma separated list of run numbers and can also "
"include ranges of runs, e.g. 123-135 or equivalently 123-35"
diff --git a/Framework/PythonInterface/mantid/api/src/Exports/ITableWorkspace.cpp b/Framework/PythonInterface/mantid/api/src/Exports/ITableWorkspace.cpp
index 97291693dc1833b249859dbf74878180fc4a9166..8640618343b35937cac4d1f8883d89034085094d 100644
--- a/Framework/PythonInterface/mantid/api/src/Exports/ITableWorkspace.cpp
+++ b/Framework/PythonInterface/mantid/api/src/Exports/ITableWorkspace.cpp
@@ -233,8 +233,8 @@ void setPlotType(ITableWorkspace &self, const bpl::object &column, int ptype) {
} else {
colptr = self.getColumn(extract<int>(column)());
}
-
colptr->setPlotType(ptype);
+ self.modified();
}
/**
@@ -452,6 +452,7 @@ void setCell(ITableWorkspace &self, const bpl::object &col_or_row,
int row(-1);
getCellLoc(self, col_or_row, row_or_col, column, row);
setValue(column, row, value);
+ self.modified();
}
} // namespace
diff --git a/Framework/PythonInterface/mantid/api/src/Exports/OrientedLatticeValidator.cpp b/Framework/PythonInterface/mantid/api/src/Exports/OrientedLatticeValidator.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fd6a74a50a1c96b043a6daa73aba8cc9671cb7c3
--- /dev/null
+++ b/Framework/PythonInterface/mantid/api/src/Exports/OrientedLatticeValidator.cpp
@@ -0,0 +1,19 @@
+#include "MantidAPI/OrientedLatticeValidator.h"
+#include "MantidPythonInterface/kernel/TypedValidatorExporter.h"
+#include <boost/python/class.hpp>
+
+using namespace Mantid::API;
+using Mantid::PythonInterface::TypedValidatorExporter;
+using namespace boost::python;
+
+// This is typed on the ExperimentInfo class
+void export_OrientedLatticeValidator() {
+ TypedValidatorExporter<ExperimentInfo_sptr>::define(
+ "OrientedLatticeValidator");
+
+ class_<OrientedLatticeValidator,
+ bases<Mantid::Kernel::TypedValidator<ExperimentInfo_sptr>>,
+ boost::noncopyable>(
+ "OrientedLatticeValidator",
+ init<>("Checks that the workspace has an orientation matrix defined"));
+}
diff --git a/Framework/PythonInterface/mantid/api/src/Exports/Sample.cpp b/Framework/PythonInterface/mantid/api/src/Exports/Sample.cpp
index 193f86bb30eb8eaec927d01ff157c12ecdd91c1a..d9fff1cd2f22be2ecb0578f7695095587dd17f6a 100644
--- a/Framework/PythonInterface/mantid/api/src/Exports/Sample.cpp
+++ b/Framework/PythonInterface/mantid/api/src/Exports/Sample.cpp
@@ -1,4 +1,5 @@
#include "MantidAPI/Sample.h"
+
#include "MantidGeometry/Crystal/CrystalStructure.h"
#include "MantidGeometry/Crystal/OrientedLattice.h"
#include "MantidKernel/Material.h"
@@ -65,6 +66,9 @@ void export_Sample() {
"Set the height in mm.")
.def("setWidth", &Sample::setWidth, (arg("self"), arg("width")),
"Set the width in mm.")
+ .def("getShape", &Sample::getShape, arg("self"),
+ "Returns a shape of a Sample object.",
+ return_value_policy<reference_existing_object>())
// -------------------------Operators
// -------------------------------------
.def("__len__", &Sample::size, arg("self"),
diff --git a/Framework/PythonInterface/mantid/api/src/Exports/SpectrumDefinition.cpp b/Framework/PythonInterface/mantid/api/src/Exports/SpectrumDefinition.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2ff4ad5dc6de07333c5383644dc7bd3e2cf54014
--- /dev/null
+++ b/Framework/PythonInterface/mantid/api/src/Exports/SpectrumDefinition.cpp
@@ -0,0 +1,35 @@
+#include "MantidTypes/SpectrumDefinition.h"
+
+#include <boost/python/class.hpp>
+#include <boost/python/tuple.hpp>
+
+using Mantid::SpectrumDefinition;
+using namespace boost::python;
+
+// Helper function to convert a std::Pair to a Python tuple
+boost::python::tuple toTuple(const SpectrumDefinition &self,
+ const size_t index) {
+ const std::pair<size_t, size_t> pair = self.operator[](index);
+ return make_tuple(pair.first, pair.second);
+}
+
+void export_SpectrumDefinition() {
+ class_<SpectrumDefinition>("SpectrumDefinition", no_init)
+
+ .def("__getitem__", &toTuple, (arg("self"), arg("index")),
+ "Returns the pair of detector index and time index at given index "
+ "of spectrum definition.")
+
+ .def("size", &SpectrumDefinition::size, arg("self"),
+ "Returns the size of the SpectrumDefinition i.e. the number of "
+ "detectors for the spectrum.")
+
+ .def("add", &SpectrumDefinition::add,
+ (arg("self"), arg("detectorIndex"), arg("timeIndex")),
+ "Adds a pair of detector index and time index to the spectrum "
+ "definition.")
+
+ .def("equals",
+ &SpectrumDefinition::operator==,(arg("self"), arg("other")),
+ "Compare spectrum definitions.");
+}
diff --git a/Framework/PythonInterface/mantid/api/src/Exports/SpectrumInfo.cpp b/Framework/PythonInterface/mantid/api/src/Exports/SpectrumInfo.cpp
index e77b73b0681e902a38bbc184bbdb51896550bf7f..b96b826fdc72210e9efcb75d33566384280fc764 100644
--- a/Framework/PythonInterface/mantid/api/src/Exports/SpectrumInfo.cpp
+++ b/Framework/PythonInterface/mantid/api/src/Exports/SpectrumInfo.cpp
@@ -1,25 +1,72 @@
#include "MantidAPI/SpectrumInfo.h"
+#include "MantidTypes/SpectrumDefinition.h"
+
#include <boost/python/class.hpp>
+#include <boost/python/copy_const_reference.hpp>
+#include <boost/python/list.hpp>
+#include <boost/python/return_value_policy.hpp>
using Mantid::API::SpectrumInfo;
+using Mantid::SpectrumDefinition;
using namespace boost::python;
+// Export SpectrumInfo
void export_SpectrumInfo() {
- // WARNING SpectrumInfo is work in progress and not ready for exposing more of
- // its functionality to Python, and should not yet be used in user scripts. DO
- // NOT ADD EXPORTS TO OTHER METHODS without contacting the team working on
- // Instrument-2.0.
class_<SpectrumInfo, boost::noncopyable>("SpectrumInfo", no_init)
+ .def("__len__", &SpectrumInfo::size, arg("self"),
+ "Returns the number of spectra.")
+
+ .def("size", &SpectrumInfo::size, arg("self"),
+ "Returns the number of spectra.")
+
.def("isMonitor", &SpectrumInfo::isMonitor, (arg("self"), arg("index")),
- "Returns true if the detector(s) associated with the spectrum are "
+ "Returns True if the detector(s) associated with the spectrum are "
"monitors.")
+
.def("isMasked", &SpectrumInfo::isMasked, (arg("self"), arg("index")),
- "Returns true if the detector(s) associated with the spectrum are "
+ "Returns True if the detector(s) associated with the spectrum are "
"masked.")
- .def("hasDetectors", &SpectrumInfo::hasDetectors, (arg("self")),
- "Returns true if the spectrum is associated with detectors in the "
- "instrument.")
+
+ .def("setMasked", &SpectrumInfo::setMasked,
+ (arg("self"), arg("index"), arg("masked")),
+ "Set the mask flag of the spectrum with the given index.")
+
.def("twoTheta", &SpectrumInfo::twoTheta, (arg("self"), arg("index")),
"Returns the scattering angle 2 theta in radians w.r.t. beam "
- "direction.");
+ "direction.")
+
+ .def("signedTwoTheta", &SpectrumInfo::signedTwoTheta,
+ (arg("self"), arg("index")),
+ "Returns the signed scattering angle 2 theta in radians w.r.t. beam "
+ "direction.")
+
+ .def("l1", &SpectrumInfo::l1, arg("self"),
+ "Returns the distance from the source to the sample.")
+
+ .def("l2", &SpectrumInfo::l2, (arg("self"), arg("index")),
+ "Returns the distance from the sample to the spectrum.")
+
+ .def("hasDetectors", &SpectrumInfo::hasDetectors, (arg("self")),
+ "Returns True if the spectrum is associated with detectors in the "
+ "instrument.")
+
+ .def("hasUniqueDetector", &SpectrumInfo::hasUniqueDetector,
+ (arg("self"), arg("index")),
+ "Returns True if the spectrum is associated with exactly one "
+ "detector.")
+
+ .def("position", &SpectrumInfo::position, (arg("self"), arg("index")),
+ "Returns the absolute position of the spectrum with the given "
+ "index.")
+
+ .def("sourcePosition", &SpectrumInfo::sourcePosition, arg("self"),
+ "Returns the absolute source position.")
+
+ .def("samplePosition", &SpectrumInfo::samplePosition, arg("self"),
+ "Returns the absolute sample position.")
+
+ .def("getSpectrumDefinition", &SpectrumInfo::spectrumDefinition,
+ return_value_policy<return_by_value>(), (arg("self"), arg("index")),
+ "Returns the SpectrumDefinition of the spectrum with the given "
+ "index.");
}
diff --git a/Framework/PythonInterface/mantid/api/src/Exports/Workspace.cpp b/Framework/PythonInterface/mantid/api/src/Exports/Workspace.cpp
index 71dad6096533d0adfef3ae75303586093dd490fc..bf77888bd387422a9b709c37ee88891c46169bfa 100644
--- a/Framework/PythonInterface/mantid/api/src/Exports/Workspace.cpp
+++ b/Framework/PythonInterface/mantid/api/src/Exports/Workspace.cpp
@@ -31,10 +31,8 @@ GNU_DIAG_ON("unused-local-typedef")
///@endcond
} // namespace
-//--------------------------------------------------------------------------------------
-// Deprecated function
-//--------------------------------------------------------------------------------------
/**
+ * DEPRECATED. Use DataItem.name()
* @param self Reference to the calling object
* @return name of the workspace.
*/
diff --git a/Framework/PythonInterface/mantid/dataobjects/src/Exports/TableWorkspace.cpp b/Framework/PythonInterface/mantid/dataobjects/src/Exports/TableWorkspace.cpp
index 4cf4849f16da0cc6d3ee86ad1c3b9b4b5b9d9b98..8a7d5f9121b27dca3591d85d866b8ba58463f294 100644
--- a/Framework/PythonInterface/mantid/dataobjects/src/Exports/TableWorkspace.cpp
+++ b/Framework/PythonInterface/mantid/dataobjects/src/Exports/TableWorkspace.cpp
@@ -14,9 +14,11 @@ using namespace boost::python;
GET_POINTER_SPECIALIZATION(TableWorkspace)
+namespace {
ITableWorkspace_sptr makeTableWorkspace() {
return WorkspaceFactory::Instance().createTable();
}
+} // namespace
void export_TableWorkspace() {
diff --git a/Framework/PythonInterface/mantid/geometry/CMakeLists.txt b/Framework/PythonInterface/mantid/geometry/CMakeLists.txt
index e711f3bf0c94e5ccfa7beeb5c6554a6767453409..40268a1b10fb9a3e1a9e14ad03288fcaced64bf6 100644
--- a/Framework/PythonInterface/mantid/geometry/CMakeLists.txt
+++ b/Framework/PythonInterface/mantid/geometry/CMakeLists.txt
@@ -16,7 +16,7 @@ set ( EXPORT_FILES
src/Exports/CompAssembly.cpp
src/Exports/ObjComponent.cpp
src/Exports/ObjCompAssembly.cpp
- src/Exports/Detector.cpp
+ src/Exports/Detector.cpp
src/Exports/DetectorGroup.cpp
src/Exports/RectangularDetector.cpp
src/Exports/Instrument.cpp
@@ -27,7 +27,7 @@ set ( EXPORT_FILES
src/Exports/Goniometer.cpp
src/Exports/CSGObject.cpp
src/Exports/PeakShape.cpp
- src/Exports/Group.cpp
+ src/Exports/Group.cpp
src/Exports/PointGroup.cpp
src/Exports/PointGroupFactory.cpp
src/Exports/SpaceGroup.cpp
@@ -39,9 +39,11 @@ set ( EXPORT_FILES
src/Exports/CrystalStructure.cpp
src/Exports/ReflectionGenerator.cpp
src/Exports/DetectorInfo.cpp
+ src/Exports/ComponentInfo.cpp
src/Exports/DetectorInfoItem.cpp
src/Exports/DetectorInfoIterator.cpp
src/Exports/DetectorInfoPythonIterator.cpp
+
)
#############################################################################################
diff --git a/Framework/PythonInterface/mantid/geometry/src/Exports/ComponentInfo.cpp b/Framework/PythonInterface/mantid/geometry/src/Exports/ComponentInfo.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fcd1ace029e11e42a9dad11caa84a5c80b75d9a8
--- /dev/null
+++ b/Framework/PythonInterface/mantid/geometry/src/Exports/ComponentInfo.cpp
@@ -0,0 +1,136 @@
+#include "MantidGeometry/Instrument/ComponentInfo.h"
+#include "MantidGeometry/Objects/IObject.h"
+#include "MantidKernel/Quat.h"
+#include "MantidKernel/V3D.h"
+#include "MantidPythonInterface/kernel/Converters/WrapWithNumpy.h"
+#include "MantidPythonInterface/kernel/Policies/VectorToNumpy.h"
+
+#include <boost/python/class.hpp>
+#include <boost/python/copy_const_reference.hpp>
+#include <boost/python/reference_existing_object.hpp>
+#include <boost/python/return_value_policy.hpp>
+
+using Mantid::Geometry::ComponentInfo;
+using Mantid::Kernel::Quat;
+using Mantid::Kernel::V3D;
+using namespace Mantid::PythonInterface::Converters;
+using namespace Mantid::PythonInterface::Policies;
+using namespace boost::python;
+
+// Function pointers to help resolve ambiguity
+Mantid::Kernel::V3D (ComponentInfo::*position)(const size_t) const =
+ &ComponentInfo::position;
+
+Mantid::Kernel::Quat (ComponentInfo::*rotation)(const size_t) const =
+ &ComponentInfo::rotation;
+
+void (ComponentInfo::*setPosition)(const size_t, const Mantid::Kernel::V3D &) =
+ &ComponentInfo::setPosition;
+
+void (ComponentInfo::*setRotation)(const size_t, const Mantid::Kernel::Quat &) =
+ &ComponentInfo::setRotation;
+
+// Export ComponentInfo
+void export_ComponentInfo() {
+ class_<ComponentInfo, boost::noncopyable>("ComponentInfo", no_init)
+
+ .def("__len__", &ComponentInfo::size, arg("self"),
+ "Returns the number of components.")
+
+ .def("size", &ComponentInfo::size, arg("self"),
+ "Returns the number of components.")
+
+ .def("isDetector", &ComponentInfo::isDetector,
+ (arg("self"), arg("index")),
+ "Checks if the component is a detector.")
+
+ .def("detectorsInSubtree", &ComponentInfo::detectorsInSubtree,
+ return_value_policy<VectorToNumpy>(), (arg("self"), arg("index")),
+ "Returns a list of detectors in the subtree for the component "
+ "identified by 'index'.")
+
+ .def("componentsInSubtree", &ComponentInfo::componentsInSubtree,
+ return_value_policy<VectorToNumpy>(), (arg("self"), arg("index")),
+ "Returns a list of components in the subtree for the component "
+ "identified by 'index'.")
+
+ .def("position", position, (arg("self"), arg("index")),
+ "Returns the absolute position of the component identified by "
+ "'index'.")
+
+ .def("rotation", rotation, (arg("self"), arg("index")),
+ "Returns the absolute rotation of the component identified by "
+ "'index'.")
+
+ .def("relativePosition", &ComponentInfo::relativePosition,
+ (arg("self"), arg("index")),
+ "Returns the absolute relative position of the component identified "
+ "by 'index'.")
+
+ .def("relativeRotation", &ComponentInfo::relativeRotation,
+ (arg("self"), arg("index")),
+ "Returns the absolute relative rotation of the component identified "
+ "by 'index'.")
+
+ .def("setPosition", setPosition,
+ (arg("self"), arg("index"), arg("newPosition")),
+ "Set the absolute position of the component identified by 'index'.")
+
+ .def("setRotation", setRotation,
+ (arg("self"), arg("index"), arg("newRotation")),
+ "Set the absolute rotation of the component identified by 'index'.")
+
+ .def("hasSource", &ComponentInfo::hasSource, arg("self"),
+ "Returns True if a source is present.")
+
+ .def("hasSample", &ComponentInfo::hasSample, arg("self"),
+ "Returns True if a sample is present.")
+
+ .def("source", &ComponentInfo::source, arg("self"),
+ "Returns the source component.")
+
+ .def("sample", &ComponentInfo::source, arg("self"),
+ "Returns the sample component.")
+
+ .def("sourcePosition", &ComponentInfo::sourcePosition, arg("self"),
+ "Returns the source position.")
+
+ .def("samplePosition", &ComponentInfo::samplePosition, arg("self"),
+ "Returns the sample position.")
+
+ .def("hasParent", &ComponentInfo::hasParent, (arg("self"), arg("index")),
+ "Returns True only if the component identified by 'index' has a "
+ "parent component.")
+
+ .def("parent", &ComponentInfo::parent, (arg("self"), arg("index")),
+ "Returns the parent component of the component identified by "
+ "'index'.")
+
+ .def("children", &ComponentInfo::children, (arg("self"), arg("index")),
+ return_value_policy<VectorRefToNumpy<WrapReadOnly>>(),
+ "Returns a list of child components for the component identified by "
+ "'index'.")
+
+ .def("name", &ComponentInfo::name, (arg("self"), arg("index")),
+ return_value_policy<copy_const_reference>(),
+ "Returns the name of the component identified by 'index'.")
+
+ .def("l1", &ComponentInfo::l1, arg("self"), "Returns the l1 value.")
+
+ .def("scaleFactor", &ComponentInfo::scaleFactor,
+ (arg("self"), arg("index")),
+ "Returns the scale factor for the component identified by 'index'.")
+
+ .def("setScaleFactor", &ComponentInfo::setScaleFactor,
+ (arg("self"), arg("index"), arg("scaleFactor")),
+ "Set the scale factor of the component identifed by 'index'.")
+
+ .def("hasValidShape", &ComponentInfo::hasValidShape,
+ (arg("self"), arg("index")),
+ "Returns True if the component identified by 'index' has a valid "
+ "shape.")
+
+ .def("shape", &ComponentInfo::shape, (arg("self"), arg("index")),
+ return_value_policy<reference_existing_object>(),
+ "Returns the shape of the component identified by 'index'.");
+}
diff --git a/Framework/PythonInterface/mantid/kernel/CMakeLists.txt b/Framework/PythonInterface/mantid/kernel/CMakeLists.txt
index b8ce08e9069086e3ec66795771b1c7875e46226e..f78be07e854e006d2e3c425723db81b549d7bbba 100644
--- a/Framework/PythonInterface/mantid/kernel/CMakeLists.txt
+++ b/Framework/PythonInterface/mantid/kernel/CMakeLists.txt
@@ -60,6 +60,7 @@ set ( EXPORT_FILES
src/Exports/UsageService.cpp
src/Exports/Atom.cpp
src/Exports/StringContainsValidator.cpp
+ src/Exports/PropertyFactory.cpp
)
set ( MODULE_DEFINITION ${CMAKE_CURRENT_BINARY_DIR}/kernel.cpp )
@@ -88,6 +89,7 @@ set ( SRC_FILES
src/Registry/TypeRegistry.cpp
src/Environment/ErrorHandling.cpp
src/Environment/GlobalInterpreterLock.cpp
+ src/Environment/ReleaseGlobalInterpreterLock.cpp
src/Environment/WrapperHelpers.cpp
)
diff --git a/Framework/PythonInterface/mantid/kernel/funcinspect.py b/Framework/PythonInterface/mantid/kernel/funcinspect.py
index 1da6e1e69032960d9efbe82e1d7f32b0642e09b0..8f6354b1287e2f690d7605ca567e13c636525bd7 100644
--- a/Framework/PythonInterface/mantid/kernel/funcinspect.py
+++ b/Framework/PythonInterface/mantid/kernel/funcinspect.py
@@ -148,7 +148,7 @@ __operator_names = set(['CALL_FUNCTION', 'CALL_FUNCTION_VAR', 'CALL_FUNCTION_KW'
'INPLACE_MODULO', 'INPLACE_ADD', 'INPLACE_SUBTRACT',
'INPLACE_LSHIFT','INPLACE_RSHIFT','INPLACE_AND', 'INPLACE_XOR',
'INPLACE_OR', 'COMPARE_OP',
- 'CALL_FUNCTION_EX'])
+ 'CALL_FUNCTION_EX', 'LOAD_METHOD', 'CALL_METHOD'])
#--------------------------------------------------------------------------------------
def process_frame(frame):
diff --git a/Framework/PythonInterface/mantid/kernel/src/Environment/ReleaseGlobalInterpreterLock.cpp b/Framework/PythonInterface/mantid/kernel/src/Environment/ReleaseGlobalInterpreterLock.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..89d8b4c56a0d437bb77a961f8d0faf1bc045eea5
--- /dev/null
+++ b/Framework/PythonInterface/mantid/kernel/src/Environment/ReleaseGlobalInterpreterLock.cpp
@@ -0,0 +1,32 @@
+#include "MantidPythonInterface/kernel/Environment/ReleaseGlobalInterpreterLock.h"
+
+namespace Mantid {
+namespace PythonInterface {
+namespace Environment {
+
+/**
+ * Ensures this thread releases the Python GIL also save trace information
+ * to be restored upon destruction.
+ */
+ReleaseGlobalInterpreterLock::ReleaseGlobalInterpreterLock()
+ : m_tracefunc(nullptr), m_tracearg(nullptr), m_saved(nullptr) {
+ PyThreadState *curThreadState = PyThreadState_GET();
+ m_tracefunc = curThreadState->c_tracefunc;
+ m_tracearg = curThreadState->c_traceobj;
+ Py_XINCREF(m_tracearg);
+ PyEval_SetTrace(nullptr, nullptr);
+ m_saved = PyEval_SaveThread();
+}
+
+/**
+ * Restores the Python GIL to the thread when the object falls out of scope.
+ */
+ReleaseGlobalInterpreterLock::~ReleaseGlobalInterpreterLock() {
+ PyEval_RestoreThread(m_saved);
+ PyEval_SetTrace(m_tracefunc, m_tracearg);
+ Py_XDECREF(m_tracearg);
+}
+
+} // namespace Environment
+} // namespace PythonInterface
+} // namespace Mantid
\ No newline at end of file
diff --git a/Framework/PythonInterface/mantid/kernel/src/Exports/ArrayProperty.cpp b/Framework/PythonInterface/mantid/kernel/src/Exports/ArrayProperty.cpp
index c765253ae931cb167a601d4dbf2a6530cee44265..3dab4e7248a82d8072dc5f2f447cd629ad4d4d34 100644
--- a/Framework/PythonInterface/mantid/kernel/src/Exports/ArrayProperty.cpp
+++ b/Framework/PythonInterface/mantid/kernel/src/Exports/ArrayProperty.cpp
@@ -33,6 +33,35 @@ template <typename type> std::string dtype(ArrayProperty<type> &self) {
return Converters::dtype(self);
}
+// Check for the special case of a string
+template <> std::string dtype(ArrayProperty<std::string> &self) {
+ // Get a vector of all the strings
+ std::vector<std::string> values = self();
+
+ // Vector of ints to store the sizes of each of the strings
+ std::vector<size_t> stringSizes;
+
+ // Block allocate memory
+ stringSizes.reserve(self.size());
+
+ // Loop for the number of strings
+ // For each string store the number of characters
+ for (auto val : values) {
+ auto size = val.size();
+ stringSizes.emplace_back(size);
+ }
+
+ // Find the maximum number of characters
+ size_t max =
+ *std::max_element(std::begin(stringSizes), std::end(stringSizes));
+
+ // Create the string to return
+ std::stringstream ss;
+ ss << "S" << max;
+ std::string retVal = ss.str();
+ return retVal;
+}
+
#define EXPORT_ARRAY_PROP(type, prefix) \
class_<ArrayProperty<type>, bases<PropertyWithValue<std::vector<type>>>, \
boost::noncopyable>(#prefix "ArrayProperty", no_init) \
diff --git a/Framework/PythonInterface/mantid/kernel/src/Exports/PropertyFactory.cpp b/Framework/PythonInterface/mantid/kernel/src/Exports/PropertyFactory.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..8e3f145c4238923e32eb696e72c465d91878f7cf
--- /dev/null
+++ b/Framework/PythonInterface/mantid/kernel/src/Exports/PropertyFactory.cpp
@@ -0,0 +1,38 @@
+#include "MantidPythonInterface/kernel/Registry/PropertyWithValueFactory.h"
+#include "MantidPythonInterface/kernel/Registry/SequenceTypeHandler.h"
+#include "MantidPythonInterface/kernel/Registry/TypedPropertyValueHandler.h"
+
+#include <boost/python/class.hpp>
+#include <boost/python/manage_new_object.hpp>
+#include <boost/python/register_ptr_to_python.hpp>
+#include <boost/python/return_value_policy.hpp>
+
+using Mantid::Kernel::Property;
+using Mantid::PythonInterface::Registry::PropertyWithValueFactory;
+using namespace boost::python;
+
+// Empty class definition
+class PropertyFactory {};
+
+// Helper namespace
+namespace propertyFactoryHelper {
+
+// Helper function to remove unique pointer and return a raw pointer
+Property *removeUniquePointer(const std::string &name,
+ const boost::python::list &defaultValue) {
+
+ // Get the unique pointer from the factory and convert it into a raw pointer
+ auto ptr = PropertyWithValueFactory::createTimeSeries(name, defaultValue);
+
+ return ptr.release();
+}
+} // namespace propertyFactoryHelper
+
+// Export the PropertyFactory
+void export_PropertyFactory() {
+ class_<PropertyFactory, boost::noncopyable>("PropertyFactory", no_init)
+ .def("createTimeSeries", &propertyFactoryHelper::removeUniquePointer,
+ arg("log_name"), arg("log_values"),
+ return_value_policy<manage_new_object>())
+ .staticmethod("createTimeSeries");
+}
diff --git a/Framework/PythonInterface/mantid/kernel/src/Exports/TimeSeriesProperty.cpp b/Framework/PythonInterface/mantid/kernel/src/Exports/TimeSeriesProperty.cpp
index 1d279c71e452db4315d262945a3a96854af0d97e..747aa190f702724de5c4485c90762c2dbf92f1ab 100644
--- a/Framework/PythonInterface/mantid/kernel/src/Exports/TimeSeriesProperty.cpp
+++ b/Framework/PythonInterface/mantid/kernel/src/Exports/TimeSeriesProperty.cpp
@@ -42,6 +42,33 @@ template <typename TYPE> std::string dtype(TimeSeriesProperty<TYPE> &self) {
return Mantid::PythonInterface::Converters::dtype(self);
}
+// Check for the special case of a string
+template <> std::string dtype(TimeSeriesProperty<std::string> &self) {
+ // Vector of ints to store the sizes of each of the strings
+ std::vector<size_t> stringSizes;
+
+ // Block allocate memory
+ stringSizes.reserve(self.size());
+
+ // Loop for the number of strings in self
+ for (int i = 0; i < self.size(); i++) {
+ // For each string store the number of characters
+ std::string val = self.nthValue(i);
+ size_t size = val.size();
+ stringSizes.emplace_back(size);
+ }
+
+ // Find the maximum number of characters
+ size_t max =
+ *std::max_element(std::begin(stringSizes), std::end(stringSizes));
+
+ // Create the string to return
+ std::stringstream ss;
+ ss << "S" << max;
+ std::string retVal = ss.str();
+ return retVal;
+}
+
// Macro to reduce copy-and-paste
#define EXPORT_TIMESERIES_PROP(TYPE, Prefix) \
register_ptr_to_python<TimeSeriesProperty<TYPE> *>(); \
diff --git a/Framework/PythonInterface/mantid/kernel/src/Registry/PropertyWithValueFactory.cpp b/Framework/PythonInterface/mantid/kernel/src/Registry/PropertyWithValueFactory.cpp
index 6a36d5fb6d89133990ec0a228e18a44c4cef0c1b..eefac49393bcb5bcc3d8dd2540593ef904baba09 100644
--- a/Framework/PythonInterface/mantid/kernel/src/Registry/PropertyWithValueFactory.cpp
+++ b/Framework/PythonInterface/mantid/kernel/src/Registry/PropertyWithValueFactory.cpp
@@ -3,15 +3,27 @@
//-----------------------------------------------------------------------------
#include "MantidPythonInterface/kernel/Registry/PropertyWithValueFactory.h"
#include "MantidKernel/PropertyWithValue.h"
+#include "MantidKernel/TimeSeriesProperty.h"
#include "MantidKernel/WarningSuppressions.h"
#include "MantidPythonInterface/kernel/Registry/MappingTypeHandler.h"
#include "MantidPythonInterface/kernel/Registry/SequenceTypeHandler.h"
#include "MantidPythonInterface/kernel/Registry/TypedPropertyValueHandler.h"
#include <boost/make_shared.hpp>
+#include <boost/python.hpp>
+#include <boost/python/class.hpp>
+#include <boost/python/extract.hpp>
+#include <boost/python/list.hpp>
+#include <boost/python/object.hpp>
#include <cassert>
+using Mantid::Kernel::TimeSeriesProperty;
+using Mantid::PythonInterface::Registry::PropertyWithValueFactory;
+using namespace boost::python;
+using namespace Mantid::Kernel;
+using namespace Mantid::PythonInterface;
+
namespace Mantid {
namespace PythonInterface {
namespace Registry {
@@ -139,6 +151,42 @@ PropertyWithValueFactory::create(const std::string &name,
return create(name, defaultValue, validator, direction);
}
+/**
+ * Creates a TimeSeriesProperty<Type> instance from the given information.
+ * The python type is mapped to a C type
+ * @param name :: The name of the property
+ * @param defaultValue :: A default value for this property.
+ * @returns A pointer to a new Property object
+ */
+std::unique_ptr<Mantid::Kernel::Property>
+PropertyWithValueFactory::createTimeSeries(const std::string &name,
+ const list &defaultValue) {
+
+ // Use a PyObject pointer to determine the type stored in the list
+ auto obj = object(defaultValue[0]).ptr();
+ auto val = defaultValue[0];
+
+ /**
+ * Decide which kind of TimeSeriesProperty to return
+ * Need to use a different method to check for boolean values
+ * since extract<> seems to get confused sometimes.
+ */
+ if (PyBool_Check(obj)) {
+ return Mantid::Kernel::make_unique<TimeSeriesProperty<bool>>(name);
+ } else if (extract<int>(val).check()) {
+ return Mantid::Kernel::make_unique<TimeSeriesProperty<int>>(name);
+ } else if (extract<double>(val).check()) {
+ return Mantid::Kernel::make_unique<TimeSeriesProperty<double>>(name);
+ } else if (extract<std::string>(val).check()) {
+ return Mantid::Kernel::make_unique<TimeSeriesProperty<std::string>>(name);
+ }
+
+ // If we reach here an error has occurred as there are no type to create
+ // a TimeSeriesProperty from
+ throw std::runtime_error(
+ "Cannot create a TimeSeriesProperty with that data type!");
+}
+
//-------------------------------------------------------------------------
// Private methods
//-------------------------------------------------------------------------
diff --git a/Framework/PythonInterface/plugins/algorithms/AlignAndFocusPowderFromFiles.py b/Framework/PythonInterface/plugins/algorithms/AlignAndFocusPowderFromFiles.py
index 11b3ee7637f8cabc129c2b0feac6254c94db330c..d5a49964a6e5cbc0ff68edb4d15cbb32e7081b10 100644
--- a/Framework/PythonInterface/plugins/algorithms/AlignAndFocusPowderFromFiles.py
+++ b/Framework/PythonInterface/plugins/algorithms/AlignAndFocusPowderFromFiles.py
@@ -17,8 +17,8 @@ PROPS_FOR_ALIGN = [CAL_FILE, GROUP_FILE,
MASK_WKSP, "MaskBinTable",
"Params", "ResampleX", "Dspacing", "DMin", "DMax",
"TMin", "TMax", "PreserveEvents",
- "RemovePromptPulseWidth", "CompressTolerance",
- "UnwrapRef", "LowResRef",
+ "RemovePromptPulseWidth", "CompressTolerance", "CompressWallClockTolerance",
+ "CompressStartTime", "UnwrapRef", "LowResRef",
"CropWavelengthMin", "CropWavelengthMax",
"LowResSpectrumOffset", "ReductionProperties"]
PROPS_FOR_ALIGN.extend(PROPS_FOR_INSTR)
diff --git a/Framework/PythonInterface/plugins/algorithms/ExportSampleLogsToHDF5.py b/Framework/PythonInterface/plugins/algorithms/ExportSampleLogsToHDF5.py
index 4c5cbe388fedbb14f45b08449d7b28fa0508ef32..ef85ddedc9e768949b794ea9ada787b5d5666290 100644
--- a/Framework/PythonInterface/plugins/algorithms/ExportSampleLogsToHDF5.py
+++ b/Framework/PythonInterface/plugins/algorithms/ExportSampleLogsToHDF5.py
@@ -49,7 +49,7 @@ class ExportSampleLogsToHDF5(PythonAlgorithm):
if prop.name not in blacklist and not self._ignore_property(prop)]
for log_property in log_properties:
- property_dtype = self._dtype_from_property_type(log_property)
+ property_dtype = log_property.dtype()
log_value = self._get_value_from_property(log_property)
if log_value is None:
continue
@@ -58,18 +58,6 @@ class ExportSampleLogsToHDF5(PythonAlgorithm):
data=[log_value])
log_dataset.attrs["Units"] = log_property.units
- def _dtype_from_property_type(self, prop):
- if isinstance(prop, (FloatPropertyWithValue, FloatTimeSeriesProperty, FloatArrayProperty)):
- return "f"
- if isinstance(prop, (IntPropertyWithValue, Int32TimeSeriesProperty, Int64TimeSeriesProperty)):
- return "i"
- if isinstance(prop, (BoolPropertyWithValue, BoolTimeSeriesProperty)):
- return "b"
- if isinstance(prop, StringPropertyWithValue):
- return "S{}".format(len(prop.value))
- raise RuntimeError("Unrecognised property type: \"{}\". Please contact the development team with this message".
- format(prop.type))
-
def _get_value_from_property(self, prop):
if isinstance(prop, FloatArrayProperty):
if len(prop.value) > 0:
diff --git a/Framework/PythonInterface/plugins/algorithms/LRScalingFactors.py b/Framework/PythonInterface/plugins/algorithms/LRScalingFactors.py
index 85432d320798cf24b808636fe26af8c4171ccd66..236e92d55103eaeade54e4c54180d3c5918da1be 100644
--- a/Framework/PythonInterface/plugins/algorithms/LRScalingFactors.py
+++ b/Framework/PythonInterface/plugins/algorithms/LRScalingFactors.py
@@ -63,7 +63,9 @@ class LRScalingFactors(PythonAlgorithm):
"Pixel range defining the data peak")
self.declareProperty(IntArrayProperty("SignalBackgroundPixelRange", [147, 163]),
"Pixel range defining the background")
- self.declareProperty(IntArrayProperty("LowResolutionPixelRange", [94, 160]),
+ self.declareProperty(IntArrayProperty("LowResolutionPixelRange",
+ [Property.EMPTY_INT, Property.EMPTY_INT],
+ direction=Direction.Input),
"Pixel range defining the region to use in the low-resolution direction")
self.declareProperty("IncidentMedium", "Medium", doc="Name of the incident medium")
self.declareProperty("FrontSlitName", "S1", doc="Name of the front slit")
@@ -454,6 +456,12 @@ class LRScalingFactors(PythonAlgorithm):
@param background_range: range of pixels defining the background
@param low_res_range: range of pixels in the x-direction
"""
+ # Check low-res axis
+ if low_res_range[0] == Property.EMPTY_INT:
+ low_res_range[0] = 0
+ if low_res_range[1] == Property.EMPTY_INT:
+ low_res_range[1] = int(workspace.getInstrument().getNumberParameter("number-of-x-pixels")[0])-1
+
# Rebin TOF axis
tof_range = self.getProperty("TOFRange").value
tof_step = self.getProperty("TOFSteps").value
diff --git a/Framework/PythonInterface/plugins/algorithms/OrderWorkspaceHistory.py b/Framework/PythonInterface/plugins/algorithms/OrderWorkspaceHistory.py
index 001cf2af382826b3d1b7561abac6d8a8d665534d..c7b67819f037f8c06172bfeb2f98ed5842898463 100644
--- a/Framework/PythonInterface/plugins/algorithms/OrderWorkspaceHistory.py
+++ b/Framework/PythonInterface/plugins/algorithms/OrderWorkspaceHistory.py
@@ -1,7 +1,8 @@
from __future__ import absolute_import, division, print_function
-import datetime
import os
+import tokenize
+import glob
import mantid.api
import mantid.kernel
@@ -37,70 +38,40 @@ class OrderWorkspaceHistory(mantid.api.PythonAlgorithm):
return dict()
def PyExec(self):
- self.write_ordered_workspace_history()
-
- def _concatenate_iso_datetime(self, date_time):
- '''
- Concatenates the datetime string provided by Mantid into a single integer
- Args:
- date_time: ISO 8601 standard datetime string
- Returns:
- int
- '''
-
- if not date_time:
- raise ValueError("No date time stamp was found in the recovery history")
- self.log().debug("Found datetime stamp: {0}".format(date_time))
-
- # Remove whitespace and any trailing zeros
- stipped_time = date_time.strip().rstrip('0')
- return datetime.datetime.strptime(stipped_time, "%Y-%m-%dT%H:%M:%S.%f")
-
- def write_ordered_workspace_history(self):
- self.log().debug("Started saving workspace histories")
- source_folder = self.getPropertyValue(_recovery_folder)
-
- # Get list of all workspace histories
- onlyfiles = [f for f in os.listdir(source_folder)
- if os.path.isfile(os.path.join(source_folder, f))]
- historyfiles = [x for x in onlyfiles if x.endswith('.py')]
-
- self.log().debug("Found {0} history files".format(len(historyfiles)))
-
- # Read each history in as a list of tuples
- original_lines = set()
- for infile in historyfiles:
- with open(os.path.join(source_folder, infile), 'r') as f:
- for line in f:
- original_lines.add(line)
-
- commands = []
- # Remove any comment lines
- for line in original_lines:
- stripped_line = line.lstrip()
- if stripped_line[0] is not '#':
- commands.append(stripped_line)
-
- self.log().debug("Found {0} unique commands".format(len(commands)))
-
- # Add lists of histories together
- all_unique_commands = [command.strip().split('#') for command in commands]
-
- # Convert the datetime into a sortable integer
- all_unique_commands = [(i[0], self._concatenate_iso_datetime(i[1]))
- for i in all_unique_commands]
-
- # Sort the new list on datetime integer
- all_unique_commands.sort(key=lambda time: (time[1]))
+
+ all_lines = []
+
+ for fn in glob.iglob(os.path.join(self.getPropertyValue(_recovery_folder), '*.py')):
+ with open(fn) as f:
+ tokens = tokenize.generate_tokens(f.readline)
+ line = None
+ for t in tokens:
+ # Start a new line when we see a name
+ if line is None and t[0] == tokenize.NAME:
+ line = [t]
+ # End the line when we see a logical line ending
+ elif t[0] == tokenize.NEWLINE:
+ # Only care about the line if it has a comment
+ have_comment = any(x[0] == tokenize.COMMENT for x in line)
+ if have_comment:
+ # line[-1][1][1:] is the comment string, with the preceeding hash stripped off;
+ # line[0][4] is the command and the comment
+ all_lines.append((line[-1][4], line[-1][1][1:]))
+ line = []
+ # Everything in between we care about
+ elif line is not None:
+ line.append(t)
+
+ # Cast as a set to remove duplicates
+ unique_lines = list(set(all_lines))
+ # Sort according to time
+ unique_lines.sort(key=lambda time: (time[1]))
destination = self.getPropertyValue(_destination_file)
- self.log().debug("Writing commands to file")
- # Write to file
with open(destination, 'w') as outfile:
- for x in all_unique_commands:
- outfile.write('{} # {} \n'.format(x[0], x[1]))
-
+ for x in unique_lines:
+ outfile.write(x[0])
# Required to have Mantid recognise the new function
mantid.api.AlgorithmFactory.subscribe(OrderWorkspaceHistory)
diff --git a/Framework/PythonInterface/plugins/algorithms/SortXAxis.py b/Framework/PythonInterface/plugins/algorithms/SortXAxis.py
deleted file mode 100644
index 41c8dd04224f554cc2d14ed84e24dd741edff6a2..0000000000000000000000000000000000000000
--- a/Framework/PythonInterface/plugins/algorithms/SortXAxis.py
+++ /dev/null
@@ -1,78 +0,0 @@
-#pylint: disable=no-init,invalid-name
-from __future__ import (absolute_import, division, print_function)
-
-from mantid.api import AlgorithmFactory, MatrixWorkspaceProperty, PythonAlgorithm
-from mantid.kernel import Direction, StringListValidator
-import numpy as np
-
-
-class SortXAxis(PythonAlgorithm):
-
- def category(self):
- return "Transforms\\Axes;Utility\\Sorting"
-
- def seeAlso(self):
- return [ "SortDetectors" ]
-
- def name(self):
- return "SortXAxis"
-
- def summary(self):
- return "Clones the input MatrixWorkspace(s) and orders the x-axis in an ascending fashion."
-
- def PyInit(self):
- self.declareProperty(MatrixWorkspaceProperty("InputWorkspace", defaultValue="", direction=Direction.Input),
- doc="Input workspace")
- self.declareProperty(MatrixWorkspaceProperty("OutputWorkspace", defaultValue="", direction=Direction.Output),
- doc="Sorted Output Workspace")
- self.declareProperty("Ordering",
- defaultValue="Ascending",
- validator=StringListValidator(["Ascending", "Descending"]),
- direction=Direction.Input,
- doc="Ascending or descending sorting")
-
- def PyExec(self):
- input_ws = self.getProperty('InputWorkspace').value
- output_ws = self.getPropertyValue('OutputWorkspace')
-
- num_specs = input_ws.getNumberHistograms()
-
- clone_alg = self.createChildAlgorithm("CloneWorkspace", enableLogging=False)
- clone_alg.setProperty("InputWorkspace", input_ws)
- clone_alg.setProperty("OutputWorkspace", output_ws)
- clone_alg.execute()
- output_ws = clone_alg.getProperty("OutputWorkspace").value
-
- for i in range(0, num_specs):
- x_data = input_ws.readX(i)
- y_data = input_ws.readY(i)
- e_data = input_ws.readE(i)
-
- indexes = x_data.argsort()
-
- if self.getPropertyValue("Ordering") == "Descending":
- self.log().information("Sort descending")
- indexes = indexes[::-1]
-
- x_ordered = x_data[indexes]
-
- if input_ws.isHistogramData():
- max_index = np.argmax(indexes)
- indexes = np.delete(indexes, max_index)
-
- y_ordered = y_data[indexes]
- e_ordered = e_data[indexes]
-
- output_ws.setX(i, x_ordered)
- output_ws.setY(i, y_ordered)
- output_ws.setE(i, e_ordered)
-
- if input_ws.hasDx(i):
- dx = input_ws.readDx(i)
- dx_ordered = dx[indexes]
- output_ws.setDx(i, dx_ordered)
-
- self.setProperty('OutputWorkspace', output_ws)
-
-
-AlgorithmFactory.subscribe(SortXAxis)
diff --git a/Framework/PythonInterface/plugins/algorithms/WorkflowAlgorithms/LoadWAND.py b/Framework/PythonInterface/plugins/algorithms/WorkflowAlgorithms/LoadWAND.py
index f4f9aa7578416a6d32915769490f87d8f863ea35..101c8126ab11f88e8380e370218ffe633221f4e5 100644
--- a/Framework/PythonInterface/plugins/algorithms/WorkflowAlgorithms/LoadWAND.py
+++ b/Framework/PythonInterface/plugins/algorithms/WorkflowAlgorithms/LoadWAND.py
@@ -1,9 +1,11 @@
from __future__ import absolute_import, division, print_function
from mantid.api import DataProcessorAlgorithm, AlgorithmFactory, MultipleFileProperty, FileAction, WorkspaceProperty
-from mantid.kernel import Direction, UnitConversion, Elastic, Property, IntArrayProperty
-from mantid.simpleapi import (LoadEventNexus, Integration, mtd, SetGoniometer, DeleteWorkspace, AddSampleLog,
- MaskBTP, RenameWorkspace, GroupWorkspaces)
+from mantid.kernel import Direction, UnitConversion, Elastic, Property, IntArrayProperty, StringListValidator
+from mantid.simpleapi import (mtd, SetGoniometer, AddSampleLog, MaskBTP, RenameWorkspace, GroupWorkspaces,
+ CreateWorkspace, LoadNexusLogs, LoadInstrument)
from six.moves import range
+import numpy as np
+import h5py
class LoadWAND(DataProcessorAlgorithm):
@@ -22,6 +24,7 @@ class LoadWAND(DataProcessorAlgorithm):
self.declareProperty(IntArrayProperty("RunNumbers", []), 'Run numbers to load')
self.declareProperty("Wavelength", 1.488, doc="Wavelength to set the workspace")
self.declareProperty("ApplyMask", True, "If True standard masking will be applied to the workspace")
+ self.declareProperty("Grouping", 'None', StringListValidator(['None', '2x2', '4x4']), "Group pixels")
self.declareProperty(WorkspaceProperty(name="OutputWorkspace", defaultValue="", direction=Direction.Output))
def validateInputs(self):
@@ -44,11 +47,59 @@ class LoadWAND(DataProcessorAlgorithm):
outWS = self.getPropertyValue("OutputWorkspace")
group_names = []
+ grouping = self.getProperty("Grouping").value
+ if grouping == 'None':
+ grouping = 1
+ else:
+ grouping = 2 if grouping == '2x2' else 4
+
for i, run in enumerate(runs):
- LoadEventNexus(Filename=run, OutputWorkspace='__tmp_load', LoadMonitors=True, EnableLogging=False,
- startProgress=i/len(runs), endProgress=(i+0.8)/len(runs))
- Integration(InputWorkspace='__tmp_load', OutputWorkspace='__tmp_load', EnableLogging=False,
- startProgress=(i+0.8)/len(runs), endProgress=(i+1)/len(runs))
+ data = np.zeros((512*480*8),dtype=np.int64)
+ with h5py.File(run, 'r') as f:
+ monitor_count = f['/entry/monitor1/total_counts'].value[0]
+ run_number = f['/entry/run_number'].value[0]
+ for b in range(8):
+ data += np.bincount(f['/entry/bank'+str(b+1)+'_events/event_id'].value,minlength=512*480*8)
+ data = data.reshape((480*8, 512))
+ if grouping == 2:
+ data = data[::2,::2] + data[1::2,::2] + data[::2,1::2] + data[1::2,1::2]
+ elif grouping == 4:
+ data = (data[::4,::4] + data[1::4,::4] + data[2::4,::4] + data[3::4,::4]
+ + data[::4,1::4] + data[1::4,1::4] + data[2::4,1::4] + data[3::4,1::4]
+ + data[::4,2::4] + data[1::4,2::4] + data[2::4,2::4] + data[3::4,2::4]
+ + data[::4,3::4] + data[1::4,3::4] + data[2::4,3::4] + data[3::4,3::4])
+
+ CreateWorkspace(DataX=[wavelength-0.001, wavelength+0.001],
+ DataY=data,
+ DataE=np.sqrt(data),
+ UnitX='Wavelength',
+ YUnitLabel='Counts',
+ NSpec=1966080//grouping**2,
+ OutputWorkspace='__tmp_load', EnableLogging=False)
+ LoadNexusLogs('__tmp_load', Filename=run, EnableLogging=False)
+ AddSampleLog('__tmp_load', LogName="monitor_count", LogType='Number', NumberType='Double',
+ LogText=str(monitor_count), EnableLogging=False)
+ AddSampleLog('__tmp_load', LogName="gd_prtn_chrg", LogType='Number', NumberType='Double',
+ LogText=str(monitor_count), EnableLogging=False)
+ AddSampleLog('__tmp_load', LogName="Wavelength", LogType='Number', NumberType='Double',
+ LogText=str(wavelength), EnableLogging=False)
+ AddSampleLog('__tmp_load', LogName="Ei", LogType='Number', NumberType='Double',
+ LogText=str(UnitConversion.run('Wavelength', 'Energy', wavelength, 0, 0, 0, Elastic, 0)), EnableLogging=False)
+ AddSampleLog('__tmp_load', LogName="run_number", LogText=run_number, EnableLogging=False)
+
+ if grouping > 1: # Fix detector IDs per spectrum before loading instrument
+ __tmp_load = mtd['__tmp_load']
+ for n in range(__tmp_load.getNumberHistograms()):
+ s=__tmp_load.getSpectrum(n)
+ for i in range(grouping):
+ for j in range(grouping):
+ s.addDetectorID(int(n*grouping%512 + n//(512/grouping)*512*grouping + j + i*512))
+
+ LoadInstrument('__tmp_load', InstrumentName='WAND', RewriteSpectraMap=False, EnableLogging=False)
+ else:
+ LoadInstrument('__tmp_load', InstrumentName='WAND', RewriteSpectraMap=True, EnableLogging=False)
+
+ SetGoniometer('__tmp_load', Axis0="HB2C:Mot:s1,0,1,0,1", EnableLogging=False)
if self.getProperty("ApplyMask").value:
MaskBTP('__tmp_load', Pixel='1,2,511,512', EnableLogging=False)
@@ -58,20 +109,6 @@ class LoadWAND(DataProcessorAlgorithm):
else:
MaskBTP('__tmp_load', Bank='8', Tube='475-480', EnableLogging=False)
- mtd['__tmp_load'].getAxis(0).setUnit("Wavelength")
- w = [wavelength-0.001, wavelength+0.001]
- for idx in range(mtd['__tmp_load'].getNumberHistograms()):
- mtd['__tmp_load'].setX(idx, w)
-
- SetGoniometer('__tmp_load', Axis0="HB2C:Mot:s1,0,1,0,1", EnableLogging=False)
- AddSampleLog('__tmp_load', LogName="gd_prtn_chrg", LogType='Number', NumberType='Double',
- LogText=str(mtd['__tmp_load'+'_monitors'].getNumberEvents()), EnableLogging=False)
- DeleteWorkspace('__tmp_load'+'_monitors', EnableLogging=False)
-
- AddSampleLog('__tmp_load', LogName="Wavelength", LogType='Number', NumberType='Double',
- LogText=str(wavelength), EnableLogging=False)
- AddSampleLog('__tmp_load', LogName="Ei", LogType='Number', NumberType='Double',
- LogText=str(UnitConversion.run('Wavelength', 'Energy', wavelength, 0, 0, 0, Elastic, 0)), EnableLogging=False)
if len(runs) == 1:
RenameWorkspace('__tmp_load', outWS, EnableLogging=False)
else:
diff --git a/Framework/PythonInterface/plugins/algorithms/WorkflowAlgorithms/WANDPowderReduction.py b/Framework/PythonInterface/plugins/algorithms/WorkflowAlgorithms/WANDPowderReduction.py
index 2cc9e8cbf5c7ad07415e90c0395cd056b45391df..d0a59e59c21cdeae92f0b9b19b32d70dd6be0b98 100644
--- a/Framework/PythonInterface/plugins/algorithms/WorkflowAlgorithms/WANDPowderReduction.py
+++ b/Framework/PythonInterface/plugins/algorithms/WorkflowAlgorithms/WANDPowderReduction.py
@@ -1,11 +1,13 @@
from __future__ import absolute_import, division, print_function
from mantid.api import (DataProcessorAlgorithm, AlgorithmFactory,
MatrixWorkspaceProperty, PropertyMode)
+from mantid.dataobjects import MaskWorkspaceProperty
from mantid.simpleapi import (ConvertSpectrumAxis, Transpose,
ResampleX, CopyInstrumentParameters,
Divide, DeleteWorkspace, Scale,
MaskAngle, ExtractMask, Minus,
- RemoveMaskedSpectra, mtd)
+ ExtractUnmaskedSpectra, mtd,
+ BinaryOperateMasks)
from mantid.kernel import StringListValidator, Direction, Property, FloatBoundedValidator
@@ -48,6 +50,11 @@ class WANDPowderReduction(DataProcessorAlgorithm):
validator=FloatBoundedValidator(0.0),
doc="The background will be scaled by this number before being subtracted.")
+ self.declareProperty(MaskWorkspaceProperty("MaskWorkspace", '',
+ optional=PropertyMode.Optional,
+ direction=Direction.Input),
+ doc='The mask from this workspace will be applied before reduction')
+
self.copyProperties('ConvertSpectrumAxis', ['Target', 'EFixed'])
self.copyProperties('ResampleX', ['XMin', 'XMax', 'NumberBins', 'LogBinning'])
@@ -65,6 +72,7 @@ class WANDPowderReduction(DataProcessorAlgorithm):
data = self.getProperty("InputWorkspace").value
cal = self.getProperty("CalibrationWorkspace").value
bkg = self.getProperty("BackgroundWorkspace").value
+ mask = self.getProperty("MaskWorkspace").value
target = self.getProperty("Target").value
eFixed = self.getProperty("EFixed").value
xMin = self.getProperty("XMin").value
@@ -88,13 +96,17 @@ class WANDPowderReduction(DataProcessorAlgorithm):
if maskAngle != Property.EMPTY_DBL:
MaskAngle(Workspace='__mask_tmp', MinAngle=maskAngle, Angle='Phi', EnableLogging=False)
- RemoveMaskedSpectra(InputWorkspace=data, MaskedWorkspace='__mask_tmp', OutputWorkspace='__data_tmp', EnableLogging=False)
+ if mask is not None:
+ BinaryOperateMasks(InputWorkspace1='__mask_tmp', InputWorkspace2=mask,
+ OperationType='OR', OutputWorkspace='__mask_tmp', EnableLogging=False)
+
+ ExtractUnmaskedSpectra(InputWorkspace=data, MaskWorkspace='__mask_tmp', OutputWorkspace='__data_tmp', EnableLogging=False)
ConvertSpectrumAxis(InputWorkspace='__data_tmp', Target=target, EFixed=eFixed, OutputWorkspace=outWS, EnableLogging=False)
Transpose(InputWorkspace=outWS, OutputWorkspace=outWS, EnableLogging=False)
ResampleX(InputWorkspace=outWS, OutputWorkspace=outWS, XMin=xMin, XMax=xMax, NumberBins=numberBins, EnableLogging=False)
if cal is not None:
- RemoveMaskedSpectra(InputWorkspace=cal, MaskedWorkspace='__mask_tmp', OutputWorkspace='__cal_tmp', EnableLogging=False)
+ ExtractUnmaskedSpectra(InputWorkspace=cal, MaskWorkspace='__mask_tmp', OutputWorkspace='__cal_tmp', EnableLogging=False)
CopyInstrumentParameters(data, '__cal_tmp', EnableLogging=False)
ConvertSpectrumAxis(InputWorkspace='__cal_tmp', Target=target, EFixed=eFixed, OutputWorkspace='__cal_tmp', EnableLogging=False)
Transpose(InputWorkspace='__cal_tmp', OutputWorkspace='__cal_tmp', EnableLogging=False)
@@ -109,7 +121,7 @@ class WANDPowderReduction(DataProcessorAlgorithm):
Scale(InputWorkspace=outWS, OutputWorkspace=outWS, Factor=cal_scale/data_scale, EnableLogging=False)
if bkg is not None:
- RemoveMaskedSpectra(InputWorkspace=bkg, MaskedWorkspace='__mask_tmp', OutputWorkspace='__bkg_tmp', EnableLogging=False)
+ ExtractUnmaskedSpectra(InputWorkspace=bkg, MaskWorkspace='__mask_tmp', OutputWorkspace='__bkg_tmp', EnableLogging=False)
CopyInstrumentParameters(data, '__bkg_tmp', EnableLogging=False)
ConvertSpectrumAxis(InputWorkspace='__bkg_tmp', Target=target, EFixed=eFixed, OutputWorkspace='__bkg_tmp', EnableLogging=False)
Transpose(InputWorkspace='__bkg_tmp', OutputWorkspace='__bkg_tmp', EnableLogging=False)
diff --git a/Framework/PythonInterface/test/cpp/CMakeLists.txt b/Framework/PythonInterface/test/cpp/CMakeLists.txt
index 4217fafedc9fa796a7aa94e911e71c7ffec481ef..86c0bb1b595b3b63fa4b9a4a89f7a7c64885da7e 100644
--- a/Framework/PythonInterface/test/cpp/CMakeLists.txt
+++ b/Framework/PythonInterface/test/cpp/CMakeLists.txt
@@ -8,6 +8,7 @@ set ( TEST_FILES
PythonAlgorithmInstantiatorTest.h
PySequenceToVectorTest.h
RunPythonScriptTest.h
+ ToPyListTest.h
)
if ( CXXTEST_FOUND )
diff --git a/Framework/PythonInterface/test/cpp/PySequenceToVectorTest.h b/Framework/PythonInterface/test/cpp/PySequenceToVectorTest.h
index 960d64327e1cd9c8064f13ab3c92065c4ccac304..f342d8d5b46222d6e366b8d354c1cd7a225ac69d 100644
--- a/Framework/PythonInterface/test/cpp/PySequenceToVectorTest.h
+++ b/Framework/PythonInterface/test/cpp/PySequenceToVectorTest.h
@@ -20,6 +20,8 @@ private:
using PySequenceToVectorDouble = PySequenceToVector<double>;
public:
+ void tearDown() override { PyErr_Clear(); }
+
void test_construction_succeeds_with_a_valid_sequence_type() {
boost::python::list testList;
TS_ASSERT_THROWS_NOTHING(PySequenceToVectorDouble converter(testList));
diff --git a/Framework/PythonInterface/test/cpp/ToPyListTest.h b/Framework/PythonInterface/test/cpp/ToPyListTest.h
new file mode 100644
index 0000000000000000000000000000000000000000..bbf707a0c677b7388529c12fca70d4e4f4073a05
--- /dev/null
+++ b/Framework/PythonInterface/test/cpp/ToPyListTest.h
@@ -0,0 +1,34 @@
+#ifndef MANTID_PYTHONINTERFACE_TOPYLISTTEST_H
+#define MANTID_PYTHONINTERFACE_TOPYLISTTEST_H
+
+#include "MantidPythonInterface/kernel/Converters/ToPyList.h"
+#include <boost/python/errors.hpp>
+#include <cxxtest/TestSuite.h>
+
+using namespace Mantid::PythonInterface::Converters;
+
+class ToPyListTest : public CxxTest::TestSuite {
+public:
+ static ToPyListTest *createSuite() { return new ToPyListTest(); }
+ static void destroySuite(ToPyListTest *suite) { delete suite; }
+
+ using ToPyListVectorDouble = ToPyList<double>;
+
+ void test_empty_vector_returns_empty_list() {
+ std::vector<double> empty;
+ boost::python::list result;
+ TS_ASSERT_THROWS_NOTHING(result = ToPyListVectorDouble()(empty));
+ TS_ASSERT_EQUALS(0, boost::python::len(result));
+ }
+
+ void test_unregistered_element_type_throws_runtime_error() {
+ std::vector<UnregisteredType> unknownElements{UnregisteredType()};
+ TS_ASSERT_THROWS(ToPyList<UnregisteredType>()(unknownElements),
+ boost::python::error_already_set);
+ }
+
+private:
+ struct UnregisteredType {};
+};
+
+#endif // MANTID_PYTHONINTERFACE_TOPYLISTTEST_H
diff --git a/Framework/PythonInterface/test/python/mantid/api/AnalysisDataServiceTest.py b/Framework/PythonInterface/test/python/mantid/api/AnalysisDataServiceTest.py
index 5512b949bd0e3c61a6d1e51fa46f2360e8ec5d2d..a53af1a6bf4f2f3f02c24726048109c52c0f750c 100644
--- a/Framework/PythonInterface/test/python/mantid/api/AnalysisDataServiceTest.py
+++ b/Framework/PythonInterface/test/python/mantid/api/AnalysisDataServiceTest.py
@@ -7,6 +7,9 @@ from mantid import mtd
class AnalysisDataServiceTest(unittest.TestCase):
+ def tearDown(self):
+ AnalysisDataService.Instance().clear()
+
def test_len_returns_correct_value(self):
self.assertEquals(len(AnalysisDataService), 0)
@@ -34,8 +37,6 @@ class AnalysisDataServiceTest(unittest.TestCase):
current_len = len(AnalysisDataService)
self._run_createws(wsname)
self.assertEquals(len(AnalysisDataService), current_len + 1)
- # Remove to clean the test up
- AnalysisDataService.remove(wsname)
def test_len_decreases_when_item_removed(self):
wsname = 'ADSTest_test_len_decreases_when_item_removed'
@@ -52,7 +53,6 @@ class AnalysisDataServiceTest(unittest.TestCase):
ws = alg.getProperty("OutputWorkspace").value
AnalysisDataService.addOrReplace(name, ws)
self.assertRaises(RuntimeError, AnalysisDataService.add, name, ws)
- AnalysisDataService.remove(name)
def test_addOrReplace_replaces_workspace_with_existing_name(self):
data = [1.0,2.0,3.0]
@@ -64,7 +64,6 @@ class AnalysisDataServiceTest(unittest.TestCase):
AnalysisDataService.addOrReplace(name, ws)
len_after = len(AnalysisDataService)
self.assertEquals(len_after, len_before)
- AnalysisDataService.remove(name)
def do_check_for_matrix_workspace_type(self, workspace):
self.assertTrue(isinstance(workspace, MatrixWorkspace))
@@ -72,12 +71,10 @@ class AnalysisDataServiceTest(unittest.TestCase):
self.assertTrue(hasattr(workspace, 'getNumberHistograms'))
self.assertTrue(hasattr(workspace, 'getMemorySize'))
-
def test_retrieve_gives_back_derived_type_not_DataItem(self):
wsname = 'ADSTest_test_retrieve_gives_back_derived_type_not_DataItem'
self._run_createws(wsname)
self.do_check_for_matrix_workspace_type(AnalysisDataService.retrieve(wsname))
- AnalysisDataService.remove(wsname)
def test_key_operator_does_same_as_retrieve(self):
wsname = 'ADSTest_test_key_operator_does_same_as_retrieve'
@@ -91,8 +88,25 @@ class AnalysisDataServiceTest(unittest.TestCase):
self.assertEquals(ws_from_op.name(), ws_from_method.name())
self.assertEquals(ws_from_op.getMemorySize(), ws_from_method.getMemorySize())
- # Remove to clean the test up
- AnalysisDataService.remove(wsname)
+ def test_retrieve_workspaces_respects_default_not_unrolling_groups(self):
+ ws_names = ["test_retrieve_workspaces_1", "test_retrieve_workspaces_2"]
+ for name in ws_names:
+ self._run_createws(name)
+ workspaces = AnalysisDataService.retrieveWorkspaces(ws_names)
+ self.assertEquals(2, len(workspaces))
+
+ def test_retrieve_workspaces_accepts_unrolling_groups_argument(self):
+ ws_names = ["test_retrieve_workspaces_1", "test_retrieve_workspaces_2"]
+ for name in ws_names:
+ self._run_createws(name)
+ group_name = 'group1'
+ alg = run_algorithm('GroupWorkspaces', InputWorkspaces=ws_names,
+ OutputWorkspace=group_name)
+
+ workspaces = AnalysisDataService.retrieveWorkspaces([group_name], True)
+ self.assertEquals(2, len(workspaces))
+ self.assertTrue(isinstance(workspaces[0], MatrixWorkspace))
+ self.assertTrue(isinstance(workspaces[1], MatrixWorkspace))
def test_removing_item_invalidates_extracted_handles(self):
# If a reference to a DataItem has been extracted from the ADS
diff --git a/Framework/PythonInterface/test/python/mantid/api/SampleTest.py b/Framework/PythonInterface/test/python/mantid/api/SampleTest.py
index 9a6e0ccdaa1406861343da32e1a07f0accd0f819..307b28b954bf34180ced14bd2c256358d310f9ee 100644
--- a/Framework/PythonInterface/test/python/mantid/api/SampleTest.py
+++ b/Framework/PythonInterface/test/python/mantid/api/SampleTest.py
@@ -5,6 +5,7 @@ from mantid.api import Sample
from mantid.simpleapi import CreateWorkspace
from mantid.simpleapi import SetSampleMaterial
from mantid.geometry import CrystalStructure
+from mantid.geometry import CSGObject
class SampleTest(unittest.TestCase):
@@ -67,6 +68,17 @@ class SampleTest(unittest.TestCase):
xs = ( xs0['coh_scatt_xs']*2 + xs1['coh_scatt_xs']*3 ) / 5
self.assertAlmostEquals(material.cohScatterXSection(), xs, places=4)
+ def test_get_shape(self):
+ sample = self._ws.sample()
+ self.assertEquals(type(sample.getShape()), CSGObject)
+
+ def test_get_shape_xml(self):
+ sample = self._ws.sample()
+ shape = sample.getShape()
+ xml = shape.getShapeXML()
+ self.assertEquals(type(xml), str)
+
+
if __name__ == '__main__':
diff --git a/Framework/PythonInterface/test/python/mantid/api/SpectrumInfoTest.py b/Framework/PythonInterface/test/python/mantid/api/SpectrumInfoTest.py
index 920386145e0c2366b3d724c2b16ac535edd81575..303f6e9fb0d079703cba9b85388bd94b7d763736 100644
--- a/Framework/PythonInterface/test/python/mantid/api/SpectrumInfoTest.py
+++ b/Framework/PythonInterface/test/python/mantid/api/SpectrumInfoTest.py
@@ -2,24 +2,306 @@ from __future__ import (absolute_import, division, print_function)
import unittest
from testhelpers import WorkspaceCreationHelper
+from mantid.kernel import V3D
+from mantid.api import SpectrumDefinition
class SpectrumInfoTest(unittest.TestCase):
_ws = None
def setUp(self):
+ """ Set up code. """
if self.__class__._ws is None:
self.__class__._ws = WorkspaceCreationHelper.create2DWorkspaceWithFullInstrument(2, 1, False) # no monitors
self.__class__._ws.getSpectrum(0).clearDetectorIDs()
+ """
+ ----------------------------------------------------------------------------
+ Normal Tests
+ ----------------------------------------------------------------------------
+ The following test cases test normal usage of the exposed methods.
+ """
+
+ def test_len(self):
+ """ Check that the number of spectra we initailly created
+ is the same as in memory. """
+ info = self._ws.spectrumInfo()
+ self.assertEquals(len(info), 2)
+
+ def test_size(self):
+ """ Check that the number of spectra we initailly created
+ is the same as in memory. """
+ info = self._ws.spectrumInfo()
+ self.assertEquals(info.size(), 2)
+
+ def test_isMonitor(self):
+ """ Check if a monitor is present. """
+ info = self._ws.spectrumInfo()
+ self.assertEquals(info.isMonitor(1), False)
+
+ def test_isMasked(self):
+ """ Check if the detector is masked. """
+ info = self._ws.spectrumInfo()
+ self.assertEquals(info.isMasked(1), False)
+
+ def test_setMaskedTrue(self):
+ """ Test that the detector's masking can be set to True. """
+ info = self._ws.spectrumInfo()
+ info.setMasked(1, True)
+ self.assertEquals(info.isMasked(1), True)
+
+ def test_setMaskedFalse(self):
+ """ Test that the detector's masking can be set to False. """
+ info = self._ws.spectrumInfo()
+ info.setMasked(1, False)
+ self.assertEquals(info.isMasked(1), False)
+
+ def test_twoTheta(self):
+ """ See if the returned value is a double (float in Python). """
+ info = self._ws.spectrumInfo()
+ self.assertEquals(type(info.twoTheta(1)), float)
+
+ def test_signedTwoTheta(self):
+ """ See if the returned value is a double (float in Python). """
+ info = self._ws.spectrumInfo()
+ self.assertEquals(type(info.signedTwoTheta(1)), float)
+
+ def test_l1(self):
+ """ Check if a distance is returned (source to sample). """
+ info = self._ws.spectrumInfo()
+ self.assertEquals(type(info.l1()), float)
+
+ def test_l2(self):
+ """ Check if a distance is returned (sample to spectrum). """
+ info = self._ws.spectrumInfo()
+ self.assertEquals(type(info.l2(1)), float)
+
def test_hasDetectors(self):
+ """ Check to see which spectrum has detectors. """
info = self._ws.spectrumInfo()
self.assertEquals(info.hasDetectors(0), False)
self.assertEquals(info.hasDetectors(1), True)
- def test_isMasked(self):
+ def test_hasUniqueDetector(self):
+ """ Test if the spectra have unique detectors. """
info = self._ws.spectrumInfo()
- self.assertEquals(info.isMasked(1), False)
+ self.assertEquals(info.hasUniqueDetector(0), False)
+ self.assertEquals(info.hasUniqueDetector(1), True)
+
+ """
+ The following are test cases test for returned V3D objects. The objects
+ represent a vector in 3 dimensions.
+ """
+
+ def test_position(self):
+ """ Test that the spectrum's position is returned. """
+ info = self._ws.spectrumInfo()
+ self.assertEquals(type(info.position(1)), V3D)
+
+ def test_sourcePosition(self):
+ """ Test that the source's position is returned. """
+ info = self._ws.spectrumInfo()
+ self.assertEquals(type(info.sourcePosition()), V3D)
+
+ def test_samplePosition(self):
+ """ Test that the sample's position is returned. """
+ info = self._ws.spectrumInfo()
+ self.assertEquals(type(info.samplePosition()), V3D)
+
+
+ """
+ ----------------------------------------------------------------------------
+ Extreme Tests
+ ----------------------------------------------------------------------------
+ The following test cases test around boundary cases for the exposed methods.
+ """
+
+ def test_isMonitor_extreme(self):
+ info = self._ws.spectrumInfo()
+ with self.assertRaises(OverflowError):
+ info.isMonitor(-1)
+
+ def test_isMasked_extreme(self):
+ info = self._ws.spectrumInfo()
+ with self.assertRaises(OverflowError):
+ info.isMasked(-1)
+
+ def test_setMasked_extreme(self):
+ info = self._ws.spectrumInfo()
+ with self.assertRaises(OverflowError):
+ info.setMasked(-1, True)
+
+ def test_twoTheta_extreme(self):
+ info = self._ws.spectrumInfo()
+ with self.assertRaises(OverflowError):
+ info.twoTheta(-1)
+
+ def test_signedTwoTheta_extreme(self):
+ info = self._ws.spectrumInfo()
+ with self.assertRaises(OverflowError):
+ info.signedTwoTheta(-1)
+
+ def test_l2_extreme(self):
+ info = self._ws.spectrumInfo()
+ with self.assertRaises(OverflowError):
+ info.l2(-1)
+
+ def test_hasUniqueDetector_extreme(self):
+ info = self._ws.spectrumInfo()
+ with self.assertRaises(OverflowError):
+ info.hasUniqueDetector(-1)
+
+ def test_position_extreme(self):
+ info = self._ws.spectrumInfo()
+ with self.assertRaises(OverflowError):
+ info.position(-1)
+
+
+ """
+ ----------------------------------------------------------------------------
+ Exceptional Tests
+ ----------------------------------------------------------------------------
+ Each of the tests below tries to pass invalid parameters to the exposed
+ methods and expect an error to be thrown.
+ """
+
+ def test_size_exceptional(self):
+ info = self._ws.spectrumInfo()
+ with self.assertRaises(TypeError):
+ info.size(0)
+
+ def test_isMonitor_exceptional(self):
+ info = self._ws.spectrumInfo()
+ with self.assertRaises(TypeError):
+ info.isMonitor("Error")
+ with self.assertRaises(TypeError):
+ info.isMonitor(10.0)
+
+ def test_isMasked_exceptional(self):
+ info = self._ws.spectrumInfo()
+ with self.assertRaises(TypeError):
+ info.isMasked("Error")
+ with self.assertRaises(TypeError):
+ info.isMasked(10.0)
+
+ def test_setMasked_exceptional(self):
+ info = self._ws.spectrumInfo()
+ with self.assertRaises(TypeError):
+ info.setMasked("Error", True)
+ with self.assertRaises(TypeError):
+ info.isMasked(10.0, True)
+ with self.assertRaises(TypeError):
+ info.setMasked(0, "True")
+ with self.assertRaises(TypeError):
+ info.isMasked(0, 1.0)
+
+ def test_twoTheta_exceptional(self):
+ info = self._ws.spectrumInfo()
+ with self.assertRaises(TypeError):
+ info.twoTheta("Zero")
+ with self.assertRaises(TypeError):
+ info.twoTheta(1.0)
+
+ def test_signedTwoTheta_exceptional(self):
+ info = self._ws.spectrumInfo()
+ with self.assertRaises(TypeError):
+ info.signedTwoTheta("Zero")
+ with self.assertRaises(TypeError):
+ info.signedTwoTheta(1.0)
+
+ def test_l1_exceptional(self):
+ info = self._ws.spectrumInfo()
+ with self.assertRaises(TypeError):
+ info.l1("One")
+
+ def test_l2_exceptional(self):
+ info = self._ws.spectrumInfo()
+ with self.assertRaises(TypeError):
+ info.l2("One")
+ with self.assertRaises(TypeError):
+ info.l2(10.0)
+
+ def test_hasDetectors_exceptional(self):
+ info = self._ws.spectrumInfo()
+ with self.assertRaises(TypeError):
+ info.hasDetectors("Zero")
+
+ def test_hasUniqueDetector_exceptional(self):
+ info = self._ws.spectrumInfo()
+ with self.assertRaises(TypeError):
+ info.hasUniqueDetector("Zero")
+ with self.assertRaises(TypeError):
+ info.hasUniqueDetector(0.0)
+
+ def test_position_exceptional(self):
+ info = self._ws.spectrumInfo()
+ with self.assertRaises(TypeError):
+ info.position("Zero")
+ with self.assertRaises(TypeError):
+ info.position(0.0)
+
+ def test_sourcePosition_exceptional(self):
+ info = self._ws.spectrumInfo()
+ with self.assertRaises(TypeError):
+ info.sourcePosition("Zero")
+ with self.assertRaises(TypeError):
+ info.sourcePosition(0.0)
+
+ def test_samplePosition_exceptional(self):
+ info = self._ws.spectrumInfo()
+ with self.assertRaises(TypeError):
+ info.samplePosition("Zero")
+ with self.assertRaises(TypeError):
+ info.samplePosition(0.0)
+
+
+ """
+ ----------------------------------------------------------------------------
+ SpectrumDefinition Tests
+ ----------------------------------------------------------------------------
+
+ The following are test cases for the exposed SpectrumDefintion methods.
+ """
+
+ def test_spectrumDefintionSize(self):
+ """ Check the size of the SpectrumDefinition
+ (i.e. number of detectors) """
+ info = self._ws.spectrumInfo()
+ spectrumDefinitionOne = info.getSpectrumDefinition(0)
+ spectrumDefinitionTwo = info.getSpectrumDefinition(1)
+ self.assertEquals(spectrumDefinitionOne.size(), 0)
+ self.assertEquals(spectrumDefinitionTwo.size(), 1)
+
+ def test_spectrumDefintionAdd(self):
+ """ Add a pair of detector index and time index """
+ info = self._ws.spectrumInfo()
+ spectrumDefinition = info.getSpectrumDefinition(1)
+ spectrumDefinition.add(1, 1)
+ self.assertEquals(spectrumDefinition.size(), 2)
+
+ def test_spectrumDefintionEquals(self):
+ """ Check the equality of the SpectrumDefintions """
+ info = self._ws.spectrumInfo()
+ spectrumDefinition = info.getSpectrumDefinition(0)
+ # Check equality with equals() and == to make sure same result is given
+ self.assertTrue(spectrumDefinition.equals(spectrumDefinition))
+ self.assertTrue(spectrumDefinition == spectrumDefinition)
+
+ def test_spectrumDefintionNotEquals(self):
+ """ Check the equality of the SpectrumDefintions """
+ info = self._ws.spectrumInfo()
+ spectrumDefinitionOne = info.getSpectrumDefinition(0)
+ spectrumDefinitionTwo = info.getSpectrumDefinition(1)
+ # Check inequality with not (by negating equals())
+ # and != to make sure same result is given
+ self.assertTrue(not spectrumDefinitionOne.equals(spectrumDefinitionTwo))
+ self.assertTrue(spectrumDefinitionOne != spectrumDefinitionTwo)
+
+ def test_spectrumDefintionGet(self):
+ """ See if indexing works """
+ info = self._ws.spectrumInfo()
+ spectrumDefinition = info.getSpectrumDefinition(1)
+ self.assertEquals(spectrumDefinition[0], (1, 0))
if __name__ == '__main__':
unittest.main()
diff --git a/Framework/PythonInterface/test/python/mantid/api/WorkspaceValidatorsTest.py b/Framework/PythonInterface/test/python/mantid/api/WorkspaceValidatorsTest.py
index 128b3f48ddfcc8310219d4063d38703a0e47eded..a2de10979bb1fda1200bdb7abfac059b819e7368 100644
--- a/Framework/PythonInterface/test/python/mantid/api/WorkspaceValidatorsTest.py
+++ b/Framework/PythonInterface/test/python/mantid/api/WorkspaceValidatorsTest.py
@@ -9,7 +9,8 @@ from mantid.kernel import IValidator
from mantid.api import (WorkspaceUnitValidator, HistogramValidator,
RawCountValidator, CommonBinsValidator,
SpectraAxisValidator, NumericAxisValidator,
- InstrumentValidator, MDFrameValidator)
+ InstrumentValidator, MDFrameValidator,
+ OrientedLatticeValidator)
class WorkspaceValidatorsTest(unittest.TestCase):
@@ -68,9 +69,19 @@ class WorkspaceValidatorsTest(unittest.TestCase):
testhelpers.assertRaisesNothing(self, InstrumentValidator)
def test_MDFrameValidator_construction(self):
+ """
+ Test that the MDFrameValidator can be constructed
+ with a single string
+ """
testhelpers.assertRaisesNothing(self, MDFrameValidator, "HKL")
self.assertRaises(Exception, MDFrameValidator)
+ def test_OrientedLatticeValidator_construction(self):
+ """
+ Test that the OrientedLatticeValidator can be constructed
+ with no args
+ """
+ testhelpers.assertRaisesNothing(self, OrientedLatticeValidator)
if __name__ == '__main__':
unittest.main()
diff --git a/Framework/PythonInterface/test/python/mantid/geometry/CMakeLists.txt b/Framework/PythonInterface/test/python/mantid/geometry/CMakeLists.txt
index 22cb63524b998c5c881652b68600205ee27cf4ae..f08f673f74817a91742e4fb20c6edad87f363232 100644
--- a/Framework/PythonInterface/test/python/mantid/geometry/CMakeLists.txt
+++ b/Framework/PythonInterface/test/python/mantid/geometry/CMakeLists.txt
@@ -21,6 +21,7 @@ set ( TEST_PY_FILES
CrystalStructureTest.py
ReflectionGeneratorTest.py
DetectorInfoTest.py
+ ComponentInfoTest.py
)
check_tests_valid ( ${CMAKE_CURRENT_SOURCE_DIR} ${TEST_PY_FILES} )
diff --git a/Framework/PythonInterface/test/python/mantid/geometry/ComponentInfoTest.py b/Framework/PythonInterface/test/python/mantid/geometry/ComponentInfoTest.py
new file mode 100644
index 0000000000000000000000000000000000000000..22b283a760275e7188ab9a1748569f27df19b56b
--- /dev/null
+++ b/Framework/PythonInterface/test/python/mantid/geometry/ComponentInfoTest.py
@@ -0,0 +1,472 @@
+from __future__ import (absolute_import, division, print_function)
+
+import unittest
+import argparse
+import numpy as np
+from testhelpers import WorkspaceCreationHelper
+from mantid.kernel import V3D
+from mantid.kernel import Quat
+from mantid.geometry import CSGObject
+from mantid.simpleapi import *
+
+class ComponentInfoTest(unittest.TestCase):
+
+ _ws = None
+
+ def setUp(self):
+ if self.__class__._ws is None:
+ self.__class__._ws = WorkspaceCreationHelper.create2DWorkspaceWithFullInstrument(2, 1, False) # no monitors
+ self.__class__._ws.getSpectrum(0).clearDetectorIDs()
+
+ """
+ ----------------------------------------------------------------------------
+ Normal Tests
+ ----------------------------------------------------------------------------
+
+ The following test cases test normal usage of the exposed methods.
+ """
+
+ def test_len(self):
+ """ Check that there are only 6 components """
+ info = self._ws.componentInfo()
+ self.assertEquals(len(info), 6)
+
+ def test_size(self):
+ """ Check that there are only 6 components """
+ info = self._ws.componentInfo()
+ self.assertEquals(info.size(), 6)
+
+ def test_isDetector(self):
+ """Check which components are detectors """
+ info = self._ws.componentInfo()
+ self.assertEquals(info.isDetector(0), True)
+ self.assertEquals(info.isDetector(1), True)
+ self.assertEquals(info.isDetector(2), False)
+ self.assertEquals(info.isDetector(3), False)
+ self.assertEquals(info.isDetector(4), False)
+ self.assertEquals(info.isDetector(5), False)
+
+ def test_detectorsInSubtree(self):
+ """ Test that a list of detectors is returned """
+ info = self._ws.componentInfo()
+ self.assertEquals(type(info.detectorsInSubtree(0)), np.ndarray)
+
+ def test_componentsInSubtree(self):
+ """ Test that a list of components is returned """
+ info = self._ws.componentInfo()
+ self.assertEquals(type(info.componentsInSubtree(0)), np.ndarray)
+
+ def test_position(self):
+ """ Test that the component's position is returned. """
+ info = self._ws.componentInfo()
+ self.assertEquals(type(info.position(0)), V3D)
+
+ def test_rotation(self):
+ """ Test that the component's rotation is returned. """
+ info = self._ws.componentInfo()
+ self.assertEquals(type(info.rotation(0)), Quat)
+
+ def test_relativePosition(self):
+ """ Test that the component's relative position is returned. """
+ info = self._ws.componentInfo()
+ self.assertEquals(type(info.relativePosition(0)), V3D)
+
+ def test_relativeRotation(self):
+ """ Test that the component's relative rotation is returned. """
+ info = self._ws.componentInfo()
+ self.assertEquals(type(info.relativeRotation(0)), Quat)
+
+ def test_setPosition(self):
+ """ Test that the component's position can be set correctly. """
+ info = self._ws.componentInfo()
+ pos = V3D(0,0,0)
+ info.setPosition(0, pos)
+ retPos = info.position(0)
+ self.assertEquals(pos, retPos)
+
+ def test_setRotation(self):
+ """ Test that the component's rotation can be set correctly. """
+ info = self._ws.componentInfo()
+ quat = Quat(0,0,0,0)
+ info.setRotation(0, quat)
+ retQuat = info.rotation(0)
+ self.assertEquals(quat, retQuat)
+
+ def test_hasSource(self):
+ """ Check if there is a source """
+ info = self._ws.componentInfo()
+ self.assertEquals(info.hasSource(), True)
+
+ def test_hasSample(self):
+ """ Check if there is a sample """
+ info = self._ws.componentInfo()
+ self.assertEquals(info.hasSample(), True)
+
+ def test_source(self):
+ """ Check if a source component is returned """
+ info = self._ws.componentInfo()
+ self.assertEquals(type(info.source()) , int)
+
+ def test_sample(self):
+ """ Check if a sample component is returned """
+ info = self._ws.componentInfo()
+ self.assertEquals(type(info.sample()) , int)
+
+ def test_sourcePosition(self):
+ """ Check that the source postition is a V3D object """
+ info = self._ws.componentInfo()
+ self.assertEquals(type(info.sourcePosition()), V3D)
+
+ def test_samplePosition(self):
+ """ Check that the sample postition is a V3D object """
+ info = self._ws.componentInfo()
+ self.assertEquals(type(info.samplePosition()), V3D)
+
+ def test_hasParent(self):
+ """ Check if a component has a parent component """
+ info = self._ws.componentInfo()
+ self.assertTrue(info.hasParent(0))
+
+ def test_parent(self):
+ """ Check that for a component that has a parent, the parent
+ component is retrieved. """
+ info = self._ws.componentInfo()
+ self.assertEquals(type(info.parent(0)), int)
+
+ def test_children(self):
+ """ Check that for a component that has children, the children
+ components can be retrieved. """
+ info = self._ws.componentInfo()
+ self.assertEquals(type(info.children(0)), np.ndarray)
+
+ def test_name(self):
+ """ Get the name of a component as a string """
+ info = self._ws.componentInfo()
+ self.assertEquals(type(info.name(0)), str)
+
+ def test_l1(self):
+ """ Get the l1 value """
+ info = self._ws.componentInfo()
+ self.assertEquals(type(info.l1()), float)
+
+ def test_scaleFactor(self):
+ """ Get the scale factor """
+ info = self._ws.componentInfo()
+ self.assertEquals(type(info.scaleFactor(0)), V3D)
+
+ def test_setScaleFactor(self):
+ """ Set the scale factor """
+ info = self._ws.componentInfo()
+ sf = V3D(0,0,0)
+ info.setScaleFactor(0, sf)
+ self.assertEquals(info.scaleFactor(0), sf)
+
+ def test_hasValidShape(self):
+ """ Check for a valid shape """
+ info = self._ws.componentInfo()
+ self.assertEquals(info.hasValidShape(0), True)
+
+ def test_shape(self):
+ """ Check a shape is returned"""
+ info = self._ws.componentInfo()
+ self.assertEquals(type(info.shape(0)), CSGObject)
+
+ def test_createWorkspaceAndComponentInfo(self):
+ """ Try to create a workspace and see if ComponentInfo object is accessable """
+ dataX = [1,2,3,4,5]
+ dataY = [1,2,3,4,5]
+ workspace = CreateWorkspace(DataX=dataX, DataY=dataY)
+ info = workspace.componentInfo()
+ self.assertEquals(info.size(), 1)
+
+
+ """
+ ----------------------------------------------------------------------------
+ Extreme Tests
+ ----------------------------------------------------------------------------
+
+ The following test cases test around boundary cases for the exposed methods.
+ """
+
+ def test_isDetector_extreme(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(OverflowError):
+ info.isDetector(-1)
+
+ def test_detectorsInSubtree_extreme(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(OverflowError):
+ info.detectorsInSubtree(-1)
+ self.assertEquals(type(info.detectorsInSubtree(5)), np.ndarray)
+
+ def test_componentsInSubtree_extreme(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(OverflowError):
+ info.componentsInSubtree(-1)
+ self.assertEquals(type(info.componentsInSubtree(5)), np.ndarray)
+
+ def test_position_extreme(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(OverflowError):
+ info.position(-1)
+ self.assertEquals(type(info.position(0)), V3D)
+ self.assertEquals(type(info.position(5)), V3D)
+
+ def test_rotation_extreme(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(OverflowError):
+ info.rotation(-1)
+ self.assertEquals(type(info.rotation(0)), Quat)
+ self.assertEquals(type(info.rotation(5)), Quat)
+
+ def test_relativePosition_extreme(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(OverflowError):
+ info.relativePosition(-1)
+ self.assertEquals(type(info.relativePosition(0)), V3D)
+ self.assertEquals(type(info.relativePosition(5)), V3D)
+
+ def test_relativeRotation_extreme(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(OverflowError):
+ info.relativeRotation(-1)
+ self.assertEquals(type(info.relativeRotation(0)), Quat)
+ self.assertEquals(type(info.relativeRotation(5)), Quat)
+
+ def test_setPosition_extreme(self):
+ info = self._ws.componentInfo()
+ pos = V3D(0,0,0)
+ with self.assertRaises(OverflowError):
+ info.setPosition(-1, pos)
+
+ def test_setRotation_extreme(self):
+ info = self._ws.componentInfo()
+ quat = Quat(0,0,0,0)
+ with self.assertRaises(OverflowError):
+ info.setRotation(-1, quat)
+
+ def test_hasParent_extreme(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(OverflowError):
+ info.hasParent(-1)
+ self.assertTrue(info.hasParent(0))
+ self.assertFalse(info.hasParent(5))
+
+ def test_parent_extreme(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(OverflowError):
+ info.parent(-1)
+ self.assertEquals(type(info.parent(0)), int)
+ self.assertEquals(type(info.parent(5)), int)
+
+ def test_children_extreme(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(OverflowError):
+ info.children(-1)
+ self.assertEquals(type(info.children(0)), np.ndarray)
+ self.assertEquals(type(info.children(5)), np.ndarray)
+
+ def test_name_extreme(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(OverflowError):
+ info.name(-1)
+ self.assertEquals(type(info.name(0)), str)
+ self.assertEquals(type(info.name(5)), str)
+
+ def test_scaleFactor_extreme(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(OverflowError):
+ info.scaleFactor(-1)
+ self.assertEquals(type(info.scaleFactor(0)), V3D)
+ self.assertEquals(type(info.scaleFactor(5)), V3D)
+
+ def test_setScaleFactor_extreme(self):
+ info = self._ws.componentInfo()
+ sf = V3D(0,0,0)
+ with self.assertRaises(OverflowError):
+ info.setScaleFactor(-1, sf)
+
+ def test_hasValidShape_extreme(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(OverflowError):
+ info.hasValidShape(-1)
+ self.assertEquals(type(info.hasValidShape(0)), bool)
+ self.assertEquals(type(info.hasValidShape(5)), bool)
+
+ def test_shape_extreme(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(OverflowError):
+ info.shape(-1)
+ self.assertEquals(type(info.shape(0)), CSGObject)
+ self.assertEquals(type(info.shape(5)), CSGObject)
+
+
+ """
+ ----------------------------------------------------------------------------
+ Exceptional Tests
+ ----------------------------------------------------------------------------
+
+ Each of the tests below tries to pass invalid parameters to the exposed
+ methods and expect an error to be thrown.
+ """
+
+ def test_size_exceptional(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(TypeError):
+ info.size(0)
+
+ def test_isDetector_exceptional(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(TypeError):
+ info.isDetector("Error")
+ with self.assertRaises(TypeError):
+ info.isDetector(10.0)
+
+ def test_detectorsInSubtree_exceptional(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(TypeError):
+ info.detectorsInSubtree("Error")
+ with self.assertRaises(TypeError):
+ info.detectorsInSubtree(10.0)
+
+ def test_componentsInSubtree_exceptional(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(TypeError):
+ info.componentsInSubtree("Error")
+ with self.assertRaises(TypeError):
+ info.componentsInSubtree(10.0)
+
+ def test_position_exceptional(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(TypeError):
+ info.position("Zero")
+ with self.assertRaises(TypeError):
+ info.position(0.0)
+
+ def test_rotation_exceptional(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(TypeError):
+ info.rotation("Zero")
+ with self.assertRaises(TypeError):
+ info.rotation(0.0)
+
+ def test_relativePosition_exceptional(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(TypeError):
+ info.relativePosition("Zero")
+ with self.assertRaises(TypeError):
+ info.relativePosition(0.0)
+
+ def test_relativeRotation_exceptional(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(TypeError):
+ info.relativeRotation("Zero")
+ with self.assertRaises(TypeError):
+ info.relativeRotation(0.0)
+
+ def test_setPosition_exceptional(self):
+ info = self._ws.componentInfo()
+ pos = [0,0,0]
+ with self.assertRaises(TypeError):
+ info.setPosition(0, pos)
+
+ def test_setRotation_exceptional(self):
+ info = self._ws.componentInfo()
+ rot = [0,0,0,0]
+ with self.assertRaises(TypeError):
+ info.setRotation(0, rot)
+
+ def test_hasSource_exceptional(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(TypeError):
+ info.hasSource(0)
+
+ def test_hasSample_exceptional(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(TypeError):
+ info.hasSample(0)
+
+ def test_source_exceptional(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(TypeError):
+ info.source(0)
+
+ def test_sample_exceptional(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(TypeError):
+ info.sample(0)
+
+ def test_sourcePosition_exceptional(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(TypeError):
+ info.sourcePosition(0)
+
+ def test_samplePosition_exceptional(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(TypeError):
+ info.samplePosition(0)
+
+ def test_hasParent_exceptional(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(TypeError):
+ info.hasParent("Zero")
+ with self.assertRaises(TypeError):
+ info.hasParent(0.0)
+
+ def test_parent_exceptional(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(TypeError):
+ info.parent("Zero")
+ with self.assertRaises(TypeError):
+ info.parent(0.0)
+
+ def test_children_exceptional(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(TypeError):
+ info.children("Zero")
+ with self.assertRaises(TypeError):
+ info.children(0.0)
+
+ def test_name_exceptional(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(TypeError):
+ info.name("Name")
+ with self.assertRaises(TypeError):
+ info.name(0.12)
+
+ def test_l1_exceptional(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(TypeError):
+ info.l1(0)
+
+ def test_scaleFactor_exceptional(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(TypeError):
+ info.scaleFactor("Scale factor")
+ with self.assertRaises(TypeError):
+ info.scaleFactor(0.12)
+
+ def test_setScaleFactor_exceptional(self):
+ info = self._ws.componentInfo()
+ sf = V3D(0,0,0)
+ with self.assertRaises(TypeError):
+ info.setScaleFactor("1", sf)
+ with self.assertRaises(TypeError):
+ info.setScaleFactor(1.0, sf)
+
+ def test_hasValidShape_exceptional(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(TypeError):
+ info.hasValidShape("ValidShape")
+ with self.assertRaises(TypeError):
+ info.hasValidShape(1010.00)
+
+ def test_shape_exceptional(self):
+ info = self._ws.componentInfo()
+ with self.assertRaises(TypeError):
+ info.shape("Shape")
+ with self.assertRaises(TypeError):
+ info.shape(11.32)
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/Framework/PythonInterface/test/python/mantid/kernel/ArrayPropertyTest.py b/Framework/PythonInterface/test/python/mantid/kernel/ArrayPropertyTest.py
index db5f08d0f2783b2a600c8b6c576f9a78edc110f4..2564e68a9791e6d2204dc09112f0cdb0ca08b244 100644
--- a/Framework/PythonInterface/test/python/mantid/kernel/ArrayPropertyTest.py
+++ b/Framework/PythonInterface/test/python/mantid/kernel/ArrayPropertyTest.py
@@ -154,17 +154,9 @@ class ArrayPropertyTest(unittest.TestCase):
str_arr = StringArrayProperty("letters", str_input_values, validator, direc)
# Test
- self.assertEquals(float_arr.dtype(), "float64")
- self.assertEquals(str_arr.dtype(), "string_")
-
- # Implementation of IntArrayProperty is based on long
- # (which is itself implementation defined, so a special case is needed here)
- if sys.platform == 'win32' or sys.platform == 'darwin':
- # Windows and macOS should return "int_"
- self.assertEquals(int_arr.dtype(), "int_")
- else:
- # Linux based systems should return "int64"
- self.assertEquals(int_arr.dtype(), "int64")
+ self.assertEquals(float_arr.dtype(), "f")
+ self.assertEquals(int_arr.dtype(), "i")
+ self.assertEquals(str_arr.dtype(), "S1")
def test_construct_numpy_array_with_given_dtype_float(self):
# Set up
@@ -174,11 +166,11 @@ class ArrayPropertyTest(unittest.TestCase):
# Create float array
float_input_values = [1.1, 2.5, 5.6, 4.6, 9.0, 6.0]
float_arr = FloatArrayProperty("floats", float_input_values, validator, direc)
-
+
# Use the returned dtype() to check it works with numpy arrays
x = np.arange(1, 10, dtype=float_arr.dtype())
self.assertIsInstance(x, np.ndarray)
- self.assertEquals(x.dtype, float_arr.dtype())
+ self.assertEquals(x.dtype, float_arr.dtype())
def test_construct_numpy_array_with_given_dtype_int(self):
# Set up
@@ -188,7 +180,7 @@ class ArrayPropertyTest(unittest.TestCase):
# Create int array
int_input_values = [1, 2, 5, 4, 9, 6]
int_arr = IntArrayProperty("integers", int_input_values, validator, direc)
-
+
# Use the returned dtype() to check it works with numpy arrays
x = np.arange(1, 10, dtype=int_arr.dtype())
self.assertIsInstance(x, np.ndarray)
@@ -202,12 +194,12 @@ class ArrayPropertyTest(unittest.TestCase):
# Create string array
str_input_values = ["hello", "testing", "word", "another word", "word"]
str_arr = StringArrayProperty("letters", str_input_values, validator, direc)
-
+
# Use the returned dtype() to check it works with numpy arrays
x = np.array(str_input_values, dtype=str_arr.dtype())
self.assertIsInstance(x, np.ndarray)
# Expect longest string to be returned
- self.assertEquals(x.dtype, "S12")
+ self.assertEquals(x.dtype, "S12")
def test_PythonAlgorithm_setProperty_With_Ranges_String(self):
"""
diff --git a/Framework/PythonInterface/test/python/mantid/kernel/PropertyWithValueTest.py b/Framework/PythonInterface/test/python/mantid/kernel/PropertyWithValueTest.py
index 56908e8161f3b6e592b3ba4dd07e1a8e2c46d88a..ecab49de0d4f581e60f363e66e929eda7929c424 100644
--- a/Framework/PythonInterface/test/python/mantid/kernel/PropertyWithValueTest.py
+++ b/Framework/PythonInterface/test/python/mantid/kernel/PropertyWithValueTest.py
@@ -128,7 +128,7 @@ class PropertyWithValueTest(unittest.TestCase):
self.assertEquals(result.endswith("98,99"), True)
# Check the dtype return value
- self.assertEquals(det_list_prop.dtype(), "int32")
+ self.assertEquals(det_list_prop.dtype(), "i")
def _do_vector_double_numpy_test(self, int_type=False):
create_ws = AlgorithmManager.createUnmanaged('CreateWorkspace')
diff --git a/Framework/PythonInterface/test/python/mantid/kernel/TimeSeriesPropertyTest.py b/Framework/PythonInterface/test/python/mantid/kernel/TimeSeriesPropertyTest.py
index 265cec042163963dc593dbb1030c5bb7965754f2..7313b62885e78df25ef71a000e1326b8e8d3eaf5 100644
--- a/Framework/PythonInterface/test/python/mantid/kernel/TimeSeriesPropertyTest.py
+++ b/Framework/PythonInterface/test/python/mantid/kernel/TimeSeriesPropertyTest.py
@@ -61,7 +61,7 @@ class TimeSeriesPropertyTest(unittest.TestCase):
self.assertEquals(log_series.size(), self._ntemp)
self.assertAlmostEqual(log_series.nthValue(0), -0.00161)
# Check the dtype return value
- self.assertEquals(log_series.dtype(), "float64")
+ self.assertEquals(log_series.dtype(), "f")
def test_time_series_int_can_be_extracted(self):
log_series = self._test_ws.getRun()["raw_frames"]
@@ -69,7 +69,7 @@ class TimeSeriesPropertyTest(unittest.TestCase):
self.assertEquals(log_series.size(), self._nframes)
self.assertEquals(log_series.nthValue(1), 1436)
# Check the dtype return value
- self.assertEquals(log_series.dtype(), "int64")
+ self.assertEquals(log_series.dtype(), "i")
def test_time_series_string_can_be_extracted(self):
log_series = self._test_ws.getRun()["icp_event"]
@@ -77,14 +77,14 @@ class TimeSeriesPropertyTest(unittest.TestCase):
self.assertEquals(log_series.size(), 4)
self.assertEquals(log_series.nthValue(0).strip(), 'CHANGE_PERIOD 1')
# Check the dtype return value
- self.assertEquals(log_series.dtype(), "string_")
+ self.assertEquals(log_series.dtype(), "S61")
def test_time_series_bool_can_be_extracted(self):
log_series = self._test_ws.getRun()["period 1"]
self._check_has_time_series_attributes(log_series)
self.assertEquals(log_series.size(), 1)
# Check the dtype return value
- self.assertEquals(log_series.dtype(), "bool_")
+ self.assertEquals(log_series.dtype(), "b")
def _check_has_time_series_attributes(self, log, values_type=np.ndarray):
self.assertTrue(hasattr(log, "value"))
diff --git a/Framework/PythonInterface/test/python/mantid/plots/plotfunctionsTest.py b/Framework/PythonInterface/test/python/mantid/plots/plotfunctionsTest.py
index 75bbf1d5e059e2c2e0dad1c0f265e337187e91ea..cff911f8752e3f43034ef312318d4f41fb25f5da 100644
--- a/Framework/PythonInterface/test/python/mantid/plots/plotfunctionsTest.py
+++ b/Framework/PythonInterface/test/python/mantid/plots/plotfunctionsTest.py
@@ -9,8 +9,8 @@ import unittest
import mantid.api
import mantid.plots.plotfunctions as funcs
from mantid.kernel import config
-from mantid.simpleapi import CreateWorkspace, DeleteWorkspace, CreateMDHistoWorkspace,\
- ConjoinWorkspaces, AddTimeSeriesLog
+from mantid.simpleapi import (CreateWorkspace, CreateEmptyTableWorkspace, DeleteWorkspace,
+ CreateMDHistoWorkspace, ConjoinWorkspaces, AddTimeSeriesLog)
@@ -116,6 +116,19 @@ class PlotFunctionsTest(unittest.TestCase):
funcs.pcolormesh(ax, self.ws_MD_2d)
funcs.pcolorfast(ax, self.ws2d_point_uneven, vmin=-1)
+ def test_1d_plots_with_unplottable_type_raises_attributeerror(self):
+ table = CreateEmptyTableWorkspace()
+ _, ax = plt.subplots()
+ self.assertRaises(AttributeError, funcs.plot, ax, table, wkspIndex=0)
+ self.assertRaises(AttributeError, funcs.errorbar, ax, table, wkspIndex=0)
+
+ def test_2d_plots_with_unplottable_type_raises_attributeerror(self):
+ table = CreateEmptyTableWorkspace()
+ _, ax = plt.subplots()
+ self.assertRaises(AttributeError, funcs.pcolor, ax, table)
+ self.assertRaises(AttributeError, funcs.pcolormesh, ax, table)
+ self.assertRaises(AttributeError, funcs.pcolorfast, ax, table)
+
if __name__ == '__main__':
unittest.main()
diff --git a/Framework/PythonInterface/test/python/plugins/algorithms/CMakeLists.txt b/Framework/PythonInterface/test/python/plugins/algorithms/CMakeLists.txt
index 2aa190d32ad242014581c093468d62cef0510403..ac9d9fe1b60b1651850d8121dfefe195460e59ef 100644
--- a/Framework/PythonInterface/test/python/plugins/algorithms/CMakeLists.txt
+++ b/Framework/PythonInterface/test/python/plugins/algorithms/CMakeLists.txt
@@ -84,7 +84,6 @@ set ( TEST_PY_FILES
SetDetScaleTest.py
SortByQVectorsTest.py
SortDetectorsTest.py
- SortXAxisTest.py
StatisticsOfTableWorkspaceTest.py
StringToPngTest.py
SuggestTibCNCSTest.py
diff --git a/Framework/PythonInterface/test/python/plugins/algorithms/ExportSampleLogsToHDF5Test.py b/Framework/PythonInterface/test/python/plugins/algorithms/ExportSampleLogsToHDF5Test.py
index e5fdde253267ccad8e974d70f435682c4930e31c..2f81160e3fe5e3e8acf397e7edb011a999abd8da 100644
--- a/Framework/PythonInterface/test/python/plugins/algorithms/ExportSampleLogsToHDF5Test.py
+++ b/Framework/PythonInterface/test/python/plugins/algorithms/ExportSampleLogsToHDF5Test.py
@@ -26,7 +26,7 @@ class ExportSampleLogsToHDF5Test(unittest.TestCase):
if mantid.mtd.doesExist(self.TEST_WS_NAME):
mantid.mtd.remove(self.TEST_WS_NAME)
-
+
def test_saveFileWithSingleValueProperties(self):
input_ws = self._create_sample_workspace()
self._add_log_to_workspace(input_ws, "Test1", 1.0)
@@ -80,6 +80,34 @@ class ExportSampleLogsToHDF5Test(unittest.TestCase):
logs_group = output_file["Sample Logs"]
self.assertEquals(logs_group["TestLog"].attrs["Units"], "uAmps")
+ def test_create_timeSeries(self):
+ """ Tests that the correct TimeSeriesProperty is returned when given a
+ name and a list of values of a given type."""
+
+ # Test for Int32TimeSeriesProperty
+ int_log_name = "Int32Series"
+ int_log_values = [1,2,3,4,5,6,7]
+ int_prop = PropertyFactory.createTimeSeries(int_log_name, int_log_values)
+ self.assertEquals(type(int_prop), Int32TimeSeriesProperty)
+
+ # Test for BoolTimeSeriesProperty
+ bool_log_name = "BoolSeries"
+ bool_log_values = [True, False, False, True, False]
+ bool_prop = PropertyFactory.createTimeSeries(bool_log_name, bool_log_values)
+ self.assertEquals(type(bool_prop), BoolTimeSeriesProperty)
+
+ # Test for StringSeriesProperty
+ str_log_name = "StringSeries"
+ str_log_values = ["Testing", "string", "time", "series", "property"]
+ str_prop = PropertyFactory.createTimeSeries(str_log_name, str_log_values)
+ self.assertEquals(type(str_prop), StringTimeSeriesProperty)
+
+ # Test for FloatTimeSeriesProperty
+ float_log_name = "FloatSeries"
+ float_log_values = [1.0 ,2.1, 3.2, 4.3, 5.6, 6.7, 7.8]
+ float_prop = PropertyFactory.createTimeSeries(float_log_name, float_log_values)
+ self.assertTrue(type(float_prop), FloatTimeSeriesProperty)
+
def _add_log_to_workspace(self, ws, log_name, log_value):
if isinstance(log_value, list):
ws.mutableRun()[log_name] = self._create_time_series_log(log_name, log_value)
@@ -98,21 +126,11 @@ class ExportSampleLogsToHDF5Test(unittest.TestCase):
return ws
def _create_time_series_log(self, log_name, log_value):
- if isinstance(log_value[0], int):
- prop = Int32TimeSeriesProperty(log_name)
- elif isinstance(log_value[0], float):
- prop = FloatTimeSeriesProperty(log_name)
- elif isinstance(log_value[0], str):
- prop = StringTimeSeriesProperty(log_name)
- elif isinstance(log_value[0], bool):
- prop = BoolTimeSeriesProperty(log_name)
- else:
- raise RuntimeError("Unsupported property type {}".format(type(log_value[0])))
-
+ prop = PropertyFactory.createTimeSeries(log_name, log_value)
for i, value in enumerate(log_value):
prop.addValue(i, value)
return prop
if __name__ == "__main__":
- unittest.main()
\ No newline at end of file
+ unittest.main()
diff --git a/Framework/PythonInterface/test/python/plugins/algorithms/SortXAxisTest.py b/Framework/PythonInterface/test/python/plugins/algorithms/SortXAxisTest.py
deleted file mode 100644
index 9b43e770f953ed20e7eaef4600dd635f58969ac8..0000000000000000000000000000000000000000
--- a/Framework/PythonInterface/test/python/plugins/algorithms/SortXAxisTest.py
+++ /dev/null
@@ -1,183 +0,0 @@
-from __future__ import (absolute_import, division, print_function)
-
-import unittest
-from mantid.simpleapi import AlgorithmManager, CreateWorkspace, DeleteWorkspace, SortXAxis
-
-
-class SortXAxisTest(unittest.TestCase):
-
-
- def test_x_ascending(self):
- dataX = [1., 2., 3.] # In ascending order, so y and e will need to be reversed.
- dataY = [1., 2., 3.]
- dataE = [1., 2., 3.]
- unsortedws = CreateWorkspace(DataX=dataX,DataY=dataY,DataE=dataE,UnitX='TOF',Distribution=True)
- # Run the algorithm
- sortedws = SortXAxis(InputWorkspace=unsortedws)
- sortedX = sortedws.readX(0)
- sortedY = sortedws.readY(0)
- sortedE = sortedws.readE(0)
- # Check the resulting data values. Sorting operation should have resulted in no changes
- self.assertEqual(dataX, sortedX.tolist())
- self.assertEqual(dataY, sortedY.tolist())
- self.assertEqual(dataE, sortedE.tolist())
- DeleteWorkspace(unsortedws)
- DeleteWorkspace(sortedws)
-
- def test_x_descending(self):
- dataX = [3., 2., 1.] # In descending order, so y and e will need to be reversed.
- dataY = [1., 2., 3.]
- dataE = [1., 2., 3.]
- unsortedws = CreateWorkspace(DataX=dataX,DataY=dataY,DataE=dataE,UnitX='TOF',Distribution=True)
- # Run the algorithm
- sortedws = SortXAxis(InputWorkspace=unsortedws)
- sortedX = sortedws.readX(0)
- sortedY = sortedws.readY(0)
- sortedE = sortedws.readE(0)
- # Check the resulting data values.
- self.assertEqual(sorted(dataX), sortedX.tolist())
- dataY.reverse()
- dataE.reverse()
- self.assertEqual(dataY, sortedY.tolist())
- self.assertEqual(dataE, sortedE.tolist())
- DeleteWorkspace(unsortedws)
- DeleteWorkspace(sortedws)
-
- def test_on_multiple_spectrum(self):
- dataX = [3., 2., 1., 3., 2., 1.] # In descending order, so y and e will need to be reversed.
- dataY = [1., 2., 3., 1., 2., 3.]
- dataE = [1., 2., 3., 1., 2., 3.]
- unsortedws = CreateWorkspace(DataX=dataX,DataY=dataY,DataE=dataE,UnitX='TOF',Distribution=True, NSpec=2)
- dataY.reverse()
- dataE.reverse()
- # Run the algorithm
- sortedws = SortXAxis(InputWorkspace=unsortedws)
- # Check the resulting data values for 1st spectrum.
- sortedX = sortedws.readX(0)
- sortedY = sortedws.readY(0)
- sortedE = sortedws.readE(0)
- self.assertEqual(sorted(dataX[0:3]), sortedX.tolist())
- self.assertEqual(dataY[0:3], sortedY.tolist())
- self.assertEqual(dataE[0:3], sortedE.tolist())
- # Check the resulting data values for 2nd spectrum.
- sortedX = sortedws.readX(1)
- sortedY = sortedws.readY(1)
- sortedE = sortedws.readE(1)
- self.assertEqual(sorted(dataX[3:]), sortedX.tolist())
- self.assertEqual(dataY[3:], sortedY.tolist())
- self.assertEqual(dataE[3:], sortedE.tolist())
- DeleteWorkspace(unsortedws)
- DeleteWorkspace(sortedws)
-
- def test_sorts_x_histogram_ascending(self):
- dataX = [1., 2., 3., 4.]
- dataY = [1., 2., 3.]
- dataE = [1., 2., 3.]
- unsortedws = CreateWorkspace(DataX=dataX,DataY=dataY,DataE=dataE,UnitX='TOF',Distribution=False)
- # Run the algorithm
- sortedws = SortXAxis(InputWorkspace=unsortedws)
- sortedX = sortedws.readX(0)
- sortedY = sortedws.readY(0)
- sortedE = sortedws.readE(0)
- # Check the resulting data values. Sorting operation should have resulted in no changes
- self.assertEqual(dataX, sortedX.tolist())
- self.assertEqual(dataY, sortedY.tolist())
- self.assertEqual(dataE, sortedE.tolist())
-
- DeleteWorkspace(unsortedws)
- DeleteWorkspace(sortedws)
-
- def test_sorts_x_histogram_descending(self):
- dataX = [4., 3., 2., 1.]
- dataY = [1., 2., 3.]
- dataE = [1., 2., 3.]
- unsortedws = CreateWorkspace(DataX=dataX,DataY=dataY,DataE=dataE,UnitX='TOF',Distribution=False)
- # Run the algorithm
- sortedws = SortXAxis(InputWorkspace=unsortedws)
- sortedX = sortedws.readX(0)
- sortedY = sortedws.readY(0)
- sortedE = sortedws.readE(0)
- # Check the resulting data values. Sorting operation should have resulted in no changes
- self.assertEqual(sorted(dataX), sortedX.tolist())
- dataY.reverse()
- dataE.reverse()
- self.assertEqual(dataY, sortedY.tolist())
- self.assertEqual(dataE, sortedE.tolist())
-
- DeleteWorkspace(unsortedws)
- DeleteWorkspace(sortedws)
-
- def test_sort_x_works_child(self):
- # Create unsorted workspace
- parent = AlgorithmManager.createUnmanaged('Load')
- create_ws_alg = parent.createChildAlgorithm("CreateWorkspace")
- dataX = [4., 3., 2., 1.]
- dataY = [1., 2., 3.]
- dataE = [1., 2., 3.]
- create_ws_alg.setProperty("DataX", dataX)
- create_ws_alg.setProperty("DataY", dataY)
- create_ws_alg.setProperty("DataE", dataE)
- create_ws_alg.setProperty("UnitX",'TOF')
- create_ws_alg.setProperty("Distribution", False)
- create_ws_alg.execute()
- # Run the algorithm
- sort_alg = parent.createChildAlgorithm("SortXAxis")
- sort_alg.setProperty("InputWorkspace", create_ws_alg.getProperty("OutputWorkspace").value)
- sort_alg.execute()
- # Check the resulting data values. Sorting operation should have resulted in no changes
- sortedws = sort_alg.getProperty("OutputWorkspace").value
- sortedX = sortedws.readX(0)
- sortedY = sortedws.readY(0)
- sortedE = sortedws.readE(0)
- self.assertEqual(sorted(dataX), sortedX.tolist())
- dataY.reverse()
- dataE.reverse()
- self.assertEqual(dataY, sortedY.tolist())
- self.assertEqual(dataE, sortedE.tolist())
-
- def test_dx_multiple_spectrum(self):
- dataX = [3, 2, 1, 3, 2, 1] # In descending order, so y and e will need to be reversed.
- dataY = [1, 2, 3, 1, 2, 3]
- dx = [1, 2, 3, 1, 2, 3]
- unsortedws = CreateWorkspace(DataX=dataX, DataY=dataY, Dx=dx, UnitX='TOF', Distribution=True, NSpec=2)
- dx.reverse()
- # Run the algorithm
- sortedws = SortXAxis(InputWorkspace=unsortedws)
- # Check the resulting data values for 1st spectrum.
- sortedDx = sortedws.readDx(0)
- self.assertEqual(dx[0:3], sortedDx.tolist())
- # Check the resulting data values for 2nd spectrum.
- sortedDx = sortedws.readDx(1)
- self.assertEqual(dx[3:], sortedDx.tolist())
- DeleteWorkspace(unsortedws)
- DeleteWorkspace(sortedws)
-
- def test_dx_histogram_ascending(self):
- dataX = [1., 2., 3., 4.]
- dataY = [1., 2., 3.]
- dx = [1., 2., 3.]
- unsortedws = CreateWorkspace(DataX=dataX, DataY=dataY, Dx=dx, UnitX='TOF', Distribution=False)
- # Run the algorithm
- sortedws = SortXAxis(InputWorkspace=unsortedws)
- sortedDx = sortedws.readDx(0)
- # Check the resulting data values. Sorting operation should have resulted in no changes
- self.assertEqual(dx, sortedDx.tolist())
- DeleteWorkspace(unsortedws)
- DeleteWorkspace(sortedws)
-
- def test_sort_descending(self):
- dataX = [1., 2., 3., 4.]
- dataY = [1., 2., 3.]
- unsortedws = CreateWorkspace(DataX=dataX, DataY=dataY, UnitX='TOF', Distribution=False)
- # Run the algorithm
- sortedws = SortXAxis(InputWorkspace=unsortedws, Ordering="Descending")
- sortedX = sortedws.readX(0)
- sortedY = sortedws.readY(0)
- # Check the resulting data values. Sorting operation should have resulted in no changes
- self.assertEqual([4., 3., 2., 1.], sortedX.tolist())
- self.assertEqual([3., 2., 1.], sortedY.tolist())
- DeleteWorkspace(unsortedws)
- DeleteWorkspace(sortedws)
-
-if __name__ == '__main__':
- unittest.main()
diff --git a/Framework/PythonInterface/test/python/plugins/algorithms/WorkflowAlgorithms/LoadWANDTest.py b/Framework/PythonInterface/test/python/plugins/algorithms/WorkflowAlgorithms/LoadWANDTest.py
index b0d5a4746ffc20ad922f0d5afeddafe1eaab9603..21ffa1ac0bfda45dc032c35be1b8347b3b430193 100644
--- a/Framework/PythonInterface/test/python/plugins/algorithms/WorkflowAlgorithms/LoadWANDTest.py
+++ b/Framework/PythonInterface/test/python/plugins/algorithms/WorkflowAlgorithms/LoadWANDTest.py
@@ -6,11 +6,11 @@ import unittest
class LoadWANDTest(unittest.TestCase):
def test(self):
- ws = LoadWAND('HB2C_7000.nxs.h5')
+ ws = LoadWAND('HB2C_7000.nxs.h5', Grouping='2x2')
self.assertTrue(ws)
self.assertEquals(ws.blocksize(), 1)
- self.assertEquals(ws.getNumberHistograms(), 1966080)
- self.assertEquals(ws.readY(1031100), 5)
+ self.assertEquals(ws.getNumberHistograms(), 1966080//4)
+ self.assertEquals(ws.readY(257775), 4)
self.assertEquals(ws.run().getProtonCharge(), 907880)
self.assertAlmostEqual(ws.run().getGoniometer().getEulerAngles()[0], -142.6)
self.assertEquals(ws.run().getLogData('Wavelength').value, 1.488)
diff --git a/Framework/TestHelpers/inc/MantidTestHelpers/HistogramDataTestHelper.h b/Framework/TestHelpers/inc/MantidTestHelpers/HistogramDataTestHelper.h
deleted file mode 100644
index 703373a09adfd84bcc3a69042e428ce3f6a67900..0000000000000000000000000000000000000000
--- a/Framework/TestHelpers/inc/MantidTestHelpers/HistogramDataTestHelper.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/*********************************************************************************
- * PLEASE READ THIS!!!!!!!
- *
- * This header MAY ONLY be included from a test using Histogram types.
- *********************************************************************************/
-
-#ifndef HISTOGRAMDATATESTHELPER_H
-#define HISTOGRAMDATATESTHELPER_H
-
-#include <MantidHistogramData/FixedLengthVector.h>
-
-namespace Mantid {
-namespace HistogramData {
-namespace detail {
-template <class T>
-bool operator==(
- const Mantid::HistogramData::detail::FixedLengthVector<T> &lhs,
- const Mantid::HistogramData::detail::FixedLengthVector<T> &rhs) {
- return lhs.rawData() == rhs.rawData();
-}
-} // namespace detail
-} // namespace HistogramData
-} // namespace Mantid
-#endif // HISTGRAMDATATESTHELPER_H
\ No newline at end of file
diff --git a/Framework/Types/inc/MantidTypes/SpectrumDefinition.h b/Framework/Types/inc/MantidTypes/SpectrumDefinition.h
index 4276b2ef7431ff33af7e87e4d9bff485e971cc77..84df7c9909a647259c64a7298a1bdf849eef8b59 100644
--- a/Framework/Types/inc/MantidTypes/SpectrumDefinition.h
+++ b/Framework/Types/inc/MantidTypes/SpectrumDefinition.h
@@ -45,6 +45,7 @@ public:
explicit SpectrumDefinition(const size_t detectorIndex,
const size_t timeIndex = 0)
: m_data{{detectorIndex, timeIndex}} {}
+
/// Returns the size of the SpectrumDefinition, i.e., the number of detectors
/// (or rather detector positions) that the spectrum comprises.
size_t size() const { return m_data.size(); }
diff --git a/Framework/WorkflowAlgorithms/src/AlignAndFocusPowder.cpp b/Framework/WorkflowAlgorithms/src/AlignAndFocusPowder.cpp
index b9cdd5c8f922d67d845db56728bf544316a95d5c..57fa1b1a7b7beeb491ff2883c47f154128e34195 100644
--- a/Framework/WorkflowAlgorithms/src/AlignAndFocusPowder.cpp
+++ b/Framework/WorkflowAlgorithms/src/AlignAndFocusPowder.cpp
@@ -10,7 +10,9 @@
#include "MantidDataObjects/TableWorkspace.h"
#include "MantidDataObjects/Workspace2D.h"
#include "MantidKernel/ArrayProperty.h"
+#include "MantidKernel/BoundedValidator.h"
#include "MantidKernel/ConfigService.h"
+#include "MantidKernel/DateTimeValidator.h"
#include "MantidKernel/EnabledWhenProperty.h"
#include "MantidKernel/InstrumentInfo.h"
#include "MantidKernel/PropertyManager.h"
@@ -116,10 +118,30 @@ void AlignAndFocusPowder::init() {
"Width of events (in "
"microseconds) near the prompt "
"pulse to remove. 0 disables");
- declareProperty("CompressTolerance", 0.01,
+ auto mustBePositive = boost::make_shared<BoundedValidator<double>>();
+ mustBePositive->setLower(0.0);
+ declareProperty(make_unique<PropertyWithValue<double>>("CompressTolerance",
+ 1e-5, mustBePositive,
+ Direction::Input),
"Compress events (in "
"microseconds) within this "
- "tolerance. (Default 0.01) ");
+ "tolerance. (Default 0.01)");
+ declareProperty(
+ make_unique<PropertyWithValue<double>>("CompressWallClockTolerance",
+ EMPTY_DBL(), mustBePositive,
+ Direction::Input),
+ "The tolerance (in seconds) on the wall-clock time for comparison. Unset "
+ "means compressing all wall-clock times together disabling pulsetime "
+ "resolution.");
+
+ auto dateValidator = boost::make_shared<DateTimeValidator>();
+ dateValidator->allowEmpty(true);
+ declareProperty(
+ "CompressStartTime", "", dateValidator,
+ "An ISO formatted date/time string specifying the timestamp for "
+ "starting filtering. Ignored if WallClockTolerance is not specified. "
+ "Default is start of run",
+ Direction::Input);
declareProperty("UnwrapRef", 0.,
"Reference total flight path for frame "
"unwrapping. Zero skips the correction");
@@ -358,14 +380,22 @@ void AlignAndFocusPowder::exec() {
if (m_inputEW) {
double tolerance = getProperty("CompressTolerance");
if (tolerance > 0.) {
- g_log.information() << "running CompressEvents(Tolerance=" << tolerance
- << ") started at "
+ double wallClockTolerance = getProperty("CompressWallClockTolerance");
+ g_log.information() << "running CompressEvents(Tolerance=" << tolerance;
+ if (!isEmpty(wallClockTolerance))
+ g_log.information() << " and WallClockTolerance=" << wallClockTolerance;
+ g_log.information() << ") started at "
<< Types::Core::DateAndTime::getCurrentTime() << "\n";
API::IAlgorithm_sptr compressAlg = createChildAlgorithm("CompressEvents");
compressAlg->setProperty("InputWorkspace", m_outputEW);
compressAlg->setProperty("OutputWorkspace", m_outputEW);
compressAlg->setProperty("OutputWorkspace", m_outputEW);
compressAlg->setProperty("Tolerance", tolerance);
+ if (!isEmpty(wallClockTolerance)) {
+ compressAlg->setProperty("WallClockTolerance", wallClockTolerance);
+ compressAlg->setPropertyValue("StartTime",
+ getPropertyValue("CompressStartTime"));
+ }
compressAlg->executeAsChildAlg();
m_outputEW = compressAlg->getProperty("OutputWorkspace");
m_outputW = boost::dynamic_pointer_cast<MatrixWorkspace>(m_outputEW);
@@ -649,14 +679,22 @@ void AlignAndFocusPowder::exec() {
double tolerance = getProperty("CompressTolerance");
m_outputEW = boost::dynamic_pointer_cast<EventWorkspace>(m_outputW);
if ((m_outputEW) && (tolerance > 0.)) {
- g_log.information() << "running CompressEvents(Tolerance=" << tolerance
- << ") started at "
+ double wallClockTolerance = getProperty("CompressWallClockTolerance");
+ g_log.information() << "running CompressEvents(Tolerance=" << tolerance;
+ if (!isEmpty(wallClockTolerance))
+ g_log.information() << " and WallClockTolerance=" << wallClockTolerance;
+ g_log.information() << ") started at "
<< Types::Core::DateAndTime::getCurrentTime() << "\n";
API::IAlgorithm_sptr compressAlg = createChildAlgorithm("CompressEvents");
compressAlg->setProperty("InputWorkspace", m_outputEW);
compressAlg->setProperty("OutputWorkspace", m_outputEW);
compressAlg->setProperty("OutputWorkspace", m_outputEW);
compressAlg->setProperty("Tolerance", tolerance);
+ if (!isEmpty(wallClockTolerance)) {
+ compressAlg->setProperty("WallClockTolerance", wallClockTolerance);
+ compressAlg->setPropertyValue("StartTime",
+ getPropertyValue("CompressStartTime"));
+ }
compressAlg->executeAsChildAlg();
m_outputEW = compressAlg->getProperty("OutputWorkspace");
m_outputW = boost::dynamic_pointer_cast<MatrixWorkspace>(m_outputEW);
diff --git a/MantidPlot/CMakeLists.txt b/MantidPlot/CMakeLists.txt
index 7d114bcccc73e7fd702e531532b1f6067f470953..66d1fff962807c4399153f6f3453780ac873e6c4 100644
--- a/MantidPlot/CMakeLists.txt
+++ b/MantidPlot/CMakeLists.txt
@@ -455,7 +455,7 @@ add_custom_command ( OUTPUT ${SIP_SRC_AUTO}
-I ${PYQT4_SIP_DIR} ${MANTIDQTPYTHON_SIP_INCLUDES} ${PYQT4_SIP_FLAGS}
-c ${CMAKE_CURRENT_BINARY_DIR} -j1 -w -o
${SIP_SPEC}
- DEPENDS ${SIP_INCLUDE_DIRECTORY}/sip.h src/qti.sip ${QTI_SIP_HDRS} ../qt/python/mantidqtpython/mantidqtpython_def.sip
+ DEPENDS ${SIP_INCLUDE_DIR}/sip.h src/qti.sip ${QTI_SIP_HDRS} ../qt/python/mantidqtpython/mantidqtpython_def.sip
COMMENT "Generating python bindings using sip"
)
diff --git a/MantidPlot/pymantidplot/__init__.py b/MantidPlot/pymantidplot/__init__.py
index bf537f68c501e696c644af7f503ed09e47a29112..fe00aacdcaa078cf3939c1d557bc48cf05b973db 100644
--- a/MantidPlot/pymantidplot/__init__.py
+++ b/MantidPlot/pymantidplot/__init__.py
@@ -57,17 +57,17 @@ def _get_analysis_data_service():
# -------------------------- Wrapped MantidPlot functions -----------------
-def runPythonScript(code, async=False, quiet=False, redirect=True):
+def runPythonScript(code, asynchronous=False, quiet=False, redirect=True):
"""
Redirects the runPythonScript method to the app object
@param code :: A string of code to execute
- @param async :: If the true the code is executed in a separate thread
+ @param asynchronous :: If the true the code is executed in a separate thread
@param quiet :: If true no messages reporting status are issued
@param redirect :: If true then output is redirected to MantidPlot
"""
- if async and QtCore.QThread.currentThread() != QtGui.qApp.thread():
- async = False
- threadsafe_call(_qti.app.runPythonScript, code, async, quiet, redirect)
+ if asynchronous and QtCore.QThread.currentThread() != QtGui.qApp.thread():
+ asynchronous = False
+ threadsafe_call(_qti.app.runPythonScript, code, asynchronous, quiet, redirect)
# Overload for consistency with qtiplot table(..) & matrix(..) commands
diff --git a/MantidPlot/src/ApplicationWindow.cpp b/MantidPlot/src/ApplicationWindow.cpp
index bdf705dc943f2f802c34aa3cf75cf5df5fa6b716..e0d36ee1e5b8c485b0f8a02df64bea87ec1667dc 100644
--- a/MantidPlot/src/ApplicationWindow.cpp
+++ b/MantidPlot/src/ApplicationWindow.cpp
@@ -5327,7 +5327,7 @@ void ApplicationWindow::saveSettings() {
#endif
// Root level is named "General" by Qt
- resultsLog->writeSettings(&settings);
+ resultsLog->writeSettings(settings);
// Our named group General, displayed as %General in the file
settings.beginGroup("/General");
diff --git a/MantidPlot/src/ApplicationWindow.h b/MantidPlot/src/ApplicationWindow.h
index 1e0122798c3b7846121c284c68e50acb3d48b8fc..61c1c66d5db19de26b8e15fb6385d817311660b8 100644
--- a/MantidPlot/src/ApplicationWindow.h
+++ b/MantidPlot/src/ApplicationWindow.h
@@ -257,7 +257,7 @@ public slots:
int lineNumber);
/// Runs an arbitrary lump of python code, return true/false on
/// success/failure.
- bool runPythonScript(const QString &code, bool async = false,
+ bool runPythonScript(const QString &code, bool asynchronous = false,
bool quiet = false, bool redirect = true);
QList<MdiSubWindow *> windowsList() const;
diff --git a/MantidPlot/src/Mantid/MantidUI.cpp b/MantidPlot/src/Mantid/MantidUI.cpp
index 120e93633bed2ba2ced2a0eb66e115f5698881ff..c23e6a1074c23fb102533da74820cdf2759b1aa5 100644
--- a/MantidPlot/src/Mantid/MantidUI.cpp
+++ b/MantidPlot/src/Mantid/MantidUI.cpp
@@ -1563,16 +1563,10 @@ bool MantidUI::canAcceptDrop(QDragEnterEvent *e) {
bool MantidUI::drop(QDropEvent *e) {
QString name = e->mimeData()->objectName();
if (name == "MantidWorkspace") {
- QString text = e->mimeData()->text();
- int endIndex = 0;
- QStringList wsNames;
- while (text.indexOf("[\"", endIndex) > -1) {
- int startIndex = text.indexOf("[\"", endIndex) + 2;
- endIndex = text.indexOf("\"]", startIndex);
- wsNames.append(text.mid(startIndex, endIndex - startIndex));
+ QStringList wsNames = e->mimeData()->text().split("\n");
+ for (const auto &wsName : wsNames) {
+ importWorkspace(wsName, false);
}
-
- foreach (const auto &wsName, wsNames) { importWorkspace(wsName, false); }
return true;
} else if (e->mimeData()->hasUrls()) {
const auto pyFiles = DropEventHelper::extractPythonFiles(e);
diff --git a/MantidPlot/src/ProjectRecovery.cpp b/MantidPlot/src/ProjectRecovery.cpp
index b5f112c34d08988843259323687746561d523a26..2195d3b9300f8a1a14834899e0aa09f37bdf8ed7 100644
--- a/MantidPlot/src/ProjectRecovery.cpp
+++ b/MantidPlot/src/ProjectRecovery.cpp
@@ -373,7 +373,7 @@ void ProjectRecovery::loadRecoveryCheckpoint(const Poco::Path &recoveryFolder) {
// Restart project recovery when the async part finishes
clearAllCheckpoints();
startProjectSaving();
-}
+} // namespace MantidQt
/**
* Compiles the project recovery script from a given checkpoint
@@ -470,8 +470,8 @@ void ProjectRecovery::saveOpenWindows(const std::string &projectDestFile) {
Qt::BlockingQueuedConnection,
Q_RETURN_ARG(bool, saveCompleted),
Q_ARG(const std::string, projectDestFile))) {
- throw std::runtime_error(
- "Project Recovery: Failed to save project windows - Qt binding failed");
+ throw std::runtime_error("Project Recovery: Failed to save project "
+ "windows - Qt binding failed");
}
if (!saveCompleted) {
diff --git a/MantidPlot/src/qti.sip b/MantidPlot/src/qti.sip
index 2972608196c575f291d27c6678b8a8d48bb0460e..679cf688fb15308704c0ee85321019cf3b5de161 100644
--- a/MantidPlot/src/qti.sip
+++ b/MantidPlot/src/qti.sip
@@ -1103,7 +1103,7 @@ sipType=sipFindType(sipCpp->metaObject()->className());
public:
void setExitCode(int code);
- bool runPythonScript(const QString & code, const bool async = false,
+ bool runPythonScript(const QString & code, const bool asynchronous = false,
bool quiet=false, bool redirect=true);
enum MatrixToTableConversion{Direct, XYZ, YXZ};
diff --git a/Testing/SystemTests/lib/systemtests/stresstesting.py b/Testing/SystemTests/lib/systemtests/stresstesting.py
index 6d7d12bc24ae83b6186b532a928f1549414e4f09..92efbd7a86f640de138235b3ded0b161f129a8e0 100644
--- a/Testing/SystemTests/lib/systemtests/stresstesting.py
+++ b/Testing/SystemTests/lib/systemtests/stresstesting.py
@@ -933,7 +933,6 @@ class MantidFrameworkConfig:
# Up the log level so that failures can give useful information
config['logging.loggers.root.level'] = self.__loglevel
- config['logging.channels.consoleFilterChannel.level'] = self.__loglevel
# Set the correct search path
config['datasearch.directories'] = self.__dataDirs
diff --git a/Testing/SystemTests/tests/analysis/LRScalingFactorsTest.py b/Testing/SystemTests/tests/analysis/LRScalingFactorsTest.py
index a501b481cd1f10049b2157d3f425c19ef8a581f7..edf904e295bf7ed368f110605aad31504bda081c 100644
--- a/Testing/SystemTests/tests/analysis/LRScalingFactorsTest.py
+++ b/Testing/SystemTests/tests/analysis/LRScalingFactorsTest.py
@@ -25,6 +25,7 @@ class LRPrimaryFractionTest(stresstesting.MantidStressTest):
TOFRange=[10008, 35000], TOFSteps=200,
SignalPeakPixelRange=[150, 160],
SignalBackgroundPixelRange=[147, 163],
+ LowResolutionPixelRange=[94, 160],
ScalingFactorFile=self.cfg_file)
def validate(self):
diff --git a/buildconfig/CMake/LinuxPackageScripts.cmake b/buildconfig/CMake/LinuxPackageScripts.cmake
index 4e70e144b791cfe3b02a08f77f0acd7b8ec31253..8fb1be25b6be2633e98510ccc7f2dab2ece4510a 100644
--- a/buildconfig/CMake/LinuxPackageScripts.cmake
+++ b/buildconfig/CMake/LinuxPackageScripts.cmake
@@ -3,6 +3,9 @@
#
# It provides:
# - launch_mantidplot.sh
+# - launch_mantidworkbench.sh
+# - mantid.sh <- for stable releases
+# - mantid.csh <- for stable releases
#
###########################################################################
@@ -17,7 +20,7 @@ set ( PLUGINS_DIR plugins )
# Separate directory of plugins to be discovered by the ParaView framework
# These cannot be mixed with our other plugins. Further sub-directories
# based on the Qt version will also be created by the installation targets
-set ( PVPLUGINS_SUBDIR paraview )
+set ( PVPLUGINS_DIR "plugins/paraview/qt4/" )
if ( CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT )
set ( CMAKE_INSTALL_PREFIX /opt/mantid${CPACK_PACKAGE_SUFFIX} CACHE PATH "Install path" FORCE )
@@ -34,7 +37,7 @@ set ( CPACK_RPM_EXCLUDE_FROM_AUTO_FILELIST_ADDITION /opt /usr/share/applications
file ( WRITE ${CMAKE_CURRENT_BINARY_DIR}/mantid.sh
"#!/bin/sh\n"
"MANTIDPATH=${CMAKE_INSTALL_PREFIX}/${BIN_DIR}\n"
- "PV_PLUGIN_PATH=${CMAKE_INSTALL_PREFIX}/${PVPLUGINS_DIR}/${PVPLUGINS_DIR}\n"
+ "PV_PLUGIN_PATH=${CMAKE_INSTALL_PREFIX}/${PVPLUGINS_DIR}\n"
"PATH=$PATH:$MANTIDPATH\n"
"export MANTIDPATH PV_PLUGIN_PATH PATH\n"
@@ -44,7 +47,7 @@ file ( WRITE ${CMAKE_CURRENT_BINARY_DIR}/mantid.sh
file ( WRITE ${CMAKE_CURRENT_BINARY_DIR}/mantid.csh
"#!/bin/csh\n"
"setenv MANTIDPATH \"${CMAKE_INSTALL_PREFIX}/${BIN_DIR}\"\n"
- "setenv PV_PLUGIN_PATH \"${CMAKE_INSTALL_PREFIX}/${PVPLUGINS_DIR}/${PVPLUGINS_DIR}\"\n"
+ "setenv PV_PLUGIN_PATH \"${CMAKE_INSTALL_PREFIX}/${PVPLUGINS_DIR}\"\n"
"setenv PATH \"\${PATH}:\${MANTIDPATH}\"\n"
)
@@ -132,6 +135,17 @@ endif()
############################################################################
# Launcher scripts
############################################################################
+# common definition of work for virtualgl - lots of escaping things from cmake
+set ( VIRTUAL_GL_WRAPPER
+"# whether or not to use vglrun
+if [ -n \"\${NXSESSIONID}\" ]; then
+ command -v vglrun >/dev/null 2>&1 || { echo >&2 \"MantidPlot requires VirtualGL but it's not installed. Aborting.\"; exit 1; }
+ VGLRUN=\"vglrun\"
+elif [ -n \"\${TLSESSIONDATA}\" ]; then
+ command -v vglrun >/dev/null 2>&1 || { echo >&2 \"MantidPlot requires VirtualGL but it's not installed. Aborting.\"; exit 1; }
+ VGLRUN=\"vglrun\"
+fi" )
+
# The scripts need tcmalloc to be resolved to the runtime library as the plain
# .so symlink is only present when a -dev/-devel package is present
if ( TCMALLOC_FOUND )
@@ -140,6 +154,46 @@ if ( TCMALLOC_FOUND )
string( REGEX REPLACE "([0-9]+)\.[0-9]+\.[0-9]+$" "\\1" TCMALLOC_RUNTIME_LIB ${TCMALLOC_RUNTIME_LIB} )
endif ()
+# definitions to preload tcmalloc
+set ( TCMALLOC_DEFINITIONS
+"# Define parameters for tcmalloc
+LOCAL_PRELOAD=${TCMALLOC_RUNTIME_LIB}
+if [ -n \"\${LD_PRELOAD}\" ]; then
+ LOCAL_PRELOAD=\${LOCAL_PRELOAD}:\${LD_PRELOAD}
+fi
+if [ -z \"\${TCMALLOC_RELEASE_RATE}\" ]; then
+ TCM_RELEASE=10000
+else
+ TCM_RELEASE=\${TCMALLOC_RELEASE_RATE}
+fi
+
+# Define when to report large memory allocation
+if [ -z \"\${TCMALLOC_LARGE_ALLOC_REPORT_THRESHOLD}\" ]; then
+ # total available memory
+ TCM_REPORT=\$(grep MemTotal /proc/meminfo --color=never | awk '{print \$2}')
+ # half of available memory
+ TCM_REPORT=`expr 512 \\* \$TCM_REPORT`
+ # minimum is 1GB
+ if [ \${TCM_REPORT} -le 1073741824 ]; then
+ TCM_REPORT=1073741824
+ fi
+else
+ TCM_REPORT=\${TCMALLOC_LARGE_ALLOC_REPORT_THRESHOLD}
+fi" )
+
+# chunk of code for fixing MANTIDPATH
+set ( MTD_PATH_DEFINITION "MANTIDPATH=\${INSTALLDIR}/bin" )
+
+# chunk of code for launching gdb
+set ( GDB_DEFINITIONS
+"# run with gdb THIS OPTION MUST BE SUPPLIED FIRST
+if [ -n \"\$1\" ] && [ \"\$1\" = \"--debug\" ]; then
+ shift
+ GDB=\"gdb --args\"
+fi" )
+
+set ( ERROR_CMD "ErrorReporter/error_dialog_app.py --exitcode=\$? --directory=\$INSTALLDIR/bin" )
+
# Local dev version
if ( MAKE_VATES )
set ( PARAVIEW_PYTHON_PATHS ":${ParaView_DIR}/lib:${ParaView_DIR}/lib/site-packages" )
@@ -147,15 +201,26 @@ else ()
set ( PARAVIEW_PYTHON_PATHS "" )
endif ()
+set ( LOCAL_PYPATH "\${INSTALLDIR}/bin" )
+set ( SCRIPTSDIR ${CMAKE_HOME_DIRECTORY}/scripts)
+
+# used by mantidplot and mantidworkbench
if (ENABLE_MANTIDPLOT)
set ( MANTIDPLOT_EXEC MantidPlot )
- set ( SCRIPTSDIR ${CMAKE_HOME_DIRECTORY}/scripts)
configure_file ( ${CMAKE_MODULE_PATH}/Packaging/launch_mantidplot.sh.in
${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/launch_mantidplot.sh @ONLY )
# Needs to be executable
execute_process ( COMMAND "chmod" "+x" "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/launch_mantidplot.sh"
OUTPUT_QUIET ERROR_QUIET )
endif ()
+if (ENABLE_WORKBENCH)
+ set ( MANTIDWORKBENCH_EXEC workbench ) # what the actual thing is called
+ configure_file ( ${CMAKE_MODULE_PATH}/Packaging/launch_mantidworkbench.sh.in
+ ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/launch_mantidworkbench.sh @ONLY )
+ # Needs to be executable
+ execute_process ( COMMAND "chmod" "+x" "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/launch_mantidworkbench.sh"
+ OUTPUT_QUIET ERROR_QUIET )
+endif()
configure_file ( ${CMAKE_MODULE_PATH}/Packaging/mantidpython.in
${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/mantidpython @ONLY )
# Needs to be executable
@@ -168,31 +233,33 @@ execute_process ( COMMAND "chmod" "+x" "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/AddPyt
OUTPUT_QUIET ERROR_QUIET )
# Package version
-set ( EXTRA_LDPATH "\${INSTALLDIR}/../lib/paraview-${ParaView_VERSION_MAJOR}.${ParaView_VERSION_MINOR}" )
if ( MAKE_VATES )
- set ( PV_PYTHON_PATH "\${INSTALLDIR}/../lib/paraview-${ParaView_VERSION_MAJOR}.${ParaView_VERSION_MINOR}" )
+ set ( EXTRA_LDPATH "\${INSTALLDIR}/lib/paraview-${ParaView_VERSION_MAJOR}.${ParaView_VERSION_MINOR}" )
+ set ( PV_PYTHON_PATH "\${INSTALLDIR}/lib/paraview-${ParaView_VERSION_MAJOR}.${ParaView_VERSION_MINOR}" )
set ( PARAVIEW_PYTHON_PATHS ":${PV_PYTHON_PATH}:${PV_PYTHON_PATH}/site-packages:${PV_PYTHON_PATH}/site-packages/vtk" )
else ()
set ( PARAVIEW_PYTHON_PATHS "" )
endif ()
+# used by mantidplot and mantidworkbench
+set ( LOCAL_PYPATH "\${INSTALLDIR}/lib:\${INSTALLDIR}/plugins" )
+set ( SCRIPTSDIR "\${INSTALLDIR}/scripts")
+
if (ENABLE_MANTIDPLOT)
set ( MANTIDPLOT_EXEC MantidPlot_exe )
- set ( SCRIPTSDIR "\${INSTALLDIR}/../scripts")
configure_file ( ${CMAKE_MODULE_PATH}/Packaging/launch_mantidplot.sh.in
${CMAKE_CURRENT_BINARY_DIR}/launch_mantidplot.sh.install @ONLY )
- install ( FILES ${CMAKE_CURRENT_BINARY_DIR}/launch_mantidplot.sh.install
- DESTINATION ${BIN_DIR} RENAME launch_mantidplot.sh
- PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ
- GROUP_EXECUTE GROUP_READ
- WORLD_EXECUTE WORLD_READ
- )
+ install ( PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/launch_mantidplot.sh.install
+ DESTINATION ${BIN_DIR} RENAME launch_mantidplot.sh )
endif ()
+if (PACKAGE_WORKBENCH) # will eventually switch to ENABLE_WORKBENCH
+ set ( MANTIDWORKBENCH_EXEC workbench ) # what the actual thing is called
+ configure_file ( ${CMAKE_MODULE_PATH}/Packaging/launch_mantidworkbench.sh.in
+ ${CMAKE_CURRENT_BINARY_DIR}/launch_mantidworkbench.sh.install @ONLY )
+ install ( PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/launch_mantidworkbench.sh.install
+ DESTINATION ${BIN_DIR} RENAME mantidworkbench )
+endif()
configure_file ( ${CMAKE_MODULE_PATH}/Packaging/mantidpython.in
${CMAKE_CURRENT_BINARY_DIR}/mantidpython.install @ONLY )
-install ( FILES ${CMAKE_CURRENT_BINARY_DIR}/mantidpython.install
- DESTINATION ${BIN_DIR} RENAME mantidpython
- PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ
- GROUP_EXECUTE GROUP_READ
- WORLD_EXECUTE WORLD_READ
-)
+install ( PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/mantidpython.install
+ DESTINATION ${BIN_DIR} RENAME mantidpython )
diff --git a/buildconfig/CMake/Packaging/launch_mantidplot.sh.in b/buildconfig/CMake/Packaging/launch_mantidplot.sh.in
index a8822b897ea6f5f97d204ae12853012924a03cb7..dc4c9d534d9ecfa1500ea81080660b4553a1328a 100644
--- a/buildconfig/CMake/Packaging/launch_mantidplot.sh.in
+++ b/buildconfig/CMake/Packaging/launch_mantidplot.sh.in
@@ -6,49 +6,18 @@
# Find out where we are
THISFILE=$(readlink -f "$0")
-INSTALLDIR=$(echo $THISFILE | sed -r -e 's|^(.*)/(.*)$|\1|g') #.* is greedy and eats up until the final slash
+INSTALLDIR=$(dirname $THISFILE) # directory of executable
+INSTALLDIR=$(dirname $INSTALLDIR) # root install directory
-# Define extra libraries and load paths
-LOCAL_PRELOAD=@TCMALLOC_RUNTIME_LIB@
-if [ -n "${LD_PRELOAD}" ]; then
- LOCAL_PRELOAD=${LOCAL_PRELOAD}:${LD_PRELOAD}
-fi
-if [ -z "${TCMALLOC_RELEASE_RATE}" ]; then
- TCM_RELEASE=10000
-else
- TCM_RELEASE=${TCMALLOC_RELEASE_RATE}
-fi
+@MTD_PATH_DEFINITION@
-if [ -n "${NXSESSIONID}" ]; then
- command -v vglrun >/dev/null 2>&1 || { echo >&2 "MantidPlot requires VirtualGL but it's not installed. Aborting."; exit 1; }
- VGLRUN="vglrun"
-elif [ -n "${TLSESSIONDATA}" ]; then
- command -v vglrun >/dev/null 2>&1 || { echo >&2 "MantidPlot requires VirtualGL but it's not installed. Aborting."; exit 1; }
- VGLRUN="vglrun"
-fi
+@TCMALLOC_DEFINITIONS@
-# Define when to report large memory allocation
-if [ -z "${TCMALLOC_LARGE_ALLOC_REPORT_THRESHOLD}" ]; then
- # total available memory
- TCM_REPORT=$(grep MemTotal /proc/meminfo --color=never | awk '{print $2}')
- # half of available memory
- TCM_REPORT=`expr 512 \* $TCM_REPORT`
- # minimum is 1GB
- if [ ${TCM_REPORT} -le 1073741824 ]; then
- TCM_REPORT=1073741824
- fi
-else
- TCM_REPORT=${TCMALLOC_LARGE_ALLOC_REPORT_THRESHOLD}
-fi
-
-# run with gdb THIS OPTION MUST BE SUPPLIED FIRST
-if [ -n "$1" ] && [ "$1" = "--debug" ]; then
- shift
- GDB="gdb --args"
-fi
+@VIRTUAL_GL_WRAPPER@
+@GDB_DEFINITIONS@
# Launch
LD_PRELOAD=${LOCAL_PRELOAD} TCMALLOC_RELEASE_RATE=${TCM_RELEASE} \
- TCMALLOC_LARGE_ALLOC_REPORT_THRESHOLD=${TCM_REPORT} QT_API=pyqt \
- @WRAPPER_PREFIX@$VGLRUN $GDB $INSTALLDIR/@MANTIDPLOT_EXEC@ $*@WRAPPER_POSTFIX@ || @PYTHON_EXECUTABLE@ @SCRIPTSDIR@/ErrorReporter/error_dialog_app.py --exitcode=$? --directory=$INSTALLDIR
+ TCMALLOC_LARGE_ALLOC_REPORT_THRESHOLD=${TCM_REPORT} \
+ @WRAPPER_PREFIX@$VGLRUN $GDB $INSTALLDIR/bin/@MANTIDPLOT_EXEC@ $*@WRAPPER_POSTFIX@ || @PYTHON_EXECUTABLE@ @SCRIPTSDIR@/@ERROR_CMD@
diff --git a/buildconfig/CMake/Packaging/launch_mantidworkbench.sh.in b/buildconfig/CMake/Packaging/launch_mantidworkbench.sh.in
new file mode 100644
index 0000000000000000000000000000000000000000..25a5d1354b675f266e61a519bb321768cf9d066f
--- /dev/null
+++ b/buildconfig/CMake/Packaging/launch_mantidworkbench.sh.in
@@ -0,0 +1,29 @@
+#!/bin/sh
+#
+# Launch Mantidplot using any necessary LD_PRELOAD or software collection behaviour
+#
+# Script is configured by CMake
+
+# Find out where we are
+THISFILE=$(readlink -f "$0")
+INSTALLDIR=$(dirname $THISFILE) # directory of executable
+INSTALLDIR=$(dirname $INSTALLDIR) # root install directory
+
+@MTD_PATH_DEFINITION@
+
+@TCMALLOC_DEFINITIONS@
+
+@VIRTUAL_GL_WRAPPER@
+
+# Define where python libraries are
+LOCAL_PYTHONPATH=@LOCAL_PYPATH@@PARAVIEW_PYTHON_PATHS@
+if [ -n "${PYTHONPATH}" ]; then
+ LOCAL_PYTHONPATH=${LOCAL_PYTHONPATH}:${PYTHONPATH}
+fi
+
+@GDB_DEFINITIONS@
+
+LD_PRELOAD=${LOCAL_PRELOAD} TCMALLOC_RELEASE_RATE=${TCM_RELEASE} \
+ TCMALLOC_LARGE_ALLOC_REPORT_THRESHOLD=${TCM_REPORT} \
+ PYTHONPATH=${LOCAL_PYTHONPATH} \
+ @WRAPPER_PREFIX@$VGLRUN $GDB @PYTHON_EXECUTABLE@ $INSTALLDIR/bin/@MANTIDWORKBENCH_EXEC@ $*@WRAPPER_POSTFIX@ || @PYTHON_EXECUTABLE@ @SCRIPTSDIR@/@ERROR_CMD@
diff --git a/buildconfig/CMake/Packaging/mantidpython.in b/buildconfig/CMake/Packaging/mantidpython.in
index 668620b986878f3a36a9dd9e47801860871eb9e4..1b9df21e90ce8a6ec06ea990e83108b3688746df 100755
--- a/buildconfig/CMake/Packaging/mantidpython.in
+++ b/buildconfig/CMake/Packaging/mantidpython.in
@@ -5,74 +5,44 @@
# Script is configured by CMake
# Find out where we are
-SCRIPTFILE=$(readlink -f "$0")
-INSTALLDIR=${SCRIPTFILE%/*}
+THISFILE=$(readlink -f "$0")
+INSTALLDIR=$(dirname $THISFILE) # directory of executable
+INSTALLDIR=$(dirname $INSTALLDIR) # root install directory
-# Define extra libraries and load paths
-LOCAL_PRELOAD=@TCMALLOC_RUNTIME_LIB@
-if [ -n "${LD_PRELOAD}" ]; then
- LOCAL_PRELOAD=${LOCAL_PRELOAD}:${LD_PRELOAD}
-fi
-if [ -z "${TCMALLOC_RELEASE_RATE}" ]; then
- TCM_RELEASE=10000
-else
- TCM_RELEASE=${TCMALLOC_RELEASE_RATE}
-fi
-LOCAL_LDPATH=@EXTRA_LDPATH@:${LD_LIBRARY_PATH}
+@MTD_PATH_DEFINITION@
-# Define when to report large memory allocation
-if [ -z "${TCMALLOC_LARGE_ALLOC_REPORT_THRESHOLD}" ]; then
- # total available memory
- TCM_REPORT=$(grep MemTotal /proc/meminfo --color=never | awk '{print $2}')
- # half of available memory
- TCM_REPORT=`expr 512 \* $TCM_REPORT`
- # minimum is 1GB
- if [ ${TCM_REPORT} -le 1073741824 ]; then
- TCM_REPORT=1073741824
- fi
-else
- TCM_REPORT=${TCMALLOC_LARGE_ALLOC_REPORT_THRESHOLD}
+@TCMALLOC_DEFINITIONS@
+
+LOCAL_LDPATH=@EXTRA_LDPATH@
+if [ -n "${LD_LIBRARY_PATH}" ]; then
+ LOCAL_LDPATH=${LOCAL_LDPATH}:${LD_LIBRARY_PATH}
fi
# Define paraview information
-PV_PLUGIN_PATH="${INSTALLDIR}/pvplugins/pvplugins"
+PV_PLUGIN_PATH="${INSTALLDIR}/plugins/paraview/qt4"
-# Define extra libraries for python
-LOCAL_PYTHONPATH=${INSTALLDIR}@PARAVIEW_PYTHON_PATHS@
+# Define where python libraries are
+LOCAL_PYTHONPATH=${INSTALLDIR}/bin:@LOCAL_PYPATH@@PARAVIEW_PYTHON_PATHS@
if [ -n "${PYTHONPATH}" ]; then
LOCAL_PYTHONPATH=${LOCAL_PYTHONPATH}:${PYTHONPATH}
fi
-# Define QT_API to pyqt if not provided
-if [ -z "${QT_API}" ]; then
- QT_API=pyqt
-fi
-
-# Define MANTIDPATH
-MANTIDPATH="${INSTALLDIR}"
-
if [ -n "$1" ] && [ "$1" = "--classic" ]; then
shift
-
set -- @WRAPPER_PREFIX@@PYTHON_EXECUTABLE@ $*@WRAPPER_POSTFIX@
-
elif [ -n "$1" ] && [ -n "$2" ] && [ "$1" = "-n" ]; then
ranks=$2
shift 2
set -- mpirun -n $ranks @WRAPPER_PREFIX@@PYTHON_EXECUTABLE@ $*@WRAPPER_POSTFIX@
-
else
IPYTHON_STARTUP="import IPython;IPython.start_ipython()"
-
set -- @WRAPPER_PREFIX@@PYTHON_EXECUTABLE@ -c "${IPYTHON_STARTUP}" $*@WRAPPER_POSTFIX@
-
fi
-
LD_PRELOAD=${LOCAL_PRELOAD} TCMALLOC_RELEASE_RATE=${TCM_RELEASE} \
- TCMALLOC_LARGE_ALLOC_REPORT_THRESHOLD=${TCM_REPORT} \
- LD_LIBRARY_PATH=${LOCAL_LDPATH} QT_API=${QT_API} \
- PV_PLUGIN_PATH=${PV_PLUGIN_PATH} \
- MANTIDPATH=${MANTIDPATH} \
- PYTHONPATH=${LOCAL_PYTHONPATH} \
- exec "$@"
+ TCMALLOC_LARGE_ALLOC_REPORT_THRESHOLD=${TCM_REPORT} \
+ PYTHONPATH=${LOCAL_PYTHONPATH} \
+ LD_LIBRARY_PATH=${LOCAL_LDPATH} \
+ PV_PLUGIN_PATH=${PV_PLUGIN_PATH} \
+ exec "$@"
+#
diff --git a/buildconfig/CMake/Packaging/rpm/scripts/rpm_post_install.sh.in b/buildconfig/CMake/Packaging/rpm/scripts/rpm_post_install.sh.in
index 98e6a3106cb167bc5edf26dd5acc56138cc8e5ed..671583b86c43ad6f2908d78ddb3ed39090f7f79c 100644
--- a/buildconfig/CMake/Packaging/rpm/scripts/rpm_post_install.sh.in
+++ b/buildconfig/CMake/Packaging/rpm/scripts/rpm_post_install.sh.in
@@ -12,6 +12,7 @@ if [ -f $RPM_INSTALL_PREFIX0/@BIN_DIR@/MantidPlot ]; then
if [ ! -s $RPM_INSTALL_PREFIX0/@BIN_DIR@/MantidPlot ]; then
ln -s $RPM_INSTALL_PREFIX0/@BIN_DIR@/launch_mantidplot.sh $RPM_INSTALL_PREFIX0/@BIN_DIR@/MantidPlot
fi
+ # create link to old name so upgrading from old packages doesn't delete the executable
if [ ! -s $RPM_INSTALL_PREFIX0/@BIN_DIR@/mantidplot ]; then
ln -s $RPM_INSTALL_PREFIX0/@BIN_DIR@/launch_mantidplot.sh $RPM_INSTALL_PREFIX0/@BIN_DIR@/mantidplot
fi
@@ -24,11 +25,20 @@ if [ ${ENVVARS_ON_INSTALL} -eq 1 ]; then
ln -s $RPM_INSTALL_PREFIX0/@ETC_DIR@/mantid.csh /etc/profile.d/mantid.csh
ln -s $RPM_INSTALL_PREFIX0/@ETC_DIR@/mantid.pth @PYTHON_SITE@/mantid.pth
else
- # Create symbolic links in world's path
- if [ ! -L /usr/bin/mantidplot@CPACK_PACKAGE_SUFFIX@ ]; then
- ln -s $RPM_INSTALL_PREFIX0/@BIN_DIR@/launch_mantidplot.sh /usr/bin/mantidplot@CPACK_PACKAGE_SUFFIX@
+ # symbolic links in world's path of mantidplot
+ if [ -e $RPM_INSTALL_PREFIX0/@BIN_DIR@/mantidplot ]; then
+ if [ ! -L /usr/bin/mantidplot@CPACK_PACKAGE_SUFFIX@ ]; then
+ ln -s $RPM_INSTALL_PREFIX0/@BIN_DIR@/mantidplot /usr/bin/mantidplot@CPACK_PACKAGE_SUFFIX@
+ fi
fi
+ # symbolic link for mantidpython
if [ ! -L /usr/bin/mantidpython@CPACK_PACKAGE_SUFFIX@ ]; then
ln -s $RPM_INSTALL_PREFIX0/@BIN_DIR@/mantidpython /usr/bin/mantidpython@CPACK_PACKAGE_SUFFIX@
fi
+ # link the workbench if it exists
+ if [ -e $RPM_INSTALL_PREFIX0/@BIN_DIR@/mantidworkbench ]; then
+ if [ ! -L /usr/bin/mantidworkbench@CPACK_PACKAGE_SUFFIX@ ]; then
+ ln -s $RPM_INSTALL_PREFIX0/@BIN_DIR@/mantidworkbench /usr/bin/mantidworkbench@CPACK_PACKAGE_SUFFIX@
+ fi
+ fi
fi
diff --git a/buildconfig/CMake/Packaging/rpm/scripts/rpm_post_uninstall.sh.in b/buildconfig/CMake/Packaging/rpm/scripts/rpm_post_uninstall.sh.in
index 3b54e3bb45e7be20ac992f5c472446c0f6eda349..2666433b40c1569ed7e664d65692aef290d01dba 100644
--- a/buildconfig/CMake/Packaging/rpm/scripts/rpm_post_uninstall.sh.in
+++ b/buildconfig/CMake/Packaging/rpm/scripts/rpm_post_uninstall.sh.in
@@ -8,10 +8,11 @@
ENVVARS_ON_INSTALL=@ENVVARS_ON_INSTALL_INT@
# Remove exe and links only if it looks like we were removed
-# and not upgraded. If launch_mantidplot.sh exists then package
-# has been upgraded and MantidPlot_exe replaced so don't touch anything
-if [ ! -e $RPM_INSTALL_PREFIX0/@BIN_DIR@/launch_mantidplot.sh ]; then
- rm $RPM_INSTALL_PREFIX0/@BIN_DIR@/MantidPlot_exe
+# and not upgraded. If $1 == 0 then it's uninstall not upgrade
+if [ $1 -eq 0 ]; then
+ if [ -e $RPM_INSTALL_PREFIX0/@BIN_DIR@/MantidPlot_exe ]; then
+ rm $RPM_INSTALL_PREFIX0/@BIN_DIR@/MantidPlot_exe
+ fi
if [ ${ENVVARS_ON_INSTALL} -eq 1 ]; then
if [ -h /etc/profile.d/mantid.sh ]; then
@@ -40,6 +41,10 @@ if [ ! -e $RPM_INSTALL_PREFIX0/@BIN_DIR@/launch_mantidplot.sh ]; then
if [ -L $RPM_INSTALL_PREFIX0/@BIN_DIR@/mantidplot ]; then
rm $RPM_INSTALL_PREFIX0/@BIN_DIR@/mantidplot
fi
+
+ if [ -L /usr/bin/mantidworkbench@CPACK_PACKAGE_SUFFIX@ ]; then
+ rm /usr/bin/mantidworkbench@CPACK_PACKAGE_SUFFIX@
+ fi
fi
# If the install prefix contains mantid then prune empty directories.
diff --git a/buildconfig/CMake/PythonPackageTargetFunctions.cmake b/buildconfig/CMake/PythonPackageTargetFunctions.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..afcc9daed46436c60aec95292fcc6fc9ac41d0d0
--- /dev/null
+++ b/buildconfig/CMake/PythonPackageTargetFunctions.cmake
@@ -0,0 +1,79 @@
+# Defines functions to help deal with python packages
+
+# Function to create links to python packages in the source tree
+# If the EXECUTABLE option is provided then it additional build rules are
+# defined to ensure startup scripts are regenerated appropriately
+function ( add_python_package pkg_name )
+ # Create a setup.py file if necessary
+ set ( _setup_py ${CMAKE_CURRENT_SOURCE_DIR}/setup.py )
+ set ( _setup_py_build_root ${CMAKE_CURRENT_BINARY_DIR} )
+ if ( EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/setup.py.in" )
+ set ( SETUPTOOLS_BUILD_COMMANDS_DEF
+"def patch_setuptools_command(cmd_cls_name):
+ import importlib
+ cmd_module = importlib.import_module('setuptools.command.' + cmd_cls_name)
+ setuptools_command_cls = getattr(cmd_module, cmd_cls_name)
+
+ class CustomCommand(setuptools_command_cls):
+ user_options = setuptools_command_cls.user_options[:]
+ boolean_options = setuptools_command_cls.boolean_options[:]
+ def finalize_options(self):
+ build_cmd = self.get_finalized_command('build')
+ self.build_lib = '${_setup_py_build_root}/build'
+ setuptools_command_cls.finalize_options(self)
+
+ return CustomCommand
+
+CustomBuildPy = patch_setuptools_command('build_py')
+CustomInstall = patch_setuptools_command('install')
+CustomInstallLib = patch_setuptools_command('install_lib')
+" )
+ set ( SETUPTOOLS_BUILD_COMMANDS_USE "cmdclass={'build_py': CustomBuildPy, 'install': CustomInstall, 'install-lib': CustomInstallLib }" )
+ configure_file ( ${CMAKE_CURRENT_SOURCE_DIR}/setup.py.in ${_setup_py} @ONLY )
+ endif ()
+
+ set ( _egg_link_dir ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${CMAKE_CFG_INTDIR} )
+ set ( _egg_link ${_egg_link_dir}/${pkg_name}.egg-link )
+
+ if ( ARGC GREATER 1 AND "${ARGN}" STREQUAL "EXECUTABLE" )
+ if ( WIN32 )
+ set ( _startup_script ${_egg_link_dir}/${pkg_name}-script.pyw )
+ set ( _startup_exe ${_egg_link_dir}/${pkg_name}.exe )
+ else ()
+ set ( _startup_script )
+ set ( _startup_exe ${_egg_link_dir}/${pkg_name} )
+ endif ()
+ endif ()
+
+ # create the developer setup which just creates a pth file rather than copying things over
+ set ( _outputs ${_egg_link} ${_startup_script} ${_startup_exe} )
+ add_custom_command ( OUTPUT ${_outputs}
+ COMMAND ${CMAKE_COMMAND} -E env PYTHONPATH=${_egg_link_dir}
+ ${PYTHON_EXECUTABLE} ${_setup_py} develop
+ --install-dir ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${CMAKE_CFG_INTDIR}
+ --script-dir ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${CMAKE_CFG_INTDIR}
+ WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+ DEPENDS ${_setup_py}
+ )
+ add_custom_target ( ${pkg_name} ALL
+ DEPENDS ${_outputs}
+ )
+
+ if ( ${PACKAGE_WORKBENCH} )
+ # setuptools by default wants to build into a directory called 'build' relative the to the working directory. We have overridden
+ # commands in setup.py.in to force the build directory to take place out of source. The install directory is specified here and then
+ # --install-scripts=bin --install-lib=lib removes any of the plaform/distribution specific install directories so we can have a flat
+ # structure
+ install(CODE "execute_process(COMMAND ${PYTHON_EXECUTABLE} ${_setup_py} install -O1 --single-version-externally-managed --root=${_setup_py_build_root}/install --install-scripts=bin --install-lib=lib WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})")
+ # register the "installed" components with cmake so it will carry them over
+ install(DIRECTORY ${_setup_py_build_root}/install/lib
+ DESTINATION .
+ PATTERN "test" EXCLUDE )
+
+ # install the generated executable - only tested with "workbench"
+ if ( ARGC GREATER 1 AND "${ARGN}" STREQUAL "EXECUTABLE" )
+ install(PROGRAMS ${_setup_py_build_root}/install/bin/${pkg_name}
+ DESTINATION bin)
+ endif()
+ endif()
+endfunction ()
diff --git a/buildconfig/CMake/QtTargetFunctions.cmake b/buildconfig/CMake/QtTargetFunctions.cmake
index 7314faba29176e1386d232ea2e288345709851e6..01772f4b161f53eb6ef84cacfea6075cc3e8dbdb 100644
--- a/buildconfig/CMake/QtTargetFunctions.cmake
+++ b/buildconfig/CMake/QtTargetFunctions.cmake
@@ -214,13 +214,11 @@ function (mtd_add_qt_target)
_append_qt_suffix (AS_DIR VERSION ${PARSED_QT_VERSION} OUTPUT_VARIABLE _install_dir
${PARSED_INSTALL_DIR_BASE})
else()
- set ( _install_dir ${LIB_DIR} )
+ set ( _install_dir "" )
+ message ( FATAL_ERROR "Target: ${_target} is configured to build but has no install destination" )
endif()
- # Hack: Only install Qt4 to packages for now...
- if (${PARSED_QT_VERSION} EQUAL 4)
- install ( TARGETS ${_target} ${SYSTEM_PACKAGE_TARGET} DESTINATION ${_install_dir} )
- endif()
- endif()
+ mtd_install_qt_library ( ${PARSED_QT_VERSION} ${_target} "${SYSTEM_PACKAGE_TARGET}" ${_install_dir} )
+ endif ()
# Group into folder for VS
set_target_properties ( ${_target} PROPERTIES FOLDER "Qt${PARSED_QT_VERSION}" )
@@ -234,6 +232,17 @@ function (mtd_add_qt_target)
endfunction()
+# Create an install rule for a Qt target
+# - qt_version The version of Qt targeted
+# - target The name of the target
+# - install_target_type The type of target that should be installed. See https://cmake.org/cmake/help/latest/command/install.html?highlight=install
+# - install_dir A relative directory to install_prefix
+function (mtd_install_qt_library qt_version target install_target_type install_dir )
+ if ( qt_version EQUAL 4 OR (qt_version EQUAL 5 AND ${PACKAGE_WORKBENCH}) )
+ install ( TARGETS ${target} ${install_target_type} DESTINATION ${install_dir} )
+ endif ()
+endfunction ()
+
function (mtd_add_qt_tests)
_qt_versions(_qt_vers ${ARGN})
# Create targets
diff --git a/buildconfig/CMake/SipQtTargetFunctions.cmake b/buildconfig/CMake/SipQtTargetFunctions.cmake
index 120ad0175939f086b12674900e8a3874cb885081..85c049f710054a0027fdd9698a5649090d320509 100644
--- a/buildconfig/CMake/SipQtTargetFunctions.cmake
+++ b/buildconfig/CMake/SipQtTargetFunctions.cmake
@@ -3,7 +3,7 @@
# of .sip definitions
include ( QtTargetFunctions )
-#
+
# brief: Add a module target to generate Python bindings
# for a set of sip sources. The sources list should be a list of filenames
# without a path. The .sip module is generated in the CMAKE_CURRENT_BINARY_DIR
@@ -17,6 +17,9 @@ include ( QtTargetFunctions )
# keyword: LINK_LIBS A list of additional target_link_libraries
# keyword: PYQT_VERSION A single value indicating the version of PyQt
# to compile against
+# keyword: INSTALL_DIR The target location for installing this library
+# keyword: OSX_INSTALL_RPATH Install path for osx version > 10.8
+# keyword: LINUX_INSTALL_RPATH Install path for CMAKE_SYSTEM_NAME == Linux
function ( mtd_add_sip_module )
find_file ( _sipmodule_template_path NAME sipqtmodule_template.sip.in
PATHS ${CMAKE_MODULE_PATH} )
@@ -27,7 +30,7 @@ function ( mtd_add_sip_module )
set ( options )
set ( oneValueArgs MODULE_NAME TARGET_NAME MODULE_OUTPUT_DIR
PYQT_VERSION FOLDER )
- set ( multiValueArgs SIP_SRCS HEADER_DEPS INCLUDE_DIRS LINK_LIBS OSX_INSTALL_RPATH LINUX_INSTALL_RPATH )
+ set ( multiValueArgs SIP_SRCS HEADER_DEPS INCLUDE_DIRS LINK_LIBS INSTALL_DIR OSX_INSTALL_RPATH LINUX_INSTALL_RPATH )
cmake_parse_arguments ( PARSED "${options}" "${oneValueArgs}"
"${multiValueArgs}" ${ARGN} )
@@ -106,6 +109,10 @@ function ( mtd_add_sip_module )
endif ()
endif ()
+ if ( PARSED_INSTALL_DIR AND PACKAGE_WORKBENCH)
+ mtd_install_qt_library ( ${PARSED_PYQT_VERSION} ${PARSED_TARGET_NAME} "" ${PARSED_INSTALL_DIR} )
+ endif ()
+
if ( WIN32 )
set_target_properties( ${PARSED_TARGET_NAME} PROPERTIES PREFIX "" SUFFIX ".pyd" )
if ( PYTHON_DEBUG_LIBRARY )
diff --git a/buildconfig/Jenkins/buildscript b/buildconfig/Jenkins/buildscript
index 7f5edb19d98c68f0420e5bca482a824c1ca135b8..e71ef1ce819b997ba276b9f47d7618493cb18fe6 100755
--- a/buildconfig/Jenkins/buildscript
+++ b/buildconfig/Jenkins/buildscript
@@ -229,8 +229,9 @@ if [[ ${DO_BUILD_PKG} == true ]]; then
PACKAGINGVARS="-DPACKAGE_DOCS=ON"
# Set some variables relating to the linux packages
if [[ "${ON_MACOS}" == true ]]; then
- PACKAGINGVARS="${PACKAGINGVARS} -DCPACK_PACKAGE_SUFFIX="
+ PACKAGINGVARS="${PACKAGINGVARS} -DPACKAGE_WORKBENCH=OFF -DCPACK_PACKAGE_SUFFIX="
else
+ PACKAGINGVARS="${PACKAGINGVARS} -DPACKAGE_WORKBENCH=ON"
# Use different suffix for linux builds if parameter is not defined
if [[ -n "${PACKAGE_SUFFIX}" ]]; then
echo "Using PACKAGE_SUFFIX=${PACKAGE_SUFFIX} from job parameter"
@@ -293,7 +294,7 @@ rm -f -- *.dmg *.rpm *.deb *.tar.gz *.tar.xz
###############################################################################
# CMake configuration
###############################################################################
-$SCL_ENABLE "${CMAKE_EXE} ${CMAKE_GENERATOR} -DCMAKE_BUILD_TYPE=${BUILD_CONFIG} -DENABLE_CPACK=ON -DMAKE_VATES=ON -DParaView_DIR=${PARAVIEW_DIR} -DMANTID_DATA_STORE=${MANTID_DATA_STORE} -DDOCS_HTML=ON -DENABLE_CONDA=ON -DENABLE_WORKBENCH=ON -DENABLE_FILE_LOGGING=OFF ${DIST_FLAGS} ${PACKAGINGVARS} ${CLANGTIDYVAR} .."
+$SCL_ENABLE "${CMAKE_EXE} ${CMAKE_GENERATOR} -DCMAKE_BUILD_TYPE=${BUILD_CONFIG} -DENABLE_CPACK=ON -DMAKE_VATES=ON -DParaView_DIR=${PARAVIEW_DIR} -DMANTID_DATA_STORE=${MANTID_DATA_STORE} -DDOCS_HTML=ON -DENABLE_CONDA=ON -DENABLE_WORKBENCH=ON ${DIST_FLAGS} ${PACKAGINGVARS} ${CLANGTIDYVAR} .."
###############################################################################
# Coverity build should exit early
@@ -341,7 +342,9 @@ fi
userconfig_dir=$HOME/.mantid
rm -fr $userconfig_dir
mkdir -p $userconfig_dir
-touch $userconfig_dir/Mantid.user.properties
+# use a fixed number of openmp threads to avoid overloading the system
+userprops_file=$userconfig_dir/Mantid.user.properties
+echo MultiThreaded.MaxCores=2 > $userprops_file
if [[ ${DO_UNITTESTS} == true ]]; then
$CTEST_EXE -j${BUILD_THREADS:?} --schedule-random --output-on-failure
@@ -351,6 +354,8 @@ fi
# User Documentation
###############################################################################
if [[ ${DO_DOCTESTS_USER} == true ]]; then
+ # use default configuration
+ rm -f $userprops_file
# Remove doctrees directory so it forces a full reparse. It seems that
# without this newly added doctests are not executed
if [ -d $BUILD_DIR/docs/doctrees ]; then
diff --git a/buildconfig/Jenkins/buildscript.bat b/buildconfig/Jenkins/buildscript.bat
index 7244fd4fd2b4f31da34e7a21d058263ef7b2cbdb..f1340fb1a750684165df1b33c30ed2394770ddae 100755
--- a/buildconfig/Jenkins/buildscript.bat
+++ b/buildconfig/Jenkins/buildscript.bat
@@ -150,7 +150,7 @@ if not "%JOB_NAME%"=="%JOB_NAME:debug=%" (
) else (
set VATES_OPT_VAL=ON
)
-call cmake.exe -G "%CM_GENERATOR%" -DCMAKE_SYSTEM_VERSION=%SDK_VERSION% -DCONSOLE=OFF -DENABLE_CPACK=ON -DMAKE_VATES=%VATES_OPT_VAL% -DParaView_DIR=%PARAVIEW_DIR% -DMANTID_DATA_STORE=!MANTID_DATA_STORE! -DENABLE_WORKBENCH=ON -DUSE_PRECOMPILED_HEADERS=ON -DENABLE_FILE_LOGGING=OFF %PACKAGE_OPTS% ..
+call cmake.exe -G "%CM_GENERATOR%" -DCMAKE_SYSTEM_VERSION=%SDK_VERSION% -DCONSOLE=OFF -DENABLE_CPACK=ON -DMAKE_VATES=%VATES_OPT_VAL% -DParaView_DIR=%PARAVIEW_DIR% -DMANTID_DATA_STORE=!MANTID_DATA_STORE! -DENABLE_WORKBENCH=ON -DPACKAGE_WORKBENCH=OFF -DUSE_PRECOMPILED_HEADERS=ON %PACKAGE_OPTS% ..
if ERRORLEVEL 1 exit /B %ERRORLEVEL%
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
@@ -170,7 +170,9 @@ del %USERPROPS%
set CONFIGDIR=%APPDATA%\mantidproject\mantid
rmdir /S /Q %CONFIGDIR%
mkdir %CONFIGDIR%
-call cmake.exe -E touch %USERPROPS%
+:: use a fixed number of openmp threads to avoid overloading the system
+echo MultiThreaded.MaxCores=2 > %USERPROPS%
+
call ctest.exe -C %BUILD_CONFIG% -j%BUILD_THREADS% --schedule-random --output-on-failure
if ERRORLEVEL 1 exit /B %ERRORLEVEL%
@@ -179,6 +181,7 @@ if ERRORLEVEL 1 exit /B %ERRORLEVEL%
:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
echo Note: not running doc-test target as it currently takes too long
:: if not "%JOB_NAME%"=="%JOB_NAME:debug=%" (
+:: del /Q %USERPROPS%
:: call cmake.exe --build . --target StandardTestData
:: call cmake.exe --build . --target docs-test
:: )
diff --git a/buildconfig/windows/visual-studio.bat.in b/buildconfig/windows/visual-studio.bat.in
old mode 100644
new mode 100755
diff --git a/dev-docs/source/GettingStartedWithPyCharm.rst b/dev-docs/source/GettingStartedWithPyCharm.rst
index 58aa3852d64eb2c6a248ed9807da7d30b75e407a..8d138d26e53fd04c859ee59410267e4cc67930f2 100644
--- a/dev-docs/source/GettingStartedWithPyCharm.rst
+++ b/dev-docs/source/GettingStartedWithPyCharm.rst
@@ -103,3 +103,18 @@ On Linux the instructions are identical to Windows except that :
- In step 1, the file is ``pycharm.sh`` rather than ``pycharm.bat``
- In step 2, use the native python interpreter (``/usr/bin/python2.7/python.exe``) rather than from ``<Mantid Source Directory>/external/src/ThirdParty/lib/python2.7/python.exe``
- In step 4, add ``<Mantid Build Directory>/bin;`` to the ``PATH`` environment variable in the new configuration (rather than ``<Mantid Build Directory>/bin/Debug;``), and remove the other three file paths.
+
+Useful Plugins
+##############
+
+You can install non-default plugins by pressing ``Ctrl+Alt+S`` to open the **Settings/Preferences** dialog and then going to **Plugins**.
+From here you can manage plugins, or add new ones by clicking **Browse repositories**.
+
+The following non-default plugins are things our team has found useful for Mantid development:
+
+- **Markdown support** - Side by side rendering of markdown documents such as``.md`` , ``.rst`` (requires `Graphviz <https://graphviz.gitlab.io/download/>`_ to show graphs in preview)
+- **dotplugin** - Syntax highlighting for ``DOT``
+- **BashSupport** - Syntax highlighting for ``BASH`` scripts
+- **CMD Support** - Syntax highlighting for ``.BAT`` ~scripts
+
+Please add to this list if you find a useful plugin of your own
diff --git a/dev-docs/source/IndividualTicketTesting.rst b/dev-docs/source/IndividualTicketTesting.rst
new file mode 100644
index 0000000000000000000000000000000000000000..de0d31601d3e47794da51efd1edd3033d7f78377
--- /dev/null
+++ b/dev-docs/source/IndividualTicketTesting.rst
@@ -0,0 +1,50 @@
+.. _IndividualTicketTesting:
+
+=========================
+Individual Ticket Testing
+=========================
+
+An important step in our :ref:`development workflow <GitWorkflow>` is the testing of individual issues/tickets after the development on them is complete, and before the code is merges into the master branch. Developers pick one from `the list <https://github.com/mantidproject/mantid/pulls>`_ of completed issues and perform a number of verification steps on it. The mechanics of testing a pull request (e.g. the git commands to use) are described :ref:`here <GitWorkflow>`. This page is concerned with the aspects that should be considered in deciding whether a pull request should be recommended to merge or sent back to the developer for further work. *There should be very little reluctance to reopen a ticket even for minor issues.*
+
+Code Review
+===========
+
+The code changes should be manually reviewed (the github compare view is ideal for this). A couple of pieces on the value of code review can be found at `scientopia <http://scientopia.org/blogs/goodmath/2011/07/06/things-everyone-should-do-code-review>`_ and `codinghorror <http://www.codinghorror.com/blog/2006/01/code-reviews-just-do-it.html>`_.
+
+* The primary aim is to find bugs that the developer and tests so far have not spotted.
+* But also consider whether the code is 'clean', well-structured and easy to read/maintain.
+* Part of this is that:
+
+ * There should be are no compiler (or doxygen) warnings coming from any modified classes
+ * The code conforms to our :ref:`coding standards <MantidStandards>`.
+
+* Unit tests (or system tests if more appropriate) should be checked that they:
+
+ * Exist and give adequate coverage (see :ref:`unit testing practices <UnitTestGoodPractice>`).
+ * If the ticket is fixing a bug there should be a test that makes sure we don't have to fix the same bug again!
+ * Do not load real data (data loading algorithms get a free pass on this one).
+ * Leave the system in the same state that they found it (i.e. clean up).
+ * Have a performance test, if appropriate.
+
+* Check that any user documentation is adequate and that there are release notes. In the case of new algorithms, there should be an accompanying ``*.rst`` file that has been added, containing an explanation of what exactly the algorithm does along with Python usage examples.
+
+Functional Testing
+==================
+
+The first thing to note is that this should **not** just be a quick check of whatever the ticket says it does. Testing should be as much, if not more, about making sure the code *does not do what it's not supposed to do* as that it *does do what it's supposed to*.
+
+* All of the builds pass
+* The developer should have included instructions in the ticket of how to test things work.
+* But, as noted above, don’t just do that – also try to break it: click random buttons on GUIs, give unexpected/invalid inputs, etc.
+* Note down what you did in the ticket, and the platform you did it on.
+
+If all the requirements have been met and documented approve the PR using `GitHub's review mechanism <https://help.github.com/articles/about-pull-request-reviews/>`_.
+
+Gatekeeper
+==========
+
+The ``@mantidproject/gatekeepers`` group is who is meant to merge pull requests into master. This is done by social contract. A gatekeeper can ``merge`` code if:
+
+* Green tick on the last build indicating all automated testing has succeeded
+* Adequate tests, both success and failure cases have been performed
+* There is comment on the code being reviewed
diff --git a/dev-docs/source/Standards/MantidStandards.rst b/dev-docs/source/Standards/MantidStandards.rst
index adfa95c3beecd23abf4a54afb0fd2f2394b5ca90..b8533c1da97b1a97e2b9fc00d027b425c4b537c4 100644
--- a/dev-docs/source/Standards/MantidStandards.rst
+++ b/dev-docs/source/Standards/MantidStandards.rst
@@ -1,3 +1,5 @@
+.. _MantidStandards:
+
================
Mantid Standards
================
@@ -106,7 +108,7 @@ Parameter names must:
- Start with a capital letter
- Have a capital letter for each new word (e.g. 'InputWorkspace')
- Use alphanumeric characters only (i.e. cannot contain any of these ``/,._-'\"`` or whitespace)
-- Can contain numbers but only allowed after the first character.
+- Can contain numbers but only allowed after the first character.
Notable exceptions to these rules are lattice constants (i.e. a, b, c,
alpha, beta, gamma).
diff --git a/dev-docs/source/index.rst b/dev-docs/source/index.rst
index f03b7c4e3dad06d0709ea427a9f8b7e30435186d..a951ad20986b624cdf8c29953a99626affefc34e 100644
--- a/dev-docs/source/index.rst
+++ b/dev-docs/source/index.rst
@@ -125,7 +125,7 @@ Tools
:doc:`GettingStartedWithPyCharm`
Describes how to set up the PyCharm interpreter, and debug python code (Windows/Linux only).
-
+
:doc:`Eclipse`
Guide to setting up Eclipse on Ubuntu
@@ -139,6 +139,7 @@ Testing
RunningTheUnitTests
DebuggingUnitTests
UnitTestGoodPractice
+ IndividualTicketTesting
WritingPerformanceTests
SystemTests
DataFilesForTesting
@@ -153,6 +154,9 @@ Testing
:doc:`UnitTestGoodPractice`
Guidance on writing good unit tests.
+:doc:`IndividualTicketTesting`
+ What to expect and inspect when reviewing an individual contribution to mantid.
+
:doc:`WritingPerformanceTests`
A walk through of how to write a performance test.
@@ -206,4 +210,3 @@ Component Overviews
RemoteJobSubmissionAPI
WritingAnAlgorithm
WritingCustomConvertToMDTransformation
-
diff --git a/docs/source/algorithms/LoadWAND-v1.rst b/docs/source/algorithms/LoadWAND-v1.rst
index e42fefb113a075212f4ba28a5b21932c003d25d9..c2229dcb094fd5b93a7606463463a411a8f44571 100644
--- a/docs/source/algorithms/LoadWAND-v1.rst
+++ b/docs/source/algorithms/LoadWAND-v1.rst
@@ -32,6 +32,11 @@ numbers, see Usage example bellow. If multiple files are loaded they
will be named 'OutputWorkspace'+'_runnumber' and be grouped in
'OutputWorkspace'.
+There is a grouping option to group pixels by either 2x2 or 4x4 which
+will help in reducing memory usage and speed up the later reduction
+steps. In most cases you will not see a difference in reduced data
+with 4x4 pixel grouping.
+
Usage
-----
diff --git a/docs/source/algorithms/MDNormDirectSC-v1.rst b/docs/source/algorithms/MDNormDirectSC-v1.rst
index 353dbdbe8a1ec881188b6b50e6605215dd215b6c..bb20fb152b42add92c41ab003a9c6debd0a8b8aa 100644
--- a/docs/source/algorithms/MDNormDirectSC-v1.rst
+++ b/docs/source/algorithms/MDNormDirectSC-v1.rst
@@ -14,17 +14,15 @@ The algorithm calculates a normalization MD workspace for single crystal direct
Trajectories of each detector in reciprocal space are calculated, and the flux is integrated between intersections with each
MDBox. A brief introduction to the multi-dimensional data normalization can be found :ref:`here <MDNorm>`.
-.. Note::
-
- This is an experimental algorithm in Release 3.3. Please check the nightly Mantid build, and the Mantid webpage
- for better offline help and usage examples.
-
.. Note::
If the MDEvent input workspace is generated from an event workspace, the algorithm gives the correct normalization
only if the event workspace is cropped and binned to the same energy transfer range. If the workspace is not cropped,
one might have events in places where the normalization is calculated to be 0.
+.. Note::
+
+ As of :ref:`Release 3.14.0 <v3.14.0>`, the algorithm can handle merged MD workspaces. Make sure all original MDEvent workspaces have the same dimensions
Usage
-----
diff --git a/docs/source/algorithms/SortXAxis-v1.rst b/docs/source/algorithms/SortXAxis-v1.rst
index aaef5edd17efc6c3a9804b3604811134c493cd89..4e1d9836d15c82dabc2b797ed605f385181de448 100644
--- a/docs/source/algorithms/SortXAxis-v1.rst
+++ b/docs/source/algorithms/SortXAxis-v1.rst
@@ -13,9 +13,63 @@ Clones the input :ref:`Matrix Workspaces <MatrixWorkspace>` and orders the
x-axis in an ascending or descending fashion. Ensures that the y-axis and error data as well as optional Dx data
are sorted in a consistent way with the x-axis.
-This algorithm is for use with small workspaces loaded. It is
+This algorithm is for use with either point data based workspaces or histogram based workspaces. It is
particularly suitable for reformatting workspaces loaded via
-:ref:`LoadAscii <algm-LoadAscii>`. Input workspaces must be point data.
+:ref:`LoadAscii <algm-LoadAscii>`.
+
+Usage
+-----
+.. testcode:: SortXAxis
+
+ #Import requirements
+ import numpy as np
+
+ # Create the workspace
+ dataX = [2., 1., 3.]
+ dataY = [2., 1., 3.]
+ dataE = [2., 1., 3.]
+ ws = CreateWorkspace(DataX=dataX,DataY=dataY,DataE=dataE,UnitX='TOF',Distribution=True)
+
+ # Print out the "Unordered X Axis"
+ print("Unordered Print")
+ print(ws.readX(0))
+ print(ws.readY(0))
+ print(ws.readE(0))
+
+ # Sort the X Axis in a Descending fashion
+ ws = SortXAxis(InputWorkspace='ws', Ordering='Descending')
+ print("In order print: Descending")
+ print(ws.readX(0))
+ print(ws.readY(0))
+ print(ws.readE(0))
+
+ # Sort the X Axis in a Ascending fashion
+ ws = SortXAxis(InputWorkspace='ws', Ordering='Ascending')
+ print("In order print: Ascending")
+ print(ws.readX(0))
+ print(ws.readY(0))
+ print(ws.readE(0))
+
+.. testcleanup:: SortXAxis
+
+ DeleteWorkspace(ws)
+
+Output:
+
+.. testoutput:: SortXAxis
+
+ Unordered Print
+ [ 2. 1. 3.]
+ [ 2. 1. 3.]
+ [ 2. 1. 3.]
+ In order print: Descending
+ [ 3. 2. 1.]
+ [ 3. 2. 1.]
+ [ 3. 2. 1.]
+ In order print: Ascending
+ [ 1. 2. 3.]
+ [ 1. 2. 3.]
+ [ 1. 2. 3.]
.. categories::
diff --git a/docs/source/api/python/mantid/api/SpectrumInfo.rst b/docs/source/api/python/mantid/api/SpectrumInfo.rst
index f66653f6cdbb965d14e84553324c15250a54b0d3..80844c9313bbdf65c5010a55121883acbb3e7b4b 100644
--- a/docs/source/api/python/mantid/api/SpectrumInfo.rst
+++ b/docs/source/api/python/mantid/api/SpectrumInfo.rst
@@ -4,6 +4,128 @@
This is a python binding to the C++ class Mantid::API::SpectrumInfo.
+Most of the information concerning ``SpectrumInfo`` can be found in the `Instrument Access Layers <https://github.com/mantidproject/mantid/blob/9e3d799d40fda4a5ca08887e8c47f41c3316da91/docs/source/concepts/InstrumentAccessLayers.rst>`_ document.
+
+--------
+Purpose
+--------
+The purpose of the ``SpectrumInfo`` object is to allow the user to access information about the spectra being used in an experiment. The ``SpectrumInfo`` object can be used to access information such as the number of spectra, the absolute position of a spectrum as well as the distance from the sample to the source. There are many other methods available as well.
+
+A spectrum corresponds to (a group of) one or more detectors. However if no instrument/beamline has been set then the number of detectors will be zero. An example test case details this below.
+
+Many users may need more information about the spectra in an experiment so that they can have a better understanding of the beamline they are using. This information is easy and fast to access via ``SpectrumInfo``.
+
+``SpectrumInfo`` is one of three objects that the user can gain access to from a workspace object.
+The other two are:
+
+* ``DetectorInfo``
+* ``ComponentInfo``
+
+------
+Usage
+------
+
+**Example 1 - Creating a SpectrumInfo Object:**
+This example shows how to obtain a ``SpectrumInfo`` object from a workspace object.
+The return value is a ``SpectrumInfo`` object.
+
+.. testcode:: CreateSpectrumInfoObject
+
+ # Create a workspace to use
+ ws = CreateSampleWorkspace()
+
+ # Get the SpectrumInfo object
+ info = ws.spectrumInfo()
+ print(type(info))
+
+Output:
+
+.. testoutput:: CreateSpectrumInfoObject
+
+ <class 'mantid.api._api.SpectrumInfo'>
+
+
+**Example 2 - Calling the hasDetectors Method on the SpectrumInfo Object:**
+This example shows how to call the ``hasDetectors`` method.
+The method takes in an integer ``index`` parameter which corresponds to a spectrum.
+The return value is True or False.
+
+.. testcode:: CallHasDetectorsMethod
+
+ # Create a workspace to use (should have a preset instrument)
+ ws = CreateSampleWorkspace()
+
+ # Get the SpectrumInfo object
+ info = ws.spectrumInfo()
+
+ # Call hasDetectors
+ print(info.hasDetectors(0))
+
+ """
+ The object returned by CreateWorkspace does not have an instrument set so
+ it is expected that we would be getting False back from hasDetectors().
+ """
+
+ # Sample data
+ intx = [1,2,3,4,5]
+ inty = [1,2,3,4,5]
+
+ # Create a workspace to use
+ wsTwo = CreateWorkspace(intx, inty)
+
+ # Get the SpectrumInfo object
+ info = wsTwo.spectrumInfo()
+
+ # Call hasDetectors
+ print(info.hasDetectors(0))
+
+Output:
+
+.. testoutput:: CallHasDetectorsMethod
+
+ True
+ False
+
+
+**Example 3 - Calling Some Methods on the SpectrumInfo Object:**
+This example shows how to call a few different methods on the SpectrumInfo object.
+
+The ``l1()`` method does not take in any parameters and returns the distance from the source to the sample.
+The return value is a float.
+
+The ``sourcePosition()`` method does not take any parameters and returns the absolute source position.
+The return value is a ``V3D`` object which is a point in 3D space.
+
+The ``getSpectrumDefinition()`` method takes in an integer ``index`` parameter and returns a ``SpectrumDefinition`` object.
+The returned object can then be used to call other methods that belong to ``SpectrumDefinition``.
+
+.. testcode:: CallMethods
+
+ # Create a workspace to use
+ ws = CreateSampleWorkspace()
+
+ # Get the SpectrumInfo object
+ info = ws.spectrumInfo()
+
+ # Call l1
+ print(info.l1())
+
+ # Call sourcePosition
+ print(info.sourcePosition())
+
+ # Get a SpectrumDefinition object
+ spectrumDefinition = info.getSpectrumDefinition(0)
+ print(type(spectrumDefinition))
+
+Output:
+
+.. testoutput:: CallMethods
+
+ 10.0
+ [0,0,-10]
+ <class 'mantid.api._api.SpectrumDefinition'>
+
+
*bases:* :py:obj:`mantid.api.SpectrumInfo`
.. module:`mantid.api`
diff --git a/docs/source/api/python/mantid/geometry/ComponentInfo.rst b/docs/source/api/python/mantid/geometry/ComponentInfo.rst
new file mode 100644
index 0000000000000000000000000000000000000000..6beabf39ffff60578c3a5bd15873f8e70a930b99
--- /dev/null
+++ b/docs/source/api/python/mantid/geometry/ComponentInfo.rst
@@ -0,0 +1,130 @@
+===============
+ ComponentInfo
+===============
+
+This is a python binding to the C++ class Mantid::Geometry::ComponentInfo.
+
+Most of the information concerning ``ComponentInfo`` can be found in the `Instrument Access Layers <https://github.com/mantidproject/mantid/blob/9e3d799d40fda4a5ca08887e8c47f41c3316da91/docs/source/concepts/InstrumentAccessLayers.rst>`_ document.
+
+--------
+Purpose
+--------
+The purpose of the ``ComponentInfo`` object is to allow the user to access geometric information about the components which are part of a beamline. A component is any physical item or group of items that is registered for the purpose of data reduction. The ``ComponentInfo`` object can be used to access information such as the total number of components in the beamline, the absolute position of a component as well as the absolute rotation of a component. ``ComponentInfo`` provides tree like access to the beamline including all the detectors.
+
+Many users may need this extra information so that they can have a better understanding of the beamline they are using and the components that make up the beamline - e.g. detectors, banks, choppers. This extra information is easy and fast to access.
+
+ComponentInfo is one of three objects that the user can gain access to from a workspace.
+The other two are:
+
+ * ``SpectrumInfo``
+ * ``DetectorInfo``
+
+---------
+Indexing
+---------
+The ``ComponentInfo`` object is accessed by an index going from 0 to N-1 where N is the number of components.
+The component index for a detector is EQUAL to the detector index. In other words, a detector with a detector index of 5 when working with a ``DetectorInfo`` object and will have a component index of 5 when working with a ``ComponentInfo`` object.
+
+Another way to think about this is that the first 0 to n-1 components referenced in ``ComponentInfo`` are detectors, where n is the total number of detectors.
+
+-------
+Usage
+-------
+
+**Example 1 - Creating a ComponentInfo Object:**
+This example shows how to obtain a ``ComponentInfo`` object from a workspace object.
+The return value is a ``ComponentInfo`` object.
+
+.. testcode:: CreateComponentInfoObject
+
+ # Create a workspace to use
+ ws = CreateSampleWorkspace()
+
+ # Get the ComponentInfo object
+ info = ws.componentInfo()
+ print(type(info))
+
+Output:
+
+.. testoutput:: CreateComponentInfoObject
+
+ <class 'mantid.geometry._geometry.ComponentInfo'>
+
+
+**Example 2 - Calling Some Methods on the ComponentInfo Object:**
+This example shows how to call a few different methods on the ComponentInfo object.
+
+The ``relativePosition`` method takes in an integer ``index`` parameter which corresponds to a component.
+The return value is a ``V3D`` object which denotes a point in 3D space.
+
+The ``setRotation()`` method takes in a ``Quat`` object which defines a rotation. The rotation is applied to the component.
+Retriving the rotation after setting it may not always give the same ``Quat`` object back - i.e. the values could be changed.
+
+The ``hasParent()`` method takes an integer ``index`` parameter which corresponds to a component.
+The return value is ``True`` if the component has a parent component or ``False`` otherwise.
+
+.. testcode:: CallMethods
+
+ # Import Quat
+ from mantid.kernel import Quat
+
+ # Create a workspace to use
+ ws = CreateSampleWorkspace()
+
+ # Get the ComponentInfo object
+ info = ws.componentInfo()
+
+ # Call relativePosition
+ print(info.relativePosition(0))
+
+ # Create a sample Quat and call setRotation
+ quat = Quat(0, 0, 0, 0)
+ info.setRotation(0, quat)
+ print(info.rotation(0))
+
+ # Call hasParent
+ print(info.hasParent(0))
+
+Output:
+
+.. testoutput:: CallMethods
+
+ [0,0,0]
+ [0,0,0,0]
+ True
+
+
+**Example 3 - Retrieving a List of Child Components from a ComponentInfo Object:**
+The ``children()`` method does not take in any parameters.
+The method returns a list of integers representing the child components.
+The returned list can then be indexed into to obtain a specific component.
+
+.. testcode:: CallChildrenMethod
+
+ # Create a workspace to use
+ ws = CreateSampleWorkspace()
+
+ # Get the ComponentInfo object
+ info = ws.componentInfo()
+
+ # Get a list of the child components
+ childComponents = info.children(0)
+ print(len(childComponents))
+ print(childComponents)
+
+Output:
+
+.. testoutput:: CallChildrenMethod
+
+ 0
+ []
+
+
+*bases:* :py:obj:`mantid.geometry.ComponentInfo`
+
+.. module:`mantid.geometry`
+
+.. autoclass:: mantid.geometry.ComponentInfo
+ :members:
+ :undoc-members:
+ :inherited-members:
\ No newline at end of file
diff --git a/docs/source/release/v3.14.0/diffraction.rst b/docs/source/release/v3.14.0/diffraction.rst
index 3e1bebd3e81151c493a06216ef8cad1b26babc30..be49fe2fd20ec69207fe0b77e31311163da0bd48 100644
--- a/docs/source/release/v3.14.0/diffraction.rst
+++ b/docs/source/release/v3.14.0/diffraction.rst
@@ -13,6 +13,9 @@ Improvements
############
- :ref:`SNAPReduce <algm-SNAPReduce>` now has progress bar and all output workspaces have history
+- :ref:`AlignAndFocusPowder <algm-AlignAndFocusPowder>` and :ref:`AlignAndFocusPowderFromFiles <algm-AlignAndFocusPowderFromFiles>` now support weighted events (with time). This allows for event filtering **after** processing the data.
+- :ref:`LoadWAND <algm-LoadWAND>` has grouping option added and loads faster
+- Mask workspace option added to :ref:`WANDPowderReduction <algm-WANDPowderReduction>`
:ref:`Release 3.14.0 <v3.14.0>`
@@ -29,4 +32,3 @@ Bugfixes
########
- :ref:`CentroidPeaksMD <algm-CentroidPeaksMD>` now updates peak bin counts.
-
diff --git a/docs/source/release/v3.14.0/direct_inelastic.rst b/docs/source/release/v3.14.0/direct_inelastic.rst
index bd9955f081f110392f1c3585718f87aa85c49086..9188a52307dc45cf94f53aa19778a2670b6aa919 100644
--- a/docs/source/release/v3.14.0/direct_inelastic.rst
+++ b/docs/source/release/v3.14.0/direct_inelastic.rst
@@ -25,11 +25,8 @@ Improvements
- Improved ``Save``-section of the TOFTOF reduction dialog.
- Behavior of the :ref:`LoadDNSLegacy <algm-LoadDNSLegacy>` for TOF data has been changed: the algorithm does not try to guess elastic channel any more, but asks for the user input.
+- :ref:`LoadDNSSCD <algm-LoadDNSSCD>` has been improved to be able to load TOF data.
+- :ref:`MDNormDirectSC <algm-MDNormDirectSC>` now can handle merged MD workspaces.
:ref:`Release 3.14.0 <v3.14.0>`
-
-Improvements
-############
-
-- :ref:`LoadDNSSCD <algm-LoadDNSSCD>` has been improved to be able to load TOF data.
diff --git a/docs/source/release/v3.14.0/framework.rst b/docs/source/release/v3.14.0/framework.rst
index 0f3567c74535eaf288d510a9aae48450ee4a00ec..c04833e09f9b3532e839b4aee22c4f6bf2f9c31c 100644
--- a/docs/source/release/v3.14.0/framework.rst
+++ b/docs/source/release/v3.14.0/framework.rst
@@ -42,7 +42,7 @@ New Algorithms
Improvements
############
-
+- :ref:`AppendSpectra <algm-AppendSpectra>` can append now multiple times the same event workspace.
Bugfixes
########
@@ -55,6 +55,8 @@ Python
New
###
+ - New python validator type: `:class:`~mantid.geometry.OrientedLattice`. Checks whether a workspace has an oriented lattice object attached.
+
Improvements
############
diff --git a/docs/source/release/v3.14.0/muon.rst b/docs/source/release/v3.14.0/muon.rst
index e0350f5c48c7760d3986cbe4afc183fc58ba4701..d7482b1100c2514bae59dd070dbbdc463a54052f 100644
--- a/docs/source/release/v3.14.0/muon.rst
+++ b/docs/source/release/v3.14.0/muon.rst
@@ -11,10 +11,12 @@ Interface
Improvements
############
- Elemental Analysis added to Muon Interfaces: Includes a selectable Periodic Table.
+- TF Asymmetry mode now displays the chi squared value at the top of the browser.
Bugfixes
########
- Results table now includes all logs that are common to all of the loaded files.
+- When turning TF Asymmetry mode off it no longer resets the global options.
Algorithms
----------
diff --git a/docs/source/release/v3.14.0/reflectometry.rst b/docs/source/release/v3.14.0/reflectometry.rst
index 2452fc016e8c72c90d04c3ca47e9e0b478c05408..503a240ed490b973076ad45c7f0152f9651f6758 100644
--- a/docs/source/release/v3.14.0/reflectometry.rst
+++ b/docs/source/release/v3.14.0/reflectometry.rst
@@ -9,4 +9,17 @@ Reflectometry Changes
putting new features at the top of the section, followed by
improvements, followed by bug fixes.
+Liquids Reflectometer
+---------------------
+
+- Default x-direction pixel range for the scaling factor calculation is now set to the full width of the detector as opposed to a restricted guess.
+
+ISIS Reflectometry Interface
+----------------------------
+
+Bug fixes
+#########
+
+- A bug has been fixed on the Settings tab where the IncludePartialBins check box had been hidden by a misplaced text entry box.
+
:ref:`Release 3.14.0 <v3.14.0>`
diff --git a/docs/source/release/v3.14.0/ui.rst b/docs/source/release/v3.14.0/ui.rst
index 15bb628796f555cae6105e972673b3bbba6a6276..7b6a37011d66cb31d4ad95bf7e2fe042cda6fd58 100644
--- a/docs/source/release/v3.14.0/ui.rst
+++ b/docs/source/release/v3.14.0/ui.rst
@@ -11,4 +11,18 @@ UI & Usability Changes
- Added time standard deviation to the sample log dialog
+Project Recovery
+----------------
+Bugfixes
+########
+- Workspaces with a '#' in their name will no longer cause issues in the loading of a recovered project
+
:ref:`Release 3.14.0 <v3.14.0>`
+
+MantidPlot
+----------
+
+BugFixes
+########
+
+- Fixed issue where an open set of data from ITableWorkspace wouldn't update if the data was changed via python
diff --git a/instrument/CRISP_Definition.xml b/instrument/CRISP_Definition.xml
index f9605c0f14a20c6d39692b96397514894b4a80ea..2f71d06477c017bcb58065f61b65a3ea0efefaa8 100644
--- a/instrument/CRISP_Definition.xml
+++ b/instrument/CRISP_Definition.xml
@@ -2,9 +2,10 @@
<instrument xmlns="http://www.mantidproject.org/IDF/1.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.mantidproject.org/IDF/1.0 http://schema.mantidproject.org/IDF/1.0/IDFSchema.xsd"
- name="CSP" valid-from ="1900-01-31 23:59:59"
- valid-to ="2100-01-31 23:59:59"
- last-modified="2010-11-04 00:00:00">
+ name="CSP"
+ valid-from ="1900-01-31 23:59:59"
+ valid-to ="2017-05-04 15:14:59"
+ last-modified="2018-08-07 11:00:00">
<defaults>
<length unit="meter" />
@@ -70,7 +71,17 @@
<component type="monitor2" idlist="monitor2">
<location z="9.92" />
+ </component>
+
+ <!-- Putting in monitors, which are defined in raw/neuxs
+ files, and have detector IDs, but currently not physically present
+ on the instrument. Defined with no geometric shape, as they do not
+ physically exist, and with a dummy position -->
+ <type>
+ <component type="no shape monitor">
+ <location z="12.12" name="placeholder monitor"/>
</component>
+ </type>
<type name="monitor2" is="monitor">
<!-- Shape specified as a minimum needs to cover the beam which
@@ -96,6 +107,8 @@
<algebra val="base : top" />
</type>
+ <type name="no shape monitor" is="monitor" />
+
<component type="point-detector" idlist="point-detector">
<location z="12.113" />
@@ -106,7 +119,7 @@
assumed to in degrees, hence the reason for the pi/180=0.0174533 transformation
to radians factor in the eq attribute. -->
<parameter name="y">
- <logfile id="theta" eq="1.863*sin(value*0.0174533)" />
+ <logfile id="theta" eq="1.8545*sin(2*value*0.0174533)" />
</parameter>
</component>
@@ -411,8 +424,8 @@
<component type="some-surface-holder">
- <!-- worry about linking relevant logfiles for y,z,theta,phi up later -->
- <location z="10.25"/>
+ <!-- worry about linking relevant logfiles for y,z,theta,phi up later. Change from 10.25 -->
+ <location z="10.2585"/>
</component>
<type name="some-surface-holder" is="SamplePos">
@@ -421,46 +434,52 @@
<!-- other components -->
- <component type="slit1">
+ <component type="slit" name="slit1">
<location z="7.3025"/>
<!-- This log file stores the vertical opening of slit -->
<parameter name="vertical gap">
- <logfile id="s1" extract-single-value-as="position 1" />
+ <logfile id="s1" extract-single-value-as="last_value" />
</parameter>
</component>
- <component type="slit2">
+ <component type="slit" name="slit2">
<location z="9.6885"/>
<!-- This log file stores the vertical opening of this. Note this
slit can also be translated in the z. However this info not stored
in log file since it is not used in the data analysis process. -->
<parameter name="vertical gap">
- <logfile id="s2" extract-single-value-as="position 1" />
+ <logfile id="s2" extract-single-value-as="last_value" />
</parameter>
</component>
- <component type="slit3">
+ <component type="slit" name="slit3">
<location z="10.651"/>
<!-- This log file stores the vertical opening of slit -->
<parameter name="vertical gap">
- <logfile id="s3" extract-single-value-as="position 1" />
+ <logfile id="s3" extract-single-value-as="last_value" />
</parameter>
</component>
- <component type="slit4">
+ <component type="slit" name="slit4">
<location z="11.983"/>
<!-- This log file stores the vertical opening of slit. Note this slit
is fixed to the point detector. -->
<parameter name="vertical gap">
- <logfile id="s4" extract-single-value-as="position 1" />
+ <logfile id="s4" extract-single-value-as="last_value" />
</parameter>
</component>
-
- <type name="slit1"></type>
- <type name="slit2"></type>
- <type name="slit3"></type>
- <type name="slit4"></type>
-
+
+<type name="slit">
+ <percent-transparency val="50" />
+ <cuboid id="bottom">
+ <left-front-bottom-point z="0.0005" x="-0.025" y="-0.03" />
+ <left-front-top-point z="0.0005" x="-0.025" y="0.0" />
+ <left-back-bottom-point z="-0.0005" x="-0.025" y="-0.03" />
+ <right-front-bottom-point z="0.0005" x="0.025" y="-0.03" />
+ </cuboid>
+ </type>
+
+
<component type="supermirror">
@@ -487,6 +506,10 @@
<id val="3" />
</idlist>
+ <idlist idname="monitor3">
+ <id val="4" />
+ </idlist>
+
<idlist idname="linear-detector">
<id start="6" end="125" />
<id start="134" end="253" />
diff --git a/instrument/CRISP_Definition_2018.xml b/instrument/CRISP_Definition_2018.xml
new file mode 100644
index 0000000000000000000000000000000000000000..1e9cb76de130279f2177595b4d0e9ce3a63d1e1e
--- /dev/null
+++ b/instrument/CRISP_Definition_2018.xml
@@ -0,0 +1,518 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<instrument xmlns="http://www.mantidproject.org/IDF/1.0"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://www.mantidproject.org/IDF/1.0 http://schema.mantidproject.org/IDF/1.0/IDFSchema.xsd"
+ name="CSP"
+ valid-from ="2017-05-04 15:15:00"
+ valid-to ="2100-01-31 23:59:59"
+ last-modified="2018-08-07 11:00:00">
+
+ <defaults>
+ <length unit="meter" />
+ <angle unit="degree" />
+ <reference-frame>
+ <along-beam axis="z" />
+ <pointing-up axis="y" />
+ <handedness val="right" />
+ </reference-frame>
+ </defaults>
+
+
+ <!-- Definition of instrument specific parameters for data reduction (e.g. wavelength cutoffs etc.) , could go into paramter file
+ MonitorBackground= [7.4,7.9]
+ MonitorsToCorrect=[1]
+ PointDetectorStart=[0] # Note: Since we are removing the monitors in the load raw command they are not counted here.
+ PointDetectorStop=[0]
+ MultiDetectorStart=[1]
+ I0MonitorIndex=1
+ -->
+
+ <!-- BRIEF DESCRIPTION OF CRISP INSTRUMENT:
+
+ Here Z=0 is defined by the neutron beam which slopes down at 1.5 deg.
+ from the horizon. This description is based on data provided by Tim
+ Charlton and Rob Dalgliesh.
+
+ Note from Tim spreedsheet
+ theta is a rotation about the y axis
+ phi is a rotation about the x axis
+ chi is a rotation about the z axis
+
+ Noticed the face of the monitors/detector shapes that faces the
+ beam/sample path is in this IDF defined to be the y-z plane.
+
+ Note the status of the instrument during a run is stored in the
+ logfile RunNo_status.txt
+ -->
+
+
+ <!-- LIST OF PHYSICAL COMPONENTS (which the instrument consists of) -->
+
+ <!-- detector components (including monitors) -->
+
+ <component type="monitor1" idlist="monitor1">
+ <location z="7.2055" />
+ </component>
+
+ <type name="monitor1" is="monitor">
+ <!-- Shape specified at least big enough to cover the beam which
+ is 10mm high and 40mm wide. Note it is described as tube, hence
+ the choice of a cylinder shape.
+ -->
+ <percent-transparency val="95" />
+ <cylinder id="shape">
+ <centre-of-bottom-base z="0.0" x="-0.02" y="0.0" />
+ <axis z="0.0" x="1.0" y="0.0" />
+ <radius val="0.01" />
+ <height val="0.04" />
+ </cylinder>
+ <algebra val="shape" />
+ </type>
+
+ <component type="monitor2" idlist="monitor2">
+ <location z="9.92" />
+ </component>
+
+ <!-- Putting in monitors, which are defined in raw/neuxs
+ files, and have detector IDs, but currently not physically present
+ on the instrument. Defined with no geometric shape, as they do not
+ physically exist, and with a dummy position -->
+ <type>
+ <component type="no shape monitor">
+ <location z="12.12" name="placeholder monitor"/>
+ </component>
+ </type>
+
+ <type name="monitor2" is="monitor">
+ <!-- Shape specified as a minimum needs to cover the beam which
+ is 10mm high and 40mm wide. The 'top' shape is included to
+ more easily recognise this monitor when visualised in MantidPlot.
+ This monitor is suppose to look a bit like a German hand grenade.
+ -->
+ <percent-transparency val="95" />
+ <cuboid id="base">
+ <left-front-bottom-point z="0.04" x="-0.02" y="-0.01" />
+ <left-front-top-point z="0.04" x="-0.02" y="0.01" />
+ <left-back-bottom-point z="-0.04" x="-0.02" y="-0.01" />
+ <right-front-bottom-point z="0.04" x="0.02" y="-0.01" />
+ </cuboid>
+
+ <cylinder id="top">
+ <centre-of-bottom-base z="0.0" x="0.0" y="0.01" />
+ <axis z="0.0" x="0.0" y="1.0" />
+ <radius val="0.02" />
+ <height val="0.04" />
+ </cylinder>
+
+ <algebra val="base : top" />
+ </type>
+
+ <type name="no shape monitor" is="monitor" />
+
+ <component type="point-detector" idlist="point-detector">
+
+ <location z="12.113" />
+
+ <!-- Link to log file that stores the z position. This angle can be used to
+ calculate the z position since the distance along the x-axis between
+ the sample and this detector is known (12.113-10.25=1.863). Also theta in the logfile is
+ assumed to in degrees, hence the reason for the pi/180=0.0174533 transformation
+ to radians factor in the eq attribute. -->
+ <parameter name="y">
+ <logfile id="theta" eq="1.8545*sin(2*value*0.0174533)" />
+ </parameter>
+
+ </component>
+
+ <type name="point-detector" is="detector">
+ <!-- Not exactly sure about the dimensions of this one. But pretty sure
+ it at least covers the beam. Also, just in front of it is a slit which
+ at the end of day will determine which neutrons get through to this
+ detector I believe.
+ -->
+ <cuboid id="shape">
+ <left-front-bottom-point z="0.01" x="-0.02" y="-0.005" />
+ <left-front-top-point z="0.01" x="-0.02" y="0.005" />
+ <left-back-bottom-point z="-0.01" x="-0.02" y="-0.005" />
+ <right-front-bottom-point z="0.01" x="0.02" y="-0.005" />
+ </cuboid>
+ <algebra val="shape" />
+ </type>
+
+
+ <component type="linear-detector" idlist="linear-detector">
+
+ <!-- Link to log file that stores the z position -->
+ <parameter name="z">
+ <logfile id="linear_det_height" eq="0.001*value" extract-single-value-as="position 1" />
+ </parameter>
+
+ <properties>
+ Thin slabs 50mm wide, one for each spectrum 1.2 mm pixel pitch growing upward
+ </properties>
+
+ <location z="12.403" />
+ </component>
+
+ <type name="linear-detector">
+ <component type="linear-detector-pixel" >
+ <location y="0" />
+ <location y="0.0012" />
+ <location y="0.0024" />
+ <location y="0.0036" />
+ <location y="0.0048" />
+ <location y="0.006" />
+ <location y="0.0072" />
+ <location y="0.0084" />
+ <location y="0.0096" />
+ <location y="0.0108" />
+ <location y="0.012" />
+ <location y="0.0132" />
+ <location y="0.0144" />
+ <location y="0.0156" />
+ <location y="0.0168" />
+ <location y="0.018" />
+ <location y="0.0192" />
+ <location y="0.0204" />
+ <location y="0.0216" />
+ <location y="0.0228" />
+ <location y="0.024" />
+ <location y="0.0252" />
+ <location y="0.0264" />
+ <location y="0.0276" />
+ <location y="0.0288" />
+ <location y="0.03" />
+ <location y="0.0312" />
+ <location y="0.0324" />
+ <location y="0.0336" />
+ <location y="0.0348" />
+ <location y="0.036" />
+ <location y="0.0372" />
+ <location y="0.0384" />
+ <location y="0.0396" />
+ <location y="0.0408" />
+ <location y="0.042" />
+ <location y="0.0432" />
+ <location y="0.0444" />
+ <location y="0.0456" />
+ <location y="0.0468" />
+ <location y="0.048" />
+ <location y="0.0492" />
+ <location y="0.0504" />
+ <location y="0.0516" />
+ <location y="0.0528" />
+ <location y="0.054" />
+ <location y="0.0552" />
+ <location y="0.0564" />
+ <location y="0.0576" />
+ <location y="0.0588" />
+ <location y="0.06" />
+ <location y="0.0612" />
+ <location y="0.0624" />
+ <location y="0.0636" />
+ <location y="0.0648" />
+ <location y="0.066" />
+ <location y="0.0672" />
+ <location y="0.0684" />
+ <location y="0.0696" />
+ <location y="0.0708" />
+ <location y="0.072" />
+ <location y="0.0732" />
+ <location y="0.0744" />
+ <location y="0.0756000000000001" />
+ <location y="0.0768000000000001" />
+ <location y="0.0780000000000001" />
+ <location y="0.0792000000000001" />
+ <location y="0.0804000000000001" />
+ <location y="0.0816000000000001" />
+ <location y="0.0828000000000001" />
+ <location y="0.0840000000000001" />
+ <location y="0.0852000000000001" />
+ <location y="0.0864000000000001" />
+ <location y="0.0876000000000001" />
+ <location y="0.0888000000000001" />
+ <location y="0.0900000000000001" />
+ <location y="0.0912000000000001" />
+ <location y="0.0924000000000001" />
+ <location y="0.0936000000000002" />
+ <location y="0.0948000000000002" />
+ <location y="0.0960000000000002" />
+ <location y="0.0972000000000002" />
+ <location y="0.0984000000000002" />
+ <location y="0.0996000000000002" />
+ <location y="0.1008" />
+ <location y="0.102" />
+ <location y="0.1032" />
+ <location y="0.1044" />
+ <location y="0.1056" />
+ <location y="0.1068" />
+ <location y="0.108" />
+ <location y="0.1092" />
+ <location y="0.1104" />
+ <location y="0.1116" />
+ <location y="0.1128" />
+ <location y="0.114" />
+ <location y="0.1152" />
+ <location y="0.1164" />
+ <location y="0.1176" />
+ <location y="0.1188" />
+ <location y="0.12" />
+ <location y="0.1212" />
+ <location y="0.1224" />
+ <location y="0.1236" />
+ <location y="0.1248" />
+ <location y="0.126" />
+ <location y="0.1272" />
+ <location y="0.1284" />
+ <location y="0.1296" />
+ <location y="0.1308" />
+ <location y="0.132" />
+ <location y="0.1332" />
+ <location y="0.1344" />
+ <location y="0.1356" />
+ <location y="0.1368" />
+ <location y="0.138" />
+ <location y="0.1392" />
+ <location y="0.1404" />
+ <location y="0.1416" />
+ <location y="0.1428" />
+ <location y="0.144" />
+ <location y="0.1452" />
+ <location y="0.1464" />
+ <location y="0.1476" />
+ <location y="0.1488" />
+ <location y="0.15" />
+ <location y="0.1512" />
+ <location y="0.1524" />
+ <location y="0.1536" />
+ <location y="0.1548" />
+ <location y="0.156" />
+ <location y="0.157200000000001" />
+ <location y="0.158400000000001" />
+ <location y="0.159600000000001" />
+ <location y="0.160800000000001" />
+ <location y="0.162000000000001" />
+ <location y="0.163200000000001" />
+ <location y="0.164400000000001" />
+ <location y="0.165600000000001" />
+ <location y="0.166800000000001" />
+ <location y="0.168000000000001" />
+ <location y="0.169200000000001" />
+ <location y="0.170400000000001" />
+ <location y="0.171600000000001" />
+ <location y="0.172800000000001" />
+ <location y="0.174000000000001" />
+ <location y="0.175200000000001" />
+ <location y="0.176400000000001" />
+ <location y="0.177600000000001" />
+ <location y="0.178800000000001" />
+ <location y="0.180000000000001" />
+ <location y="0.181200000000001" />
+ <location y="0.182400000000001" />
+ <location y="0.183600000000001" />
+ <location y="0.184800000000001" />
+ <location y="0.186000000000001" />
+ <location y="0.187200000000001" />
+ <location y="0.188400000000001" />
+ <location y="0.189600000000001" />
+ <location y="0.190800000000001" />
+ <location y="0.192000000000001" />
+ <location y="0.193200000000001" />
+ <location y="0.194400000000001" />
+ <location y="0.195600000000001" />
+ <location y="0.196800000000001" />
+ <location y="0.198000000000001" />
+ <location y="0.199200000000001" />
+ <location y="0.200400000000001" />
+ <location y="0.201600000000001" />
+ <location y="0.202800000000001" />
+ <location y="0.204000000000001" />
+ <location y="0.205200000000001" />
+ <location y="0.206400000000001" />
+ <location y="0.207600000000001" />
+ <location y="0.208800000000001" />
+ <location y="0.210000000000001" />
+ <location y="0.211200000000001" />
+ <location y="0.212400000000001" />
+ <location y="0.213600000000001" />
+ <location y="0.214800000000001" />
+ <location y="0.216000000000001" />
+ <location y="0.217200000000001" />
+ <location y="0.218400000000001" />
+ <location y="0.219600000000001" />
+ <location y="0.220800000000001" />
+ <location y="0.222000000000001" />
+ <location y="0.223200000000001" />
+ <location y="0.224400000000001" />
+ <location y="0.225600000000001" />
+ <location y="0.226800000000001" />
+ <location y="0.228000000000001" />
+ <location y="0.229200000000001" />
+ <location y="0.230400000000001" />
+ <location y="0.231600000000001" />
+ <location y="0.232800000000001" />
+ <location y="0.234000000000001" />
+ <location y="0.235200000000001" />
+ <location y="0.236400000000001" />
+ <location y="0.237600000000001" />
+ <location y="0.238800000000001" />
+ <location y="0.240000000000001" />
+ <location y="0.241200000000001" />
+ <location y="0.242400000000001" />
+ <location y="0.243600000000001" />
+ <location y="0.244800000000001" />
+ <location y="0.246000000000001" />
+ <location y="0.247200000000001" />
+ <location y="0.248400000000001" />
+ <location y="0.249600000000001" />
+ <location y="0.250800000000001" />
+ <location y="0.252000000000001" />
+ <location y="0.253200000000001" />
+ <location y="0.254400000000001" />
+ <location y="0.255600000000001" />
+ <location y="0.256800000000001" />
+ <location y="0.258000000000001" />
+ <location y="0.259200000000001" />
+ <location y="0.260400000000001" />
+ <location y="0.261600000000001" />
+ <location y="0.262800000000001" />
+ <location y="0.264000000000001" />
+ <location y="0.265200000000001" />
+ <location y="0.266400000000001" />
+ <location y="0.267600000000001" />
+ <location y="0.268800000000001" />
+ <location y="0.270000000000001" />
+ <location y="0.271200000000001" />
+ <location y="0.272400000000001" />
+ <location y="0.273600000000001" />
+ <location y="0.274800000000001" />
+ <location y="0.276000000000001" />
+ <location y="0.277200000000001" />
+ <location y="0.278400000000001" />
+ <location y="0.279600000000001" />
+ <location y="0.2808" />
+ <location y="0.282" />
+ <location y="0.2832" />
+ <location y="0.2844" />
+ <location y="0.2856" />
+ <location y="0.2868" />
+ </component>
+ </type>
+
+ <type name="linear-detector-pixel" is="detector">
+ <cuboid id="shape">
+ <left-front-bottom-point z="0.01" x="-0.025" y="-0.0006" />
+ <left-front-top-point z="0.01" x="-0.025" y="0.0006" />
+ <left-back-bottom-point z="-0.01" x="-0.025" y="-0.0006" />
+ <right-front-bottom-point z="0.01" x="0.025" y="-0.0006" />
+ </cuboid>
+ <algebra val="shape" />
+ </type>
+
+
+ <!-- source and sample-position components -->
+
+ <component type="source">
+ <location />
+ </component>
+
+ <type name="source" is="Source">
+ <properties>
+ 10mm(H) x 40mm(W)
+ </properties>
+ </type>
+
+
+ <component type="some-surface-holder">
+ <!-- worry about linking relevant logfiles for y,z,theta,phi up later. Change from 10.25 -->
+ <location z="10.2585"/>
+ </component>
+
+ <type name="some-surface-holder" is="SamplePos">
+ </type>
+
+
+ <!-- other components -->
+
+ <component type="slit" name="slit1">
+ <location z="7.3025"/>
+ <!-- This log file stores the vertical opening of slit -->
+ <parameter name="vertical gap">
+ <logfile id="s1vg" extract-single-value-as="last_value" />
+ </parameter>
+ </component>
+
+ <component type="slit" name="slit2">
+ <location z="9.6885"/>
+ <!-- This log file stores the vertical opening of this. Note this
+ slit can also be translated in the z. However this info not stored
+ in log file since it is not used in the data analysis process. -->
+ <parameter name="vertical gap">
+ <logfile id="s2vg" extract-single-value-as="last_value" />
+ </parameter>
+ </component>
+
+ <component type="slit" name="slit3">
+ <location z="10.651"/>
+ <!-- This log file stores the vertical opening of slit -->
+ <parameter name="vertical gap">
+ <logfile id="s3vg" extract-single-value-as="last_value" />
+ </parameter>
+ </component>
+
+ <component type="slit" name="slit4">
+ <location z="11.983"/>
+ <!-- This log file stores the vertical opening of slit. Note this slit
+ is fixed to the point detector. -->
+ <parameter name="vertical gap">
+ <logfile id="s4vg" extract-single-value-as="last_value" />
+ </parameter>
+ </component>
+
+<type name="slit">
+ <percent-transparency val="50" />
+ <cuboid id="bottom">
+ <left-front-bottom-point z="0.0005" x="-0.025" y="-0.03" />
+ <left-front-top-point z="0.0005" x="-0.025" y="0.0" />
+ <left-back-bottom-point z="-0.0005" x="-0.025" y="-0.03" />
+ <right-front-bottom-point z="0.0005" x="0.025" y="-0.03" />
+ </cuboid>
+ </type>
+
+
+
+
+ <component type="supermirror">
+ <!-- Worry about linking relevant logfiles for z,theta up later -->
+ <location z="7.7685"/>
+ </component>
+
+ <type name="supermirror" />
+
+
+
+
+ <!-- DETECTOR and MONITOR ID LISTS -->
+
+ <idlist idname="monitor1">
+ <id val="1" />
+ </idlist>
+
+ <idlist idname="monitor2">
+ <id val="2" />
+ </idlist>
+
+ <idlist idname="point-detector">
+ <id val="3" />
+ </idlist>
+
+ <idlist idname="monitor3">
+ <id val="4" />
+ </idlist>
+
+ <idlist idname="linear-detector">
+ <id start="6" end="125" />
+ <id start="134" end="253" />
+ </idlist>
+
+</instrument>
diff --git a/instrument/CRISP_Parameters.xml b/instrument/CRISP_Parameters.xml
index 8b05b80de69896755efe9bc24b968966faaae67d..5375b9a520f3bea298cd4be9667f22a9458b42e5 100644
--- a/instrument/CRISP_Parameters.xml
+++ b/instrument/CRISP_Parameters.xml
@@ -13,11 +13,11 @@
</parameter>
<parameter name="MonitorIntegralMin">
- <value val="4.0"/>
+ <value val="2.0"/>
</parameter>
<parameter name="MonitorIntegralMax">
- <value val="10.0"/>
+ <value val="6.44"/>
</parameter>
<parameter name="PointDetectorStart">
@@ -41,7 +41,8 @@
</parameter>
<parameter name="LambdaMax">
- <value val="6.5"/>
+ <!--<value val="6.5"/>-->
+ <value val="6.44"/>
</parameter>
<!-- parameters for efficiency correction -->
@@ -101,14 +102,5 @@
<value val="0.972762,0.001828,-0.000261,0.0"/>
</parameter>
</component-link>
-<component-link name="pointdetector">
- <!-- Link to log file that stores the z position. This angle can be used to
- calculate the z position since the distance along the x-axis between
- the sample and this detector is known (12.113-10.25=1.863). Also theta in the logfile is
- assumed to in degrees, hence the reason for the pi/180=0.0174533 transformation
- to radians factor in the eq attribute. -->
- <parameter name="z">
- <logfile id="theta" eq="1.863*sin(value*0.0174533)" />
- </parameter>
-</component-link>
+
</parameter-file>
diff --git a/instrument/OFFSPEC_Definition.xml b/instrument/OFFSPEC_Definition.xml
index 93c11222f1afc1c68bc060a39a54443cf6fb6acb..da8facc157b722433b75da16e9838cc14b5f78c5 100644
--- a/instrument/OFFSPEC_Definition.xml
+++ b/instrument/OFFSPEC_Definition.xml
@@ -4,9 +4,10 @@
<instrument xmlns="http://www.mantidproject.org/IDF/1.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.mantidproject.org/IDF/1.0 http://schema.mantidproject.org/IDF/1.0/IDFSchema.xsd"
- name="OFFSPEC" valid-from ="2012-01-02 00:00:00"
- valid-to ="2115-01-02 23:59:59"
- last-modified="2015-10-10 15:00:00">
+ name="OFFSPEC"
+ valid-from ="1900-02-01 00:00:00"
+ valid-to ="2115-01-02 23:59:59"
+ last-modified="2018-08-07 11:00:00">
<defaults>
<length unit="meter" />
diff --git a/instrument/OFFSPEC_Definition_2018.xml b/instrument/OFFSPEC_Definition_2018.xml
new file mode 100644
index 0000000000000000000000000000000000000000..807b1de166b672908216eb898e9e04dc7ec41d85
--- /dev/null
+++ b/instrument/OFFSPEC_Definition_2018.xml
@@ -0,0 +1,801 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- For help on the notation used to specify an Instrument Definition File
+ see http://www.mantidproject.org/IDF -->
+<instrument xmlns="http://www.mantidproject.org/IDF/1.0"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://www.mantidproject.org/IDF/1.0 http://schema.mantidproject.org/IDF/1.0/IDFSchema.xsd"
+ name="OFFSPEC"
+ valid-from ="1900-01-31 23:59:59"
+ valid-to ="1900-01-31 23:59:59"
+ last-modified="2018-08-07 11:00:00">
+
+ <defaults>
+ <length unit="meter" />
+ <angle unit="degree" />
+ <reference-frame>
+ <along-beam axis="z" />
+ <pointing-up axis="y" />
+ <handedness val="right" />
+ </reference-frame>
+ <components-are-facing x="0.0" y="0.0" z="0.0" />
+ </defaults>
+
+ <!-- source and sample-position components -->
+
+ <component type="source">
+ <location z="-23.83" />
+ </component>
+ <type name="source" is="Source">
+ <properties>
+ 40mm(H) x 60mm(W)
+ </properties>
+ </type>
+
+ <component type="some-surface-holder">
+ <location x="0.0" y="0.0" z="0.0" />
+ </component>
+ <type name="some-surface-holder" is="SamplePos"/>
+
+<!-- source and sample-position components END=============================== -->
+
+
+<!-- LIST OF PHYSICAL COMPONENTS (which the instrument consists of) -->
+<!-- detector components (including monitors) -->
+
+<!-- ================MONITOR 1 START========================================= -->
+ <component type="monitor1" idlist="monitor1">
+ <location r="11.38" t="180.0" />
+ </component>
+
+ <type name="monitor1" is="monitor">
+ <percent-transparency val="95" />
+ <cylinder id="shape">
+ <centre-of-bottom-base x="0.0" y="-0.02" z="0.0" />
+ <axis x="0.0" y="1.0" z="0.0" />
+ <radius val="0.015" />
+ <height val="0.04" />
+ </cylinder>
+ <algebra val="shape" />
+ </type>
+<!-- ================MONITOR 1 END=========================================== -->
+
+<!-- ================MONITOR 2 START========================================= -->
+ <component type="monitor2" idlist="monitor2">
+ <location r="5.62" t="180.0" />
+ </component>
+
+ <type name="monitor2" is="monitor">
+ <percent-transparency val="95" />
+ <cylinder id="shape">
+ <centre-of-bottom-base x="-0.02" y="0.0" z="0.0" />
+ <axis x="1.0" y="0.0" z="0.0" />
+ <radius val="0.015" />
+ <height val="0.04" />
+ </cylinder>
+ <algebra val="shape" />
+ </type>
+<!-- ================MONITOR 2 END=========================================== -->
+
+<!-- ================MONITOR 3 START========================================= -->
+ <component type="monitor3" idlist="monitor3">
+ <!-- <location r="0.4" t="180.0" /> -->
+ <location r="0.55" t="180.0" />
+ </component>
+
+ <type name="monitor3" is="monitor">
+ <percent-transparency val="95" />
+ <cylinder id="top">
+ <centre-of-bottom-base x="0.0" y="-0.05" z="0.0" />
+ <axis x="0.0" y="1.0" z="0.0" />
+ <radius val="0.04" />
+ <height val="0.1" />
+ </cylinder>
+
+ <cylinder id="base">
+ <centre-of-bottom-base x="0.0" y="-0.15" z="0.0" />
+ <axis x="0.0" y="1.0" z="0.0" />
+ <radius val="0.02" />
+ <height val="0.1" />
+ </cylinder>
+
+ <algebra val="base : top" />
+ </type>
+<!-- ================MONITOR 2 END=========================================== -->
+
+<!-- ================DETECTORs START==================================== -->
+ <component type="DetectorBench" idlist="DetectorBench">
+ <location z="0.0" />
+ <parameter name="rotx">
+ <logfile id="Theta" eq="-2*value" extract-single-value-as="last_value"/>
+ </parameter>
+ <!-- <facing x="0" y="0" z="0"/> </location -->
+ </component>
+
+ <type name="DetectorBench">
+ <component type="point-detector">
+ <!-- <location z="3.2" /> -->
+ <location z="3.19" />
+ </component>
+ <component type="LinearDetector">
+ <!-- <location z="3.65" /> -->
+ <location z="3.65" />
+ </component>
+ <component type="LarmorDetectorSection">
+ <location z=" 3.52 " />
+ </component>
+ <component type="WLSFDetector">
+ <location z=" 3.62 " />
+ </component>
+ </type>
+
+ <type name="point-detector" is="detector">
+ <cylinder id="shape">
+ <centre-of-bottom-base x="-0.05" y="0.0" z="0.0" />
+ <axis x="1.0" y="0.0" z="0.0" />
+ <radius val="0.005" />
+ <height val="0.1" />
+ </cylinder>
+ <algebra val="shape" />
+ </type>
+
+
+
+ <type name="LinearDetector">
+ <component type="pixel">
+ <locations y="-0.1301" y-end="0.1771" n-elements="256" />
+ </component>
+ </type>
+
+ <type name="pixel" is="detector">
+ <cuboid id="shape">
+ <left-front-bottom-point x="-0.025" y="-0.0006" z="0.0" />
+ <left-front-top-point x="-0.025" y="0.0006" z="0.0" />
+ <left-back-bottom-point x="-0.025" y="-0.0006" z="0.05" />
+ <right-front-bottom-point x="0.025" y="-0.0006" z="0.0" />
+ </cuboid>
+ <algebra val="shape" />
+ </type>
+
+ <!-- Larmor Detector Section 8 tubes -->
+
+<type name="LarmorDetectorSection">
+ <properties />
+ <component type="tube">
+<location x=" 0.0028 " y="-0.00703125" name="tube001" />
+<location x=" 0.0020 " y="0.000234375" name="tube002" />
+<location x=" 0.0012 " y="-0.00703125" name="tube003" />
+<location x=" 0.004 " y="0.000234375" name="tube004" />
+<location x=" -0.004 " y="-0.000234375" name="tube005" />
+<location x=" -0.0012 " y="0.000234375" name="tube006" />
+<location x=" -0.0020 " y="-0.000234375" name="tube007" />
+<location x=" -0.0028 " y="0.00703125" name="tube008" />
+ </component>
+ </type>
+
+ <type name="tube" outline="yes">
+ <component type="tubepixel">
+ <location y=" -0.2133 "/>
+ <location y="-0.21212813 "/>
+ <location y="-0.21095625 "/>
+ <location y="-0.20978438 "/>
+ <location y=" -0.2086125 "/>
+ <location y="-0.20744063 "/>
+ <location y="-0.20626875 "/>
+ <location y="-0.20509688 "/>
+ <location y=" -0.203925 "/>
+ <location y="-0.20275313 "/>
+ <location y="-0.20158125 "/>
+ <location y="-0.20040938 "/>
+ <location y=" -0.1992375 "/>
+ <location y="-0.19806563 "/>
+ <location y="-0.19689375 "/>
+ <location y="-0.19572188 "/>
+ <location y=" -0.19455 "/>
+ <location y="-0.19337813 "/>
+ <location y="-0.19220625 "/>
+ <location y="-0.19103438 "/>
+ <location y=" -0.1898625 "/>
+ <location y="-0.18869063 "/>
+ <location y="-0.18751875 "/>
+ <location y="-0.18634688 "/>
+ <location y=" -0.185175 "/>
+ <location y="-0.18400313 "/>
+ <location y="-0.18283125 "/>
+ <location y="-0.18165938 "/>
+ <location y=" -0.1804875 "/>
+ <location y="-0.17931563 "/>
+ <location y="-0.17814375 "/>
+ <location y="-0.17697188 "/>
+ <location y=" -0.1758 "/>
+ <location y="-0.17462813 "/>
+ <location y="-0.17345625 "/>
+ <location y="-0.17228438 "/>
+ <location y=" -0.1711125 "/>
+ <location y="-0.16994063 "/>
+ <location y="-0.16876875 "/>
+ <location y="-0.16759688 "/>
+ <location y=" -0.166425 "/>
+ <location y="-0.16525313 "/>
+ <location y="-0.16408125 "/>
+ <location y="-0.16290938 "/>
+ <location y=" -0.1617375 "/>
+ <location y="-0.16056563 "/>
+ <location y="-0.15939375 "/>
+ <location y="-0.15822188 "/>
+ <location y=" -0.15705 "/>
+ <location y="-0.15587813 "/>
+ <location y="-0.15470625 "/>
+ <location y="-0.15353438 "/>
+ <location y=" -0.1523625 "/>
+ <location y="-0.15119063 "/>
+ <location y="-0.15001875 "/>
+ <location y="-0.14884688 "/>
+ <location y=" -0.147675 "/>
+ <location y="-0.14650313 "/>
+ <location y="-0.14533125 "/>
+ <location y="-0.14415938 "/>
+ <location y=" -0.1429875 "/>
+ <location y="-0.14181563 "/>
+ <location y="-0.14064375 "/>
+ <location y="-0.13947188 "/>
+ <location y=" -0.1383 "/>
+ <location y="-0.13712813 "/>
+ <location y="-0.13595625 "/>
+ <location y="-0.13478438 "/>
+ <location y=" -0.1336125 "/>
+ <location y="-0.13244063 "/>
+ <location y="-0.13126875 "/>
+ <location y="-0.13009688 "/>
+ <location y=" -0.128925 "/>
+ <location y="-0.12775313 "/>
+ <location y="-0.12658125 "/>
+ <location y="-0.12540938 "/>
+ <location y=" -0.1242375 "/>
+ <location y="-0.12306563 "/>
+ <location y="-0.12189375 "/>
+ <location y="-0.12072188 "/>
+ <location y=" -0.11955 "/>
+ <location y="-0.11837813 "/>
+ <location y="-0.11720625 "/>
+ <location y="-0.11603438 "/>
+ <location y=" -0.1148625 "/>
+ <location y="-0.11369063 "/>
+ <location y="-0.11251875 "/>
+ <location y="-0.11134688 "/>
+ <location y=" -0.110175 "/>
+ <location y="-0.10900313 "/>
+ <location y="-0.10783125 "/>
+ <location y="-0.10665938 "/>
+ <location y=" -0.1054875 "/>
+ <location y="-0.10431563 "/>
+ <location y="-0.10314375 "/>
+ <location y="-0.10197188 "/>
+ <location y=" -0.1008 "/>
+ <location y="-0.09962813 "/>
+ <location y="-0.09845625 "/>
+ <location y="-0.09728438 "/>
+ <location y=" -0.0961125 "/>
+ <location y="-0.09494063 "/>
+ <location y="-0.09376875 "/>
+ <location y="-0.09259688 "/>
+ <location y=" -0.091425 "/>
+ <location y="-0.09025313 "/>
+ <location y="-0.08908125 "/>
+ <location y="-0.08790938 "/>
+ <location y=" -0.0867375 "/>
+ <location y="-0.08556563 "/>
+ <location y="-0.08439375 "/>
+ <location y="-0.08322188 "/>
+ <location y=" -0.08205 "/>
+ <location y="-0.08087813 "/>
+ <location y="-0.07970625 "/>
+ <location y="-0.07853438 "/>
+ <location y=" -0.0773625 "/>
+ <location y="-0.07619063 "/>
+ <location y="-0.07501875 "/>
+ <location y="-0.07384688 "/>
+ <location y=" -0.072675 "/>
+ <location y="-0.07150313 "/>
+ <location y="-0.07033125 "/>
+ <location y="-0.06915938 "/>
+ <location y=" -0.0679875 "/>
+ <location y="-0.06681563 "/>
+ <location y="-0.06564375 "/>
+ <location y="-0.06447188 "/>
+ <location y=" -0.0633 "/>
+ <location y="-0.06212813 "/>
+ <location y="-0.06095625 "/>
+ <location y="-0.05978438 "/>
+ <location y=" -0.0586125 "/>
+ <location y="-0.05744063 "/>
+ <location y="-0.05626875 "/>
+ <location y="-0.05509688 "/>
+ <location y=" -0.053925 "/>
+ <location y="-0.05275313 "/>
+ <location y="-0.05158125 "/>
+ <location y="-0.05040938 "/>
+ <location y=" -0.0492375 "/>
+ <location y="-0.04806563 "/>
+ <location y="-0.04689375 "/>
+ <location y="-0.04572188 "/>
+ <location y=" -0.04455 "/>
+ <location y="-0.04337813 "/>
+ <location y="-0.04220625 "/>
+ <location y="-0.04103438 "/>
+ <location y=" -0.0398625 "/>
+ <location y="-0.03869063 "/>
+ <location y="-0.03751875 "/>
+ <location y="-0.03634688 "/>
+ <location y=" -0.035175 "/>
+ <location y="-0.03400313 "/>
+ <location y="-0.03283125 "/>
+ <location y="-0.03165938 "/>
+ <location y=" -0.0304875 "/>
+ <location y="-0.02931563 "/>
+ <location y="-0.02814375 "/>
+ <location y="-0.02697188 "/>
+ <location y=" -0.0258 "/>
+ <location y="-0.02462813 "/>
+ <location y="-0.02345625 "/>
+ <location y="-0.02228438 "/>
+ <location y=" -0.0211125 "/>
+ <location y="-0.01994063 "/>
+ <location y="-0.01876875 "/>
+ <location y="-0.01759688 "/>
+ <location y=" -0.016425 "/>
+ <location y="-0.01525313 "/>
+ <location y="-0.01408125 "/>
+ <location y="-0.01290938 "/>
+ <location y=" -0.0117375 "/>
+ <location y="-0.01056563 "/>
+ <location y="-0.00939375 "/>
+ <location y="-0.00822188 "/>
+ <location y=" -0.00705 "/>
+ <location y="-0.00587813 "/>
+ <location y="-0.00470625 "/>
+ <location y="-0.00353438 "/>
+ <location y=" -0.0023625 "/>
+ <location y="-0.00119063 "/>
+ <location y=" -1.875E-05 "/>
+ <location y="0.001153125 "/>
+ <location y=" 0.002325 "/>
+ <location y="0.003496875 "/>
+ <location y=" 0.00466875 "/>
+ <location y="0.005840625 "/>
+ <location y=" 0.0070125 "/>
+ <location y="0.008184375 "/>
+ <location y=" 0.00935625 "/>
+ <location y="0.010528125 "/>
+ <location y=" 0.0117 "/>
+ <location y="0.012871875 "/>
+ <location y=" 0.01404375 "/>
+ <location y="0.015215625 "/>
+ <location y=" 0.0163875 "/>
+ <location y="0.017559375 "/>
+ <location y=" 0.01873125 "/>
+ <location y="0.019903125 "/>
+ <location y=" 0.021075 "/>
+ <location y="0.022246875 "/>
+ <location y=" 0.02341875 "/>
+ <location y="0.024590625 "/>
+ <location y=" 0.0257625 "/>
+ <location y="0.026934375 "/>
+ <location y=" 0.02810625 "/>
+ <location y="0.029278125 "/>
+ <location y=" 0.03045 "/>
+ <location y="0.031621875 "/>
+ <location y=" 0.03279375 "/>
+ <location y="0.033965625 "/>
+ <location y=" 0.0351375 "/>
+ <location y="0.036309375 "/>
+ <location y=" 0.03748125 "/>
+ <location y="0.038653125 "/>
+ <location y=" 0.039825 "/>
+ <location y="0.040996875 "/>
+ <location y=" 0.04216875 "/>
+ <location y="0.043340625 "/>
+ <location y=" 0.0445125 "/>
+ <location y="0.045684375 "/>
+ <location y=" 0.04685625 "/>
+ <location y="0.048028125 "/>
+ <location y=" 0.0492 "/>
+ <location y="0.050371875 "/>
+ <location y=" 0.05154375 "/>
+ <location y="0.052715625 "/>
+ <location y=" 0.0538875 "/>
+ <location y="0.055059375 "/>
+ <location y=" 0.05623125 "/>
+ <location y="0.057403125 "/>
+ <location y=" 0.058575 "/>
+ <location y="0.059746875 "/>
+ <location y=" 0.06091875 "/>
+ <location y="0.062090625 "/>
+ <location y=" 0.0632625 "/>
+ <location y="0.064434375 "/>
+ <location y=" 0.06560625 "/>
+ <location y="0.066778125 "/>
+ <location y=" 0.06795 "/>
+ <location y="0.069121875 "/>
+ <location y=" 0.07029375 "/>
+ <location y="0.071465625 "/>
+ <location y=" 0.0726375 "/>
+ <location y="0.073809375 "/>
+ <location y=" 0.07498125 "/>
+ <location y="0.076153125 "/>
+ <location y=" 0.077325 "/>
+ <location y="0.078496875 "/>
+ <location y=" 0.07966875 "/>
+ <location y="0.080840625 "/>
+ <location y=" 0.0820125 "/>
+ <location y="0.083184375 "/>
+ <location y=" 0.08435625 "/>
+ <location y="0.085528125 "/>
+ <location y=" 0.0867 "/>
+ <location y="0.087871875 "/>
+ <location y=" 0.08904375 "/>
+ <location y="0.090215625 "/>
+ <location y=" 0.0913875 "/>
+ <location y="0.092559375 "/>
+ <location y=" 0.09373125 "/>
+ <location y="0.094903125 "/>
+ <location y=" 0.096075 "/>
+ <location y="0.097246875 "/>
+ <location y=" 0.09841875 "/>
+ <location y="0.099590625 "/>
+ <location y=" 0.1007625 "/>
+ <location y="0.101934375 "/>
+ <location y=" 0.10310625 "/>
+ <location y="0.104278125 "/>
+ <location y=" 0.10545 "/>
+ <location y="0.106621875 "/>
+ <location y=" 0.10779375 "/>
+ <location y="0.108965625 "/>
+ <location y=" 0.1101375 "/>
+ <location y="0.111309375 "/>
+ <location y=" 0.11248125 "/>
+ <location y="0.113653125 "/>
+ <location y=" 0.114825 "/>
+ <location y="0.115996875 "/>
+ <location y=" 0.11716875 "/>
+ <location y="0.118340625 "/>
+ <location y=" 0.1195125 "/>
+ <location y="0.120684375 "/>
+ <location y=" 0.12185625 "/>
+ <location y="0.123028125 "/>
+ <location y=" 0.1242 "/>
+ <location y="0.125371875 "/>
+ <location y=" 0.12654375 "/>
+ <location y="0.127715625 "/>
+ <location y=" 0.1288875 "/>
+ <location y="0.130059375 "/>
+ <location y=" 0.13123125 "/>
+ <location y="0.132403125 "/>
+ <location y=" 0.133575 "/>
+ <location y="0.134746875 "/>
+ <location y=" 0.13591875 "/>
+ <location y="0.137090625 "/>
+ <location y=" 0.1382625 "/>
+ <location y="0.139434375 "/>
+ <location y=" 0.14060625 "/>
+ <location y="0.141778125 "/>
+ <location y=" 0.14295 "/>
+ <location y="0.144121875 "/>
+ <location y=" 0.14529375 "/>
+ <location y="0.146465625 "/>
+ <location y=" 0.1476375 "/>
+ <location y="0.148809375 "/>
+ <location y=" 0.14998125 "/>
+ <location y="0.151153125 "/>
+ <location y=" 0.152325 "/>
+ <location y="0.153496875 "/>
+ <location y=" 0.15466875 "/>
+ <location y="0.155840625 "/>
+ <location y=" 0.1570125 "/>
+ <location y="0.158184375 "/>
+ <location y=" 0.15935625 "/>
+ <location y="0.160528125 "/>
+ <location y=" 0.1617 "/>
+ <location y="0.162871875 "/>
+ <location y=" 0.16404375 "/>
+ <location y="0.165215625 "/>
+ <location y=" 0.1663875 "/>
+ <location y="0.167559375 "/>
+ <location y=" 0.16873125 "/>
+ <location y="0.169903125 "/>
+ <location y=" 0.171075 "/>
+ <location y="0.172246875 "/>
+ <location y=" 0.17341875 "/>
+ <location y="0.174590625 "/>
+ <location y=" 0.1757625 "/>
+ <location y="0.176934375 "/>
+ <location y=" 0.17810625 "/>
+ <location y="0.179278125 "/>
+ <location y=" 0.18045 "/>
+ <location y="0.181621875 "/>
+ <location y=" 0.18279375 "/>
+ <location y="0.183965625 "/>
+ <location y=" 0.1851375 "/>
+ <location y="0.186309375 "/>
+ <location y=" 0.18748125 "/>
+ <location y="0.188653125 "/>
+ <location y=" 0.189825 "/>
+ <location y="0.190996875 "/>
+ <location y=" 0.19216875 "/>
+ <location y="0.193340625 "/>
+ <location y=" 0.1945125 "/>
+ <location y="0.195684375 "/>
+ <location y=" 0.19685625 "/>
+ <location y="0.198028125 "/>
+ <location y=" 0.1992 "/>
+ <location y="0.200371875 "/>
+ <location y=" 0.20154375 "/>
+ <location y="0.202715625 "/>
+ <location y=" 0.2038875 "/>
+ <location y="0.205059375 "/>
+ <location y=" 0.20623125 "/>
+ <location y="0.207403125 "/>
+ <location y=" 0.208575 "/>
+ <location y="0.209746875 "/>
+ <location y=" 0.21091875 "/>
+ <location y="0.212090625 "/>
+ <location y=" 0.2132625 "/>
+ <location y="0.214434375 "/>
+ <location y=" 0.21560625 "/>
+ <location y="0.216778125 "/>
+ <location y=" 0.21795 "/>
+ <location y="0.219121875 "/>
+ <location y=" 0.22029375 "/>
+ <location y="0.221465625 "/>
+ <location y=" 0.2226375 "/>
+ <location y="0.223809375 "/>
+ <location y=" 0.22498125 "/>
+ <location y="0.226153125 "/>
+ <location y=" 0.227325 "/>
+ <location y="0.228496875 "/>
+ <location y=" 0.22966875 "/>
+ <location y="0.230840625 "/>
+ <location y=" 0.2320125 "/>
+ <location y="0.233184375 "/>
+ <location y=" 0.23435625 "/>
+ <location y="0.235528125 "/>
+ <location y=" 0.2367 "/>
+ <location y="0.237871875 "/>
+ <location y=" 0.23904375 "/>
+ <location y="0.240215625 "/>
+ <location y=" 0.2413875 "/>
+ <location y="0.242559375 "/>
+ <location y=" 0.24373125 "/>
+ <location y="0.244903125 "/>
+ <location y=" 0.246075 "/>
+ <location y="0.247246875 "/>
+ <location y=" 0.24841875 "/>
+ <location y="0.249590625 "/>
+ <location y=" 0.2507625 "/>
+ <location y="0.251934375 "/>
+ <location y=" 0.25310625 "/>
+ <location y="0.254278125 "/>
+ <location y=" 0.25545 "/>
+ <location y="0.256621875 "/>
+ <location y=" 0.25779375 "/>
+ <location y="0.258965625 "/>
+ <location y=" 0.2601375 "/>
+ <location y="0.261309375 "/>
+ <location y=" 0.26248125 "/>
+ <location y="0.263653125 "/>
+ <location y=" 0.264825 "/>
+ <location y="0.265996875 "/>
+ <location y=" 0.26716875 "/>
+ <location y="0.268340625 "/>
+ <location y=" 0.2695125 "/>
+ <location y="0.270684375 "/>
+ <location y=" 0.27185625 "/>
+ <location y="0.273028125 "/>
+ <location y=" 0.2742 "/>
+ <location y="0.275371875 "/>
+ <location y=" 0.27654375 "/>
+ <location y="0.277715625 "/>
+ <location y=" 0.2788875 "/>
+ <location y="0.280059375 "/>
+ <location y=" 0.28123125 "/>
+ <location y="0.282403125 "/>
+ <location y=" 0.283575 "/>
+ <location y="0.284746875 "/>
+ <location y=" 0.28591875 "/>
+ <location y="0.287090625 "/>
+ <location y=" 0.2882625 "/>
+ <location y="0.289434375 "/>
+ <location y=" 0.29060625 "/>
+ <location y="0.291778125 "/>
+ <location y=" 0.29295 "/>
+ <location y="0.294121875 "/>
+ <location y=" 0.29529375 "/>
+ <location y="0.296465625 "/>
+ <location y=" 0.2976375 "/>
+ <location y="0.298809375 "/>
+ <location y=" 0.29998125 "/>
+ <location y="0.301153125 "/>
+ <location y=" 0.302325 "/>
+ <location y="0.303496875 "/>
+ <location y=" 0.30466875 "/>
+ <location y="0.305840625 "/>
+ <location y=" 0.3070125 "/>
+ <location y="0.308184375 "/>
+ <location y=" 0.30935625 "/>
+ <location y="0.310528125 "/>
+ <location y=" 0.3117 "/>
+ <location y="0.312871875 "/>
+ <location y=" 0.31404375 "/>
+ <location y="0.315215625 "/>
+ <location y=" 0.3163875 "/>
+ <location y="0.317559375 "/>
+ <location y=" 0.31873125 "/>
+ <location y="0.319903125 "/>
+ <location y=" 0.321075 "/>
+ <location y="0.322246875 "/>
+ <location y=" 0.32341875 "/>
+ <location y="0.324590625 "/>
+ <location y=" 0.3257625 "/>
+ <location y="0.326934375 "/>
+ <location y=" 0.32810625 "/>
+ <location y="0.329278125 "/>
+ <location y=" 0.33045 "/>
+ <location y="0.331621875 "/>
+ <location y=" 0.33279375 "/>
+ <location y="0.333965625 "/>
+ <location y=" 0.3351375 "/>
+ <location y="0.336309375 "/>
+ <location y=" 0.33748125 "/>
+ <location y="0.338653125 "/>
+ <location y=" 0.339825 "/>
+ <location y="0.340996875 "/>
+ <location y=" 0.34216875 "/>
+ <location y="0.343340625 "/>
+ <location y=" 0.3445125 "/>
+ <location y="0.345684375 "/>
+ <location y=" 0.34685625 "/>
+ <location y="0.348028125 "/>
+ <location y=" 0.3492 "/>
+ <location y="0.350371875 "/>
+ <location y=" 0.35154375 "/>
+ <location y="0.352715625 "/>
+ <location y=" 0.3538875 "/>
+ <location y="0.355059375 "/>
+ <location y=" 0.35623125 "/>
+ <location y="0.357403125 "/>
+ <location y=" 0.358575 "/>
+ <location y="0.359746875 "/>
+ <location y=" 0.36091875 "/>
+ <location y="0.362090625 "/>
+ <location y=" 0.3632625 "/>
+ <location y="0.364434375 "/>
+ <location y=" 0.36560625 "/>
+ <location y="0.366778125 "/>
+ <location y=" 0.36795 "/>
+ <location y="0.369121875 "/>
+ <location y=" 0.37029375 "/>
+ <location y="0.371465625 "/>
+ <location y=" 0.3726375 "/>
+ <location y="0.373809375 "/>
+ <location y=" 0.37498125 "/>
+ <location y="0.376153125 "/>
+ <location y=" 0.377325 "/>
+ <location y="0.378496875 "/>
+ <location y=" 0.37966875 "/>
+ <location y="0.380840625 "/>
+ <location y=" 0.3820125 "/>
+ <location y="0.383184375 "/>
+ <location y=" 0.38435625 "/>
+ <location y="0.385528125 "/>
+ </component>
+ </type>
+
+ <type name="tubepixel" is="detector">
+ <cylinder id="cyl-approx">
+ <centre-of-bottom-base r="0.0" t="0.0" p="0.0" />
+ <axis x="0.0" y="0.2" z="0.0" />
+ <radius val="0.004" />
+ <height val="1.171875e-3" />
+ </cylinder>
+ <algebra val="cyl-approx" />
+ </type>
+
+ <!-- <type name="WLSFDetector">
+ <locations y="-0.19975" y-end="0.18425" n-elements="768" />
+ <locations y="-0.200" y-end="0.184" n-elements="768" />
+ <locations y="-0.19775" y-end="0.18225" n-elements="768" />
+ <locations y="-0.202325" y-end="0.186145" n-elements="768" />
+-->
+ <type name="WLSFDetector">
+ <component type="wlsfpixel">
+ <locations y="-0.2074" y-end="0.190808" n-elements="768" />
+ </component>
+ </type>
+
+ <type name="wlsfpixel" is="detector">
+ <cuboid id="shape">
+ <left-front-bottom-point x="-0.025" y="-0.00025925" z="0.0" />
+ <left-front-top-point x="-0.025" y="0.00025925" z="0.0" />
+ <left-back-bottom-point x="-0.025" y="-0.00025925" z="0.05" />
+ <right-front-bottom-point x="0.025" y="-0.00025925" z="0.0" />
+ </cuboid>
+ <algebra val="shape" />
+ </type>
+
+ <!-- other components -->
+
+ <component type="slit" name="slit1">
+ <location z="-5.5474"/>
+ <!-- This log file stores the vertical opening of slit -->
+ <parameter name="vertical gap">
+ <logfile id="s1vgap" extract-single-value-as="last_value" />
+ </parameter>
+ </component>
+
+ <component type="slit" name="slit2">
+ <location z="-0.3853"/>
+ <!-- This log file stores the vertical opening of this. Note this
+ slit can also be translated in the z. However this info not stored
+ in log file since it is not used in the data analysis process. -->
+ <parameter name="vertical gap">
+ <logfile id="s2vgap" extract-single-value-as="last_value" />
+ </parameter>
+ </component>
+
+ <component type="slit" name="slit3">
+ <location z="0.5"/>
+ <!-- This log file stores the vertical opening of slit -->
+ <parameter name="vertical gap">
+ <logfile id="s3vgap" extract-single-value-as="last_value" />
+ </parameter>
+ </component>
+
+
+ <type name="slit">
+ <percent-transparency val="50" />
+ <cuboid id="bottom">
+ <left-front-bottom-point z="0.0005" x="-0.025" y="-0.03" />
+ <left-front-top-point z="0.0005" x="-0.025" y="0.0" />
+ <left-back-bottom-point z="-0.0005" x="-0.025" y="-0.03" />
+ <right-front-bottom-point z="0.0005" x="0.025" y="-0.03" />
+ </cuboid>
+ </type>
+
+ <component type="supermirror">
+ <location z="28.52"/> <!-- x=32.0-3.480 -->
+ </component>
+ <type name="supermirror" />
+
+
+
+ <!-- DETECTOR and MONITOR ID LISTS -->
+
+ <idlist idname="monitor1">
+ <id val="1" />
+ </idlist>
+
+ <idlist idname="monitor2">
+ <id val="2" />
+ </idlist>
+
+ <idlist idname="monitor3">
+ <id val="3" />
+ </idlist>
+
+ <!-- detector IDs required NOT spectrum numbers (See documentation) -->
+
+ <idlist idname="DetectorBench">
+ <id val="4" />
+ <id start="2001" end="2240" />
+ <id start="2501" end="2516" />
+ <id start="1106000" end="1106511" />
+ <id start="1107000" end="1107511" />
+ <id start="1108000" end="1108511" />
+ <id start="1111000" end="1111511" />
+ <id start="1112000" end="1112511" />
+ <id start="1113000" end="1113511" />
+ <id start="1114000" end="1114511" />
+ <id start="1116000" end="1116511" />
+ <id start="3001" end="3768" />
+ </idlist>
+
+</instrument>
diff --git a/instrument/OFFSPEC_Parameters.xml b/instrument/OFFSPEC_Parameters.xml
index 9f82f9daf36552947ab6474067aa78066fae98af..11f12d0972ddadc6e005ba2e0a3e183b4854d36c 100644
--- a/instrument/OFFSPEC_Parameters.xml
+++ b/instrument/OFFSPEC_Parameters.xml
@@ -31,6 +31,10 @@
<parameter name="I0MonitorIndex">
<value val="1"/>
</parameter>
+
+ <parameter name="dQ/Q">
+ <value val="0.03"/>
+ </parameter>
<parameter name="LambdaMin">
<value val="2.0"/>
@@ -60,7 +64,48 @@
<value val="MultiDetectorAnalysis"/>
</parameter>
-
+ <parameter name="polarization_correction_method" type="string">
+ <value val="Fredrikze" />
+ </parameter>
+
+ <parameter name="polarization_correction_option" type="string">
+ <value val="PA" />
+ </parameter>
+
+ <parameter name="efficiency_lambda" type="string">
+ <value val="0.525 0.5775 0.63525 0.698775 0.768653 0.845518 0.93007 1.02308 1.12538 1.23792 1.36171 1.49789 1.64767 1.81244 1.99369 2.19306 2.41236 2.6536 2.91896 3.21085 3.53194 3.88513 4.27364 4.70101 5.17111 5.68822 6.25704 6.88275 7.57102 8.32812 9.16094 10.077 11.0847 12.1932 13.4125 14.2756
+" />
+ <description is="The wavelengths at which the efficiencies are sampled."/>
+ </parameter>
+
+ <parameter name="Pp" type="string">
+ <value val="0 0 0 0 0 0 0 0 0 0 0 0 0 0 1.0139 0.97379 0.965953 0.980644 0.979261 0.977655 0.97455 0.970945 0.974806 0.970071 0.967974 0.968093 0.97512 0.991765 0.993302 0.996431 0.977246 0.985539 0.957359 1.03561 1.01837 1.04475
+
+ " />
+ <description is="The values of the Pp efficiency."/>
+ </parameter>
+
+ <parameter name="Ap" type="string">
+ <value val="0 0 0 0 0 0 0 0 0 0 0 0 0 0 0.745479 0.967815 0.970664 0.981661 0.981843 0.976273 0.9759 0.966285 0.971235 0.968561 0.966756 0.953646 0.963183 0.955027 0.955512 0.956767 0.926777 0.931862 0.898449 0.972329 0.931238 0.975078
+
+" />
+ <description is="The values of the Ap efficiency."/>
+ </parameter>
+
+ <parameter name="Rho" type="string">
+ <value val="0 0 0 0 0 0 0 0 0 0 0 0 -1.00258 0.24991 0.85494 0.982662 0.988821 0.986798 0.992301 0.99371 0.995676 1.00137 0.996985 0.994724 0.995284 1.00655 0.993882 0.998729 0.997638 0.997585 1.01743 1.00586 1.04017 0.958108 0.971127 0.953178
+
+" />
+ <description is="The values of the Rho efficiency."/>
+ </parameter>
+
+ <parameter name="Alpha" type="string">
+ <value val="0 0 0 0 0 0 0 0 0 0 -0.017246 0 0 0.427951 0.889674 0.990357 0.994557 0.992129 0.992332 0.99546 0.99509 1.00178 0.995673 0.994003 0.995741 1.01016 0.995621 1.00353 1.00041 0.99505 1.01836 1.00574 1.0412 0.955931 0.974025 0.937772
+
+" />
+ <description is="The values of the Alpha efficiency."/>
+ </parameter>
+
</component-link>
</parameter-file>
diff --git a/instrument/V20_4-tubes_150deg_Definition_v01.xml b/instrument/V20_4-tubes_150deg_Definition_v01.xml
index f124bc641ea87c3f4a44f41ad39e96f2a8d04e50..1b270aeaf13d461c0d48798c7af92dbd8341ed7f 100644
--- a/instrument/V20_4-tubes_150deg_Definition_v01.xml
+++ b/instrument/V20_4-tubes_150deg_Definition_v01.xml
@@ -1,6 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- For help on the notation used to specify an Instrument Definition File
see http://www.mantidproject.org/IDF -->
+<!-- IDF configurations can be gound here https://github.com/mantidproject/documents/blob/master/IDF-Configurations/V20_idf_configurations_v05.pptx -->
<instrument xmlns="http://www.mantidproject.org/IDF/1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.mantidproject.org/IDF/1.0 Schema/IDFSchema.xsd"
name="IMAT" valid-from ="1900-01-31 23:59:59"
valid-to ="2099-12-31 23:59:59"
@@ -19,7 +20,7 @@ last-modified="2018-02-09 09:00:00">
</defaults>
<component type="source-chopper">
- <location x="0.0" y="0.0" z="-50.6"/>
+ <location x="0.0" y="0.0" z="-28.9"/>
</component>
<type name="source-chopper"/>
diff --git a/instrument/V20_4-tubes_90deg_Definition_v01.xml b/instrument/V20_4-tubes_90deg_Definition_v01.xml
index f798c1ca10ba3ef246ea8d465661d3a5c2b51c94..e60b04144da4c94225646941f05b950306304906 100644
--- a/instrument/V20_4-tubes_90deg_Definition_v01.xml
+++ b/instrument/V20_4-tubes_90deg_Definition_v01.xml
@@ -1,6 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- For help on the notation used to specify an Instrument Definition File
see http://www.mantidproject.org/IDF -->
+<!-- IDF configurations can be gound here https://github.com/mantidproject/documents/blob/master/IDF-Configurations/V20_idf_configurations_v05.pptx -->
<instrument xmlns="http://www.mantidproject.org/IDF/1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.mantidproject.org/IDF/1.0 Schema/IDFSchema.xsd"
name="IMAT" valid-from ="1900-01-31 23:59:59"
valid-to ="2099-12-31 23:59:59"
@@ -19,7 +20,7 @@ last-modified="2018-02-09 09:00:00">
</defaults>
<component type="source-chopper">
- <location x="0.0" y="0.0" z="-50.6"/>
+ <location x="0.0" y="0.0" z="-28.9"/>
</component>
<type name="source-chopper"/>
@@ -42,7 +43,7 @@ last-modified="2018-02-09 09:00:00">
<location x="-0.070" />
<location x="-0.035" />
<location x="0.000" />
- <location x="-0.035" />
+ <location x="0.035" />
</component>
</type>
diff --git a/instrument/V20_Transm_BeamMonitor_Definition_v01.xml b/instrument/V20_Transm_BeamMonitor_Definition_v01.xml
new file mode 100644
index 0000000000000000000000000000000000000000..9a3777c977f49c2821ab272939074eff43772bf4
--- /dev/null
+++ b/instrument/V20_Transm_BeamMonitor_Definition_v01.xml
@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- For help on the notation used to specify an Instrument Definition File
+see http://www.mantidproject.org/IDF -->
+<!-- IDF configurations can be gound here https://github.com/mantidproject/documents/blob/master/IDF-Configurations/V20_idf_configurations_v05.pptx -->
+<instrument xmlns="http://www.mantidproject.org/IDF/1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.mantidproject.org/IDF/1.0 Schema/IDFSchema.xsd"
+name="IMAT" valid-from ="1900-01-31 23:59:59"
+valid-to ="2099-12-31 23:59:59"
+last-modified="2018-02-09 09:00:00">
+ <defaults>
+ <length unit="meter"/>
+ <angle unit="degree"/>
+ <reference-frame>
+ <!-- The z-axis is set parallel to and in the direction of the beam. the
+ y-axis points up and the coordinate system is right handed. -->
+ <along-beam axis="z"/>
+ <pointing-up axis="y"/>
+ <handedness val="right"/>
+ </reference-frame>
+ <default-view axis-view="z"/>
+ </defaults>
+
+ <component type="source-chopper">
+ <location x="0.0" y="0.0" z="-25.3"/>
+ </component>
+ <type name="source-chopper"/>
+
+ <component type="wfm-chopper">
+ <location x="0.0" y="0.0" z="-18.45"/>
+ </component>
+ <type name="wfm-chopper" is="Source" />
+
+ <component type="some-sample-holder">
+ <location x="0.0" y="0.0" z="0"/>
+ </component>
+ <type name="some-sample-holder" is="SamplePos" />
+
+ <component name="transmission-beam-monitor" type="monitor" idlist="monitor-id-list">
+ <location x="0.0" y="0.0" z="0.030" />
+ </component>
+
+ <type name="monitor" is="monitor">
+ <cuboid id="shape">
+ <left-front-bottom-point x="0.02" y="-0.0525" z="0.0" />
+ <left-front-top-point x="0.02" y="-0.0525" z="0.040" />
+ <left-back-bottom-point x="-0.02" y="-0.0525" z="0.0" />
+ <right-front-bottom-point x="0.02" y="0.0525" z="0.0" />
+ </cuboid>
+ </type>
+
+ <idlist idname="monitor-id-list">
+ <id val="3" />
+ </idlist>
+
+</instrument>
diff --git a/qt/CMakeLists.txt b/qt/CMakeLists.txt
index 28e79e57ca2f3bf5ee139bc00793373bd40f8634..5df1efb28936b4320e15951c35aceb7fd8e4bc42 100644
--- a/qt/CMakeLists.txt
+++ b/qt/CMakeLists.txt
@@ -3,37 +3,6 @@ find_package ( QScintillaQt4 REQUIRED )
# Utilities for defining targets
include ( QtTargetFunctions )
-# Function to create links to python packages in the source tree
-# If the EXECUTABLE option is provided then it additional build rules are
-# defined to ensure startup scripts are regenerated appropriately
-function ( add_python_package pkg_name )
- # Create a setup.py file
- set ( _setup_py ${CMAKE_CURRENT_SOURCE_DIR}/setup.py )
- set ( _egg_link_dir ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${CMAKE_CFG_INTDIR} )
- set ( _egg_link ${_egg_link_dir}/${pkg_name}.egg-link )
- if ( ARGV0 EQUAL "EXECUTABLE" )
- if ( WIN32 )
- set ( _startup_script ${_egg_link_dir}/${pkg_name}-script.pyw )
- set ( _startup_exe ${_egg_link_dir}/${pkg_name}.exe )
- else ()
- set ( _startup_script )
- set ( _startup_exe ${_egg_link_dir}/${pkg_name} )
- endif ()
- endif ()
- set ( _outputs ${_egg_link} ${_startup_script} ${_startup_exe} )
- add_custom_command ( OUTPUT ${_outputs}
- COMMAND ${CMAKE_COMMAND} -E env PYTHONPATH=${_egg_link_dir}
- ${PYTHON_EXECUTABLE} ${_setup_py} develop
- --install-dir ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${CMAKE_CFG_INTDIR}
- --script-dir ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/${CMAKE_CFG_INTDIR}
- WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
- DEPENDS ${_setup_py}
- )
- add_custom_target ( ${pkg_name} ALL
- DEPENDS ${_outputs}
- )
-endfunction ()
-
# Resource compiler for PyQt5
if ( ENABLE_WORKBENCH AND NOT PYRCC5_CMD )
# Newer versions of PyQt5 have a pyrcc_main python module, whereas older
diff --git a/qt/applications/workbench/CMakeLists.txt b/qt/applications/workbench/CMakeLists.txt
index 22e85645b70d41c8c1e61efd4cdc898f59caade4..ed59fab1bbabd5f22daf7d412cac8d5d50dcdecb 100644
--- a/qt/applications/workbench/CMakeLists.txt
+++ b/qt/applications/workbench/CMakeLists.txt
@@ -20,6 +20,8 @@ set ( TEST_FILES
workbench/config/test/test_user.py
workbench/test/test_import.py
+ workbench/plotting/test/test_functions.py
+
workbench/widgets/plotselector/test/test_plotselector_model.py
workbench/widgets/plotselector/test/test_plotselector_presenter.py
workbench/widgets/plotselector/test/test_plotselector_view.py
diff --git a/qt/applications/workbench/setup.py b/qt/applications/workbench/setup.py.in
similarity index 76%
rename from qt/applications/workbench/setup.py
rename to qt/applications/workbench/setup.py.in
index 6e3db4ad665309e688d04d56de958f5b79b2dfc1..dedef6c41ab3a5163ac374765dd40d1cdac50b42 100644
--- a/qt/applications/workbench/setup.py
+++ b/qt/applications/workbench/setup.py.in
@@ -16,15 +16,20 @@
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
-from setuptools import setup
+from setuptools import find_packages, setup
+
+@SETUPTOOLS_BUILD_COMMANDS_DEF@
# The most basic setup possible to be able to use setup.py develop
setup(
- name="workbench",
+ name='MantidWorkbench', # probaly the wrong name if someone wants to include it
+ version='@VERSION_MAJOR@.@VERSION_MINOR@.@VERSION_PATCH@',
install_requires=['mantidqt'],
+ packages=find_packages(exclude=['*.test']),
entry_points={
'gui_scripts': [
'workbench = workbench.app.mainwindow:main'
]
},
+ @SETUPTOOLS_BUILD_COMMANDS_USE@
)
diff --git a/qt/applications/workbench/workbench/app/mainwindow.py b/qt/applications/workbench/workbench/app/mainwindow.py
index 19c6f7e14d6acdf693fa91d9c4eb084aa6d4ac3e..a306d25a6ca945fab95cb45c1daf78dc459d206e 100644
--- a/qt/applications/workbench/workbench/app/mainwindow.py
+++ b/qt/applications/workbench/workbench/app/mainwindow.py
@@ -21,7 +21,9 @@ from __future__ import (absolute_import, division,
print_function, unicode_literals)
import atexit
+import imp
import importlib
+import os
import sys
# -----------------------------------------------------------------------------
@@ -42,15 +44,18 @@ requirements.check_qt()
# -----------------------------------------------------------------------------
# Qt
# -----------------------------------------------------------------------------
-from qtpy.QtCore import (QEventLoop, Qt, QTimer, QCoreApplication) # noqa
+from qtpy.QtCore import (QEventLoop, Qt, QCoreApplication, QSettings, QPoint, QSize) # noqa
from qtpy.QtGui import (QColor, QPixmap) # noqa
from qtpy.QtWidgets import (QApplication, QDesktopWidget, QFileDialog,
QMainWindow, QSplashScreen) # noqa
from mantidqt.utils.qt import plugins, widget_updates_disabled # noqa
+from mantidqt.algorithminputhistory import AlgorithmInputHistory # noqa
# Pre-application setup
plugins.setup_library_paths()
+from workbench.config import APPNAME, CONF, ORG_DOMAIN, ORGANIZATION # noqa
+
# -----------------------------------------------------------------------------
# Create the application instance early, set the application name for window
@@ -65,7 +70,14 @@ def qapplication():
app = QApplication.instance()
if app is None:
QCoreApplication.setAttribute(Qt.AA_ShareOpenGLContexts)
- app = QApplication(['Mantid Workbench'])
+ argv = sys.argv[:]
+ argv[0] = APPNAME # replace application name
+ app = QApplication(argv)
+ app.setOrganizationName(ORGANIZATION)
+ app.setOrganizationDomain(ORG_DOMAIN)
+ app.setApplicationName(APPNAME)
+ # not calling app.setApplicationVersion(mantid.kernel.version_str())
+ # because it needs to happen after logging is monkey-patched in
return app
@@ -90,11 +102,8 @@ QApplication.processEvents(QEventLoop.AllEvents)
# -----------------------------------------------------------------------------
# Utilities/Widgets
# -----------------------------------------------------------------------------
-from mantidqt.py3compat import qbytearray_to_str # noqa
from mantidqt.utils.qt import add_actions, create_action # noqa
from mantidqt.widgets.manageuserdirectories import ManageUserDirectories # noqa
-from workbench.config.main import CONF # noqa
-from workbench.external.mantid import prepare_mantid_env # noqa
# -----------------------------------------------------------------------------
# MainWindow
@@ -108,17 +117,12 @@ class MainWindow(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
- qapp = QApplication.instance()
- qapp.setAttribute(Qt.AA_UseHighDpiPixmaps)
- if hasattr(Qt, 'AA_EnableHighDpiScaling'):
- qapp.setAttribute(Qt.AA_EnableHighDpiScaling, True)
-
+ # -- instance attributes --
self.setWindowTitle("Mantid Workbench")
- # -- instance attributes --
- self.window_size = None
- self.window_position = None
- self.maximized_flag = None
+ # uses default configuration as necessary
+ self.readSettings(CONF)
+
# widgets
self.messagedisplay = None
self.ipythonconsole = None
@@ -259,14 +263,8 @@ class MainWindow(QMainWindow):
# ----------------------- Layout ---------------------------------
def setup_layout(self):
- self.setup_for_first_run()
-
- def setup_for_first_run(self):
"""Assume this is a first run of the application and set layouts
accordingly"""
- self.setWindowState(Qt.WindowMaximized)
- desktop = QDesktopWidget()
- self.window_size = desktop.screenGeometry().size()
self.setup_default_layouts()
def prep_window_for_reset(self):
@@ -308,7 +306,8 @@ class MainWindow(QMainWindow):
# flatten list
widgets = [item for column in widgets_layout for row in column for item in row]
# show everything
- map(lambda w: w.toggle_view(True), widgets)
+ for w in widgets:
+ w.toggle_view(True)
# split everything on the horizontal
for i in range(len(widgets) - 1):
first, second = widgets[i], widgets[i+1]
@@ -336,6 +335,8 @@ class MainWindow(QMainWindow):
def closeEvent(self, event):
# Close editors
if self.editor.app_closing():
+ self.writeSettings(CONF) # write current window information to global settings object
+
# Close all open plots
# We don't want this at module scope here
import matplotlib.pyplot as plt #noqa
@@ -362,6 +363,58 @@ class MainWindow(QMainWindow):
def open_manage_directories(self):
ManageUserDirectories(self).exec_()
+ def readSettings(self, settings):
+ qapp = QApplication.instance()
+ qapp.setAttribute(Qt.AA_UseHighDpiPixmaps)
+ if hasattr(Qt, 'AA_EnableHighDpiScaling'):
+ qapp.setAttribute(Qt.AA_EnableHighDpiScaling, settings.get('main/high_dpi_scaling'))
+
+ # get the saved window geometry
+ window_size = settings.get('main/window/size')
+ if not isinstance(window_size, QSize):
+ window_size = QSize(*window_size)
+ window_pos = settings.get('main/window/position')
+ if not isinstance(window_pos, QPoint):
+ window_pos = QPoint(*window_pos)
+
+ # make sure main window is smaller than the desktop
+ desktop = QDesktopWidget()
+
+ # this gives the maximum screen number if the position is off screen
+ screen = desktop.screenNumber(window_pos)
+
+ # recalculate the window size
+ desktop_geom = desktop.screenGeometry(screen)
+ w = min(desktop_geom.size().width(), window_size.width())
+ h = min(desktop_geom.size().height(), window_size.height())
+ window_size = QSize(w, h)
+
+ # and position it on the supplied desktop screen
+ x = max(window_pos.x(), desktop_geom.left())
+ y = max(window_pos.y(), desktop_geom.top())
+ window_pos = QPoint(x, y)
+
+ # set the geometry
+ self.resize(window_size)
+ self.move(window_pos)
+
+ # restore window state
+ if settings.has('main/window/state'):
+ self.restoreState(settings.get('main/window/state'))
+ else:
+ self.setWindowState(Qt.WindowMaximized)
+
+ # have algorithm dialogs do their thing
+ AlgorithmInputHistory().readSettings(settings)
+
+ def writeSettings(self, settings):
+ settings.set('main/window/size', self.size()) # QSize
+ settings.set('main/window/position', self.pos()) # QPoint
+ settings.set('main/window/state', self.saveState()) # QByteArray
+
+ # have algorithm dialogs do their thing
+ AlgorithmInputHistory().writeSettings(settings)
+
def initialize():
"""Perform an initialization of the application instance. Most notably
@@ -403,29 +456,35 @@ def start_workbench(app):
importlib.import_module('mantid')
main_window.show()
+
if main_window.splash:
main_window.splash.hide()
# lift-off!
- app.exec_()
-
- return main_window
+ return app.exec_()
def main():
"""Main entry point for the application"""
- # Prepare for mantid import
- prepare_mantid_env()
+ # Mantid needs to be able to find its .properties file. It looks
+ # in the application directory by default but this is
+ # the directory of python[.exe] and not guaranteed to be where
+ # the properties files is located. MANTIDPATH overrides this.
+ # If we allow a user to override MANTIDPATH then we could end up
+ # loading the wrong properties file and plugins built against
+ # a different version of Mantid and this would likely result in
+ # segfault.
+ _, pkgpath, _ = imp.find_module('mantid')
+ os.environ['MANTIDPATH'] = os.path.dirname(pkgpath)
# todo: parse command arguments
- # general initialization
app = initialize()
# the default sys check interval leads to long lags
# when request scripts to be aborted
sys.setcheckinterval(SYSCHECK_INTERVAL)
- main_window = None
+ exit_value = 0
try:
- main_window = start_workbench(app)
+ exit_value = start_workbench(app)
except BaseException:
# We count this as a crash
import traceback
@@ -433,12 +492,9 @@ def main():
# about. Prints to stderr as we can't really count on anything
# else
traceback.print_exc(file=ORIGINAL_STDERR)
-
- if main_window is None:
- # An exception occurred don't exit here
- return
-
- ORIGINAL_SYS_EXIT()
+ exit_value = -1
+ finally:
+ ORIGINAL_SYS_EXIT(exit_value)
if __name__ == '__main__':
diff --git a/qt/applications/workbench/workbench/config/__init__.py b/qt/applications/workbench/workbench/config/__init__.py
index 38b6452e68f2d819b646bccff5c213e92581ea5a..89f8d58fb99cadf829b135b6ccbf0d4e88c88922 100644
--- a/qt/applications/workbench/workbench/config/__init__.py
+++ b/qt/applications/workbench/workbench/config/__init__.py
@@ -14,3 +14,37 @@
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
+""" Main configuration module.
+
+A singleton instance called CONF is defined. Modules wishing to access the settings
+should import the CONF object as
+
+ from workbench.config import CONF
+
+and use it to access the settings
+"""
+from __future__ import (absolute_import, unicode_literals)
+
+from workbench.config.user import UserConfig
+
+# -----------------------------------------------------------------------------
+# Constants
+# -----------------------------------------------------------------------------
+ORGANIZATION = 'mantidproject'
+ORG_DOMAIN = 'mantidproject.org'
+APPNAME = 'mantidworkbench'
+
+# Iterable containing defaults for each configurable section of the code
+# General application settings are in the main section
+DEFAULTS = {
+ 'main': {
+ 'high_dpi_scaling': True,
+ 'window/size': (1260, 740),
+ 'window/position': (10, 10),
+ }
+}
+
+# -----------------------------------------------------------------------------
+# 'Singleton' instance
+# -----------------------------------------------------------------------------
+CONF = UserConfig(ORGANIZATION, APPNAME, defaults=DEFAULTS)
diff --git a/qt/applications/workbench/workbench/config/main.py b/qt/applications/workbench/workbench/config/main.py
deleted file mode 100644
index 02373c0993723b403de5e1dad4f754f768a703b5..0000000000000000000000000000000000000000
--- a/qt/applications/workbench/workbench/config/main.py
+++ /dev/null
@@ -1,51 +0,0 @@
-# This file is part of the mantid workbench.
-#
-# Copyright (C) 2017 mantidproject
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program. If not, see <http://www.gnu.org/licenses/>.
-""" Main configuration module.
-
-A singleton instance called CONF is defined. Modules wishing to access the settings
-should import the CONF object as
-
- from workbench.config.main import CONF
-
-and use it to access the settings
-"""
-from __future__ import (absolute_import, unicode_literals)
-
-from workbench.config.user import UserConfig
-
-# -----------------------------------------------------------------------------
-# Constants
-# -----------------------------------------------------------------------------
-ORGANIZATION = 'mantidproject'
-APPNAME = 'workbench'
-
-# Iterable containing defaults for each configurable section of the code
-# General application settings are in the main section
-DEFAULTS = {
- 'main': {
- 'high_dpi_scaling': True,
- 'window/size': (1260, 740),
- 'window/position': (10, 10),
- 'window/is_maximized': True,
- 'window/is_fullscreen': False,
- }
-}
-
-# -----------------------------------------------------------------------------
-# 'Singleton' instance
-# -----------------------------------------------------------------------------
-CONF = UserConfig(ORGANIZATION, APPNAME, defaults=DEFAULTS)
diff --git a/qt/applications/workbench/workbench/config/test/test_user.py b/qt/applications/workbench/workbench/config/test/test_user.py
index 1f2b353a0429e127c88668b21983194a88d29a30..6b600c3c421483cc1d19c6c8a41425e4e3d0ccc7 100644
--- a/qt/applications/workbench/workbench/config/test/test_user.py
+++ b/qt/applications/workbench/workbench/config/test/test_user.py
@@ -30,7 +30,8 @@ class ConfigUserTest(TestCase):
defaults = {
'main': {
'a_default_key': 100,
- 'bool_option': False
+ 'bool_option': False,
+ 'bool_option2': True
},
}
cls.cfg = UserConfig(cls.__name__, cls.__name__, defaults)
@@ -53,28 +54,45 @@ class ConfigUserTest(TestCase):
def test_value_not_in_settings_retrieves_default_if_it_exists(self):
self.assertEqual(100, self.cfg.get('main', 'a_default_key'))
+ self.assertEqual(100, self.cfg.get('main/a_default_key'))
def test_boolean_with_default_false_can_be_retrieved(self):
self.assertEqual(False, self.cfg.get('main', 'bool_option'))
+ self.assertEqual(False, self.cfg.get('main/bool_option'))
+
+ self.assertEqual(True, self.cfg.get('main/bool_option2'))
+
+ def test_has_keys(self):
+ self.assertTrue(self.cfg.has('main', 'a_default_key'))
+ self.assertTrue(self.cfg.has('main/a_default_key'))
+ self.assertFalse(self.cfg.has('main', 'missing-key'))
+ self.assertFalse(self.cfg.has('main/missing-key'))
+
+ def test_remove_key(self):
+ self.cfg.set('main', 'key1', 1)
+ self.assertTrue(self.cfg.has('main/key1'))
+ self.cfg.remove('main/key1')
+ self.assertFalse(self.cfg.has('main/key1'))
# ----------------------------------------------
# Failure tests
# ----------------------------------------------
def test_get_raises_error_with_invalid_section_type(self):
- self.assertRaises(RuntimeError, self.cfg.get, 1, 'key1')
+ self.assertRaises(TypeError, self.cfg.get, 1, 'key1')
def test_get_raises_error_with_invalid_option_type(self):
- self.assertRaises(RuntimeError, self.cfg.get, 'section', 1)
+ self.assertRaises(TypeError, self.cfg.get, 'section', 1)
def test_get_raises_keyerror_with_no_saved_setting_or_default(self):
self.assertRaises(KeyError, self.cfg.get, 'main', 'missing-key')
+ self.assertRaises(KeyError, self.cfg.get, 'main/missing-key')
def test_set_raises_error_with_invalid_section_type(self):
- self.assertRaises(RuntimeError, self.cfg.set, 1, 'key1', 1)
+ self.assertRaises(TypeError, self.cfg.set, 1, 'key1', 1)
def test_set_raises_error_with_invalid_option_type(self):
- self.assertRaises(RuntimeError, self.cfg.set, 'section', 1, 1)
+ self.assertRaises(TypeError, self.cfg.set, 'section', 1, 1)
if __name__ == '__main__':
diff --git a/qt/applications/workbench/workbench/config/user.py b/qt/applications/workbench/workbench/config/user.py
index b88450695712334abdf070fc1f41b8f2ea944e52..6d60ed6865ece272fadbf2ad463d26964dd6df96 100644
--- a/qt/applications/workbench/workbench/config/user.py
+++ b/qt/applications/workbench/workbench/config/user.py
@@ -18,7 +18,7 @@ from __future__ import (absolute_import, division, print_function,
unicode_literals)
from mantidqt.py3compat import is_text_string
-
+from posixpath import join as joinsettings
from qtpy.QtCore import QSettings
@@ -32,11 +32,9 @@ class UserConfig(object):
# The raw QSettings instance
qsettings = None
- defaults = None
def __init__(self, organization, application, defaults=None):
"""
-
:param organization: A string name for the organization
:param application: A string name for the application name
:param defaults: Default configuration values for this instance in the
@@ -45,77 +43,113 @@ class UserConfig(object):
# Loads the saved settings if found
self.qsettings = QSettings(QSettings.IniFormat, QSettings.UserScope,
organization, application)
- self.defaults = defaults
- def all_keys(self):
- return self.qsettings.allKeys()
+ # convert the defaults into something that qsettings can handle
+ default_settings = self._flatten_defaults(defaults)
+
+ # put defaults into qsettings if they weren't there already
+ configFileKeys = self.qsettings.allKeys()
+ for key in default_settings.keys():
+ if key not in configFileKeys:
+ self.qsettings.setValue(key, default_settings[key])
+
+ # fixup the values of booleans - they do not evaluate correctly when read from the config file
+ # TODO come up with a unit test for this
+ for key in self.all_keys():
+ value = self.get(key)
+ if value == 'true':
+ self.set(key, True)
+ elif value == 'false':
+ self.set(key, False)
+
+ def all_keys(self, group=None):
+ if group is not None:
+ self.qsettings.beginGroup(group)
+ result = self.qsettings.allKeys()
+ self.qsettings.endGroup()
+ else:
+ result = self.qsettings.allKeys()
+
+ return result
@property
def filename(self):
return self.qsettings.fileName()
- def get(self, section, option):
- """
- Return a value for an option in a given section. If not
- specified in the saved settings then the initial
- defaults are consulted. If no option is found then
+ def get(self, option, second=None):
+ """Return a value for an option. If two arguments are given the first
+ is the group/section and the second is the option within it.
+ ``config.get('main', 'window/size')`` is equivalent to
+ ``config.get('main/window/size')`` If no option is found then
a KeyError is raised
- :param section: A string section name
- :param option: A string option name
- :return: The value of the option
"""
- value = self.qsettings.value(self._settings_path(section, option))
- if not value:
- value = self._get_default_or_raise(section, option)
-
- return value
-
- def set(self, section, option, value):
+ option = self._check_section_option_is_valid(option, second)
+ value = self.qsettings.value(option)
+
+ # qsettings appears to return None if the option isn't found
+ if value is None:
+ raise KeyError('Unknown config item requested: "{}"'.format(option))
+ else:
+ return value
+
+ def has(self, option, second=None):
+ """Return a True if the key exists in the
+ settings. ``config.get('main', 'window/size')`` and
+ ``config.get('main/window/size')`` are equivalent.
+ """
+ option = self._check_section_option_is_valid(option, second)
+ return option in self.all_keys()
+
+ def set(self, option, value, extra=None):
+ """Set a value for an option in a given section. Can either supply
+ the fully qualified option or add the section as an additional
+ first argument. ``config.set('main', 'high_dpi_scaling',
+ True)`` is equivalent to ``config.set('main/high_dpi_scaling',
+ True)``
"""
- Set a value for an option in a given section.
- :param section: A string section name
- :param option: A string option name
- :param value: The value of the setting
+ if extra is None:
+ option = self._check_section_option_is_valid(option, extra)
+ # value is in the right place
+ else:
+ option = self._check_section_option_is_valid(option, value)
+ value = extra
+ self.qsettings.setValue(option, value)
+
+ def remove(self, option, second=None):
+ """Removes a key from the settings. Key not existing returns without effect.
"""
- self.qsettings.setValue(self._settings_path(section, option), value)
+ option = self._check_section_option_is_valid(option, second)
+ if self.has(option):
+ self.qsettings.remove(option)
# -------------------------------------------------------------------------
# "Private" methods
# -------------------------------------------------------------------------
- def _check_section_option_is_valid(self, section, option):
- """
- Sanity check the section and option are strings
- """
- if not is_text_string(section):
- raise RuntimeError("section is not a text string")
- if not is_text_string(option):
- raise RuntimeError("option is not a text string")
-
- def _get_default_or_raise(self, section, option):
- """
- Returns the value listed in the defaults if it exists
- :param section: A string denoting the section (not checked)
- :param option: A string denoting the option name
- :return: The value of the default
- :raises KeyError: if the item does not exist
- """
- value = None
- if self.defaults and section in self.defaults:
- try:
- value = self.defaults[section][option]
- except KeyError:
- raise KeyError("Unknown config item requested: " +
- self._settings_path(section, option))
- return value
-
- def _settings_path(self, section, option):
+ @staticmethod
+ def _flatten_defaults(input_dict):
+ result = {}
+ for key in input_dict:
+ value = input_dict[key]
+ if isinstance(value, dict):
+ value = UserConfig._flatten_defaults(value)
+ for key_inner in value.keys():
+ result[joinsettings(key, key_inner)] = value[key_inner]
+ else:
+ result[key] = value
+ return result
+
+ def _check_section_option_is_valid(self, option, second):
"""
- Private method to construct a path to the given option with the
- section
- :param section: The name of the section
- :param option: The name of the option
- :return: A path to the location within the QSettings instance
+ Sanity check the section and option are strings and return the flattened option key
"""
- self._check_section_option_is_valid(section, option)
- return section + "/" + option
+ if second is None:
+ if not is_text_string(option):
+ raise TypeError('Found invalid type ({}) for option ({}) must be a string'.format(type(option), option))
+ return option
+ else: # fist argument is actually the section/group
+ if not is_text_string(option):
+ raise TypeError('Found invalid type ({}) for section ({}) must be a string'.format(type(option), option))
+ if not is_text_string(second):
+ raise TypeError('Found invalid type ({}) for option ({}) must be a string'.format(type(second), second))
+ return joinsettings(option, second)
diff --git a/qt/applications/workbench/workbench/external/__init__.py b/qt/applications/workbench/workbench/external/__init__.py
deleted file mode 100644
index 38b6452e68f2d819b646bccff5c213e92581ea5a..0000000000000000000000000000000000000000
--- a/qt/applications/workbench/workbench/external/__init__.py
+++ /dev/null
@@ -1,16 +0,0 @@
-# This file is part of the mantid workbench.
-#
-# Copyright (C) 2017 mantidproject
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program. If not, see <http://www.gnu.org/licenses/>.
diff --git a/qt/applications/workbench/workbench/external/mantid.py b/qt/applications/workbench/workbench/external/mantid.py
deleted file mode 100644
index 39dd34eedca38d121b8d0f8b150cf1bf53e147ee..0000000000000000000000000000000000000000
--- a/qt/applications/workbench/workbench/external/mantid.py
+++ /dev/null
@@ -1,33 +0,0 @@
-# This file is part of the mantid workbench.
-#
-# Copyright (C) 2017 mantidproject
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program. If not, see <http://www.gnu.org/licenses/>.
-"""Defines utility functionality for interacting with the mantid framework
-"""
-from __future__ import unicode_literals
-
-from imp import find_module
-import os
-
-
-def prepare_mantid_env():
- # Mantid needs to be able to find its .properties file. It looks
- # in the application directory but by default but this is python.exe.
- # MANTIDPATH can be used to override this. If it is not set
- # we currently assume the Mantid.properties is in the same location as the
- # mantid module itself
- if 'MANTIDPATH' not in os.environ:
- _, pkgpath, _ = find_module('mantid')
- os.environ['MANTIDPATH'] = os.path.dirname(pkgpath)
diff --git a/qt/applications/workbench/workbench/plotting/figuremanager.py b/qt/applications/workbench/workbench/plotting/figuremanager.py
index 21e58e85ea8947692a0da3c17021846c19b104d1..434a19e30b9a8149fdaa65d8824c305c370751c5 100644
--- a/qt/applications/workbench/workbench/plotting/figuremanager.py
+++ b/qt/applications/workbench/workbench/plotting/figuremanager.py
@@ -21,37 +21,15 @@ import matplotlib
from matplotlib.backend_bases import FigureManagerBase
from matplotlib.backends.backend_qt5agg import (FigureCanvasQTAgg, backend_version, draw_if_interactive, show) # noqa
from matplotlib._pylab_helpers import Gcf
-from qtpy.QtCore import Qt, QEvent, QObject, Signal
-from qtpy.QtWidgets import QApplication, QLabel, QMainWindow
+from qtpy.QtCore import Qt, QObject
+from qtpy.QtWidgets import QApplication, QLabel
from six import text_type
# local imports
-from .propertiesdialog import LabelEditor, XAxisEditor, YAxisEditor
-from .toolbar import WorkbenchNavigationToolbar
-from .qappthreadcall import QAppThreadCall
-
-
-class MainWindow(QMainWindow):
- activated = Signal()
- closing = Signal()
- visibility_changed = Signal()
-
- def event(self, event):
- if event.type() == QEvent.WindowActivate:
- self.activated.emit()
- return QMainWindow.event(self, event)
-
- def closeEvent(self, event):
- self.closing.emit()
- QMainWindow.closeEvent(self, event)
-
- def hideEvent(self, event):
- self.visibility_changed.emit()
- QMainWindow.hideEvent(self, event)
-
- def showEvent(self, event):
- self.visibility_changed.emit()
- QMainWindow.showEvent(self, event)
+from workbench.plotting.figurewindow import FigureWindow
+from workbench.plotting.propertiesdialog import LabelEditor, XAxisEditor, YAxisEditor
+from workbench.plotting.toolbar import WorkbenchNavigationToolbar
+from workbench.plotting.qappthreadcall import QAppThreadCall
class FigureManagerWorkbench(FigureManagerBase, QObject):
@@ -86,15 +64,14 @@ class FigureManagerWorkbench(FigureManagerBase, QObject):
self.fig_visibility_changed_orig = self.fig_visibility_changed
self.fig_visibility_changed = QAppThreadCall(self.fig_visibility_changed_orig)
- self.canvas = canvas
- self.window = MainWindow()
+ self.window = FigureWindow(canvas)
self.window.activated.connect(self._window_activated)
self.window.closing.connect(canvas.close_event)
self.window.closing.connect(self._widgetclosed)
self.window.visibility_changed.connect(self.fig_visibility_changed)
self.window.setWindowTitle("Figure %d" % num)
- self.canvas.figure.set_label("Figure %d" % num)
+ canvas.figure.set_label("Figure %d" % num)
# Give the keyboard focus to the figure instead of the
# manager; StrongFocus accepts both tab and click to focus and
@@ -103,8 +80,8 @@ class FigureManagerWorkbench(FigureManagerBase, QObject):
# clicked
# on. http://qt-project.org/doc/qt-4.8/qt.html#FocusPolicy-enum or
# http://doc.qt.digia.com/qt/qt.html#FocusPolicy-enum
- self.canvas.setFocusPolicy(Qt.StrongFocus)
- self.canvas.setFocus()
+ canvas.setFocusPolicy(Qt.StrongFocus)
+ canvas.setFocus()
self.window._destroying = False
@@ -112,7 +89,7 @@ class FigureManagerWorkbench(FigureManagerBase, QObject):
self.statusbar_label = QLabel()
self.window.statusBar().addWidget(self.statusbar_label)
- self.toolbar = self._get_toolbar(self.canvas, self.window)
+ self.toolbar = self._get_toolbar(canvas, self.window)
if self.toolbar is not None:
self.window.addToolBar(self.toolbar)
self.toolbar.message.connect(self.statusbar_label.setText)
@@ -129,17 +106,17 @@ class FigureManagerWorkbench(FigureManagerBase, QObject):
height = cs.height() + self._status_and_tool_height
self.window.resize(cs.width(), height)
- self.window.setCentralWidget(self.canvas)
+ self.window.setCentralWidget(canvas)
if matplotlib.is_interactive():
self.window.show()
- self.canvas.draw_idle()
+ canvas.draw_idle()
def notify_axes_change(fig):
# This will be called whenever the current axes is changed
if self.toolbar is not None:
self.toolbar.update()
- self.canvas.figure.add_axobserver(notify_axes_change)
+ canvas.figure.add_axobserver(notify_axes_change)
# Register canvas observers
self._cids = []
@@ -160,7 +137,8 @@ class FigureManagerWorkbench(FigureManagerBase, QObject):
if self.window._destroying:
return
self.window._destroying = True
- map(self.canvas.mpl_disconnect, self._cids)
+ for id in self._cids:
+ self.canvas.mpl_disconnect(id)
try:
Gcf.destroy(self.num)
except AttributeError:
diff --git a/qt/applications/workbench/workbench/plotting/figuretype.py b/qt/applications/workbench/workbench/plotting/figuretype.py
index ce0d801adacdf67abd3fc424d525c7e571e191b2..24f74e1cd143bb91c3d02c17ce42c6817371747d 100644
--- a/qt/applications/workbench/workbench/plotting/figuretype.py
+++ b/qt/applications/workbench/workbench/plotting/figuretype.py
@@ -19,7 +19,9 @@ Provides facilities to check plot types
"""
from __future__ import absolute_import
+# third party
from mantidqt.py3compat import Enum
+from matplotlib.container import ErrorbarContainer
class FigureType(Enum):
@@ -32,7 +34,7 @@ class FigureType(Enum):
Line = 1
# Line plot with error bars
Errorbar = 2
- # An image plot from imshow, pcolor
+ # An image plot from imshow, pcolor, pcolormesh
Image = 3
# Any other type of plot
Other = 100
@@ -51,25 +53,25 @@ def axes_type(ax):
axtype = FigureType.Other
if nrows == 1 and ncols == 1:
- if len(ax.lines) > 0:
+ # an errorbar plot also has len(lines) > 0
+ if len(ax.containers) > 0 and isinstance(ax.containers[0], ErrorbarContainer):
+ axtype = FigureType.Errorbar
+ elif len(ax.lines) > 0:
axtype = FigureType.Line
- elif len(ax.images) > 0:
+ elif len(ax.images) > 0 or len(ax.collections) > 0:
axtype = FigureType.Image
return axtype
def figure_type(fig):
- """Return the type of the figure
+ """Return the type of the figure. It inspects the axes
+ return by fig.gca()
:param fig: A matplotlib figure instance
:return: An enumeration defining the plot type
"""
- all_axes = fig.axes
- all_axes_length = len(all_axes)
- if all_axes_length == 0:
+ if len(fig.get_axes()) == 0:
return FigureType.Empty
- elif all_axes_length == 1:
- return axes_type(all_axes[0])
else:
- return FigureType.Other
+ return axes_type(fig.gca())
diff --git a/qt/applications/workbench/workbench/plotting/figurewindow.py b/qt/applications/workbench/workbench/plotting/figurewindow.py
new file mode 100644
index 0000000000000000000000000000000000000000..11952fb67465bd91c0f9603de5eb5a57bc0a928e
--- /dev/null
+++ b/qt/applications/workbench/workbench/plotting/figurewindow.py
@@ -0,0 +1,106 @@
+# This file is part of the mantid workbench.
+#
+# Copyright (C) 2018 mantidproject
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+"""Provides the QMainWindow subclass for a plotting window"""
+from __future__ import absolute_import
+
+# std imports
+import weakref
+
+# 3rdparty imports
+from qtpy.QtCore import QEvent, Signal
+from qtpy.QtWidgets import QMainWindow
+
+# local imports
+from .figuretype import figure_type, FigureType
+
+
+class FigureWindow(QMainWindow):
+ """A MainWindow that will hold plots"""
+ activated = Signal()
+ closing = Signal()
+ visibility_changed = Signal()
+
+ def __init__(self, canvas, parent=None):
+ QMainWindow.__init__(self, parent=parent)
+ # attributes
+ self._canvas = weakref.proxy(canvas)
+
+ self.setAcceptDrops(True)
+
+ def event(self, event):
+ if event.type() == QEvent.WindowActivate:
+ self.activated.emit()
+ return QMainWindow.event(self, event)
+
+ def closeEvent(self, event):
+ self.closing.emit()
+ QMainWindow.closeEvent(self, event)
+
+ def hideEvent(self, event):
+ self.visibility_changed.emit()
+ QMainWindow.hideEvent(self, event)
+
+ def showEvent(self, event):
+ self.visibility_changed.emit()
+ QMainWindow.showEvent(self, event)
+
+ def dragEnterEvent(self, event):
+ """
+ Accepts drag events if the event contains text and no
+ urls.
+
+ :param event: A QDragEnterEvent instance for the most
+ recent drag
+ """
+ data = event.mimeData()
+ if data.hasText() and not data.hasUrls():
+ event.acceptProposedAction()
+
+ def dropEvent(self, event):
+ """
+ If the event data contains a workspace reference then
+ request a plot of the workspace.
+
+ :param event: A QDropEvent containing the MIME
+ data of the action
+ """
+ self._plot_on_here(event.mimeData().text().split('\n'))
+ QMainWindow.dropEvent(self, event)
+
+ # private api
+
+ def _plot_on_here(self, names):
+ """
+ Assume the list of strings refer to workspace names and they are to be plotted
+ on this figure. If the current figure contains an image plot then
+ a new image plot will replace the current image. If the current figure
+ contains a line plot then the user will be asked what should be plotted and this
+ will overplot onto the figure. If the first line of the plot
+ :param names: A list of workspace names
+ """
+ if len(names) == 0:
+ return
+ # local import to avoid circular import with FigureManager
+ from workbench.plotting.functions import pcolormesh_from_names, plot_from_names
+
+ fig = self._canvas.figure
+ fig_type = figure_type(fig)
+ if fig_type == FigureType.Image:
+ pcolormesh_from_names(names, fig=fig)
+ else:
+ plot_from_names(names, errors=(fig_type == FigureType.Errorbar),
+ overplot=True, fig=fig)
diff --git a/qt/applications/workbench/workbench/plotting/functions.py b/qt/applications/workbench/workbench/plotting/functions.py
index 9795fc0cd9737abcf20854de94033afd3900cd2d..b6e113a9c9d61b67b1fb1c9b9f83391498e1a8bf 100644
--- a/qt/applications/workbench/workbench/plotting/functions.py
+++ b/qt/applications/workbench/workbench/plotting/functions.py
@@ -23,51 +23,54 @@ import collections
import math
# 3rd party imports
-from mantid.api import MatrixWorkspace
+from mantid.api import AnalysisDataService, MatrixWorkspace
+from mantid.kernel import Logger
import matplotlib.pyplot as plt
+try:
+ from matplotlib.cm import viridis as DEFAULT_CMAP
+except ImportError:
+ from matplotlib.cm import jet as DEFAULT_CMAP
from mantidqt.py3compat import is_text_string
+from mantidqt.dialogs.spectraselectordialog import get_spectra_selection
+from matplotlib.gridspec import GridSpec
+import numpy as np
# local imports
+from .figuretype import figure_type, FigureType
# -----------------------------------------------------------------------------
# Constants
# -----------------------------------------------------------------------------
PROJECTION = 'mantid'
-DEFAULT_COLORMAP = 'viridis'
# See https://matplotlib.org/api/_as_gen/matplotlib.figure.SubplotParams.html#matplotlib.figure.SubplotParams
SUBPLOT_WSPACE = 0.5
SUBPLOT_HSPACE = 0.5
+LOGGER = Logger("workspace.plotting.functions")
# -----------------------------------------------------------------------------
-# Functions
+# 'Public' Functions
# -----------------------------------------------------------------------------
-def raise_if_not_sequence(seq, seq_name):
- accepted_types = [list, tuple]
- if type(seq) not in accepted_types:
- raise ValueError("{} should be a list or tuple".format(seq_name))
-
-
-def _validate_plot_inputs(workspaces, spectrum_nums, wksp_indices):
- """Raises a ValueError if any arguments have the incorrect types"""
- if spectrum_nums is not None and wksp_indices is not None:
- raise ValueError("Both spectrum_nums and wksp_indices supplied. "
- "Please supply only 1.")
-
- if not isinstance(workspaces, MatrixWorkspace):
- raise_if_not_sequence(workspaces, 'Workspaces')
-
- if spectrum_nums is not None:
- raise_if_not_sequence(spectrum_nums, 'spectrum_nums')
- if wksp_indices is not None:
- raise_if_not_sequence(wksp_indices, 'wksp_indices')
+def can_overplot():
+ """
+ Checks if overplotting on the current figure can proceed
+ with the given options
+ :return: A 2-tuple of boolean indicating compatability and
+ a string containing an error message if the current figure is not
+ compatible.
+ """
+ compatible = False
+ msg = "Unable to overplot on currently active plot type.\n" \
+ "Please select another plot."
+ fig = current_figure_or_none()
+ if fig is not None:
+ figtype = figure_type(fig)
+ if figtype is FigureType.Line or figtype is FigureType.Errorbar:
+ compatible, msg = True, None
-def _validate_pcolormesh_inputs(workspaces):
- """Raises a ValueError if any arguments have the incorrect types"""
- if not isinstance(workspaces, MatrixWorkspace):
- raise_if_not_sequence(workspaces, 'Workspaces')
+ return compatible, msg
def current_figure_or_none():
@@ -103,8 +106,35 @@ def figure_title(workspaces, fig_num):
return wsname(first) + '-' + str(fig_num)
+def plot_from_names(names, errors, overplot, fig=None):
+ """
+ Given a list of names of workspaces, raise a dialog asking for the
+ a selection of what to plot and then plot it.
+
+ :param names: A list of workspace names
+ :param errors: If true then error bars will be plotted on the points
+ :param overplot: If true then the add to the current figure if one
+ exists and it is a compatible figure
+ :param fig: If not None then use this figure object to plot
+ :return: The figure containing the plot or None if selection was cancelled
+ """
+ workspaces = AnalysisDataService.Instance().retrieveWorkspaces(names, unrollGroups=True)
+ try:
+ selection = get_spectra_selection(workspaces)
+ except Exception as exc:
+ LOGGER.warning(format(str(exc)))
+ selection = None
+
+ if selection is None:
+ return None
+
+ return plot(selection.workspaces, spectrum_nums=selection.spectra,
+ wksp_indices=selection.wksp_indices,
+ errors=errors, overplot=overplot, fig=fig)
+
+
def plot(workspaces, spectrum_nums=None, wksp_indices=None, errors=False,
- overplot=False):
+ overplot=False, fig=None):
"""
Create a figure with a single subplot and for each workspace/index add a
line plot to the new axes. show() is called before returning the figure instance. A legend
@@ -115,7 +145,8 @@ def plot(workspaces, spectrum_nums=None, wksp_indices=None, errors=False,
:param wksp_indices: A list of workspace indexes (starts from 0)
:param errors: If true then error bars are added for each plot
:param overplot: If true then overplot over the current figure if one exists
- :returns: The figure containing the plots
+ :param fig: If not None then use this Figure object to plot
+ :return: The figure containing the plots
"""
# check inputs
_validate_plot_inputs(workspaces, spectrum_nums, wksp_indices)
@@ -124,13 +155,16 @@ def plot(workspaces, spectrum_nums=None, wksp_indices=None, errors=False,
else:
kw, nums = 'wkspIndex', wksp_indices
- # get/create the axes to hold the plot
- if overplot:
- ax = plt.gca(projection=PROJECTION)
- fig = ax.figure
+ if fig is None:
+ # get/create the axes to hold the plot
+ if overplot:
+ ax = plt.gca(projection=PROJECTION)
+ fig = ax.figure
+ else:
+ fig = plt.figure()
+ ax = fig.add_subplot(111, projection=PROJECTION)
else:
- fig = plt.figure()
- ax = fig.add_subplot(111, projection=PROJECTION)
+ ax = fig.gca()
# do the plotting
plot_fn = ax.errorbar if errors else ax.plot
@@ -148,14 +182,28 @@ def plot(workspaces, spectrum_nums=None, wksp_indices=None, errors=False,
return fig
-def pcolormesh(workspaces):
+def pcolormesh_from_names(names, fig=None):
+ """
+ Create a figure containing pcolor subplots
+
+ :param names: A list of workspace names
+ :param fig: An optional figure to contain the new plots. Its current contents will be cleared
+ :returns: The figure containing the plots
+ """
+ try:
+ return pcolormesh(AnalysisDataService.retrieveWorkspaces(names, unrollGroups=True),
+ fig=fig)
+ except Exception as exc:
+ LOGGER.warning(format(str(exc)))
+ return None
+
+
+def pcolormesh(workspaces, fig=None):
"""
- Create a figure containing subplots
+ Create a figure containing pcolor subplots
:param workspaces: A list of workspace handles
- :param spectrum_nums: A list of spectrum number identifiers (general start from 1)
- :param wksp_indices: A list of workspace indexes (starts from 0)
- :param errors: If true then error bars are added for each plot
+ :param fig: An optional figure to contain the new plots. Its current contents will be cleared
:returns: The figure containing the plots
"""
# check inputs
@@ -164,26 +212,17 @@ def pcolormesh(workspaces):
# create a subplot of the appropriate number of dimensions
# extend in number of columns if the number of plottables is not a square number
workspaces_len = len(workspaces)
- square_side_len = int(math.ceil(math.sqrt(workspaces_len)))
- nrows, ncols = square_side_len, square_side_len
- if square_side_len*square_side_len != workspaces_len:
- # not a square number - square_side_len x square_side_len
- # will be large enough but we could end up with an empty
- # row so chop that off
- if workspaces_len <= (nrows-1)*ncols:
- nrows -= 1
+ fig, axes, nrows, ncols = _create_subplots(workspaces_len, fig=fig)
- fig, axes = plt.subplots(nrows, ncols, squeeze=False,
- subplot_kw=dict(projection=PROJECTION))
row_idx, col_idx = 0, 0
for subplot_idx in range(nrows*ncols):
ax = axes[row_idx][col_idx]
if subplot_idx < workspaces_len:
ws = workspaces[subplot_idx]
ax.set_title(ws.name())
- pcm = ax.pcolormesh(ws, cmap=DEFAULT_COLORMAP)
- xticks = ax.get_xticklabels()
- map(lambda lbl: lbl.set_rotation(45), xticks)
+ pcm = ax.pcolormesh(ws, cmap=DEFAULT_CMAP)
+ for lbl in ax.get_xticklabels():
+ lbl.set_rotation(45)
if col_idx < ncols - 1:
col_idx += 1
else:
@@ -201,8 +240,9 @@ def pcolormesh(workspaces):
fig.show()
return fig
+# ----------------- Compatability functions ---------------------
+
-# Compatibility function for existing MantidPlot functionality
def plotSpectrum(workspaces, indices, distribution=None, error_bars=False,
type=None, window=None, clearWindow=None,
waterfall=False):
@@ -229,3 +269,83 @@ def plotSpectrum(workspaces, indices, distribution=None, error_bars=False,
return plot(workspaces, wksp_indices=indices,
errors=error_bars, fmt=fmt)
+
+
+# -----------------------------------------------------------------------------
+# 'Private' Functions
+# -----------------------------------------------------------------------------
+def _raise_if_not_sequence(value, seq_name, element_type=None):
+ """
+ Raise a ValueError if the given object is not a sequence
+
+ :param value: The value object to validate
+ :param seq_name: The variable name of the sequence for the error message
+ :param element_type: An optional type to provide to check that each element
+ is an instance of this type
+ :raises ValueError: if the conditions are not met
+ """
+ accepted_types = (list, tuple)
+ if type(value) not in accepted_types:
+ raise ValueError("{} should be a list or tuple".format(seq_name))
+ if element_type is not None:
+ def raise_if_not_type(x):
+ if not isinstance(x, element_type):
+ raise ValueError("Unexpected type: '{}'".format(x.__class__.__name__))
+
+ map(raise_if_not_type, value)
+
+
+def _validate_plot_inputs(workspaces, spectrum_nums, wksp_indices):
+ """Raises a ValueError if any arguments have the incorrect types"""
+ if spectrum_nums is not None and wksp_indices is not None:
+ raise ValueError("Both spectrum_nums and wksp_indices supplied. "
+ "Please supply only 1.")
+
+ _raise_if_not_sequence(workspaces, 'workspaces', MatrixWorkspace)
+
+ if spectrum_nums is not None:
+ _raise_if_not_sequence(spectrum_nums, 'spectrum_nums')
+
+ if wksp_indices is not None:
+ _raise_if_not_sequence(wksp_indices, 'wksp_indices')
+
+
+def _validate_pcolormesh_inputs(workspaces):
+ """Raises a ValueError if any arguments have the incorrect types"""
+ _raise_if_not_sequence(workspaces, 'workspaces', MatrixWorkspace)
+
+
+def _create_subplots(nplots, fig=None):
+ """
+ Create a set of subplots suitable for a given number of plots. A stripped down
+ version of plt.subplots that can accept an existing figure instance.
+
+ :param nplots: The number of plots required
+ :param fig: An optional figure. It is cleared before plotting the new contents
+ :return: A 2-tuple of (fig, axes)
+ """
+ square_side_len = int(math.ceil(math.sqrt(nplots)))
+ nrows, ncols = square_side_len, square_side_len
+ if square_side_len*square_side_len != nplots:
+ # not a square number - square_side_len x square_side_len
+ # will be large enough but we could end up with an empty
+ # row so chop that off
+ if nplots <= (nrows-1)*ncols:
+ nrows -= 1
+
+ if fig is None:
+ fig = plt.figure()
+ else:
+ fig.clf()
+ # annoyling this repl
+ nplots = nrows*ncols
+ gs = GridSpec(nrows, ncols)
+ axes = np.empty(nplots, dtype=object)
+ ax0 = fig.add_subplot(gs[0, 0], projection=PROJECTION)
+ axes[0] = ax0
+ for i in range(1, nplots):
+ axes[i] = fig.add_subplot(gs[i // ncols, i % ncols],
+ projection=PROJECTION)
+ axes = axes.reshape(nrows, ncols)
+
+ return fig, axes, nrows, ncols
diff --git a/qt/applications/workbench/workbench/plotting/test/test_figuretype.py b/qt/applications/workbench/workbench/plotting/test/test_figuretype.py
index 1d23fbbfd6b34c8b6535783de3bf6ac37532bda4..6e691d3783fd5b574eab2e1330f6f93a6c692a0d 100644
--- a/qt/applications/workbench/workbench/plotting/test/test_figuretype.py
+++ b/qt/applications/workbench/workbench/plotting/test/test_figuretype.py
@@ -42,6 +42,11 @@ class FigureTypeTest(TestCase):
ax.plot([1])
self.assertEqual(FigureType.Line, figure_type(ax.figure))
+ def test_error_plot_returns_error(self):
+ ax = plt.subplot(111)
+ ax.errorbar([1], [1], yerr=[0.01])
+ self.assertEqual(FigureType.Errorbar, figure_type(ax.figure))
+
def test_image_plot_returns_image(self):
ax = plt.subplot(111)
ax.imshow([[1],[1]])
diff --git a/qt/applications/workbench/workbench/plotting/test/test_functions.py b/qt/applications/workbench/workbench/plotting/test/test_functions.py
index 54f17df00f093aa5529f5a3e8a98fdff96f4c190..a1c11d316eaf0a2860315f7c827485ec75821ce0 100644
--- a/qt/applications/workbench/workbench/plotting/test/test_functions.py
+++ b/qt/applications/workbench/workbench/plotting/test/test_functions.py
@@ -18,14 +18,22 @@ from __future__ import absolute_import
# std imports
from unittest import TestCase, main
+try:
+ from unittest import mock
+except ImportError:
+ import mock
-# thirdparty imports
+# third party imports
+from mantid.api import AnalysisDataService, WorkspaceFactory
import matplotlib
matplotlib.use('AGG') # noqa
import matplotlib.pyplot as plt
+from mantidqt.dialogs.spectraselectordialog import SpectraSelection
+import numpy as np
# local imports
-from workbench.plotting.functions import current_figure_or_none, figure_title
+from workbench.plotting.functions import (can_overplot, current_figure_or_none, figure_title,
+ plot, plot_from_names, pcolormesh_from_names)
# Avoid importing the whole of mantid for a single mock of the workspace class
@@ -40,8 +48,30 @@ class FakeWorkspace(object):
class FunctionsTest(TestCase):
- def test_current_figure_or_none_returns_none_if_no_figures_exist(self):
+ _test_ws = None
+
+ def setUp(self):
+ if self._test_ws is None:
+ self.__class__._test_ws = WorkspaceFactory.Instance().create("Workspace2D", NVectors=2, YLength=5, XLength=5)
+
+ def tearDown(self):
+ AnalysisDataService.Instance().clear()
plt.close('all')
+
+ def test_can_overplot_returns_false_with_no_active_plots(self):
+ self.assertFalse(can_overplot()[0])
+
+ def test_can_overplot_returns_true_for_active_line_plot(self):
+ plt.plot([1, 2])
+ self.assertTrue(can_overplot()[0])
+
+ def test_can_overplot_returns_false_for_active_patch_plot(self):
+ plt.pcolormesh(np.arange(9.).reshape(3,3))
+ allowed, msg = can_overplot()
+ self.assertFalse(allowed)
+ self.assertTrue(len(msg) > 0)
+
+ def test_current_figure_or_none_returns_none_if_no_figures_exist(self):
self.assertTrue(current_figure_or_none() is None)
def test_figure_title_with_single_string(self):
@@ -61,6 +91,107 @@ class FunctionsTest(TestCase):
with self.assertRaises(AssertionError):
figure_title([], 5)
+ @mock.patch('workbench.plotting.functions.get_spectra_selection')
+ @mock.patch('workbench.plotting.functions.plot')
+ def test_plot_from_names_calls_plot(self, get_spectra_selection_mock, plot_mock):
+ ws_name = 'test_plot_from_names_calls_plot-1'
+ AnalysisDataService.Instance().addOrReplace(ws_name, self._test_ws)
+ selection = SpectraSelection([self._test_ws])
+ selection.wksp_indices = [0]
+ get_spectra_selection_mock.return_value = selection
+ plot_from_names([ws_name], errors=False, overplot=False)
+
+ self.assertEqual(1, plot_mock.call_count)
+
+ @mock.patch('workbench.plotting.functions.get_spectra_selection')
+ def test_plot_from_names_produces_single_line_plot_for_valid_name(self, get_spectra_selection_mock):
+ self._do_plot_from_names_test(get_spectra_selection_mock, expected_labels=["spec 1"], wksp_indices=[0],
+ errors=False, overplot=False)
+
+ @mock.patch('workbench.plotting.functions.get_spectra_selection')
+ def test_plot_from_names_produces_single_error_plot_for_valid_name(self, get_spectra_selection_mock):
+ fig = self._do_plot_from_names_test(get_spectra_selection_mock,
+ # matplotlib does not set labels on the lines for error plots
+ expected_labels=[None, None, None],
+ wksp_indices=[0], errors=True, overplot=False)
+ self.assertEqual(1, len(fig.gca().containers))
+
+ @mock.patch('workbench.plotting.functions.get_spectra_selection')
+ def test_plot_from_names_produces_overplot_for_valid_name(self, get_spectra_selection_mock):
+ # make first plot
+ plot([self._test_ws], wksp_indices=[0])
+ self._do_plot_from_names_test(get_spectra_selection_mock, expected_labels=["spec 1", "spec 2"],
+ wksp_indices=[1], errors=False, overplot=True)
+
+ @mock.patch('workbench.plotting.functions.get_spectra_selection')
+ def test_plot_from_names_within_existing_figure(self, get_spectra_selection_mock):
+ # make existing plot
+ fig = plot([self._test_ws], wksp_indices=[0])
+ self._do_plot_from_names_test(get_spectra_selection_mock, expected_labels=["spec 1", "spec 2"],
+ wksp_indices=[1], errors=False, overplot=False,
+ target_fig=fig)
+
+ @mock.patch('workbench.plotting.functions.pcolormesh')
+ def test_pcolormesh_from_names_calls_pcolormesh(self, pcolormesh_mock):
+ ws_name = 'test_pcolormesh_from_names_calls_pcolormesh-1'
+ AnalysisDataService.Instance().addOrReplace(ws_name, self._test_ws)
+ pcolormesh_from_names([ws_name])
+
+ self.assertEqual(1, pcolormesh_mock.call_count)
+
+ def test_pcolormesh_from_names(self):
+ ws_name = 'test_pcolormesh_from_names-1'
+ AnalysisDataService.Instance().addOrReplace(ws_name, self._test_ws)
+ fig = pcolormesh_from_names([ws_name])
+
+ self.assertEqual(1, len(fig.gca().collections))
+
+ def test_pcolormesh_from_names_using_existing_figure(self):
+ ws_name = 'test_pcolormesh_from_names-1'
+ AnalysisDataService.Instance().addOrReplace(ws_name, self._test_ws)
+ target_fig = plt.figure()
+ fig = pcolormesh_from_names([ws_name], fig=target_fig)
+
+ self.assertEqual(fig, target_fig)
+ self.assertEqual(1, len(fig.gca().collections))
+
+ # ------------- Failure tests -------------
+
+ def test_plot_from_names_with_non_plottable_workspaces_returns_None(self):
+ table = WorkspaceFactory.Instance().createTable()
+ table_name = 'test_plot_from_names_with_non_plottable_workspaces_returns_None'
+ AnalysisDataService.Instance().addOrReplace(table_name, table)
+ result = plot_from_names([table_name], errors=False, overplot=False)
+ self.assertTrue(result is None)
+
+ def test_pcolormesh_from_names_with_non_plottable_workspaces_returns_None(self):
+ table = WorkspaceFactory.Instance().createTable()
+ table_name = 'test_pcolormesh_from_names_with_non_plottable_workspaces_returns_None'
+ AnalysisDataService.Instance().addOrReplace(table_name, table)
+ result = pcolormesh_from_names([table_name])
+ self.assertTrue(result is None)
+
+ # ------------- Private -------------------
+ def _do_plot_from_names_test(self, get_spectra_selection_mock, expected_labels,
+ wksp_indices, errors, overplot, target_fig=None):
+ ws_name = 'test_plot_from_names-1'
+ AnalysisDataService.Instance().addOrReplace(ws_name, self._test_ws)
+
+ selection = SpectraSelection([self._test_ws])
+ selection.wksp_indices = wksp_indices
+ get_spectra_selection_mock.return_value = selection
+ fig = plot_from_names([ws_name], errors, overplot, target_fig)
+ if target_fig is not None:
+ self.assertEqual(target_fig, fig)
+
+ plotted_lines = fig.gca().get_lines()
+ self.assertEqual(len(expected_labels), len(plotted_lines))
+ for label_part, line in zip(expected_labels, plotted_lines):
+ if label_part is not None:
+ self.assertTrue(label_part in line.get_label(),
+ msg="Label fragment '{}' not found in line label".format(label_part))
+ return fig
+
if __name__ == '__main__':
main()
diff --git a/qt/applications/workbench/workbench/plugins/test/test_jupyterconsole.py b/qt/applications/workbench/workbench/plugins/test/test_jupyterconsole.py
index f1ae661e90d3e4e8d804651b025fdc944edb1f9e..ed88ea6334583c8f3310dd4e8ab1715144406709 100644
--- a/qt/applications/workbench/workbench/plugins/test/test_jupyterconsole.py
+++ b/qt/applications/workbench/workbench/plugins/test/test_jupyterconsole.py
@@ -20,7 +20,7 @@ from __future__ import (absolute_import)
import unittest
# third-party library imports
-from mantidqt.utils.qt.testing import requires_qapp
+from mantidqt.utils.qt.test import requires_qapp
from qtpy.QtWidgets import QMainWindow
# local package imports
diff --git a/qt/applications/workbench/workbench/plugins/workspacewidget.py b/qt/applications/workbench/workbench/plugins/workspacewidget.py
index 2ffcc1c21be7aec370d6cf2f516fe73c82553943..c8c7698117ebd3be48430e689a097e49cddfb220 100644
--- a/qt/applications/workbench/workbench/plugins/workspacewidget.py
+++ b/qt/applications/workbench/workbench/plugins/workspacewidget.py
@@ -20,48 +20,13 @@ from __future__ import (absolute_import, unicode_literals)
import functools
# third-party library imports
-from mantid.api import AnalysisDataService, MatrixWorkspace, WorkspaceGroup
-from mantid.kernel import Logger
-from mantidqt.dialogs.spectraselectordialog import get_spectra_selection
+from mantid.api import AnalysisDataService
from mantidqt.widgets.workspacewidget.workspacetreewidget import WorkspaceTreeWidget
from qtpy.QtWidgets import QMessageBox, QVBoxLayout
# local package imports
from workbench.plugins.base import PluginWidget
-from workbench.plotting.figuretype import figure_type, FigureType
-from workbench.plotting.functions import current_figure_or_none, pcolormesh, plot
-
-LOGGER = Logger(b"workspacewidget")
-
-
-def _workspaces_from_names(names):
- """
- Convert a list of workspace names to a list of MatrixWorkspace handles. Any WorkspaceGroup
- encountered is flattened and its members inserted into the list at this point
-
- Flattens any workspace groups with the list, preserving the order of the remaining elements
- :param names: A list of workspace names
- :return: A list where each element is a single MatrixWorkspace
- """
- ads = AnalysisDataService.Instance()
- flat = []
- for name in names:
- try:
- ws = ads[name.encode('utf-8')]
- except KeyError:
- LOGGER.warning("Skipping {} as it does not exist".format(name))
- continue
-
- if isinstance(ws, MatrixWorkspace):
- flat.append(ws)
- elif isinstance(ws, WorkspaceGroup):
- group_len = len(ws)
- for i in range(group_len):
- flat.append(ws[i])
- else:
- LOGGER.warning("{} it is not a MatrixWorkspace or WorkspaceGroup.".format(name))
-
- return flat
+from workbench.plotting.functions import can_overplot, pcolormesh, plot_from_names
class WorkspaceWidget(PluginWidget):
@@ -70,6 +35,8 @@ class WorkspaceWidget(PluginWidget):
def __init__(self, parent):
super(WorkspaceWidget, self).__init__(parent)
+ self._ads = AnalysisDataService.Instance()
+
# layout
self.workspacewidget = WorkspaceTreeWidget()
layout = QVBoxLayout()
@@ -110,20 +77,12 @@ class WorkspaceWidget(PluginWidget):
exists and it is a compatible figure
"""
if overplot:
- compatible, error_msg = self._can_overplot()
+ compatible, error_msg = can_overplot()
if not compatible:
QMessageBox.warning(self, "", error_msg)
return
- try:
- selection = get_spectra_selection(_workspaces_from_names(names), self)
- if selection is not None:
- plot(selection.workspaces, spectrum_nums=selection.spectra,
- wksp_indices=selection.wksp_indices,
- errors=errors, overplot=overplot)
- except BaseException:
- import traceback
- traceback.print_exc()
+ plot_from_names(names, errors, overplot)
def _do_plot_colorfill(self, names):
"""
@@ -132,26 +91,7 @@ class WorkspaceWidget(PluginWidget):
:param names: A list of workspace names
"""
try:
- pcolormesh(_workspaces_from_names(names))
+ pcolormesh(self._ads.retrieveWorkspaces(names, unrollGroups=True))
except BaseException:
import traceback
traceback.print_exc()
-
- def _can_overplot(self):
- """
- Checks if overplotting can proceed with the given options
-
- :return: A 2-tuple of boolean indicating compatability and
- a string containing an error message if the current figure is not
- compatible.
- """
- compatible = False
- msg = "Unable to overplot on currently active plot type.\n" \
- "Please select another plot."
- fig = current_figure_or_none()
- if fig is not None:
- figtype = figure_type(fig)
- if figtype is FigureType.Line or figtype is FigureType.Errorbar:
- compatible, msg = True, None
-
- return compatible, msg
diff --git a/qt/applications/workbench/workbench/widgets/plotselector/test/test_plotselector_view.py b/qt/applications/workbench/workbench/widgets/plotselector/test/test_plotselector_view.py
index fba1be352f09d0e0f51f8fdf0c53dd3f5330b992..dcb7fa8b9bc75df912e9eb9056c43934c0486a74 100644
--- a/qt/applications/workbench/workbench/widgets/plotselector/test/test_plotselector_view.py
+++ b/qt/applications/workbench/workbench/widgets/plotselector/test/test_plotselector_view.py
@@ -21,7 +21,7 @@ from qtpy.QtTest import QTest
import qtawesome as qta
-from mantidqt.utils.qt.testing import requires_qapp
+from mantidqt.utils.qt.test import requires_qapp
from workbench.widgets.plotselector.presenter import PlotSelectorPresenter
from workbench.widgets.plotselector.view import EXPORT_TYPES, PlotSelectorView, Column
diff --git a/qt/paraview_ext/VatesAlgorithms/CMakeLists.txt b/qt/paraview_ext/VatesAlgorithms/CMakeLists.txt
index 5fc54adb2eeddf14972e2714d1fd9130b6818eda..8d4a794b3cb33c5f4745f254454c4de8237d6e4e 100644
--- a/qt/paraview_ext/VatesAlgorithms/CMakeLists.txt
+++ b/qt/paraview_ext/VatesAlgorithms/CMakeLists.txt
@@ -50,7 +50,7 @@ ${POCO_LIBRARIES}
if (OSX_VERSION VERSION_GREATER 10.8)
set_target_properties(VatesAlgorithms PROPERTIES INSTALL_RPATH "@loader_path/../Contents/MacOS;@loader_path/../Libraries")
elseif ( ${CMAKE_SYSTEM_NAME} STREQUAL "Linux" )
- set_target_properties(VatesAlgorithms PROPERTIES INSTALL_RPATH "\$ORIGIN/../${LIB_DIR}")
+ set_target_properties(VatesAlgorithms PROPERTIES INSTALL_RPATH "\$ORIGIN/../${LIB_DIR};\$ORIGIN/../${LIB_DIR}/paraview-${ParaView_VERSION_MAJOR}.${ParaView_VERSION_MINOR}")
endif ()
# Create test file projects
diff --git a/qt/paraview_ext/VatesSimpleGui/ViewWidgets/src/MdViewerWidget.cpp b/qt/paraview_ext/VatesSimpleGui/ViewWidgets/src/MdViewerWidget.cpp
index e4fdad8166d15c8f887accc64074d3376d8ba8ef..c99fc62342b593f723b5ec88f64cc2d1a2a06a12 100644
--- a/qt/paraview_ext/VatesSimpleGui/ViewWidgets/src/MdViewerWidget.cpp
+++ b/qt/paraview_ext/VatesSimpleGui/ViewWidgets/src/MdViewerWidget.cpp
@@ -1651,11 +1651,8 @@ bool otherWorkspacePresent() {
void MdViewerWidget::handleDragAndDropPeaksWorkspaces(QEvent *e,
const QString &text,
QStringList &wsNames) {
- int endIndex = 0;
- while (text.indexOf("[\"", endIndex) > -1) {
- int startIndex = text.indexOf("[\"", endIndex) + 2;
- endIndex = text.indexOf("\"]", startIndex);
- QString candidate = text.mid(startIndex, endIndex - startIndex);
+ const QStringList selectedWorkspaces = text.split("\n");
+ for (const auto &candidate : selectedWorkspaces) {
// Only append the candidate if SplattorPlotView is selected and an
// MDWorkspace is loaded.
if (currentView->getViewType() == ModeControlWidget::Views::SPLATTERPLOT &&
diff --git a/qt/python/CMakeLists.txt b/qt/python/CMakeLists.txt
index 508b70e03026ca2f7cf23c5f7150a0e5a3366cea..e92c9fd5375c586af71ca8c5ad6c13d0973518db 100644
--- a/qt/python/CMakeLists.txt
+++ b/qt/python/CMakeLists.txt
@@ -1,6 +1,7 @@
# This file manages building/installation of the mantidqt and mantidqtpython
# Python wrappers.
#
+include ( PythonPackageTargetFunctions )
# Legacy wrappers for MantidPlot
add_subdirectory ( mantidqtpython )
@@ -20,7 +21,6 @@ if ( ENABLE_WORKBENCH )
${CMAKE_CURRENT_SOURCE_DIR}/mantidqt/utils/qt/plugins.py
)
- # Create egg link to binary output directory for mantidqt
add_python_package ( mantidqt )
# Configure resources data in place for ease of development. The output
diff --git a/qt/python/mantidqt/CMakeLists.txt b/qt/python/mantidqt/CMakeLists.txt
index 1ec7b21fc9d2478fea791db55318cfe486266792..6ca91e85bdc9c66d88074b58a1754ab417e5c70b 100644
--- a/qt/python/mantidqt/CMakeLists.txt
+++ b/qt/python/mantidqt/CMakeLists.txt
@@ -2,7 +2,6 @@ include ( SipQtTargetFunctions )
set ( COMMON_INC_DIR ../../../widgets/common/inc )
set ( HEADER_DEPENDS
- ${COMMON_INC_DIR}/MantidQtWidgets/Common/AlgorithmDialog.h
${COMMON_INC_DIR}/MantidQtWidgets/Common/AlgorithmDialog.h
${COMMON_INC_DIR}/MantidQtWidgets/Common/Message.h
${COMMON_INC_DIR}/MantidQtWidgets/Common/MessageDisplay.h
@@ -18,7 +17,8 @@ list ( APPEND common_link_libs
${PYTHON_LIBRARIES}
)
-# Wrapper module linked against Qt4
+# Wrapper module linked against Qt4 - not currently installed until required for backward compatability
+# with MantidPlot
mtd_add_sip_module (
MODULE_NAME _commonqt4
TARGET_NAME mantidqt_commonqt4
@@ -59,5 +59,9 @@ mtd_add_sip_module (
${PYTHON_LIBRARIES}
${Boost_LIBRARIES}
API
+ INSTALL_DIR
+ ${LIB_DIR}/mantidqt
+ LINUX_INSTALL_RPATH
+ "\$ORIGIN/.."
FOLDER Qt5
)
diff --git a/qt/python/mantidqt/_common.sip b/qt/python/mantidqt/_common.sip
index 06cb888dbd1bec155256342910cd17321872dd7d..e78fc66c6bd175de83b0b2a8d54a1f0e366dec2b 100644
--- a/qt/python/mantidqt/_common.sip
+++ b/qt/python/mantidqt/_common.sip
@@ -37,7 +37,7 @@ class Configurable {
public:
void readSettings(const QSettings &storage);
- void writeSettings(QSettings *storage);
+ void writeSettings(QSettings &storage);
private:
// Not constructible or copyable
@@ -45,6 +45,25 @@ private:
Configurable(const Configurable&);
};
+class AlgorithmInputHistoryImpl : Configurable /PyName=AlgorithmInputHistory/ {
+%TypeHeaderCode
+#include "MantidQtWidgets/Common/AlgorithmInputHistory.h"
+%End
+
+public:
+static SIP_PYOBJECT Instance() const;
+%MethodCode
+ auto &cppInstance = MantidQt::API::AlgorithmInputHistory::Instance();
+ return sipConvertFromType(&cppInstance, sipType_AlgorithmInputHistoryImpl, nullptr);
+%End
+
+private:
+ // lifetime management is with C++ so don't generate any of that in Python
+ AlgorithmInputHistoryImpl();
+ ~AlgorithmInputHistoryImpl();
+ AlgorithmInputHistoryImpl(const AlgorithmInputHistoryImpl &);
+};
+
class MessageDisplay : QWidget, Configurable {
%TypeHeaderCode
#include "MantidQtWidgets/Common/MessageDisplay.h"
diff --git a/qt/python/mantidqt/algorithminputhistory.py b/qt/python/mantidqt/algorithminputhistory.py
new file mode 100644
index 0000000000000000000000000000000000000000..0a83607928385a3a04554be7675aa49a96c74037
--- /dev/null
+++ b/qt/python/mantidqt/algorithminputhistory.py
@@ -0,0 +1,46 @@
+# This file is part of the mantidqt package
+#
+# Copyright (C) 2017 mantidproject
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+from __future__ import (absolute_import)
+
+from mantidqt.utils.qt import import_qt
+
+
+_AlgorithmInputHistory = import_qt('._common', 'mantidqt', 'AlgorithmInputHistory')
+
+
+def _toQSettings(settings):
+ '''Utility function to convert supplied settings object to a qtpy.QtCore.QSettings
+ '''
+ try: # workbench.config.user
+ return settings.qsettings
+ except: # must be a QSettings already
+ return settings
+
+
+class AlgorithmInputHistory(object):
+ '''Wrapper class around MantidQtWidgets::Common::AlgorithmInputHistory
+ '''
+ _singleton = _AlgorithmInputHistory.Instance()
+
+ def __init__(self):
+ pass
+
+ def readSettings(self, settings):
+ self._singleton.readSettings(_toQSettings(settings))
+
+ def writeSettings(self, settings):
+ self._singleton.writeSettings(_toQSettings(settings))
diff --git a/qt/python/mantidqt/dialogs/spectraselectordialog.py b/qt/python/mantidqt/dialogs/spectraselectordialog.py
index 0bde6df74688864fa3641688a2c72d390d7902a1..4e81ccef4593d96e064d43d64283a93d36f27dc2 100644
--- a/qt/python/mantidqt/dialogs/spectraselectordialog.py
+++ b/qt/python/mantidqt/dialogs/spectraselectordialog.py
@@ -19,6 +19,7 @@ from __future__ import (absolute_import, unicode_literals)
# std imports
# 3rd party imports
+from mantid.api import MatrixWorkspace
import qtawesome as qta
from qtpy.QtWidgets import QDialogButtonBox
@@ -54,9 +55,17 @@ class SpectraSelection(object):
class SpectraSelectionDialog(SpectraSelectionDialogUIBase):
+ @staticmethod
+ def raise_error_if_workspaces_not_compatible(workspaces):
+ for ws in workspaces:
+ if not isinstance(ws, MatrixWorkspace):
+ raise ValueError("Expected MatrixWorkspace, found {}.".format(ws.__class__.__name__))
+
def __init__(self, workspaces,
parent=None):
super(SpectraSelectionDialog, self).__init__(parent)
+ self.raise_error_if_workspaces_not_compatible(workspaces)
+
# attributes
self._workspaces = workspaces
self.spec_min, self.spec_max = None, None
@@ -78,6 +87,7 @@ class SpectraSelectionDialog(SpectraSelectionDialogUIBase):
self.accept()
# ------------------- Private -------------------------
+
def _init_ui(self):
ui = SpectraSelectionDialogUI()
ui.setupUi(self)
@@ -161,17 +171,19 @@ class SpectraSelectionDialog(SpectraSelectionDialogUIBase):
return self.selection is not None
-def get_spectra_selection(workspaces, parent_widget):
+def get_spectra_selection(workspaces, parent_widget=None):
"""Decides whether it is necessary to request user input
when asked to plot a list of workspaces. The input
dialog will only be shown in the case where all workspaces
have more than 1 spectrum
:param workspaces: A list of MatrixWorkspaces that will be plotted
- :param parent_widget: A parent_widget to use for the input selection dialog
+ :param parent_widget: An optional parent_widget to use for the input selection dialog
:returns: Either a SpectraSelection object containing the details of workspaces to plot or None indicating
the request was cancelled
+ :raises ValueError: if the workspaces are not of type MatrixWorkspace
"""
+ SpectraSelectionDialog.raise_error_if_workspaces_not_compatible(workspaces)
single_spectra_ws = [wksp.getNumberHistograms() for wksp in workspaces if wksp.getNumberHistograms() == 1]
if len(single_spectra_ws) > 0:
# At least 1 workspace contains only a single spectrum so this is all
diff --git a/qt/python/mantidqt/dialogs/test/test_algorithm_dialog.py b/qt/python/mantidqt/dialogs/test/test_algorithm_dialog.py
index d5ac28bfd304a7da8221cd7fd6f590e8570d5319..3d4595a4e13d49b8e43db64031d48543e1c498ff 100644
--- a/qt/python/mantidqt/dialogs/test/test_algorithm_dialog.py
+++ b/qt/python/mantidqt/dialogs/test/test_algorithm_dialog.py
@@ -20,7 +20,7 @@ from qtpy.QtWidgets import QWidget, QLineEdit
from mantid.api import AlgorithmManager, AlgorithmFactory, PythonAlgorithm
from mantid.kernel import Direction, FloatArrayProperty
-from mantidqt.utils.qt.testing import requires_qapp
+from mantidqt.utils.qt.test import requires_qapp
from mantidqt.dialogs.algorithmdialog import AlgorithmDialog
from mantidqt.dialogs.genericdialog import GenericDialog
from mantidqt.interfacemanager import InterfaceManager
diff --git a/qt/python/mantidqt/dialogs/test/test_spectraselectiondialog.py b/qt/python/mantidqt/dialogs/test/test_spectraselectiondialog.py
index 135614b46a41c1f39fb20cbac9d6062c3098a72d..578ae5f66bd8fc7d60fa21468fff0f07348159c4 100644
--- a/qt/python/mantidqt/dialogs/test/test_spectraselectiondialog.py
+++ b/qt/python/mantidqt/dialogs/test/test_spectraselectiondialog.py
@@ -16,51 +16,63 @@
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# std imports
-import time
import unittest
+try:
+ from unittest import mock
+except ImportError:
+ import mock
# 3rdparty imports
-from mantid.simpleapi import CreateSampleWorkspace, CropWorkspace
-from qtpy.QtWidgets import QDialogButtonBox
+from mantid.api import WorkspaceFactory
+from qtpy.QtWidgets import QDialog, QDialogButtonBox
# local imports
-from mantidqt.utils.qt.testing import requires_qapp
-from mantidqt.dialogs.spectraselectordialog import parse_selection_str, SpectraSelectionDialog
+from mantidqt.utils.qt.test import requires_qapp
+from mantidqt.dialogs.spectraselectordialog import (get_spectra_selection, parse_selection_str,
+ SpectraSelectionDialog)
@requires_qapp
class SpectraSelectionDialogTest(unittest.TestCase):
+ _single_spec_ws = None
+ _multi_spec_ws = None
+
+ def setUp(self):
+ if self._single_spec_ws is None:
+ self.__class__._single_spec_ws = WorkspaceFactory.Instance().create("Workspace2D", NVectors=1,
+ XLength=1, YLength=1)
+ self.__class__._multi_spec_ws = WorkspaceFactory.Instance().create("Workspace2D", NVectors=200,
+ XLength=1, YLength=1)
+
def test_initial_dialog_setup(self):
- workspaces = [CreateSampleWorkspace(OutputWorkspace='ws', StoreInADS=False)]
+ workspaces = [self._multi_spec_ws]
dlg = SpectraSelectionDialog(workspaces)
self.assertFalse(dlg._ui.buttonBox.button(QDialogButtonBox.Ok).isEnabled())
def test_filling_workspace_details_single_workspace(self):
- workspaces = [CreateSampleWorkspace(OutputWorkspace='ws', StoreInADS=False)]
+ workspaces = [self._multi_spec_ws]
dlg = SpectraSelectionDialog(workspaces)
self.assertEqual("valid range: 1-200", dlg._ui.specNums.placeholderText())
self.assertEqual("valid range: 0-199", dlg._ui.wkspIndices.placeholderText())
def test_filling_workspace_details_multiple_workspaces_of_same_size(self):
- workspaces = [CreateSampleWorkspace(OutputWorkspace='ws', StoreInADS=False),
- CreateSampleWorkspace(OutputWorkspace='ws2', StoreInADS=False)]
+ workspaces = [self._multi_spec_ws,
+ self._multi_spec_ws]
dlg = SpectraSelectionDialog(workspaces)
self.assertEqual("valid range: 1-200", dlg._ui.specNums.placeholderText())
self.assertEqual("valid range: 0-199", dlg._ui.wkspIndices.placeholderText())
def test_filling_workspace_details_multiple_workspaces_of_different_sizes(self):
- ws1 = CreateSampleWorkspace(OutputWorkspace='ws', NumBanks=1, StoreInADS=False)
- ws1 = CropWorkspace(ws1, StartWorkspaceIndex=50)
- ws2 = CreateSampleWorkspace(OutputWorkspace='ws', StoreInADS=False)
-
- dlg = SpectraSelectionDialog([ws1, ws2])
+ cropped_ws = WorkspaceFactory.Instance().create("Workspace2D", NVectors=50, XLength=1, YLength=1)
+ for i in range(cropped_ws.getNumberHistograms()):
+ cropped_ws.getSpectrum(i).setSpectrumNo(51 + i)
+ dlg = SpectraSelectionDialog([cropped_ws, self._multi_spec_ws])
self.assertEqual("valid range: 51-100", dlg._ui.specNums.placeholderText())
self.assertEqual("valid range: 0-49", dlg._ui.wkspIndices.placeholderText())
def test_valid_text_in_boxes_activates_ok(self):
- workspaces = [CreateSampleWorkspace(OutputWorkspace='ws', StoreInADS=False)]
- dlg = SpectraSelectionDialog(workspaces)
+ dlg = SpectraSelectionDialog([self._multi_spec_ws])
def do_test(input_box):
input_box.setText("1")
@@ -72,13 +84,51 @@ class SpectraSelectionDialogTest(unittest.TestCase):
do_test(dlg._ui.specNums)
def test_plot_all_gives_only_workspaces_indices(self):
- ws = CreateSampleWorkspace(OutputWorkspace='ws', StoreInADS=False)
- dlg = SpectraSelectionDialog([ws])
+ dlg = SpectraSelectionDialog([self._multi_spec_ws])
dlg._ui.buttonBox.button(QDialogButtonBox.YesToAll).click()
self.assertTrue(dlg.selection is not None)
self.assertTrue(dlg.selection.spectra is None)
self.assertEqual(range(200), dlg.selection.wksp_indices)
+ def test_entered_workspace_indices_gives_correct_selection_back(self):
+ dlg = SpectraSelectionDialog([self._multi_spec_ws])
+ dlg._ui.wkspIndices.setText("1-3,5")
+ dlg._ui.buttonBox.button(QDialogButtonBox.Ok).click()
+
+ self.assertTrue(dlg.selection is not None)
+ self.assertTrue(dlg.selection.spectra is None)
+ self.assertEqual([1, 2, 3, 5], dlg.selection.wksp_indices)
+
+ def test_entered_spectra_gives_correct_selection_back(self):
+ dlg = SpectraSelectionDialog([self._multi_spec_ws])
+ dlg._ui.wkspIndices.setText("50-60")
+ dlg._ui.buttonBox.button(QDialogButtonBox.Ok).click()
+
+ self.assertTrue(dlg.selection is not None)
+ self.assertTrue(dlg.selection.spectra is None)
+ self.assertEqual(list(range(50, 61)), dlg.selection.wksp_indices)
+
+ @mock.patch('mantidqt.dialogs.spectraselectordialog.SpectraSelectionDialog', autospec=True)
+ def test_get_spectra_selection_cancelled_returns_None(self, dialog_mock):
+ # a new instance of the mock created inside get_spectra_selection will return
+ # dialog_mock
+ dialog_mock.return_value = dialog_mock
+ dialog_mock.Rejected = QDialog.Rejected
+ dialog_mock.exec_.return_value = dialog_mock.Rejected
+
+ selection = get_spectra_selection([self._multi_spec_ws])
+
+ dialog_mock.exec_.assert_called_once_with()
+ self.assertTrue(selection is None)
+
+ @mock.patch('mantidqt.dialogs.spectraselectordialog.SpectraSelectionDialog')
+ def test_get_spectra_selection_does_not_use_dialog_for_single_spectrum(self, dialog_mock):
+ selection = get_spectra_selection([self._single_spec_ws])
+
+ dialog_mock.assert_not_called()
+ self.assertEqual([0], selection.wksp_indices)
+ self.assertEqual([self._single_spec_ws], selection.workspaces)
+
def test_parse_selection_str_single_number(self):
s = '1'
self.assertEqual([1], parse_selection_str(s, 1, 3))
@@ -108,8 +158,15 @@ class SpectraSelectionDialogTest(unittest.TestCase):
self.assertEqual([1, 2, 3, 5, 8, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],
parse_selection_str(s, 1, 20))
+ # --------------- failure tests -----------
+ def test_construction_with_non_MatrixWorkspace_type_raises_exception(self):
+ table = WorkspaceFactory.Instance().createTable()
+ self.assertRaises(ValueError, SpectraSelectionDialog, [self._single_spec_ws, table])
+
+ def test_get_spectra_selection_raises_error_with_wrong_workspace_type(self):
+ table = WorkspaceFactory.Instance().createTable()
+ self.assertRaises(ValueError, get_spectra_selection, [self._single_spec_ws, table])
+
if __name__ == '__main__':
unittest.main()
- # investigate why this is needed to avoid a segfault on Linux
- time.sleep(0.5)
diff --git a/qt/python/mantidqt/utils/qt/testing/__init__.py b/qt/python/mantidqt/utils/qt/test/__init__.py
similarity index 98%
rename from qt/python/mantidqt/utils/qt/testing/__init__.py
rename to qt/python/mantidqt/utils/qt/test/__init__.py
index 19a8885cfe81a5134675f81103b61d5810b03e8e..9380bdb1feb93d780de7b546281198e887b8fafe 100644
--- a/qt/python/mantidqt/utils/qt/testing/__init__.py
+++ b/qt/python/mantidqt/utils/qt/test/__init__.py
@@ -63,7 +63,7 @@ def requires_qapp(cls):
qapp = QApplication.instance()
if qapp is None:
setup_library_paths()
- self._qapp = QApplication([''])
+ cls._qapp = QApplication([cls.__name__])
else:
self._qapp = qapp
orig_setUp(self)
diff --git a/qt/python/mantidqt/utils/qt/testing/modal_tester.py b/qt/python/mantidqt/utils/qt/test/modal_tester.py
similarity index 100%
rename from qt/python/mantidqt/utils/qt/testing/modal_tester.py
rename to qt/python/mantidqt/utils/qt/test/modal_tester.py
diff --git a/qt/python/mantidqt/utils/qt/testing/run_test_app.py b/qt/python/mantidqt/utils/qt/test/run_test_app.py
similarity index 100%
rename from qt/python/mantidqt/utils/qt/testing/run_test_app.py
rename to qt/python/mantidqt/utils/qt/test/run_test_app.py
diff --git a/qt/python/mantidqt/utils/test/test_modal_tester.py b/qt/python/mantidqt/utils/test/test_modal_tester.py
index 66ec5ff868b2092b947658ad327bd18462163dd3..9d68103564fd269b16e9edc55b824ea5ebd4fafc 100644
--- a/qt/python/mantidqt/utils/test/test_modal_tester.py
+++ b/qt/python/mantidqt/utils/test/test_modal_tester.py
@@ -22,7 +22,7 @@ import unittest
from qtpy.QtWidgets import QInputDialog
-from mantidqt.utils.qt.testing import requires_qapp, ModalTester
+from mantidqt.utils.qt.test import requires_qapp, ModalTester
@requires_qapp
diff --git a/qt/python/mantidqt/utils/test/test_qt_utils.py b/qt/python/mantidqt/utils/test/test_qt_utils.py
index 6e9497eaf7ed1d56aa70560cfefb4ec20a89c5e8..d1d88a021bd98dafb4538b498fb45c6b94b1f1d0 100644
--- a/qt/python/mantidqt/utils/test/test_qt_utils.py
+++ b/qt/python/mantidqt/utils/test/test_qt_utils.py
@@ -27,7 +27,7 @@ try:
except ImportError:
NEW_STYLE_SIGNAL = True
-from mantidqt.utils.qt.testing import requires_qapp
+from mantidqt.utils.qt.test import requires_qapp
from mantidqt.utils.qt import add_actions, create_action
diff --git a/qt/python/mantidqt/utils/test/test_writetosignal.py b/qt/python/mantidqt/utils/test/test_writetosignal.py
index e65614158ae8ac1bb7058806cf4b7b19ca39d198..5742e465dd9acba02a5aee5d224c9a786dbcb3e9 100644
--- a/qt/python/mantidqt/utils/test/test_writetosignal.py
+++ b/qt/python/mantidqt/utils/test/test_writetosignal.py
@@ -23,7 +23,7 @@ import unittest
from qtpy.QtCore import QCoreApplication, QObject
# local imports
-from mantidqt.utils.qt.testing import requires_qapp
+from mantidqt.utils.qt.test import requires_qapp
from mantidqt.utils.writetosignal import WriteToSignal
diff --git a/qt/python/mantidqt/widgets/algorithmselector/test/test_algorithmselector.py b/qt/python/mantidqt/widgets/algorithmselector/test/test_algorithmselector.py
index ae0da9bbb0a345b6e979513582c72ddab9d321f8..c346fd1266bd52a75c11d2f2206a298cd5ad8089 100644
--- a/qt/python/mantidqt/widgets/algorithmselector/test/test_algorithmselector.py
+++ b/qt/python/mantidqt/widgets/algorithmselector/test/test_algorithmselector.py
@@ -23,7 +23,7 @@ import unittest
from qtpy.QtCore import Qt
from qtpy.QtTest import QTest
-from mantidqt.utils.qt.testing import requires_qapp, select_item_in_combo_box, select_item_in_tree
+from mantidqt.utils.qt.test import requires_qapp, select_item_in_combo_box, select_item_in_tree
from mantidqt.widgets.algorithmselector.model import AlgorithmSelectorModel
from mantidqt.widgets.algorithmselector.widget import AlgorithmSelectorWidget
diff --git a/qt/python/mantidqt/widgets/codeeditor/test/test_codeeditor.py b/qt/python/mantidqt/widgets/codeeditor/test/test_codeeditor.py
index 933547f4e0c0de6cef74fd06ff31cc0c647a8e18..63887f2d8a8d39c8a1d810ae058b4fbfe5eee833 100644
--- a/qt/python/mantidqt/widgets/codeeditor/test/test_codeeditor.py
+++ b/qt/python/mantidqt/widgets/codeeditor/test/test_codeeditor.py
@@ -21,7 +21,7 @@ import unittest
# local imports
from mantidqt.widgets.codeeditor.editor import CodeEditor
-from mantidqt.utils.qt.testing import requires_qapp
+from mantidqt.utils.qt.test import requires_qapp
TEST_LANG = "Python"
diff --git a/qt/python/mantidqt/widgets/codeeditor/test/test_execution.py b/qt/python/mantidqt/widgets/codeeditor/test/test_execution.py
index b0d6a5b7865644ca2882d7d21827ba53437ce2ab..9c202e8f99e65d258fec3ce06dd71e0074acd025 100644
--- a/qt/python/mantidqt/widgets/codeeditor/test/test_execution.py
+++ b/qt/python/mantidqt/widgets/codeeditor/test/test_execution.py
@@ -23,7 +23,7 @@ import unittest
from qtpy.QtCore import QCoreApplication, QObject
# local imports
-from mantidqt.utils.qt.testing import requires_qapp
+from mantidqt.utils.qt.test import requires_qapp
from mantidqt.widgets.codeeditor.execution import PythonCodeExecution
@@ -75,9 +75,9 @@ class PythonCodeExecutionTest(unittest.TestCase):
def test_execute_places_output_in_globals(self):
code = "_local=100"
user_globals = self._verify_serial_execution_successful(code)
- self.assertEquals(100, user_globals['_local'])
+ self.assertEqual(100, user_globals['_local'])
user_globals = self._verify_async_execution_successful(code)
- self.assertEquals(100, user_globals['_local'])
+ self.assertEqual(100, user_globals['_local'])
def test_execute_async_calls_success_signal_on_completion(self):
code = "x=1+2"
diff --git a/qt/python/mantidqt/widgets/codeeditor/test/test_interpreter.py b/qt/python/mantidqt/widgets/codeeditor/test/test_interpreter.py
index 18cfbb0d85db0bec0e740485ff0572b9750ba0c6..43956c43a5659fb2963b15b8010c2715a1329565 100644
--- a/qt/python/mantidqt/widgets/codeeditor/test/test_interpreter.py
+++ b/qt/python/mantidqt/widgets/codeeditor/test/test_interpreter.py
@@ -24,7 +24,7 @@ import six
# local imports
from mantidqt.widgets.codeeditor.interpreter import PythonFileInterpreter
-from mantidqt.utils.qt.testing import requires_qapp
+from mantidqt.utils.qt.test import requires_qapp
if six.PY2:
import mock
diff --git a/qt/python/mantidqt/widgets/codeeditor/test/test_multifileinterpreter.py b/qt/python/mantidqt/widgets/codeeditor/test/test_multifileinterpreter.py
index 2122b51f23169e5cdd40d11ce8fe7bc9426ba3e6..c152e31c23da4dab3d83092c5f1e8451f2b97c50 100644
--- a/qt/python/mantidqt/widgets/codeeditor/test/test_multifileinterpreter.py
+++ b/qt/python/mantidqt/widgets/codeeditor/test/test_multifileinterpreter.py
@@ -22,7 +22,7 @@ import unittest
# third-party library imports
# local imports
-from mantidqt.utils.qt.testing import requires_qapp
+from mantidqt.utils.qt.test import requires_qapp
from mantidqt.widgets.codeeditor.multifileinterpreter import MultiPythonFileInterpreter
diff --git a/qt/python/mantidqt/widgets/test/test_jupyterconsole.py b/qt/python/mantidqt/widgets/test/test_jupyterconsole.py
index b102633b5c92652eb504ccb9f5c5a09dce04a367..c13e8e3c877e1843b54e57fae112bb60eb4b09cf 100644
--- a/qt/python/mantidqt/widgets/test/test_jupyterconsole.py
+++ b/qt/python/mantidqt/widgets/test/test_jupyterconsole.py
@@ -26,7 +26,7 @@ from qtpy import QT_VERSION
# local package imports
from mantidqt.widgets.jupyterconsole import InProcessJupyterConsole
-from mantidqt.utils.qt.testing import requires_qapp
+from mantidqt.utils.qt.test import requires_qapp
PRE_IPY5_PY3_QT5 = (sys.version_info.major == 3 and IPython.version_info[0] < 5 and int(QT_VERSION[0]) == 5)
diff --git a/qt/python/mantidqt/widgets/test/test_messagedisplay.py b/qt/python/mantidqt/widgets/test/test_messagedisplay.py
index 01a2fc1287d9ef0367e118ce9a69ebe7ca346757..665d73c88c00d3c3026ec0cfc86196af4b5e82f6 100644
--- a/qt/python/mantidqt/widgets/test/test_messagedisplay.py
+++ b/qt/python/mantidqt/widgets/test/test_messagedisplay.py
@@ -20,7 +20,7 @@ from __future__ import (absolute_import, division, print_function,
import unittest
from mantidqt.widgets.messagedisplay import MessageDisplay
-from mantidqt.utils.qt.testing import requires_qapp
+from mantidqt.utils.qt.test import requires_qapp
@requires_qapp
diff --git a/qt/python/mantidqt/widgets/workspacewidget/test/test_workspacetreewidget.py b/qt/python/mantidqt/widgets/workspacewidget/test/test_workspacetreewidget.py
index c58f0c263fc8320d25b9cd3ba5303a9e8f2b3158..bcd52c80976fb17b152005878e17cc4fbbf190c1 100644
--- a/qt/python/mantidqt/widgets/workspacewidget/test/test_workspacetreewidget.py
+++ b/qt/python/mantidqt/widgets/workspacewidget/test/test_workspacetreewidget.py
@@ -19,7 +19,7 @@ from __future__ import absolute_import, print_function
import unittest
from mantidqt.widgets.workspacewidget.workspacetreewidget import WorkspaceTreeWidget
-from mantidqt.utils.qt.testing import requires_qapp
+from mantidqt.utils.qt.test import requires_qapp
@requires_qapp
diff --git a/qt/python/mantidqt/widgets/workspacewidget/workspacetreewidget.py b/qt/python/mantidqt/widgets/workspacewidget/workspacetreewidget.py
index f8fee5faa670f553f8595f478f3c8bcfede1c4c5..fbb7909906199c03ac31c44a3635f487a6f71d2f 100644
--- a/qt/python/mantidqt/widgets/workspacewidget/workspacetreewidget.py
+++ b/qt/python/mantidqt/widgets/workspacewidget/workspacetreewidget.py
@@ -24,5 +24,5 @@ from __future__ import (absolute_import, unicode_literals)
from mantidqt.utils.qt import import_qt
-WorkspaceTreeWidget = import_qt('.._common', 'mantidqt.widgets.workspacewidget',
+WorkspaceTreeWidget = import_qt('..._common', 'mantidqt.widgets.workspacewidget',
'WorkspaceTreeWidgetSimple')
diff --git a/qt/python/setup.py b/qt/python/setup.py.in
similarity index 70%
rename from qt/python/setup.py
rename to qt/python/setup.py.in
index bdfe7f9bd16f6f1e16d2ca037f09879741805526..12ed9d606069c5e990b1b74048429d6fd1ddb27d 100644
--- a/qt/python/setup.py
+++ b/qt/python/setup.py.in
@@ -16,9 +16,15 @@
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
-from setuptools import setup
+from setuptools import find_packages, setup
+
+@SETUPTOOLS_BUILD_COMMANDS_DEF@
# The most basic setup possible to be able to use setup.py develop
setup(
- name="mantidqt",
+ name='mantidqt', # must match what is required by workbench setup.py
+ version='@VERSION_MAJOR@.@VERSION_MINOR@.@VERSION_PATCH@',
+ packages=find_packages(exclude=['*.test']),
+ package_data={'mantidqt': ['dialogs/*.ui']},
+ @SETUPTOOLS_BUILD_COMMANDS_USE@
)
diff --git a/qt/scientific_interfaces/ISISReflectometry/ReflSettingsWidget.ui b/qt/scientific_interfaces/ISISReflectometry/ReflSettingsWidget.ui
index b4fa1771b3f37e92df09d3476f80063a0546e931..b30520a301b423006cb0c7f9c98066ed29824680 100644
--- a/qt/scientific_interfaces/ISISReflectometry/ReflSettingsWidget.ui
+++ b/qt/scientific_interfaces/ISISReflectometry/ReflSettingsWidget.ui
@@ -364,7 +364,7 @@
<widget class="QWidget" name="pageParamFile">
<layout class="QHBoxLayout" name="horizontalLayout_3">
<item>
- <widget class="QLabel" name="label">
+ <widget class="QLabel" name="parametersLabel">
<property name="text">
<string>Use parameters from the instrument parameter file</string>
</property>
@@ -403,7 +403,7 @@
</widget>
</item>
<item row="2" column="2">
- <widget class="QLabel" name="stitchLabel">
+ <widget class="QLabel" name="includePartialBinsLabel">
<property name="text">
<string>IncludePartialBins</string>
</property>
@@ -433,14 +433,14 @@
</widget>
</item>
<item row="7" column="0">
- <widget class="QLabel" name="stitchLabel_2">
+ <widget class="QLabel" name="stitchLabel">
<property name="text">
<string>Stitch1DMany</string>
</property>
</widget>
</item>
<item row="0" column="2">
- <widget class="QLabel" name="label1">
+ <widget class="QLabel" name="debugLabel">
<property name="text">
<string>Debug</string>
</property>
diff --git a/qt/scientific_interfaces/test/ALCBaselineModellingModelTest.h b/qt/scientific_interfaces/test/ALCBaselineModellingModelTest.h
index 481b80dada920491c4654e9b25418bbf8342c169..6e5908793beca53fdc8d74302b95a0c53b1ba0a3 100644
--- a/qt/scientific_interfaces/test/ALCBaselineModellingModelTest.h
+++ b/qt/scientific_interfaces/test/ALCBaselineModellingModelTest.h
@@ -8,7 +8,6 @@
#include "MantidAPI/ITableWorkspace.h"
#include "MantidAPI/MatrixWorkspace.h"
#include "MantidAPI/WorkspaceFactory.h"
-#include "MantidTestHelpers/HistogramDataTestHelper.h"
#include "../Muon/ALCBaselineModellingModel.h"
diff --git a/qt/scientific_interfaces/test/EnggVanadiumCorrectionsModelTest.h b/qt/scientific_interfaces/test/EnggVanadiumCorrectionsModelTest.h
index a595f1e56aae5fbdcd1495f524149bc51bfbe179..e9f4fe9144bf8d0d453a535b71b7c60118f3ed85 100644
--- a/qt/scientific_interfaces/test/EnggVanadiumCorrectionsModelTest.h
+++ b/qt/scientific_interfaces/test/EnggVanadiumCorrectionsModelTest.h
@@ -7,7 +7,6 @@
#include "MantidAPI/FrameworkManager.h"
#include "MantidAPI/TableRow.h"
#include "MantidAPI/WorkspaceFactory.h"
-#include "MantidTestHelpers/HistogramDataTestHelper.h"
#include "MantidTestHelpers/WorkspaceCreationHelper.h"
#include <Poco/File.h>
diff --git a/qt/widgets/common/CMakeLists.txt b/qt/widgets/common/CMakeLists.txt
index 58323bb8d146747ce0b1eea469939e39b426d508..2783cc5b2400bd7457126257969078b2630873fe 100644
--- a/qt/widgets/common/CMakeLists.txt
+++ b/qt/widgets/common/CMakeLists.txt
@@ -531,6 +531,8 @@ mtd_add_qt_library (TARGET_NAME MantidQtWidgetsCommon
Qt5::PrintSupport
${_webwidgets_tgt}
Qt5::Qscintilla
+ INSTALL_DIR
+ ${LIB_DIR}
OSX_INSTALL_RPATH
@loader_path/../MacOS
@loader_path/../Libraries
diff --git a/qt/widgets/common/inc/MantidQtWidgets/Common/AlgorithmDialog.h b/qt/widgets/common/inc/MantidQtWidgets/Common/AlgorithmDialog.h
index b76d2429daad9e78f8a4296c20cecf314cbce613..56ae4633890d5913f0ff6a35d7b1b4651896159a 100644
--- a/qt/widgets/common/inc/MantidQtWidgets/Common/AlgorithmDialog.h
+++ b/qt/widgets/common/inc/MantidQtWidgets/Common/AlgorithmDialog.h
@@ -252,7 +252,7 @@ protected:
/// argument
/// @param propName :: Name of the property
/// @return Previous value. If there is no value, empty string is returned
- QString getPreviousValue(const QString &propName);
+ QString getPreviousValue(const QString &propName) const;
/// Set a value based on any old input that we have
void setPreviousValue(QWidget *widget, const QString &property);
/// Handle completion of algorithm started while staying open
diff --git a/qt/widgets/common/inc/MantidQtWidgets/Common/AlgorithmInputHistory.h b/qt/widgets/common/inc/MantidQtWidgets/Common/AlgorithmInputHistory.h
index 2c603a16b5a0ab89270bd5a0d0e52e63a944ecf5..10af9a0808a4e585692bb491f3bdbb3d7f5ce6a6 100644
--- a/qt/widgets/common/inc/MantidQtWidgets/Common/AlgorithmInputHistory.h
+++ b/qt/widgets/common/inc/MantidQtWidgets/Common/AlgorithmInputHistory.h
@@ -6,6 +6,7 @@
//----------------------------------
#include "DllOption.h"
#include "MantidKernel/SingletonHolder.h"
+#include "MantidQtWidgets/Common/Configurable.h"
#include <QHash>
#include <QString>
@@ -33,7 +34,8 @@ namespace API {
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
-class EXPORT_OPT_MANTIDQT_COMMON AbstractAlgorithmInputHistory {
+class EXPORT_OPT_MANTIDQT_COMMON AbstractAlgorithmInputHistory
+ : public MantidWidgets::Configurable {
public:
AbstractAlgorithmInputHistory(const AbstractAlgorithmInputHistory &) = delete;
AbstractAlgorithmInputHistory &
@@ -63,6 +65,12 @@ public:
/// Save the values stored here to persistent storage
void save() const;
+ /// @copydoc MantidWidgets::Configurable::readSettings
+ void readSettings(const QSettings &storage) override;
+
+ /// @copydoc MantidWidgets::Configurable::writeSettings
+ void writeSettings(QSettings &storage) const override;
+
protected:
/// Constructor
AbstractAlgorithmInputHistory(QString settingsGroup);
diff --git a/qt/widgets/common/inc/MantidQtWidgets/Common/Configurable.h b/qt/widgets/common/inc/MantidQtWidgets/Common/Configurable.h
index 5498ae9bb87eba52fe98bfdedaf29cb6810b523f..46970f15207908c152068738e968fe5abbcee220 100644
--- a/qt/widgets/common/inc/MantidQtWidgets/Common/Configurable.h
+++ b/qt/widgets/common/inc/MantidQtWidgets/Common/Configurable.h
@@ -41,7 +41,7 @@ class EXPORT_OPT_MANTIDQT_COMMON Configurable {
public:
virtual ~Configurable() = default;
virtual void readSettings(const QSettings &) = 0;
- virtual void writeSettings(QSettings *) = 0;
+ virtual void writeSettings(QSettings &) const = 0;
};
} // namespace MantidWidgets
} // namespace MantidQt
diff --git a/qt/widgets/common/inc/MantidQtWidgets/Common/MessageDisplay.h b/qt/widgets/common/inc/MantidQtWidgets/Common/MessageDisplay.h
index 5b548f600a2583820f25c22b78c58028a65d9c90..6e3b14cc63f3c2b4c8e230adc59923dfdb0a3868 100644
--- a/qt/widgets/common/inc/MantidQtWidgets/Common/MessageDisplay.h
+++ b/qt/widgets/common/inc/MantidQtWidgets/Common/MessageDisplay.h
@@ -42,7 +42,7 @@ class EXPORT_OPT_MANTIDQT_COMMON MessageDisplay : public QWidget,
public:
// Configurable interface
void readSettings(const QSettings &storage) override;
- void writeSettings(QSettings *storage) override;
+ void writeSettings(QSettings &storage) const override;
public:
/// Default constructor with optional parent
diff --git a/qt/widgets/common/inc/MantidQtWidgets/Common/ScriptEditor.h b/qt/widgets/common/inc/MantidQtWidgets/Common/ScriptEditor.h
index 4c4287ccf83a04c74b0a3d6d7f04a540328d8136..6228f18b215739ed50f8e12c7bb7511d190e7931 100644
--- a/qt/widgets/common/inc/MantidQtWidgets/Common/ScriptEditor.h
+++ b/qt/widgets/common/inc/MantidQtWidgets/Common/ScriptEditor.h
@@ -17,6 +17,7 @@ class FindReplaceDialog;
class QAction;
class QMenu;
+class QMimeData;
class QKeyEvent;
class QMouseEvent;
class QsciAPIs;
@@ -158,6 +159,8 @@ protected:
void dropEvent(QDropEvent *de) override;
void dragMoveEvent(QDragMoveEvent *de) override;
void dragEnterEvent(QDragEnterEvent *de) override;
+ QByteArray fromMimeData(const QMimeData *source,
+ bool &rectangular) const override;
private slots:
diff --git a/qt/widgets/common/src/AlgorithmDialog.cpp b/qt/widgets/common/src/AlgorithmDialog.cpp
index 872f92a818b4cd59e7969c750757dc82bdddb5ff..a9c97719c5a58f165adc318c543327d1f864655c 100644
--- a/qt/widgets/common/src/AlgorithmDialog.cpp
+++ b/qt/widgets/common/src/AlgorithmDialog.cpp
@@ -944,7 +944,7 @@ QString AlgorithmDialog::getValue(QWidget *widget) {
}
}
-QString AlgorithmDialog::getPreviousValue(const QString &propName) {
+QString AlgorithmDialog::getPreviousValue(const QString &propName) const {
QString value;
if (!isForScript()) {
diff --git a/qt/widgets/common/src/AlgorithmInputHistory.cpp b/qt/widgets/common/src/AlgorithmInputHistory.cpp
index da3a9730bfea91b8a3700d04d90605c7854782bc..fbbe2e7417808a92489acd1aaf708e9dbf84fa09 100644
--- a/qt/widgets/common/src/AlgorithmInputHistory.cpp
+++ b/qt/widgets/common/src/AlgorithmInputHistory.cpp
@@ -93,26 +93,60 @@ const QString &AbstractAlgorithmInputHistory::getPreviousDirectory() const {
*/
void AbstractAlgorithmInputHistory::save() const {
QSettings settings;
- settings.beginGroup(m_algorithmsGroup);
+ this->writeSettings(settings);
+}
+
+void AbstractAlgorithmInputHistory::readSettings(const QSettings &storage) {
+ // unfortunately QSettings does not allow const when using beginGroup and
+ // endGroup
+ m_lastInput.clear();
+ const_cast<QSettings &>(storage).beginGroup(m_algorithmsGroup);
+ // QStringList algorithms = settings.childGroups();
+ QListIterator<QString> algNames(storage.childGroups());
+
+ // Each property is a key of the algorithm group
+ while (algNames.hasNext()) {
+ QHash<QString, QString> algorithmProperties;
+ QString group = algNames.next();
+ const_cast<QSettings &>(storage).beginGroup(group);
+ QListIterator<QString> properties(storage.childKeys());
+ while (properties.hasNext()) {
+ QString propName = properties.next();
+ QString value = storage.value(propName).toString();
+ if (!value.isEmpty())
+ algorithmProperties.insert(propName, value);
+ }
+ m_lastInput.insert(group, algorithmProperties);
+ const_cast<QSettings &>(storage).endGroup();
+ }
+
+ // The previous dir
+ m_previousDirectory = storage.value(m_dirKey).toString();
+
+ const_cast<QSettings &>(storage).endGroup();
+}
+
+void AbstractAlgorithmInputHistory::writeSettings(QSettings &storage) const {
+ storage.beginGroup(m_algorithmsGroup);
QHashIterator<QString, QHash<QString, QString>> inputHistory(m_lastInput);
while (inputHistory.hasNext()) {
inputHistory.next();
- settings.beginGroup(inputHistory.key());
+ storage.beginGroup(inputHistory.key());
// Remove all keys for this group that exist at the moment
- settings.remove("");
+ storage.remove("");
QHash<QString, QString>::const_iterator iend = inputHistory.value().end();
for (QHash<QString, QString>::const_iterator itr =
inputHistory.value().begin();
itr != iend; ++itr) {
- settings.setValue(itr.key(), itr.value());
+ storage.setValue(itr.key(), itr.value());
}
- settings.endGroup();
+ storage.endGroup();
}
// Store the previous directory
- settings.setValue(m_dirKey, m_previousDirectory);
+ storage.setValue(m_dirKey, m_previousDirectory);
- settings.endGroup();
+ storage.endGroup();
}
//----------------------------------
@@ -124,30 +158,6 @@ void AbstractAlgorithmInputHistory::save() const {
* clears all currently values stored
*/
void AbstractAlgorithmInputHistory::load() {
- m_lastInput.clear();
QSettings settings;
- settings.beginGroup(m_algorithmsGroup);
- // QStringList algorithms = settings.childGroups();
- QListIterator<QString> algNames(settings.childGroups());
-
- // Each property is a key of the algorithm group
- while (algNames.hasNext()) {
- QHash<QString, QString> algorithmProperties;
- QString group = algNames.next();
- settings.beginGroup(group);
- QListIterator<QString> properties(settings.childKeys());
- while (properties.hasNext()) {
- QString propName = properties.next();
- QString value = settings.value(propName).toString();
- if (!value.isEmpty())
- algorithmProperties.insert(propName, value);
- }
- m_lastInput.insert(group, algorithmProperties);
- settings.endGroup();
- }
-
- // The previous dir
- m_previousDirectory = settings.value(m_dirKey).toString();
-
- settings.endGroup();
+ this->readSettings(settings);
}
diff --git a/qt/widgets/common/src/MantidTreeWidget.cpp b/qt/widgets/common/src/MantidTreeWidget.cpp
index 0b18d9debfcdf2eaffad098a3bfeee8aa6d4d5b8..f46559d17962d8cfc266e70cc61a00966c68b3f5 100644
--- a/qt/widgets/common/src/MantidTreeWidget.cpp
+++ b/qt/widgets/common/src/MantidTreeWidget.cpp
@@ -105,30 +105,18 @@ void MantidTreeWidget::mouseMoveEvent(QMouseEvent *e) {
QApplication::startDragDistance())
return;
- // Start dragging
- QDrag *drag = new QDrag(this);
- QMimeData *mimeData = new QMimeData;
-
- QStringList wsnames = getSelectedWorkspaceNames();
- if (wsnames.size() == 0)
+ QStringList wsNames = getSelectedWorkspaceNames();
+ if (wsNames.isEmpty())
return;
- QString importStatement = "";
- foreach (const QString wsname, wsnames) {
- QString prefix = "";
- if (wsname[0].isDigit())
- prefix = "ws";
- if (importStatement.size() > 0)
- importStatement += "\n";
- importStatement += prefix + wsname + " = mtd[\"" + wsname + "\"]";
- }
-
- mimeData->setText(importStatement);
- mimeData->setObjectName("MantidWorkspace");
+ // Start dragging - Qt docs say not to delete the QDrag object
+ // manually
+ QDrag *drag = new QDrag(this);
+ QMimeData *mimeData = new QMimeData;
drag->setMimeData(mimeData);
-
- Qt::DropAction dropAction = drag->exec(Qt::CopyAction | Qt::MoveAction);
- (void)dropAction;
+ mimeData->setObjectName("MantidWorkspace");
+ mimeData->setText(wsNames.join("\n"));
+ drag->exec(Qt::CopyAction | Qt::MoveAction);
}
void MantidTreeWidget::mouseDoubleClickEvent(QMouseEvent *e) {
diff --git a/qt/widgets/common/src/MessageDisplay.cpp b/qt/widgets/common/src/MessageDisplay.cpp
index b2a818117327a2add9c9cb271caefbf3b96c589e..50c261b79d19a72cb8464093173a2504cbdb21ec 100644
--- a/qt/widgets/common/src/MessageDisplay.cpp
+++ b/qt/widgets/common/src/MessageDisplay.cpp
@@ -53,9 +53,8 @@ void MessageDisplay::readSettings(const QSettings &storage) {
* @param storage A pointer to an existing QSettings instance opened
* at the group where the values should be stored.
*/
-void MessageDisplay::writeSettings(QSettings *storage) {
- Q_ASSERT(storage);
- storage->setValue("MessageDisplayPriority", Poco::Logger::root().getLevel());
+void MessageDisplay::writeSettings(QSettings &storage) const {
+ storage.setValue("MessageDisplayPriority", Poco::Logger::root().getLevel());
}
/**
diff --git a/qt/widgets/common/src/MuonFitPropertyBrowser.cpp b/qt/widgets/common/src/MuonFitPropertyBrowser.cpp
index 0f583c6c95b0ba88d3cea7047475cd80335176e9..243dc4aadce2c2c5c95eb00867e97a8cc128cd1f 100644
--- a/qt/widgets/common/src/MuonFitPropertyBrowser.cpp
+++ b/qt/widgets/common/src/MuonFitPropertyBrowser.cpp
@@ -872,7 +872,6 @@ void MuonFitPropertyBrowser::showEvent(QShowEvent *e) {
* @param ws :: The workspace
*/
bool MuonFitPropertyBrowser::isWorkspaceValid(Workspace_sptr ws) const {
- auto fsad = ws->getName();
QString workspaceName(QString::fromStdString(ws->getName()));
if ((workspaceName.contains("_Raw")) ||
@@ -944,6 +943,11 @@ void MuonFitPropertyBrowser::finishHandleTF(const IAlgorithm *alg) {
std::vector<std::string> wsList =
alg->getProperty("UnNormalizedWorkspaceList");
emit fittingDone(QString::fromStdString(wsList[0]));
+ double quality = alg->getProperty("ChiSquared");
+ // std::string costFunction =
+
+ emit changeWindowTitle(QString("Fit Function (") + "Chi-sq " + " = " +
+ QString::number(quality) + ", " + status + ")");
if (nWorkspaces == 1) {
emit algorithmFinished(QString::fromStdString(wsList[0] + "_workspace"));
}
@@ -1170,7 +1174,7 @@ void MuonFitPropertyBrowser::ConvertFitFunctionForMuonTFAsymmetry(
boost::dynamic_pointer_cast<IFunction>(m_compositeFunction);
QStringList globals;
- if (enabled && m_isMultiFittingMode) {
+ if (m_isMultiFittingMode) {
// manually set the function values
old = m_functionBrowser->getGlobalFunction();
globals = m_functionBrowser->getGlobalParameters();
diff --git a/qt/widgets/common/src/ScriptEditor.cpp b/qt/widgets/common/src/ScriptEditor.cpp
index 4f27612803ffa5740c9766d5d9d855e5c8104a4e..ccac7fda8b66c5650c0884d8b20671e74a327f80 100644
--- a/qt/widgets/common/src/ScriptEditor.cpp
+++ b/qt/widgets/common/src/ScriptEditor.cpp
@@ -413,9 +413,22 @@ void ScriptEditor::dragMoveEvent(QDragMoveEvent *de) {
* @param de :: The drag enter event
*/
void ScriptEditor::dragEnterEvent(QDragEnterEvent *de) {
- if (!de->mimeData()->hasUrls())
- // pass to base class - This handles text appropriately
+ if (!de->mimeData()->hasUrls()) {
QsciScintilla::dragEnterEvent(de);
+ }
+}
+
+/**
+ * If the QMimeData object holds workspaces names then extract text from a
+ * QMimeData object and add the necessary wrapping text to import mantid.
+ * @param source An existing QMimeData object
+ * @param rectangular On return rectangular is set if the text corresponds to a
+ * rectangular selection.
+ * @return The text
+ */
+QByteArray ScriptEditor::fromMimeData(const QMimeData *source,
+ bool &rectangular) const {
+ return QsciScintilla::fromMimeData(source, rectangular);
}
/**
@@ -423,11 +436,10 @@ void ScriptEditor::dragEnterEvent(QDragEnterEvent *de) {
* @param de :: The drag drop event
*/
void ScriptEditor::dropEvent(QDropEvent *de) {
- QStringList filenames;
- const QMimeData *mimeData = de->mimeData();
- if (!mimeData->hasUrls()) {
+ if (!de->mimeData()->hasUrls()) {
+ QDropEvent localDrop(*de);
// pass to base class - This handles text appropriately
- QsciScintilla::dropEvent(de);
+ QsciScintilla::dropEvent(&localDrop);
}
}
diff --git a/qt/widgets/common/src/WorkspacePresenter/WorkspaceTreeWidgetSimple.cpp b/qt/widgets/common/src/WorkspacePresenter/WorkspaceTreeWidgetSimple.cpp
index f0f02481484e227a7277b24d879bbbbac2bbecc1..f73e0022f362e469bef361265c62cb5fa5a4309a 100644
--- a/qt/widgets/common/src/WorkspacePresenter/WorkspaceTreeWidgetSimple.cpp
+++ b/qt/widgets/common/src/WorkspacePresenter/WorkspaceTreeWidgetSimple.cpp
@@ -58,17 +58,26 @@ void WorkspaceTreeWidgetSimple::popupContextMenu() {
menu = new QMenu(this);
menu->setObjectName("WorkspaceContextMenu");
- // plot submenu first
- QMenu *plotSubMenu(new QMenu("Plot", menu));
- plotSubMenu->addAction(m_plotSpectrum);
- plotSubMenu->addAction(m_overplotSpectrum);
- plotSubMenu->addAction(m_plotSpectrumWithErrs);
- plotSubMenu->addAction(m_overplotSpectrumWithErrs);
- plotSubMenu->addSeparator();
- plotSubMenu->addAction(m_plotColorfill);
- menu->addMenu(plotSubMenu);
-
- menu->addSeparator();
+ // plot submenu first for MatrixWorkspace.
+ // Check is defensive just in case the workspace has disappeared
+ Workspace_sptr workspace;
+ try {
+ workspace = AnalysisDataService::Instance().retrieve(
+ selectedWsName.toStdString());
+ } catch (Exception::NotFoundError &) {
+ return;
+ }
+ if (boost::dynamic_pointer_cast<MatrixWorkspace>(workspace)) {
+ QMenu *plotSubMenu(new QMenu("Plot", menu));
+ plotSubMenu->addAction(m_plotSpectrum);
+ plotSubMenu->addAction(m_overplotSpectrum);
+ plotSubMenu->addAction(m_plotSpectrumWithErrs);
+ plotSubMenu->addAction(m_overplotSpectrumWithErrs);
+ plotSubMenu->addSeparator();
+ plotSubMenu->addAction(m_plotColorfill);
+ menu->addMenu(plotSubMenu);
+ menu->addSeparator();
+ }
menu->addAction(m_rename);
menu->addAction(m_saveNexus);
diff --git a/qt/widgets/common/test/DataProcessorUI/QOneLevelTreeModelTest.h b/qt/widgets/common/test/DataProcessorUI/QOneLevelTreeModelTest.h
index 8f6600b9915d58c2dd53544aec29b44d0e0cf0bc..1b4781825063e60bb674e81b1764ecf4d0d113c6 100644
--- a/qt/widgets/common/test/DataProcessorUI/QOneLevelTreeModelTest.h
+++ b/qt/widgets/common/test/DataProcessorUI/QOneLevelTreeModelTest.h
@@ -14,6 +14,12 @@ using namespace Mantid::API;
class QOneLevelTreeModelTest : public CxxTest::TestSuite {
public:
+ // This means the constructor isn't called when running other tests
+ static QOneLevelTreeModelTest *createSuite() {
+ return new QOneLevelTreeModelTest();
+ }
+ static void destroySuite(QOneLevelTreeModelTest *suite) { delete suite; }
+
// Create a white list
QOneLevelTreeModelTest() {
m_whitelist.addElement("Column1", "Property1", "Description1");
diff --git a/qt/widgets/common/test/DataProcessorUI/QTwoLevelTreeModelTest.h b/qt/widgets/common/test/DataProcessorUI/QTwoLevelTreeModelTest.h
index 422db813088bb1c4a5ee46ff342bed0e5c05975f..95a10e16c84a8eea4bb2ac71132615408ed430be 100644
--- a/qt/widgets/common/test/DataProcessorUI/QTwoLevelTreeModelTest.h
+++ b/qt/widgets/common/test/DataProcessorUI/QTwoLevelTreeModelTest.h
@@ -12,8 +12,13 @@ using namespace MantidQt::MantidWidgets::DataProcessor;
using namespace Mantid::API;
class QTwoLevelTreeModelTest : public CxxTest::TestSuite {
-
public:
+ // This means the constructor isn't called when running other tests
+ static QTwoLevelTreeModelTest *createSuite() {
+ return new QTwoLevelTreeModelTest();
+ }
+ static void destroySuite(QTwoLevelTreeModelTest *suite) { delete suite; }
+
// Constructor (initializes whitelist)
QTwoLevelTreeModelTest() {
m_whitelist.addElement("Column1", "Property1", "Description1");
diff --git a/qt/widgets/factory/CMakeLists.txt b/qt/widgets/factory/CMakeLists.txt
index 1f6dd12c4dd5f92a61183efd198fe9f8f009c656..be29eaa80bbf78bafb8fd38dcf5315a5bfe24b1b 100644
--- a/qt/widgets/factory/CMakeLists.txt
+++ b/qt/widgets/factory/CMakeLists.txt
@@ -6,11 +6,11 @@ set ( INC_FILES
inc/MantidQtWidgets/Factory/WidgetFactory.h
)
-set ( MOC_FILES
+set ( MOC_FILES
inc/MantidQtWidgets/Factory/WidgetFactory.h
)
-set ( UI_FILES
+set ( UI_FILES
)
set ( TEST_FILES
@@ -37,7 +37,8 @@ mtd_add_qt_library (TARGET_NAME MantidQtWidgetsFactory
MantidQtWidgetsCommon
MantidQtWidgetsLegacyQwt
MantidQtWidgetsSliceViewer
+ INSTALL_DIR
+ ${LIB_DIR}
LINUX_INSTALL_RPATH
"\$ORIGIN/../${LIB_DIR}"
)
-
diff --git a/qt/widgets/instrumentview/CMakeLists.txt b/qt/widgets/instrumentview/CMakeLists.txt
index a0573d09f7853c4e3fac66650aecb7591d17e045..e63d30c9986470a3c20b27e65682038b098c6534 100644
--- a/qt/widgets/instrumentview/CMakeLists.txt
+++ b/qt/widgets/instrumentview/CMakeLists.txt
@@ -135,10 +135,11 @@ mtd_add_qt_library (TARGET_NAME MantidQtWidgetsInstrumentView
MTD_QT_LINK_LIBS
MantidQtWidgetsCommon
MantidQtWidgetsLegacyQwt
+ INSTALL_DIR
+ ${LIB_DIR}
+ OSX_INSTALL_RPATH
+ @loader_path/../MacOS
+ @loader_path/../Libraries
+ LINUX_INSTALL_RPATH
+ "\$ORIGIN/../${LIB_DIR}"
)
-
-if (OSX_VERSION VERSION_GREATER 10.8)
- set_target_properties(MantidQtWidgetsInstrumentViewQt4 PROPERTIES INSTALL_RPATH "@loader_path/../MacOS;@loader_path/../Libraries")
-elseif ( ${CMAKE_SYSTEM_NAME} STREQUAL "Linux" )
- set_target_properties(MantidQtWidgetsInstrumentViewQt4 PROPERTIES INSTALL_RPATH "\$ORIGIN/../${LIB_DIR}")
-endif ()
diff --git a/qt/widgets/legacyqwt/CMakeLists.txt b/qt/widgets/legacyqwt/CMakeLists.txt
index 004a0271725b9273dc9f2c10eb9ff12b3d7d49fa..d2014997a426d7489ccd0b6ba24417b41fb93768 100644
--- a/qt/widgets/legacyqwt/CMakeLists.txt
+++ b/qt/widgets/legacyqwt/CMakeLists.txt
@@ -77,6 +77,8 @@ mtd_add_qt_library (TARGET_NAME MantidQtWidgetsLegacyQwt
Qwt5
MTD_QT_LINK_LIBS
MantidQtWidgetsCommon
+ INSTALL_DIR
+ ${LIB_DIR}
OSX_INSTALL_RPATH
@loader_path/../MacOS
LINUX_INSTALL_RPATH
diff --git a/qt/widgets/plugins/algorithm_dialogs/inc/MantidQtWidgets/Plugins/AlgorithmDialogs/FitDialog.h b/qt/widgets/plugins/algorithm_dialogs/inc/MantidQtWidgets/Plugins/AlgorithmDialogs/FitDialog.h
index e17b6ce5f669da6daf94c9643e4bc66b5ab2e3cb..23018d4052bc400b8509d2d00550f94310891c8c 100644
--- a/qt/widgets/plugins/algorithm_dialogs/inc/MantidQtWidgets/Plugins/AlgorithmDialogs/FitDialog.h
+++ b/qt/widgets/plugins/algorithm_dialogs/inc/MantidQtWidgets/Plugins/AlgorithmDialogs/FitDialog.h
@@ -95,8 +95,6 @@ private:
/// Get the domain type: Simple, Sequential, or Parallel
QString getDomainTypeString() const;
- /// Return property value stored in history
- QString getStoredPropertyValue(const QString &propName) const;
/// Get allowed values for a property
QStringList getAllowedPropertyValues(const QString &propName) const;
/// Set i-th workspace name
@@ -123,7 +121,7 @@ public:
InputWorkspaceWidget(FitDialog *parent, int domainIndex = 0);
/// Return property value stored in history
QString getStoredPropertyValue(const QString &propName) const {
- return m_fitDialog->getStoredPropertyValue(propName);
+ return m_fitDialog->getPreviousValue(propName);
}
/// Get allowed values for a property
QStringList getAllowedPropertyValues(const QString &propName) const {
diff --git a/qt/widgets/plugins/algorithm_dialogs/src/FitDialog.cpp b/qt/widgets/plugins/algorithm_dialogs/src/FitDialog.cpp
index e62b200697acf0cd50627c288a7d129c740331fd..1b72c9bd7fad54f4eca9635d01f392ee6c2d6c74 100644
--- a/qt/widgets/plugins/algorithm_dialogs/src/FitDialog.cpp
+++ b/qt/widgets/plugins/algorithm_dialogs/src/FitDialog.cpp
@@ -364,7 +364,7 @@ void FitDialog::parseInput() {
* @param readHistory :: If true then the history will be re read.
*/
void FitDialog::tieStaticWidgets(const bool readHistory) {
- QString funValue = getStoredPropertyValue("Function");
+ QString funValue = getPreviousValue("Function");
if (!funValue.isEmpty()) {
m_form.function->setFunction(funValue);
}
@@ -386,7 +386,7 @@ void FitDialog::tieStaticWidgets(const bool readHistory) {
// tie(m_form.cbDomainType, "DomainType", m_form.staticLayout, readHistory);
connect(m_form.cbDomainType, SIGNAL(currentIndexChanged(int)), this,
SLOT(domainTypeChanged()));
- QString domainTypeValue = getStoredPropertyValue("DomainType");
+ QString domainTypeValue = getPreviousValue("DomainType");
if (!domainTypeValue.isEmpty()) {
m_form.cbDomainType->setItemText(-1, domainTypeValue);
}
@@ -398,7 +398,7 @@ void FitDialog::tieStaticWidgets(const bool readHistory) {
// read value from history
tie(m_form.cbMinimizer, "Minimizer", m_form.staticLayout, readHistory);
- auto value = getStoredPropertyValue("InputWorkspace");
+ auto value = getPreviousValue("InputWorkspace");
setWorkspaceName(0, value);
}
@@ -486,29 +486,6 @@ void FitDialog::functionChanged() {
// createDynamicLayout();
}
-/**
- * Return property value stored in history
- * @param propName :: A property name
- */
-QString FitDialog::getStoredPropertyValue(const QString &propName) const {
- // Get the value from either the previous input store or from Python argument
- QString value("");
- Mantid::Kernel::Property *property = getAlgorithmProperty(propName);
-
- if (!isForScript()) {
- value = m_propertyValueMap.value(propName);
- if (value.isEmpty()) {
- value =
- AlgorithmInputHistory::Instance().previousInput(m_algName, propName);
- }
- } else {
- if (!property)
- return "";
- value = m_propertyValueMap.value(propName);
- }
- return value;
-}
-
/**
* Get allowed values for a property
* @param propName :: A property name
diff --git a/qt/widgets/refdetectorview/CMakeLists.txt b/qt/widgets/refdetectorview/CMakeLists.txt
index e0f806beb037465e0332b81c78721d8cc9d769e8..2d651511e4ff97ebe1b796c514aad3f57e99f6dc 100644
--- a/qt/widgets/refdetectorview/CMakeLists.txt
+++ b/qt/widgets/refdetectorview/CMakeLists.txt
@@ -50,14 +50,14 @@ mtd_add_qt_library (TARGET_NAME MantidQtWidgetsRefDetectorView
Qwt5
MTD_QT_LINK_LIBS
MantidQtWidgetsSpectrumViewer
+ INSTALL_DIR
+ ${LIB_DIR}
+ OSX_INSTALL_RPATH
+ @loader_path/../MacOS
+ LINUX_INSTALL_RPATH
+ "\$ORIGIN/../${LIB_DIR}"
)
-if (OSX_VERSION VERSION_GREATER 10.8)
- set_target_properties( MantidQtWidgetsRefDetectorViewQt4 PROPERTIES INSTALL_RPATH "@loader_path/../MacOS")
-elseif ( ${CMAKE_SYSTEM_NAME} STREQUAL "Linux" )
- set_target_properties( MantidQtWidgetsRefDetectorViewQt4 PROPERTIES INSTALL_RPATH "\$ORIGIN/../${LIB_DIR}")
-endif ()
-
###########################################################################
# DEMO/GUI TESTING APPLICATIONS
###########################################################################
diff --git a/qt/widgets/sliceviewer/CMakeLists.txt b/qt/widgets/sliceviewer/CMakeLists.txt
index 3473c45eddebfbe39d90627bd6f1b78a7ed6fd7f..97fe4355fa4b8b60918c1bd932e04dbacc89063e 100644
--- a/qt/widgets/sliceviewer/CMakeLists.txt
+++ b/qt/widgets/sliceviewer/CMakeLists.txt
@@ -138,6 +138,8 @@ mtd_add_qt_library (TARGET_NAME MantidQtWidgetsSliceViewer
MTD_QT_LINK_LIBS
MantidQtWidgetsCommon
MantidQtWidgetsLegacyQwt
+ INSTALL_DIR
+ ${LIB_DIR}
OSX_INSTALL_RPATH
loader_path/../MacOS
LINUX_INSTALL_RPATH
diff --git a/qt/widgets/spectrumviewer/CMakeLists.txt b/qt/widgets/spectrumviewer/CMakeLists.txt
index 233088f1c7a150dfbf97d02d72335167420906f2..29f1e5638fa6335f628f8b73c36376285d81bd93 100644
--- a/qt/widgets/spectrumviewer/CMakeLists.txt
+++ b/qt/widgets/spectrumviewer/CMakeLists.txt
@@ -74,6 +74,8 @@ mtd_add_qt_library (TARGET_NAME MantidQtWidgetsSpectrumViewer
MTD_QT_LINK_LIBS
MantidQtWidgetsCommon
MantidQtWidgetsLegacyQwt
+ INSTALL_DIR
+ ${LIB_DIR}
)
if (OSX_VERSION VERSION_GREATER 10.8)
diff --git a/scripts/Diffraction/isis_powder/routines/focus.py b/scripts/Diffraction/isis_powder/routines/focus.py
index 12bf824393a51892b190dd8dff9a93817c3a71b0..ae7eda231e8a8175d2e49eace35c4e883de21a64 100644
--- a/scripts/Diffraction/isis_powder/routines/focus.py
+++ b/scripts/Diffraction/isis_powder/routines/focus.py
@@ -19,7 +19,7 @@ def focus(run_number_string, instrument, perform_vanadium_norm, absorb, sample_d
raise ValueError("Input batching not passed through. Please contact development team.")
-def _focus_one_ws(input_workspace, run_number, instrument, perform_vanadium_norm, absorb, sample_details):
+def _focus_one_ws(input_workspace, run_number, instrument, perform_vanadium_norm, absorb, sample_details, vanadium_path):
run_details = instrument._get_run_details(run_number_string=run_number)
if perform_vanadium_norm:
_test_splined_vanadium_exists(instrument, run_details)
@@ -55,9 +55,9 @@ def _focus_one_ws(input_workspace, run_number, instrument, perform_vanadium_norm
focused_ws = mantid.DiffractionFocussing(InputWorkspace=aligned_ws,
GroupingFileName=run_details.grouping_file_path)
- calibrated_spectra = _apply_vanadium_corrections(instrument=instrument, run_number=run_number,
- input_workspace=focused_ws,
- perform_vanadium_norm=perform_vanadium_norm)
+ calibrated_spectra = _apply_vanadium_corrections(input_workspace=focused_ws,
+ perform_vanadium_norm=perform_vanadium_norm,
+ vanadium_splines=vanadium_path)
output_spectra = instrument._crop_banks_to_user_tof(calibrated_spectra)
@@ -82,14 +82,13 @@ def _focus_one_ws(input_workspace, run_number, instrument, perform_vanadium_norm
return d_spacing_group
-def _apply_vanadium_corrections(instrument, run_number, input_workspace, perform_vanadium_norm):
- run_details = instrument._get_run_details(run_number_string=run_number)
+def _apply_vanadium_corrections(input_workspace, perform_vanadium_norm, vanadium_splines):
input_workspace = mantid.ConvertUnits(InputWorkspace=input_workspace, OutputWorkspace=input_workspace, Target="TOF")
split_data_spectra = common.extract_ws_spectra(input_workspace)
if perform_vanadium_norm:
processed_spectra = _divide_by_vanadium_splines(spectra_list=split_data_spectra,
- spline_file_path=run_details.splined_vanadium_file_path)
+ vanadium_splines=vanadium_splines)
else:
processed_spectra = split_data_spectra
@@ -99,11 +98,16 @@ def _apply_vanadium_corrections(instrument, run_number, input_workspace, perform
def _batched_run_focusing(instrument, perform_vanadium_norm, run_number_string, absorb, sample_details):
read_ws_list = common.load_current_normalised_ws_list(run_number_string=run_number_string,
instrument=instrument)
+ run_details = instrument._get_run_details(run_number_string=run_number_string)
+ vanadium_splines = None
+ if perform_vanadium_norm:
+ vanadium_splines = mantid.LoadNexus(Filename=run_details.splined_vanadium_file_path)
+
output = None
for ws in read_ws_list:
output = _focus_one_ws(input_workspace=ws, run_number=run_number_string, instrument=instrument,
perform_vanadium_norm=perform_vanadium_norm, absorb=absorb,
- sample_details=sample_details)
+ sample_details=sample_details, vanadium_path=vanadium_splines)
return output
@@ -113,8 +117,7 @@ def _divide_one_spectrum_by_spline(spectrum, spline):
return divided
-def _divide_by_vanadium_splines(spectra_list, spline_file_path):
- vanadium_splines = mantid.LoadNexus(Filename=spline_file_path)
+def _divide_by_vanadium_splines(spectra_list, vanadium_splines):
if hasattr(vanadium_splines, "OutputWorkspace"): # vanadium_splines is a group
vanadium_splines = vanadium_splines.OutputWorkspace
@@ -138,11 +141,16 @@ def _divide_by_vanadium_splines(spectra_list, spline_file_path):
def _individual_run_focusing(instrument, perform_vanadium_norm, run_number, absorb, sample_details):
# Load and process one by one
run_numbers = common.generate_run_numbers(run_number_string=run_number)
+ run_details = instrument._get_run_details(run_number_string=run_number)
+ vanadium_splines = None
+ if perform_vanadium_norm:
+ vanadium_splines = mantid.LoadNexus(Filename=run_details.splined_vanadium_file_path)
output = None
for run in run_numbers:
ws = common.load_current_normalised_ws_list(run_number_string=run, instrument=instrument)
output = _focus_one_ws(input_workspace=ws[0], run_number=run, instrument=instrument, absorb=absorb,
- perform_vanadium_norm=perform_vanadium_norm, sample_details=sample_details)
+ perform_vanadium_norm=perform_vanadium_norm, sample_details=sample_details,
+ vanadium_path=vanadium_splines)
return output
diff --git a/scripts/Elemental_Analysis.py b/scripts/Elemental_Analysis.py
index 1672bfaf7cb037964ff17eb131a1e86bf4fe4fc1..47471502c58dc48c215c86b58b042f9dbd027217 100644
--- a/scripts/Elemental_Analysis.py
+++ b/scripts/Elemental_Analysis.py
@@ -13,6 +13,12 @@ from Muon.GUI.Common import message_box
class ElementalAnalysisGui(QtGui.QMainWindow):
def __init__(self, parent=None):
super(ElementalAnalysisGui, self).__init__(parent)
+ self.menu = self.menuBar()
+ self.menu.addAction("File")
+ edit_menu = self.menu.addMenu("Edit")
+ edit_menu.addAction("Change Peak Data file", self.select_data_file)
+ self.menu.addAction("Binning")
+ self.menu.addAction("Normalise")
self.ptable = PeriodicTablePresenter(
PeriodicTableView(), PeriodicTableModel())
@@ -32,6 +38,11 @@ class ElementalAnalysisGui(QtGui.QMainWindow):
def table_changed(self, items):
print("Table Changed: {}".format([i.symbol for i in items]))
+ def select_data_file(self):
+ filename = str(QtGui.QFileDialog.getOpenFileName())
+ if filename:
+ self.ptable.set_peak_datafile(filename)
+
def qapp():
if QtGui.QApplication.instance():
diff --git a/scripts/Muon/GUI/Common/dummy/dummy_widget.py b/scripts/Muon/GUI/Common/dummy/dummy_widget.py
index b3a3cfcb49ee44fbae42ce62dee7871477a4fef1..fcd808085567764b33a24d9c44c7ca6e84653910 100644
--- a/scripts/Muon/GUI/Common/dummy/dummy_widget.py
+++ b/scripts/Muon/GUI/Common/dummy/dummy_widget.py
@@ -11,16 +11,16 @@ class DummyWidget(object):
def __init__(self,name,parent=None):
view=DummyView(name,parent)
model=None
- self.presenter = DummyPresenter(view,model)
+ self._presenter = DummyPresenter(view,model)
@property
def presenter(self):
- return self.presenter
+ return self._presenter
@property
def widget(self):
- return self.presenter.widget
+ return self._presenter.widget
def setButtonConnection(self,slot):
- view=self.presenter.widget
+ view=self._presenter.widget
view.buttonSignal.connect(slot)
diff --git a/scripts/Muon/GUI/ElementalAnalysis/PeriodicTable/periodic_table.py b/scripts/Muon/GUI/ElementalAnalysis/PeriodicTable/periodic_table.py
index b6e6b7fa5b4bc9bdbeabfd3751f8cd75668b8a76..2b2d0fe5b5ca529467bd0cebc41f93f7b4b04397 100644
--- a/scripts/Muon/GUI/ElementalAnalysis/PeriodicTable/periodic_table.py
+++ b/scripts/Muon/GUI/ElementalAnalysis/PeriodicTable/periodic_table.py
@@ -306,7 +306,7 @@ class _ElementButton(qt.QPushButton):
self.customContextMenuRequested.connect(self.rightClickedSlot)
def sizeHint(self):
- return QtCore.QSize(40, 40)
+ return QtCore.QSize(30, 30)
def setCurrent(self, b):
"""Set this element button as current.
@@ -496,6 +496,12 @@ class PeriodicTable(qt.QWidget):
self.__addElement(elmt)
self.elements = elements
+ def silentSetElementSelected(self, symbol, state):
+ """
+ Identical to setElementSelected, but doesn't emit sigSelectionChanged
+ """
+ self._eltButtons[symbol].setSelected(state)
+
def enableElementButton(self, element):
try:
self._eltButtons[element].setEnabled(True)
diff --git a/scripts/Muon/GUI/ElementalAnalysis/PeriodicTable/periodic_table_model.py b/scripts/Muon/GUI/ElementalAnalysis/PeriodicTable/periodic_table_model.py
index 41446d65b5ea09b7fab5d25ebfb159f67fd90ede..50f2fbec26967f47ca6ffb528676af4259df2881 100644
--- a/scripts/Muon/GUI/ElementalAnalysis/PeriodicTable/periodic_table_model.py
+++ b/scripts/Muon/GUI/ElementalAnalysis/PeriodicTable/periodic_table_model.py
@@ -3,7 +3,6 @@ from __future__ import print_function, absolute_import
import os
import json
-from Muon.GUI.Common import message_box
from Muon.GUI import ElementalAnalysis
@@ -19,11 +18,8 @@ class PeriodicTableModel(object):
def load_peak_data(self):
# using os.path.isfile allows file modifications to take place before opening:
# we don't want this.
- try:
- with open(self._peak_data_file, "r") as f:
- self._peak_data = json.load(f)
- except Exception as error:
- message_box.warning(error)
+ with open(self._peak_data_file, "r") as f:
+ self._peak_data = json.load(f)
@property
def peak_data(self):
diff --git a/scripts/Muon/GUI/ElementalAnalysis/PeriodicTable/periodic_table_presenter.py b/scripts/Muon/GUI/ElementalAnalysis/PeriodicTable/periodic_table_presenter.py
index 62a59ff7185d6753cd02bd5e6ecd109be09cb51a..d7833f123fcfec393e22ad7b2a99ec91a56587a1 100644
--- a/scripts/Muon/GUI/ElementalAnalysis/PeriodicTable/periodic_table_presenter.py
+++ b/scripts/Muon/GUI/ElementalAnalysis/PeriodicTable/periodic_table_presenter.py
@@ -1,5 +1,7 @@
from __future__ import print_function
+from Muon.GUI.Common import message_box
+
class PeriodicTablePresenter(object):
def __init__(self, view, model):
@@ -17,6 +19,7 @@ class PeriodicTablePresenter(object):
def set_buttons(self):
for el in self.view.ptable.elements:
+ self.view.ptable.silentSetElementSelected(el.symbol, False)
if el.symbol in self.model.peak_data:
self.view.ptable.enableElementButton(el.symbol)
else:
@@ -41,16 +44,32 @@ class PeriodicTablePresenter(object):
self.view.on_table_changed(slot)
def unregister_table_changed(self, slot):
- self.view.unreg_on_table_changed(slot)
+ try:
+ self.view.unreg_on_table_changed(slot)
+ except TypeError:
+ return
def register_table_lclicked(self, slot):
self.view.on_table_lclicked(slot)
def unregister_table_lclicked(self, slot):
- self.view.unreg_on_table_lclicked(slot)
+ try:
+ self.view.unreg_on_table_lclicked(slot)
+ except TypeError:
+ return
def register_table_rclicked(self, slot):
self.view.on_table_rclicked(slot)
def unregister_table_rclicked(self, slot):
- self.view.unreg_on_table_rclicked(slot)
+ try:
+ self.view.unreg_on_table_rclicked(slot)
+ except TypeError:
+ return
+
+ def set_peak_datafile(self, filename):
+ try:
+ self.model.peak_data_file = filename
+ self.set_buttons()
+ except Exception as error:
+ message_box.warning(error)
diff --git a/scripts/Muon/GUI/MuonAnalysis/dock/dock_widget.py b/scripts/Muon/GUI/MuonAnalysis/dock/dock_widget.py
index 28ccae93e6c9a7ad8be023ec493be2f6cf27a432..8f3fa4717a24138b92b17205f94ed29788b3c4ab 100644
--- a/scripts/Muon/GUI/MuonAnalysis/dock/dock_widget.py
+++ b/scripts/Muon/GUI/MuonAnalysis/dock/dock_widget.py
@@ -43,6 +43,9 @@ class DockWidget(QtGui.QWidget):
self.dockWidget.setLayout(QHbox)
+ def loadFromProject(self, project):
+ self.label.updateLabel(project)
+
def handleButton(self, message):
self.label.updateLabel(message)
diff --git a/scripts/Muon_Analysis_2.py b/scripts/Muon_Analysis_2.py
index 74284382f744613147277c229d202d0dd7f54b15..f0b290ba90ecd44b004103b20bf7e8f7aab46819 100644
--- a/scripts/Muon_Analysis_2.py
+++ b/scripts/Muon_Analysis_2.py
@@ -9,6 +9,8 @@ import PyQt4.QtCore as QtCore
from Muon.GUI.Common.dummy_label.dummy_label_widget import DummyLabelWidget
from Muon.GUI.MuonAnalysis.dock.dock_widget import DockWidget
+muonGUI = None
+
class MuonAnalysis2Gui(QtGui.QMainWindow):
@@ -31,6 +33,8 @@ class MuonAnalysis2Gui(QtGui.QMainWindow):
# cancel algs if window is closed
def closeEvent(self, event):
self.dockWidget.closeEvent(event)
+ global muonGUI
+ muonGUI = None
def qapp():
@@ -41,12 +45,32 @@ def qapp():
return _app
-app = qapp()
-try:
- ex = MuonAnalysis2Gui()
- ex.resize(700, 700)
- ex.show()
- app.exec_()
-except RuntimeError as error:
- ex = QtGui.QWidget()
- QtGui.QMessageBox.warning(ex, "Muon Analysis version 2", str(error))
+def main():
+ app = qapp()
+ try:
+ global muonGUI
+ muonGUI = MuonAnalysis2Gui()
+ muonGUI.resize(700, 700)
+ muonGUI.show()
+ app.exec_()
+ return muonGUI
+ except RuntimeError as error:
+ muonGUI = QtGui.QWidget()
+ QtGui.QMessageBox.warning(muonGUI, "Muon Analysis version 2", str(error))
+ return muonGUI
+
+
+def saveToProject():
+ if muonGUI is None:
+ return ""
+ project = "test"
+ return project
+
+
+def loadFromProject(project):
+ muonGUI = main()
+ muonGUI.dockWidget.loadFromProject(project)
+ return muonGUI
+
+if __name__ == '__main__':
+ muonGUI = main()
diff --git a/scripts/test/Muon/FFTPresenter_test.py b/scripts/test/Muon/FFTPresenter_test.py
index 846fd9886c1674570ac08b0205556035121c6b16..d3352a648b69539eaab573c1561c6b1dea71c8cd 100644
--- a/scripts/test/Muon/FFTPresenter_test.py
+++ b/scripts/test/Muon/FFTPresenter_test.py
@@ -28,6 +28,8 @@ class FFTPresenterTest(unittest.TestCase):
self.view.phaseCheckSignal = mock.Mock(return_value=True)
# needed for connect in presenter
self.view.buttonSignal = mock.Mock()
+ self.view.tableClickSignal = mock.Mock()
+ self.view.phaseCheckSignal = mock.Mock()
self.view.changed = mock.MagicMock()
self.view.changedHideUnTick = mock.MagicMock()
self.view.initFFTInput = mock.Mock(
@@ -74,9 +76,19 @@ class FFTPresenterTest(unittest.TestCase):
row, col = self.view.tableClickSignal()
self.presenter.tableClicked(row, col)
+ def test_connects(self):
+ assert(self.view.tableClickSignal.connect.call_count==1)
+ self.view.tableClickSignal.connect.assert_called_with(self.presenter.tableClicked)
+
+ assert(self.view.buttonSignal.connect.call_count==1)
+ self.view.buttonSignal.connect.assert_called_with(self.presenter.handleButton)
+
+ assert(self.view.phaseCheckSignal.connect.call_count==1)
+ self.view.phaseCheckSignal.connect.assert_called_with(self.presenter.phaseCheck)
+
def test_ImBox(self):
- self.sendSignal()
self.view.tableClickSignal = mock.Mock(return_value=[3, 1])
+ self.sendSignal()
assert(self.view.changedHideUnTick.call_count == 1)
assert(self.view.changed.call_count == 0)
diff --git a/scripts/test/Muon/MaxEntPresenter_test.py b/scripts/test/Muon/MaxEntPresenter_test.py
index 15e73d7830bb285d7d63e94848c7f8dfa2e51e75..9ee81d594cc8206d028b9d03cab1fa1e32d3fc59 100644
--- a/scripts/test/Muon/MaxEntPresenter_test.py
+++ b/scripts/test/Muon/MaxEntPresenter_test.py
@@ -49,14 +49,25 @@ class MaxEntPresenterTest(unittest.TestCase):
self.thread.threadWrapperSetup = mock.Mock()
self.thread.threadWrapperTearDown = mock.Mock()
- self.presenter.createThread=mock.Mock(return_value=self.thread)
- self.presenter.createPhaseThread=mock.Mock(return_value=self.thread)
+ def test_connects(self):
+ assert(self.view.cancelSignal.connect.call_count==1)
+ self.view.cancelSignal.connect.assert_called_with(self.presenter.cancel)
+
+ assert(self.view.maxEntButtonSignal.connect.call_count==1)
+ self.view.maxEntButtonSignal.connect.assert_called_with(self.presenter.handleMaxEntButton)
+
+ assert(self.view.phaseSignal.connect.call_count==1)
+ self.view.phaseSignal.connect.assert_called_with(self.presenter.handlePhase)
def test_button(self):
+ self.presenter.createThread = lambda *args:self.thread
+
self.presenter.handleMaxEntButton()
assert(self.view.initMaxEntInput.call_count==1)
assert(self.thread.start.call_count==1)
+ assert(self.thread.threadWrapperSetUp.call_count==1)
+
def test_dataHasChanged(self):
self.load.hasDataChanged = mock.MagicMock(return_value=True)
self.presenter.handleMaxEntButton()
diff --git a/scripts/test/Muon/PeriodicTablePresenter_test.py b/scripts/test/Muon/PeriodicTablePresenter_test.py
index 89256a745f25ff0306f2965de0ab1d1cbc01f3ae..07d38913c61bf2d78211a9a6a2cdee77c4f2bb38 100644
--- a/scripts/test/Muon/PeriodicTablePresenter_test.py
+++ b/scripts/test/Muon/PeriodicTablePresenter_test.py
@@ -5,7 +5,7 @@ import unittest
from Muon.GUI.ElementalAnalysis.PeriodicTable.periodic_table_presenter import PeriodicTablePresenter
from Muon.GUI.ElementalAnalysis.PeriodicTable.periodic_table_view import PeriodicTableView
from Muon.GUI.ElementalAnalysis.PeriodicTable.periodic_table_model import PeriodicTableModel
-from Muon.GUI.ElementalAnalysis.PeriodicTable.periodic_table import PeriodicTable as silxPT
+from Muon.GUI.ElementalAnalysis.PeriodicTable.periodic_table import PeriodicTable as silxPT, PeriodicTableItem
from Muon.GUI.Common import mock_widget
@@ -24,15 +24,14 @@ class PeriodicTablePresenterTest(unittest.TestCase):
self.presenter = PeriodicTablePresenter(
self.view, self._model)
self.presenter.is_selected = mock.Mock()
- self.mock_elem = mock.Mock()
+ self.mock_elem = mock.create_autospec(PeriodicTableItem)
+ self.mock_elem.symbol = mock.Mock()
self.view.ptable = mock.create_autospec(silxPT)
self.view.ptable.getSelection = mock.Mock(
return_value=self.mock_elem)
self.view.ptable.isElementSelected = mock.Mock(
return_value=True)
- self.view.ptable.setSelection = mock.Mock()
- self.view.ptable.setElementSelected = mock.Mock()
self.view.on_table_lclicked = mock.Mock()
self.view.on_table_rclicked = mock.Mock()
@@ -96,6 +95,19 @@ class PeriodicTablePresenterTest(unittest.TestCase):
self.presenter.add_elements,
self.view.ptable.setSelection)
+ def test_set_buttons(self):
+ self.presenter.model.peak_data = [self.mock_elem.symbol]
+ self.view.ptable.elements = [self.mock_elem]
+ self.presenter.set_buttons()
+ assert self.view.ptable.silentSetElementSelected.call_count == 1
+ assert self.view.ptable.enableElementButton.call_count == 1
+
+ def test_set_peak_datafile(self):
+ self.presenter.set_buttons = mock.Mock()
+ test_filename = mock.Mock
+ self.presenter.set_peak_datafile(test_filename)
+ assert self.presenter.model.peak_data_file == test_filename
+
if __name__ == "__main__":
unittest.main()
diff --git a/scripts/test/Muon/transformWidget_test.py b/scripts/test/Muon/transformWidget_test.py
index 94c78456a0b014bf7f858b74453ef776cbe06b93..1e92c0c6a42bb2c63a883e1b00977505ee5fc947 100644
--- a/scripts/test/Muon/transformWidget_test.py
+++ b/scripts/test/Muon/transformWidget_test.py
@@ -16,7 +16,7 @@ if sys.version_info.major == 3:
else:
import mock
-class FFTTransformTest(unittest.TestCase):
+class TransformTest(unittest.TestCase):
def setUp(self):
self._qapp = mock_widget.mockQapp()
self.load= mock.create_autospec( load_utils.LoadUtils,spec_set=True)