diff --git a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/BasicHKLFilters.h b/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/BasicHKLFilters.h
deleted file mode 100644
index 8081a3ebe33d623b95637c87a4995dfab5e02f74..0000000000000000000000000000000000000000
--- a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/BasicHKLFilters.h
+++ /dev/null
@@ -1,162 +0,0 @@
-#ifndef MANTID_GEOMETRY_BASICHKLFILTERS_H_
-#define MANTID_GEOMETRY_BASICHKLFILTERS_H_
-
-#include "MantidGeometry/DllConfig.h"
-#include "MantidGeometry/Crystal/HKLFilter.h"
-#include "MantidGeometry/Crystal/ReflectionCondition.h"
-#include "MantidGeometry/Crystal/StructureFactorCalculator.h"
-#include "MantidGeometry/Crystal/SpaceGroup.h"
-#include "MantidGeometry/Crystal/UnitCell.h"
-
-#include <strstream>
-
-namespace Mantid {
-namespace Geometry {
-
-/** BasicHKLFilters
-
- This file contains some implementations of HKLFilter that
- provide filtering based on things like d-value, space group
- or centering.
-
- A common use would be to generate a specific list of HKLs,
- for example all reflections that are allowed according to a certain
- range of d-values and the reflection conditions of a space group:
-
- HKLFilter_const_sptr filter =
- boost::make_shared<HKLFilterDRange>(unitCell, 0.5)
- & boost::make_shared<HKLFilterSpaceGroup>(spaceGroup);
-
- HKLGenerator gen(unitCell, 0.5);
- std::vector<V3D> hkls;
-
- std::remove_copy_if(gen.begin(), gen.end(), std::back_inserter(hkls),
- (~filter)->fn());
-
- An existing list of HKLs could be checked for indices that match the
- reflection conditions of a space group:
-
- HKLFilter_const_sptr sgFilter =
- boost::make_shared<HKLFilterSpaceGroup>(spaceGroup);
-
- auto matchingHKLCount = std::count_if(hkls.begin(), hkls.end(),
- sgFilter->fn());
-
- auto violatingHKLCount = std::count_if(hkls.begin(), hkls.end(),
- (~sgFilter)->fn());
-
- Combining HKLGenerator and different HKLFilters provides a very flexible
- system for creating and processing specific sets of Miller indices that
- is easy to expand by adding other HKLFilters.
-
- @author Michael Wedel, ESS
- @date 23/09/2015
-
- 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>
-*/
-
-/**
- * A class to filter HKLs by their d-values
- *
- * This class takes a UnitCell object and calculates the spacing of
- * the lattice planes for each HKL. If the lattice spacing is within
- * the spcified range of values, the reflection is allowed.
- *
- * If the first constructor with only dMin is used, dMax is taken to
- * be the lattice parameter with the largest value. There can not be
- * a greater interplanar spacing than that value.
- */
-class MANTID_GEOMETRY_DLL HKLFilterDRange : public HKLFilter {
-public:
- HKLFilterDRange(const UnitCell &cell, double dMin);
- HKLFilterDRange(const UnitCell &cell, double dMin, double dMax);
-
- std::string getDescription() const;
- bool isAllowed(const Kernel::V3D &hkl) const;
-
-private:
- void checkProperDRangeValues();
-
- UnitCell m_cell;
- double m_dmin, m_dmax;
-};
-
-/**
- * A class to filter HKLs according to a space group
- *
- * HKLFilterSpaceGroup stores a SpaceGroup object and marks those
- * reflections as allowed that are allowed according to the
- * reflection conditions of the space group.
- */
-class MANTID_GEOMETRY_DLL HKLFilterSpaceGroup : public HKLFilter {
-public:
- HKLFilterSpaceGroup(const SpaceGroup_const_sptr &spaceGroup);
-
- std::string getDescription() const;
- bool isAllowed(const Kernel::V3D &hkl) const;
-
-protected:
- SpaceGroup_const_sptr m_spaceGroup;
-};
-
-/**
- * A class to filter HKLs according to structure factor magnitudes
- *
- * This filter takes a StructureFactorCalculator and calculates the
- * structure factor for each HKL. If F^2 is larger than the specified
- * minimum, the reflection is considered allowed. The default minimum
- * is 1e-6.
- */
-class MANTID_GEOMETRY_DLL HKLFilterStructureFactor : public HKLFilter {
-public:
- HKLFilterStructureFactor(const StructureFactorCalculator_sptr &calculator,
- double fSquaredMin = 1.0e-6);
-
- std::string getDescription() const;
- bool isAllowed(const Kernel::V3D &hkl) const;
-
-protected:
- StructureFactorCalculator_sptr m_calculator;
- double m_fSquaredMin;
-};
-
-/**
- * A class to filter HKLs according to a lattice centering
- *
- * HKLFilterCentering is a filter that stores a ReflectionCondition object
- * internally and filters the HKLs according to that.
- */
-class MANTID_GEOMETRY_DLL HKLFilterCentering : public HKLFilter {
-public:
- HKLFilterCentering(const ReflectionCondition_sptr ¢ering);
-
- std::string getDescription() const;
- bool isAllowed(const Kernel::V3D &hkl) const;
-
-protected:
- ReflectionCondition_sptr m_centering;
-};
-
-} // namespace Geometry
-} // namespace Mantid
-
-#endif /* MANTID_GEOMETRY_BASICHKLFILTERS_H_ */
diff --git a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/HKLFilter.h b/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/HKLFilter.h
deleted file mode 100644
index ca812aebdefeb7fdaa31219407f718d6becdfa2b..0000000000000000000000000000000000000000
--- a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/HKLFilter.h
+++ /dev/null
@@ -1,175 +0,0 @@
-#ifndef MANTID_GEOMETRY_HKLFILTER_H_
-#define MANTID_GEOMETRY_HKLFILTER_H_
-
-#include "MantidGeometry/DllConfig.h"
-#include "MantidKernel/V3D.h"
-
-#include <boost/shared_ptr.hpp>
-#include <functional>
-
-namespace Mantid {
-namespace Geometry {
-
-/** HKLFilter
-
- There are many ways to filter lists of Miller indices HKL. In order
- to be able to use HKLGenerator with arbitrary filters, HKLFilter provides
- a general interface for such filters.
-
- The abstract base class HKLFilter defines a pure virtual method
- HKLFilter::isAllowed(), which takes a V3D as argument and returns a boolean.
- Implementing classes can then implement this method, wrapping very different
- concepts of checking HKLs for certain characteristics.
-
- There are two general ways of using HKLFilters. When used "standalone",
- the isAllowed()-function can be used directly:
-
- if(filter->isAllowed(hkl)) {
- // do something
- }
-
- For interoperability with STL-algorithms, HKLFilter provides a method that
- returns a function-object with the filter:
-
- std::copy_if(generator.begin(), generator.end(),
- hkls.begin(), filter->fn());
-
- Often, it's not enough to filter a list by one criterion. To this end,
- there are two implementations of HKLFilter that provide binary logic
- operations
- "and" (HKLFilterAnd) and "or" (HKLFilterOr). They can be constructed from two
- HKLFilter_const_sptrs, or, more conveniently, by using the operators & and |
- directly with those types. This makes it possible to combine filters in many
- ways:
-
- HKLFilter_const_sptr filter = (filter1 | filter2) & filter3;
-
- Lastly, the unary logic operation "not" (HKLFilterNot) is implemented. This is
- important for usability with the pre-C++11 algorithm std::remove_copy_if that
- works logically reversed compared to std::copy_if:
-
- std::remove_copy_if(generator.begin(), generator.end(), hkls.begin(),
- (~filter)->fn());
-
- For actual implementations of HKLFilter, check out BasicHKLFilters, where some
- important filters are defined.
-
- @author Michael Wedel, ESS
- @date 06/09/2015
-
- 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>
-*/
-class MANTID_GEOMETRY_DLL HKLFilter {
-public:
- virtual ~HKLFilter() {}
-
- std::function<bool(const Kernel::V3D &)> fn() const;
-
- virtual std::string getDescription() const = 0;
- virtual bool isAllowed(const Kernel::V3D &hkl) const = 0;
-};
-
-typedef boost::shared_ptr<const HKLFilter> HKLFilter_const_sptr;
-
-/// Base class for unary logic operations for HKLFilter.
-class MANTID_GEOMETRY_DLL HKLFilterUnaryLogicOperation : public HKLFilter {
-public:
- HKLFilterUnaryLogicOperation(const HKLFilter_const_sptr &filter);
- ~HKLFilterUnaryLogicOperation() {}
-
- /// Returns the operand of the function.
- const HKLFilter_const_sptr &getOperand() const { return m_operand; }
-
-protected:
- HKLFilter_const_sptr m_operand;
-};
-
-/// Logical "Not"-operation for HKLFilter.
-class MANTID_GEOMETRY_DLL HKLFilterNot : public HKLFilterUnaryLogicOperation {
-public:
- /// Constructor, calls base class constructor, throws exception if filter is a
- /// null pointer.
- HKLFilterNot(const HKLFilter_const_sptr &filter)
- : HKLFilterUnaryLogicOperation(filter) {}
- ~HKLFilterNot() {}
-
- std::string getDescription() const;
- bool isAllowed(const Kernel::V3D &hkl) const;
-};
-
-/// Base class for binary logic operations for HKLFilter.
-class MANTID_GEOMETRY_DLL HKLFilterBinaryLogicOperation : public HKLFilter {
-public:
- HKLFilterBinaryLogicOperation(const HKLFilter_const_sptr &lhs,
- const HKLFilter_const_sptr &rhs);
- virtual ~HKLFilterBinaryLogicOperation() {}
-
- /// Returns the left-hand side operand of the operation.
- const HKLFilter_const_sptr &getLHS() const { return m_lhs; }
-
- /// Returns the right-hand side operand of the operation.
- const HKLFilter_const_sptr &getRHS() const { return m_rhs; }
-
-protected:
- HKLFilter_const_sptr m_lhs;
- HKLFilter_const_sptr m_rhs;
-};
-
-/// Logical "And"-operation for HKLFilter.
-class MANTID_GEOMETRY_DLL HKLFilterAnd : public HKLFilterBinaryLogicOperation {
-public:
- /// Constructor, calls base class constructor, throws exception if either of
- /// the operands is null.
- HKLFilterAnd(const HKLFilter_const_sptr &lhs, const HKLFilter_const_sptr &rhs)
- : HKLFilterBinaryLogicOperation(lhs, rhs) {}
- ~HKLFilterAnd() {}
-
- std::string getDescription() const;
- bool isAllowed(const Kernel::V3D &hkl) const;
-};
-
-/// Logical "Or"-operation for HKLFilter.
-class MANTID_GEOMETRY_DLL HKLFilterOr : public HKLFilterBinaryLogicOperation {
-public:
- /// Constructor, calls base class constructor, throws exception if either of
- /// the operands is null.
- HKLFilterOr(const HKLFilter_const_sptr &lhs, const HKLFilter_const_sptr &rhs)
- : HKLFilterBinaryLogicOperation(lhs, rhs) {}
- ~HKLFilterOr() {}
-
- std::string getDescription() const;
- bool isAllowed(const Kernel::V3D &hkl) const;
-};
-
-MANTID_GEOMETRY_DLL const HKLFilter_const_sptr
-operator~(const HKLFilter_const_sptr &filter);
-
-MANTID_GEOMETRY_DLL const HKLFilter_const_sptr
-operator&(const HKLFilter_const_sptr &lhs, const HKLFilter_const_sptr &rhs);
-
-MANTID_GEOMETRY_DLL const HKLFilter_const_sptr
-operator|(const HKLFilter_const_sptr &lhs, const HKLFilter_const_sptr &rhs);
-
-} // namespace Geometry
-} // namespace Mantid
-
-#endif /* MANTID_GEOMETRY_HKLFILTER_H_ */
diff --git a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/HKLGenerator.h b/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/HKLGenerator.h
deleted file mode 100644
index 5c4259677314690be059cfb72b1d252d8f5e19c8..0000000000000000000000000000000000000000
--- a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/HKLGenerator.h
+++ /dev/null
@@ -1,182 +0,0 @@
-#ifndef MANTID_GEOMETRY_HKLGENERATOR_H_
-#define MANTID_GEOMETRY_HKLGENERATOR_H_
-
-#include "MantidGeometry/DllConfig.h"
-#include "MantidGeometry/Crystal/UnitCell.h"
-#include "MantidKernel/V3D.h"
-
-#include <boost/iterator/iterator_facade.hpp>
-
-namespace Mantid {
-namespace Geometry {
-
-/** HKLGenerator
-
- HKLGenerator is a pseudo-container that helps in generating actual
- containers with V3D-objects representing Miller indices (HKL).
-
- It's a common task to generate lists of Miller indices. The simplest
- way of doing that is to simply create a nested loop structure that
- goes through all combinations of H, K, L within some limits and then
- put them into a container (vector, list, set, ...):
-
- for(int h = -hmin; h <= hmax; ++h) {
- for(int k = -kmin; k <= kmax; ++k) {
- for(int l = -lmin; l <= lmax; ++l) {
- hkls.push_back(V3D(h, k, l));
- }
- }
- }
-
- In most cases the list is not used like that, instead it's filtered
- using some criteria, for example a certain range of d-spacings or
- others, so the reflection needs to be checked first:
-
- ...
- hkl = V3D(h, k, l)
- if(isOk(hkl)) {
- hkls.push_back(hkl);
- }
- ...
-
- Instead of explicitly stating the triple-loop, HKLGenerator provides
- a shorter way for this process using a const_iterator. The first code
- example then becomes this:
-
- HKLGenerator generator(V3D(hmin, kmin, lmin), V3D(hmax, kmax, lmax));
- for(auto hkl = generator.begin(); hkl != generator.end(); ++hkl) {
- hkls.push_back(*hkl);
- }
-
- Or even shorter, using std::copy:
-
- HKLGenerator generator(V3D(hmin, kmin, lmin), V3D(hmax, kmax, lmax));
- std::copy(generator.begin(), generator.end(), std::back_inserter(hkls));
-
- It's also possible to use filters this way, but in a much easier fashion,
- using std::copy_remove_if (pre C++11) or std::copy_if (C++11):
-
- // pre C++11
- std::copy_remove_if(generator.begin(), generator.end(),
- std::back_inserter(hkls), isNotOk)
-
- // C++11
- std::copy_if(generator.begin(), generator.end(), std::back_inserter(hkls),
- isOk)
-
- See the documentation for HKLFilter for more details on how to perform
- actual filtering.
-
- Please be aware that the iterator increments infinitely if it passes the
- specified maximimum HKL. In that case K and L remain constant while H is
- incremented (until it overflows).
-
- @author Michael Wedel, ESS
- @date 23/09/2015
-
- 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>
-*/
-class MANTID_GEOMETRY_DLL HKLGenerator {
-public:
- /**
- * @brief The const_iterator class
- *
- * This class uses boost::iterator_facade to provide a const_iterator
- * interface to HKLGenerator. This makes it very easy to use the standard
- * library algorithms. It's a forward iterator, so it's not possible to use
- * operator[] for random access of specific HKLs (this would have to be
- * done on the generated container if that supports it).
- *
- * While the iterators can be instantiated directly, the intention is to
- * use HKLGenerator::begin() and HKLGenerator::end().
- */
- class const_iterator
- : public boost::iterator_facade<const_iterator, const Kernel::V3D &,
- boost::forward_traversal_tag> {
- public:
- /// Default constructor, requirement from boost::iterator_facade
- const_iterator() {}
-
- explicit const_iterator(const Kernel::V3D ¤t);
-
- explicit const_iterator(const Kernel::V3D &hklMin,
- const Kernel::V3D &hklMax);
-
- private:
- // Required for boost::iterator_facade to work
- friend class boost::iterator_core_access;
-
- void increment();
-
- /// Returns true if other is at the same position
- inline bool equal(const const_iterator &other) const {
- return this->m_h == other.m_h && this->m_k == other.m_k &&
- this->m_l == other.m_l;
- }
-
- /// Returns a const reference to the currently pointed at HKL.
- inline const Kernel::V3D &dereference() const { return m_hkl; }
-
- int m_h, m_k, m_l;
- Kernel::V3D m_hkl;
-
- int m_hMin, m_hMax;
- int m_kMin, m_kMax;
- int m_lMin, m_lMax;
- };
-
- HKLGenerator(const Kernel::V3D &hklMin, const Kernel::V3D &hklMax);
- HKLGenerator(const Kernel::V3D &hklMinMax);
- HKLGenerator(int hMinMax, int kMinMax, int lMinMax);
- HKLGenerator(const UnitCell &unitCell, double dMin);
-
- virtual ~HKLGenerator() {}
-
- /// Returns the number of HKLs to be generated.
- inline size_t size() const { return m_size; }
-
- /// Returns an iterator to the beginning of the sequence.
- inline const const_iterator &begin() const { return m_begin; }
-
- /// Returns an iterator which "points at" one element past the end.
- inline const const_iterator &end() const { return m_end; }
-
-private:
- size_t getSize(const Kernel::V3D &min, const Kernel::V3D &max) const;
-
- const_iterator getBeginIterator() const;
- const_iterator getEndIterator() const;
- Kernel::V3D getEndHKL() const;
-
- Kernel::V3D m_hklMin;
- Kernel::V3D m_hklMax;
-
- size_t m_size;
-
- const_iterator m_begin;
- const_iterator m_end;
-};
-
-} // namespace Geometry
-} // namespace Mantid
-
-#endif /* MANTID_GEOMETRY_HKLGENERATOR_H_ */
diff --git a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/ReflectionGenerator.h b/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/ReflectionGenerator.h
deleted file mode 100644
index 439fcfa162daeee23ff22469fd2f258932b7ad74..0000000000000000000000000000000000000000
--- a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/ReflectionGenerator.h
+++ /dev/null
@@ -1,144 +0,0 @@
-#ifndef MANTID_GEOMETRY_REFLECTIONGENERATOR_H_
-#define MANTID_GEOMETRY_REFLECTIONGENERATOR_H_
-
-#include "MantidGeometry/DllConfig.h"
-#include "MantidGeometry/Crystal/CrystalStructure.h"
-#include "MantidGeometry/Crystal/StructureFactorCalculator.h"
-#include "MantidGeometry/Crystal/HKLFilter.h"
-
-namespace Mantid {
-namespace Geometry {
-
-enum struct ReflectionConditionFilter {
- None,
- Centering,
- SpaceGroup,
- StructureFactor
-};
-
-/** ReflectionGenerator
-
- ReflectionGenerator is a class that provides the means to perform some
- common tasks involving generation of reflections. While the combination
- of HKLGenerator and HKLFilter is very flexible, very often a limited set
- of operations has to be performed repeatedly, involving the crystal
- structure.
-
- ReflectionGenerator is constructed from a CrystalStructure object, which
- is then stored internally. Additionally, a default filter for reflection
- conditions can be set, which is applied for HKL-generation in addition
- to a DRangeFilter. For more flexibility, a method is provided that accepts
- an HKLFilter as additional argument, this filter is then added to the
- DRangeFilter.
-
- This way it's very simple to obtain for example a list of unique reflections
- for a given crystal structure:
-
- CrystalStructure structure("5.43 5.43 5.43",
- "F d -3 m", "Si 0 0 0 1.0 0.05");
- ReflectionGenerator generator(structure);
-
- // Get all unique HKLs between 0.5 and 5.0 Angstrom
- std::vector<V3D> hkls = generator.getUniqueHKLs(0.5, 5.0);
-
- Additionally there are methods to obtain structure factors and d-values
- for a given list of HKLs.
-
- The generated reflection lists can be filtered by several criteria to remove
- reflections that are not allowed. In the default case, the reflection
- conditions of the space group are used. Alternatively, the reflections can be
- filtered according to the centering of the lattice or, with some more
- computational effort, by their structure factors.
-
- The default filter method can be supplied to the constructor in the form of
- the enum ReflectionConditionFilter. Furthermore, it's possible to provide
- self-defined filters in overloaded versions of the HKL generation methods.
- These can also be generated by using a small helper method that creates
- the filters and populates them with values associated to the stored crystal
- structure:
-
-
- ReflectionGenerator generator(
- CrystalStructure("5.43 5.43 5.43",
- "F d -3 m", "Si 0 0 0 1.0 0.05"));
- auto filter = generator.getReflectionConditionFilter(
- ReflectionConditionFilter::StructureFactor);
-
- The filter can then be used in connection with HKLGenerator or the HKL-
- generation methods of ReflectionGenerator.
-
- An example where structure factors are required can be found in a very
- common crystal structure, the structure of Silicon. Silicon crystallizes
- in the space group Fd-3m (No. 227) and the asymmetric unit consists of
- one Si-atom at the position (1/8, 1/8, 1/8) (for origin choice 2, with the
- inversion at the origin). Looking up this space group in the International
- Tables for Crystallography A reveals that placing a scatterer at this
- position introduces a new reflection condition for general reflections hkl:
-
- h = 2n + 1 (reflections with odd h are allowed)
- or h + k + l = 4n
-
- This means that for example the reflection family {2 2 2} is not allowed,
- even though the F-centering would allow it. Using the structure factor
- calculation filter solves this problem.
-
- @author Michael Wedel, ESS
- @date 30/09/2015
-
- 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>
-*/
-class MANTID_GEOMETRY_DLL ReflectionGenerator {
-public:
- ReflectionGenerator(const CrystalStructure &crystalStructure,
- ReflectionConditionFilter defaultFilter =
- ReflectionConditionFilter::SpaceGroup);
- ~ReflectionGenerator() {}
-
- const CrystalStructure &getCrystalStructure() const;
-
- HKLFilter_const_sptr getDRangeFilter(double dMin, double dMax) const;
- HKLFilter_const_sptr
- getReflectionConditionFilter(ReflectionConditionFilter filter);
-
- std::vector<Kernel::V3D> getHKLs(double dMin, double dMax) const;
- std::vector<Kernel::V3D>
- getHKLs(double dMin, double dMax,
- HKLFilter_const_sptr reflectionConditionFilter) const;
-
- std::vector<Kernel::V3D> getUniqueHKLs(double dMin, double dMax) const;
- std::vector<Kernel::V3D>
- getUniqueHKLs(double dMin, double dMax,
- HKLFilter_const_sptr reflectionConditionFilter) const;
-
- std::vector<double> getDValues(const std::vector<Kernel::V3D> &hkls) const;
- std::vector<double> getFsSquared(const std::vector<Kernel::V3D> &hkls) const;
-
-private:
- CrystalStructure m_crystalStructure;
- StructureFactorCalculator_sptr m_sfCalculator;
- HKLFilter_const_sptr m_defaultHKLFilter;
-};
-
-} // namespace Geometry
-} // namespace Mantid
-
-#endif /* MANTID_GEOMETRY_REFLECTIONGENERATOR_H_ */
diff --git a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/StructureFactorCalculator.h b/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/StructureFactorCalculator.h
deleted file mode 100644
index 04b51ff0b49f016817b43884dd822c9c59e09041..0000000000000000000000000000000000000000
--- a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/StructureFactorCalculator.h
+++ /dev/null
@@ -1,82 +0,0 @@
-#ifndef MANTID_GEOMETRY_STRUCTUREFACTORCALCULATOR_H_
-#define MANTID_GEOMETRY_STRUCTUREFACTORCALCULATOR_H_
-
-#include "MantidGeometry/DllConfig.h"
-#include "MantidGeometry/Crystal/CrystalStructure.h"
-
-namespace Mantid {
-namespace Geometry {
-
-/** StructureFactorCalculator
-
- This is a base class for concrete structure factor calculators. It is used
- to logically separate this calculation from CrystalStructure so that different
- methods of calculation can be used. For actual implementations please consult
- the available sub-classes.
-
- @author Michael Wedel, ESS
- @date 05/09/2015
-
- 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>
-*/
-class MANTID_GEOMETRY_DLL StructureFactorCalculator {
-public:
- StructureFactorCalculator();
- virtual ~StructureFactorCalculator() {}
-
- void setCrystalStructure(const CrystalStructure &crystalStructure);
-
- /// In implementations this method should return the structure factor for the
- /// specified HKL.
- virtual StructureFactor getF(const Kernel::V3D &hkl) const = 0;
- virtual double getFSquared(const Kernel::V3D &hkl) const;
-
- virtual std::vector<StructureFactor>
- getFs(const std::vector<Kernel::V3D> &hkls) const;
- virtual std::vector<double>
- getFsSquared(const std::vector<Kernel::V3D> &hkls) const;
-
-protected:
- virtual void
- crystalStructureSetHook(const CrystalStructure &crystalStructure);
-};
-
-typedef boost::shared_ptr<StructureFactorCalculator>
- StructureFactorCalculator_sptr;
-
-namespace StructureFactorCalculatorFactory {
-/// Small templated factory function that creates the desired calculator
-/// and initializes it by setting the crystal structure.
-template <typename T>
-StructureFactorCalculator_sptr
-create(const CrystalStructure &crystalStructure) {
- boost::shared_ptr<T> calculator = boost::make_shared<T>();
- calculator->setCrystalStructure(crystalStructure);
-
- return calculator;
-}
-}
-
-} // namespace Geometry
-} // namespace Mantid
-
-#endif /* MANTID_GEOMETRY_STRUCTUREFACTORCALCULATOR_H_ */
diff --git a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/StructureFactorCalculatorSummation.h b/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/StructureFactorCalculatorSummation.h
deleted file mode 100644
index 5cfed836be0c671fee66916460800dcfc735911f..0000000000000000000000000000000000000000
--- a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/StructureFactorCalculatorSummation.h
+++ /dev/null
@@ -1,64 +0,0 @@
-#ifndef MANTID_GEOMETRY_STRUCTUREFACTORCALCULATORSUMMATION_H_
-#define MANTID_GEOMETRY_STRUCTUREFACTORCALCULATORSUMMATION_H_
-
-#include "MantidGeometry/DllConfig.h"
-#include "MantidGeometry/Crystal/StructureFactorCalculator.h"
-
-namespace Mantid {
-namespace Geometry {
-
-/** StructureFactorCalculatorSummation
-
- This implementation of StructureFactorCalculator uses the summation method
- provided by BraggScatterer and its sub-classes. It obtains all scatterers in
- the unit cell by combining the space group and the scatterers located in the
- asymmetric unit (both taken from CrystalStructure) and stores them.
-
- @author Michael Wedel, ESS
- @date 05/09/2015
-
- 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>
-*/
-class MANTID_GEOMETRY_DLL StructureFactorCalculatorSummation
- : public StructureFactorCalculator {
-public:
- StructureFactorCalculatorSummation();
- virtual ~StructureFactorCalculatorSummation() {}
-
- StructureFactor getF(const Kernel::V3D &hkl) const;
-
-protected:
- void crystalStructureSetHook(const CrystalStructure &crystalStructure);
-
- void updateUnitCellScatterers(const CrystalStructure &crystalStructure);
- std::string getV3DasString(const Kernel::V3D &point) const;
-
- CompositeBraggScatterer_sptr m_unitCellScatterers;
-};
-
-typedef boost::shared_ptr<StructureFactorCalculatorSummation>
- StructureFactorSummation_sptr;
-
-} // namespace Geometry
-} // namespace Mantid
-
-#endif /* MANTID_GEOMETRY_STRUCTUREFACTORCALCULATORSUMMATION_H_ */
diff --git a/Code/Mantid/Framework/Geometry/src/Crystal/BasicHKLFilters.cpp b/Code/Mantid/Framework/Geometry/src/Crystal/BasicHKLFilters.cpp
deleted file mode 100644
index 9dfec3038a8b7d458404e4ea5490392e80bc2182..0000000000000000000000000000000000000000
--- a/Code/Mantid/Framework/Geometry/src/Crystal/BasicHKLFilters.cpp
+++ /dev/null
@@ -1,120 +0,0 @@
-#include "MantidGeometry/Crystal/BasicHKLFilters.h"
-
-namespace Mantid {
-namespace Geometry {
-
-/// Constructor, dMax is set to the largest lattice parameter.
-HKLFilterDRange::HKLFilterDRange(const UnitCell &cell, double dMin)
- : m_cell(cell), m_dmin(dMin) {
- m_dmax = std::max(m_cell.a(), std::max(m_cell.b(), m_cell.c()));
-
- checkProperDRangeValues();
-}
-
-/// Constructor with explicit dMax.
-HKLFilterDRange::HKLFilterDRange(const UnitCell &cell, double dMin, double dMax)
- : m_cell(cell), m_dmin(dMin), m_dmax(dMax) {
- checkProperDRangeValues();
-}
-
-/// Returns a description containing the parameters of the filter.
-std::string HKLFilterDRange::getDescription() const {
- std::ostringstream strm;
- strm << "(" << m_dmin << " <= d <= " << m_dmax << ")";
-
- return strm.str();
-}
-
-/// Returns true if the d-value of the HKL is within the specified range.
-bool HKLFilterDRange::isAllowed(const Kernel::V3D &hkl) const {
- double d = m_cell.d(hkl);
-
- return d >= m_dmin && d <= m_dmax;
-}
-
-/// Throws exception if m_dMin or m_dMax is <= 0 or if m_dMax < m_dMin.
-void HKLFilterDRange::checkProperDRangeValues() {
- if (m_dmin <= 0.0) {
- throw std::range_error("dMin cannot be <= 0.");
- }
-
- if (m_dmax <= 0.0) {
- throw std::range_error("dMax cannot be <= 0.");
- }
-
- if (m_dmax <= m_dmin) {
- throw std::range_error("dMax cannot be smaller than dMin.");
- }
-}
-
-/// Constructor, throws exception if the supplied pointer is invalid.
-HKLFilterSpaceGroup::HKLFilterSpaceGroup(
- const SpaceGroup_const_sptr &spaceGroup)
- : m_spaceGroup(spaceGroup) {
- if (!m_spaceGroup) {
- throw std::runtime_error(
- "Cannot construct HKLFilterSpaceGroup from null space group.");
- }
-}
-
-/// Returns a description of the filter that contains the space group symbol.
-std::string HKLFilterSpaceGroup::getDescription() const {
- std::ostringstream strm;
- strm << "(Space group: " << m_spaceGroup->hmSymbol() << ")";
-
- return strm.str();
-}
-
-/// Returns true if the reflection is allowed by the space group reflection
-/// conditions.
-bool HKLFilterSpaceGroup::isAllowed(const Kernel::V3D &hkl) const {
- return m_spaceGroup->isAllowedReflection(hkl);
-}
-
-/// Constructor, throws exception if the calculator pointer is invalid.
-HKLFilterStructureFactor::HKLFilterStructureFactor(
- const StructureFactorCalculator_sptr &calculator, double fSquaredMin)
- : m_calculator(calculator), m_fSquaredMin(fSquaredMin) {
- if (!m_calculator) {
- throw std::runtime_error(
- "Cannot construct HKLFilterStructureFactor from null calculator.");
- }
-}
-
-/// Returns a description for the filter that contains the minimum F^2.
-std::string HKLFilterStructureFactor::getDescription() const {
- std::ostringstream strm;
- strm << "(F^2 > " << m_fSquaredMin << ")";
-
- return strm.str();
-}
-
-/// Returns true if F^2(hkl) is larger than the stored minimum.
-bool HKLFilterStructureFactor::isAllowed(const Kernel::V3D &hkl) const {
- return m_calculator->getFSquared(hkl) > m_fSquaredMin;
-}
-
-/// Constructor, throws exception if pointer is null.
-HKLFilterCentering::HKLFilterCentering(
- const ReflectionCondition_sptr ¢ering)
- : m_centering(centering) {
- if (!m_centering) {
- throw std::runtime_error(
- "Cannot construct HKLFilterCentering from null centering.");
- }
-}
-
-/// Returns a description with the centering symbol.
-std::string HKLFilterCentering::getDescription() const {
- return "(Centering: " + m_centering->getSymbol() + ")";
-}
-
-/// Returns true if the HKL is allowed according to the lattice centering.
-bool HKLFilterCentering::isAllowed(const Kernel::V3D &hkl) const {
- return m_centering->isAllowed(static_cast<int>(hkl.X()),
- static_cast<int>(hkl.Y()),
- static_cast<int>(hkl.Z()));
-}
-
-} // namespace Geometry
-} // namespace Mantid
diff --git a/Code/Mantid/Framework/Geometry/src/Crystal/HKLFilter.cpp b/Code/Mantid/Framework/Geometry/src/Crystal/HKLFilter.cpp
deleted file mode 100644
index ed218cb7fdb2f3fce2bdeaa204efc113e8479009..0000000000000000000000000000000000000000
--- a/Code/Mantid/Framework/Geometry/src/Crystal/HKLFilter.cpp
+++ /dev/null
@@ -1,117 +0,0 @@
-#include "MantidGeometry/Crystal/HKLFilter.h"
-#include <boost/make_shared.hpp>
-#include <stdexcept>
-
-namespace Mantid {
-namespace Geometry {
-
-/**
- * Returns a function object that wraps HKLFilter::isAllowed
- *
- * This method uses std::bind to create a function object that
- * represents the HKLFilter::isAllowed() method. This way it's
- * possible to pass the function to STL-algorithms easily (see
- * class documentation).
- *
- * @return Function object with filter function for V3D.s
- */
-std::function<bool(const Kernel::V3D &)> HKLFilter::fn() const {
- return std::bind(&HKLFilter::isAllowed, this, std::placeholders::_1);
-}
-
-/// Stores the supplied filter, throws exception if filter is null.
-HKLFilterUnaryLogicOperation::HKLFilterUnaryLogicOperation(
- const HKLFilter_const_sptr &filter)
- : m_operand(filter) {
- if (!m_operand) {
- throw std::runtime_error(
- "Cannot create HKLFilterUnaryLogicOperation from null operand.");
- }
-}
-
-/// Returns a description of the HKLFilterNot.
-std::string HKLFilterNot::getDescription() const {
- return "!" + m_operand->getDescription();
-}
-
-/// Returns true if the wrapped filter returns false and false otherwise.
-bool HKLFilterNot::isAllowed(const Kernel::V3D &hkl) const {
- return !(m_operand->isAllowed(hkl));
-}
-
-/// Stores the left-hand and right-hand side operators, throws exception if
-/// either is null.
-HKLFilterBinaryLogicOperation::HKLFilterBinaryLogicOperation(
- const HKLFilter_const_sptr &lhs, const HKLFilter_const_sptr &rhs)
- : m_lhs(lhs), m_rhs(rhs) {
- if (!m_lhs || !m_rhs) {
- throw std::runtime_error("Cannot construct HKLFilterBinaryLogicOperation "
- "with one or more null-operands.");
- }
-}
-
-/// Returns a description of the HKLFilterAnd.
-std::string HKLFilterAnd::getDescription() const {
- return "(" + m_lhs->getDescription() + " & " + m_rhs->getDescription() + ")";
-}
-
-/// Returns true if both wrapped filters return true.
-bool HKLFilterAnd::isAllowed(const Kernel::V3D &hkl) const {
- return m_lhs->isAllowed(hkl) && m_rhs->isAllowed(hkl);
-}
-
-/// Returns a description of the HKLFilterOr.
-std::string HKLFilterOr::getDescription() const {
- return "(" + m_lhs->getDescription() + " | " + m_rhs->getDescription() + ")";
-}
-
-/// Returns true if either of the wrapped filters returns true.
-bool HKLFilterOr::isAllowed(const Kernel::V3D &hkl) const {
- return m_lhs->isAllowed(hkl) || m_rhs->isAllowed(hkl);
-}
-
-/**
- * Constructs an HKLFilterNot from the operand
- *
- * This function makes it easy to construct HKLFilterNot by using the
- * operator ~, which inverts the wrapped filter.
- *
- * @param filter :: HKLFilter to invert.
- * @return HKLFilterNot with the wrapped filter.
- */
-const HKLFilter_const_sptr operator~(const HKLFilter_const_sptr &filter) {
- return boost::make_shared<const HKLFilterNot>(filter);
-}
-
-/**
- * Constructs an HKLFilterAnd from the operands
- *
- * This function makes it easy to construct HKLFilterAnd by using the
- * operator & directly on HKLFilter_const_sptr.
- *
- * @param lhs :: Left-hand side HKLFilter operand.
- * @param rhs :: Right-hand side HKLFilter operand.
- * @return HKLFilterAnd with two wrapped filters.
- */
-const HKLFilter_const_sptr operator&(const HKLFilter_const_sptr &lhs,
- const HKLFilter_const_sptr &rhs) {
- return boost::make_shared<const HKLFilterAnd>(lhs, rhs);
-}
-
-/**
- * Constructs an HKLFilterOr from the operands
- *
- * This function makes it easy to construct HKLFilterOr by using the
- * operator | directly on HKLFilter_const_sptr.
- *
- * @param lhs :: Left-hand side HKLFilter operand.
- * @param rhs :: Right-hand side HKLFilter operand.
- * @return HKLFilterOr with two wrapped filters.
- */
-const HKLFilter_const_sptr operator|(const HKLFilter_const_sptr &lhs,
- const HKLFilter_const_sptr &rhs) {
- return boost::make_shared<HKLFilterOr>(lhs, rhs);
-}
-
-} // namespace Geometry
-} // namespace Mantid
diff --git a/Code/Mantid/Framework/Geometry/src/Crystal/HKLGenerator.cpp b/Code/Mantid/Framework/Geometry/src/Crystal/HKLGenerator.cpp
deleted file mode 100644
index 0156cd97045b0a347af482893774907c011935c0..0000000000000000000000000000000000000000
--- a/Code/Mantid/Framework/Geometry/src/Crystal/HKLGenerator.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-#include "MantidGeometry/Crystal/HKLGenerator.h"
-
-namespace Mantid {
-namespace Geometry {
-
-using namespace Kernel;
-
-/// Constructs a generator that creates all indices from hklMin to hklMax.
-HKLGenerator::HKLGenerator(const Kernel::V3D &hklMin, const Kernel::V3D &hklMax)
- : m_hklMin(hklMin), m_hklMax(hklMax), m_size(getSize(m_hklMin, m_hklMax)),
- m_begin(getBeginIterator()), m_end(getEndIterator()) {}
-
-/// Constructs a generator that creates all indices from -hklMinMax to
-/// hklMinMax.
-HKLGenerator::HKLGenerator(const Kernel::V3D &hklMinMax)
- : m_hklMin(hklMinMax * -1), m_hklMax(hklMinMax),
- m_size(getSize(m_hklMin, m_hklMax)), m_begin(getBeginIterator()),
- m_end(getEndIterator()) {}
-
-/// Constructs a generator that creates all indices from -h,-k,-l to h,k,l.
-HKLGenerator::HKLGenerator(int hMinMax, int kMinMax, int lMinMax) {
- m_hklMax = V3D(hMinMax, kMinMax, lMinMax);
- m_hklMin = m_hklMax * -1;
- m_size = getSize(m_hklMin, m_hklMax);
-
- m_begin = getBeginIterator();
- m_end = getEndIterator();
-}
-
-/// Constructs a generator that creates all indices for the given cell up to
-/// dMin.
-HKLGenerator::HKLGenerator(const UnitCell &unitCell, double dMin) {
- m_hklMax = V3D(unitCell.a() / dMin, unitCell.b() / dMin, unitCell.c() / dMin);
- m_hklMin = m_hklMax * -1;
- m_size = getSize(m_hklMin, m_hklMax);
-
- m_begin = getBeginIterator();
- m_end = getEndIterator();
-}
-
-/// Returns the number of indices between min and max.
-size_t HKLGenerator::getSize(const V3D &min, const V3D &max) const {
- V3D diff = (max - min) + V3D(1, 1, 1);
- return static_cast<size_t>(diff.X() * diff.Y() * diff.Z());
-}
-
-/// Constructs an iterator that points to the beginning of the sequence.
-HKLGenerator::const_iterator HKLGenerator::getBeginIterator() const {
- return HKLGenerator::const_iterator(m_hklMin, m_hklMax);
-}
-
-/// Constructs an iterator that points to an HKL one past the maximum.
-HKLGenerator::const_iterator HKLGenerator::getEndIterator() const {
- return HKLGenerator::const_iterator(getEndHKL());
-}
-
-/// Returns the HKL "one past the maximum".
-V3D HKLGenerator::getEndHKL() const {
- return V3D(m_hklMax.X() + 1, m_hklMin.Y(), m_hklMin.Z());
-}
-
-/// Return an iterator with min = max = current.
-HKLGenerator::const_iterator::const_iterator(const V3D ¤t)
- : m_h(static_cast<int>(current.X())), m_k(static_cast<int>(current.Y())),
- m_l(static_cast<int>(current.Z())), m_hkl(current), m_hMin(m_h),
- m_hMax(m_h), m_kMin(m_k), m_kMax(m_k), m_lMin(m_l), m_lMax(m_l) {}
-
-/// Return an iterator that can move from min to max, with current = min
-HKLGenerator::const_iterator::const_iterator(const V3D &hklMin,
- const V3D &hklMax)
- : m_h(static_cast<int>(hklMin.X())), m_k(static_cast<int>(hklMin.Y())),
- m_l(static_cast<int>(hklMin.Z())), m_hkl(hklMin), m_hMin(m_h),
- m_hMax(static_cast<int>(hklMax.X())), m_kMin(m_k),
- m_kMax(static_cast<int>(hklMax.Y())), m_lMin(m_l),
- m_lMax(static_cast<int>(hklMax.Z())) {}
-
-/// Increments HKL, l moves fastest, h moves slowest, wrapping around at the max
-/// for each index.
-void HKLGenerator::const_iterator::increment() {
- ++m_l;
-
- if (m_l > m_lMax) {
- m_l = m_lMin;
-
- ++m_k;
- if (m_k > m_kMax) {
- m_k = m_kMin;
- ++m_h;
- }
- }
-
- m_hkl = V3D(m_h, m_k, m_l);
-}
-
-} // namespace Geometry
-} // namespace Mantid
diff --git a/Code/Mantid/Framework/Geometry/src/Crystal/ReflectionGenerator.cpp b/Code/Mantid/Framework/Geometry/src/Crystal/ReflectionGenerator.cpp
deleted file mode 100644
index 59fd597ef216ad55f5d601c3a8f688c5e443738d..0000000000000000000000000000000000000000
--- a/Code/Mantid/Framework/Geometry/src/Crystal/ReflectionGenerator.cpp
+++ /dev/null
@@ -1,146 +0,0 @@
-#include "MantidGeometry/Crystal/ReflectionGenerator.h"
-#include "MantidGeometry/Crystal/BasicHKLFilters.h"
-#include "MantidGeometry/Crystal/StructureFactorCalculatorSummation.h"
-#include "MantidGeometry/Crystal/HKLGenerator.h"
-
-namespace Mantid {
-namespace Geometry {
-
-using namespace Kernel;
-
-/// Small helper functor to calculate d-Values from a unit cell.
-class LatticeSpacingCalculator {
-public:
- LatticeSpacingCalculator(const UnitCell &cell) : m_cell(cell) {}
-
- double operator()(const V3D &hkl) { return m_cell.d(hkl); }
-
-private:
- UnitCell m_cell;
-};
-
-/// Constructor
-ReflectionGenerator::ReflectionGenerator(
- const CrystalStructure &crystalStructure,
- ReflectionConditionFilter defaultFilter)
- : m_crystalStructure(crystalStructure),
- m_sfCalculator(StructureFactorCalculatorFactory::create<
- StructureFactorCalculatorSummation>(m_crystalStructure)),
- m_defaultHKLFilter(getReflectionConditionFilter(defaultFilter)) {}
-
-/// Returns the internally stored crystal structure
-const CrystalStructure &ReflectionGenerator::getCrystalStructure() const {
- return m_crystalStructure;
-}
-
-/// Returns a DRangeFilter from the supplied d-limits and the internally stored
-/// cell.
-HKLFilter_const_sptr ReflectionGenerator::getDRangeFilter(double dMin,
- double dMax) const {
- return boost::make_shared<const HKLFilterDRange>(m_crystalStructure.cell(),
- dMin, dMax);
-}
-
-/// Returns a reflection condition HKLFilter based on the supplied enum.
-HKLFilter_const_sptr ReflectionGenerator::getReflectionConditionFilter(
- ReflectionConditionFilter filter) {
- switch (filter) {
- case ReflectionConditionFilter::Centering:
- return boost::make_shared<const HKLFilterCentering>(
- m_crystalStructure.centering());
- break;
- case ReflectionConditionFilter::SpaceGroup:
- return boost::make_shared<const HKLFilterSpaceGroup>(
- m_crystalStructure.spaceGroup());
- break;
- case ReflectionConditionFilter::StructureFactor:
- return boost::make_shared<const HKLFilterStructureFactor>(m_sfCalculator);
- default:
- return HKLFilter_const_sptr();
- }
-}
-
-/// Returns a list of HKLs within the specified d-limits using the default
-/// reflection condition filter.
-std::vector<V3D> ReflectionGenerator::getHKLs(double dMin, double dMax) const {
- return getHKLs(dMin, dMax, m_defaultHKLFilter);
-}
-
-/// Returns a list of HKLs within the specified d-limits using the specified
-/// filter. If the pointer is null, it's ignored.
-std::vector<Kernel::V3D> ReflectionGenerator::getHKLs(
- double dMin, double dMax,
- HKLFilter_const_sptr reflectionConditionFilter) const {
- HKLGenerator generator(m_crystalStructure.cell(), dMin);
-
- HKLFilter_const_sptr filter = getDRangeFilter(dMin, dMax);
- if (reflectionConditionFilter) {
- filter = filter & reflectionConditionFilter;
- }
-
- std::vector<V3D> hkls;
- hkls.reserve(generator.size());
-
- std::remove_copy_if(generator.begin(), generator.end(),
- std::back_inserter(hkls), (~filter)->fn());
- return hkls;
-}
-
-/// Returns a list of symetrically independent HKLs within the specified
-/// d-limits using the default reflection condition filter.
-std::vector<V3D> ReflectionGenerator::getUniqueHKLs(double dMin,
- double dMax) const {
- return getUniqueHKLs(dMin, dMax, m_defaultHKLFilter);
-}
-
-/// Returns a list of symetrically independent HKLs within the specified
-/// d-limits using the specified reflection condition filter.
-std::vector<V3D> ReflectionGenerator::getUniqueHKLs(
- double dMin, double dMax,
- HKLFilter_const_sptr reflectionConditionFilter) const {
- HKLGenerator generator(m_crystalStructure.cell(), dMin);
-
- HKLFilter_const_sptr filter = getDRangeFilter(dMin, dMax);
- if (reflectionConditionFilter) {
- filter = filter & reflectionConditionFilter;
- }
-
- std::vector<V3D> hkls;
- hkls.reserve(generator.size());
-
- PointGroup_sptr pg = m_crystalStructure.spaceGroup()->getPointGroup();
-
- for (auto hkl = generator.begin(); hkl != generator.end(); ++hkl) {
- if (filter->isAllowed(*hkl)) {
- hkls.push_back(pg->getReflectionFamily(*hkl));
- }
- }
-
- std::sort(hkls.begin(), hkls.end());
- hkls.erase(std::unique(hkls.begin(), hkls.end()), hkls.end());
-
- return hkls;
-}
-
-/// Returns a list of d-values that correspond to the supplied hkl list, using
-/// the unit cell of the stored crystal structure.
-std::vector<double>
-ReflectionGenerator::getDValues(const std::vector<V3D> &hkls) const {
- std::vector<double> dValues;
- dValues.reserve(hkls.size());
-
- std::transform(hkls.begin(), hkls.end(), std::back_inserter(dValues),
- LatticeSpacingCalculator(m_crystalStructure.cell()));
-
- return dValues;
-}
-
-/// Returns a list of squared structure factor amplitudes corresponding to the
-/// supplied list of HKLs.
-std::vector<double>
-ReflectionGenerator::getFsSquared(const std::vector<V3D> &hkls) const {
- return m_sfCalculator->getFsSquared(hkls);
-}
-
-} // namespace Geometry
-} // namespace Mantid
diff --git a/Code/Mantid/Framework/Geometry/src/Crystal/StructureFactorCalculator.cpp b/Code/Mantid/Framework/Geometry/src/Crystal/StructureFactorCalculator.cpp
deleted file mode 100644
index df4cb44ed97825cee453bb450b2be33a9b5be755..0000000000000000000000000000000000000000
--- a/Code/Mantid/Framework/Geometry/src/Crystal/StructureFactorCalculator.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-#include "MantidGeometry/Crystal/StructureFactorCalculator.h"
-
-#include <boost/bind.hpp>
-
-namespace Mantid {
-namespace Geometry {
-
-StructureFactorCalculator::StructureFactorCalculator() {}
-
-/**
- * Sets the crystal structure for which to calculate structure factors
- *
- * Additionally StructureFactorCalculator::crystalStructureSetHook() is called
- * with the CrystalStructure. This function may be re-implemented
- * by concrete structure factor calculators to perform other necessary actions
- * that involve the crystal structure (for example extracting and storing
- * members of it).
- *
- * @param crystalStructure :: Crystal structure for calculations.
- */
-void StructureFactorCalculator::setCrystalStructure(
- const CrystalStructure &crystalStructure) {
- crystalStructureSetHook(crystalStructure);
-}
-
-/// Returns F^2 for the given HKL, calling StructureFactorCalculator::getF().
-double StructureFactorCalculator::getFSquared(const Kernel::V3D &hkl) const {
- StructureFactor sf = getF(hkl);
-
- return sf.real() * sf.real() + sf.imag() * sf.imag();
-}
-
-/**
- * Returns structure factors for each HKL in the container
- *
- * The default implementation uses StructureFactorCalculator::getF() to get
- * the structure factor for each HKL. This behavior can be overriden in
- * sub-classes for example to implement this in a more efficient way.
- *
- * @param hkls :: Vector of HKLs.
- * @return :: Vector of structure factors for the given HKLs.
- */
-std::vector<StructureFactor>
-StructureFactorCalculator::getFs(const std::vector<Kernel::V3D> &hkls) const {
- std::vector<StructureFactor> structureFactors(hkls.size());
-
- std::transform(hkls.begin(), hkls.end(), structureFactors.begin(),
- boost::bind(&StructureFactorCalculator::getF, this, _1));
-
- return structureFactors;
-}
-
-/**
- * Returns structure factors for each HKL in the container
- *
- * The default implementation uses StructureFactorCalculator::getFSquared() with
- * each HKL. This behavior can be overriden in
- * sub-classes for example to implement this in a more efficient way.
- *
- * @param hkls :: Vector of HKLs.
- * @return :: Vector of squared structure factors for the given HKLs.
- */
-std::vector<double> StructureFactorCalculator::getFsSquared(
- const std::vector<Kernel::V3D> &hkls) const {
- std::vector<double> fSquareds(hkls.size());
-
- std::transform(
- hkls.begin(), hkls.end(), fSquareds.begin(),
- boost::bind(&StructureFactorCalculator::getFSquared, this, _1));
-
- return fSquareds;
-}
-
-/// This function is called from
-/// StructureFactorCalculator::setCrystalStructure() and can be overriden to
-/// perform additional actions.
-void StructureFactorCalculator::crystalStructureSetHook(
- const CrystalStructure &crystalStructure) {
- UNUSED_ARG(crystalStructure)
-}
-
-} // namespace Geometry
-} // namespace Mantid
diff --git a/Code/Mantid/Framework/Geometry/src/Crystal/StructureFactorCalculatorSummation.cpp b/Code/Mantid/Framework/Geometry/src/Crystal/StructureFactorCalculatorSummation.cpp
deleted file mode 100644
index eabc22952cbd37217570255a766d4f023f170d83..0000000000000000000000000000000000000000
--- a/Code/Mantid/Framework/Geometry/src/Crystal/StructureFactorCalculatorSummation.cpp
+++ /dev/null
@@ -1,82 +0,0 @@
-#include "MantidGeometry/Crystal/StructureFactorCalculatorSummation.h"
-#include "MantidGeometry/Crystal/BraggScattererInCrystalStructure.h"
-
-#include <iomanip>
-
-namespace Mantid {
-namespace Geometry {
-
-using namespace Kernel;
-
-StructureFactorCalculatorSummation::StructureFactorCalculatorSummation()
- : StructureFactorCalculator(),
- m_unitCellScatterers(CompositeBraggScatterer::create()) {}
-
-/// Returns the structure factor obtained from the stored scatterers.
-StructureFactor
-StructureFactorCalculatorSummation::getF(const Kernel::V3D &hkl) const {
- return m_unitCellScatterers->calculateStructureFactor(hkl);
-}
-
-/// Calls updateUnitCellScatterers() to rebuild the complete list of scatterers.
-void StructureFactorCalculatorSummation::crystalStructureSetHook(
- const CrystalStructure &crystalStructure) {
- updateUnitCellScatterers(crystalStructure);
-}
-
-/**
- * Rebuilds the internal list of scatterers
- *
- * This method extracts two items from the supplied CrystalStructure object, the
- * list of scatterers in the asymmetric unit and the space group. Then it
- * generates all equivalent positions and creates a complete list of scatterers.
- *
- * @param crystalStructure :: CrystalStructure for structure factor calculation.
- */
-void StructureFactorCalculatorSummation::updateUnitCellScatterers(
- const CrystalStructure &crystalStructure) {
- m_unitCellScatterers->removeAllScatterers();
-
- CompositeBraggScatterer_sptr scatterersInAsymmetricUnit =
- crystalStructure.getScatterers();
- SpaceGroup_const_sptr spaceGroup = crystalStructure.spaceGroup();
-
- if (spaceGroup) {
- std::vector<BraggScatterer_sptr> braggScatterers;
- braggScatterers.reserve(scatterersInAsymmetricUnit->nScatterers() *
- spaceGroup->order());
-
- for (size_t i = 0; i < scatterersInAsymmetricUnit->nScatterers(); ++i) {
- BraggScattererInCrystalStructure_sptr current =
- boost::dynamic_pointer_cast<BraggScattererInCrystalStructure>(
- scatterersInAsymmetricUnit->getScatterer(i));
-
- if (current) {
- std::vector<V3D> positions =
- spaceGroup->getEquivalentPositions(current->getPosition());
-
- for (auto pos = positions.begin(); pos != positions.end(); ++pos) {
- BraggScatterer_sptr clone = current->clone();
- clone->setProperty("Position", getV3DasString(*pos));
-
- braggScatterers.push_back(clone);
- }
- }
- }
-
- m_unitCellScatterers->setScatterers(braggScatterers);
- }
-}
-
-/// Return V3D as string without losing precision.
-std::string
-StructureFactorCalculatorSummation::getV3DasString(const V3D &point) const {
- std::ostringstream posStream;
- posStream << std::setprecision(17);
- posStream << point;
-
- return posStream.str();
-}
-
-} // namespace Geometry
-} // namespace Mantid
diff --git a/Code/Mantid/Framework/Geometry/test/BasicHKLFiltersTest.h b/Code/Mantid/Framework/Geometry/test/BasicHKLFiltersTest.h
deleted file mode 100644
index 7295290c09a156062be0e9cd70d3c2308ef2bead..0000000000000000000000000000000000000000
--- a/Code/Mantid/Framework/Geometry/test/BasicHKLFiltersTest.h
+++ /dev/null
@@ -1,146 +0,0 @@
-#ifndef MANTID_GEOMETRY_BASICHKLFILTERSTEST_H_
-#define MANTID_GEOMETRY_BASICHKLFILTERSTEST_H_
-
-#include <cxxtest/TestSuite.h>
-#include <gtest/gtest.h>
-#include <gmock/gmock.h>
-
-#include "MantidGeometry/Crystal/BasicHKLFilters.h"
-#include "MantidGeometry/Crystal/SpaceGroupFactory.h"
-#include "MantidGeometry/Crystal/StructureFactorCalculator.h"
-
-#include <strstream>
-
-using namespace Mantid::Geometry;
-using namespace Mantid::Kernel;
-
-using ::testing::_;
-using ::testing::Return;
-using ::testing::Mock;
-
-class BasicHKLFiltersTest : 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 BasicHKLFiltersTest *createSuite() {
- return new BasicHKLFiltersTest();
- }
- static void destroySuite(BasicHKLFiltersTest *suite) { delete suite; }
-
- void testHKLFilterDRangeConstructors() {
- UnitCell cell(10., 10., 10.);
-
- TS_ASSERT_THROWS_NOTHING(HKLFilterDRange dFilter(cell, 1.0));
- TS_ASSERT_THROWS(HKLFilterDRange dFilter(cell, -1.0), std::range_error);
- TS_ASSERT_THROWS(HKLFilterDRange dFilter(cell, 0.0), std::range_error);
-
- TS_ASSERT_THROWS_NOTHING(HKLFilterDRange dFilter(cell, 1.0, 2.0));
- TS_ASSERT_THROWS(HKLFilterDRange dFilter(cell, 1.0, 0.5), std::range_error);
- TS_ASSERT_THROWS(HKLFilterDRange dFilter(cell, 1.0, -0.5),
- std::range_error);
- }
-
- void testHKLFilterDRangeDescription() {
- UnitCell cell(10., 10., 10.);
-
- std::ostringstream reference;
- reference << "(" << 1.0 << " <= d <= " << 10.0 << ")";
-
- HKLFilterDRange dFilter(cell, 1.0);
- TS_ASSERT_EQUALS(dFilter.getDescription(), reference.str());
- }
-
- void testHKLFilterDRangeIsAllowed() {
- UnitCell cell(10., 10., 10.);
- HKLFilterDRange dFilter(cell, 1.0, 9.0);
-
- TS_ASSERT(dFilter.isAllowed(V3D(1, 2, 3)));
-
- TS_ASSERT(dFilter.isAllowed(V3D(2, 0, 0)));
- TS_ASSERT(!dFilter.isAllowed(V3D(1, 0, 0)));
-
- TS_ASSERT(dFilter.isAllowed(V3D(10, 0, 0)));
- TS_ASSERT(!dFilter.isAllowed(V3D(11, 0, 0)));
- }
-
- void testHKLFilterSpaceGroupConstructor() {
- SpaceGroup_const_sptr invalid;
- TS_ASSERT_THROWS(HKLFilterSpaceGroup sgFilter(invalid), std::runtime_error);
-
- SpaceGroup_const_sptr sg =
- SpaceGroupFactory::Instance().createSpaceGroup("F d -3 m");
- TS_ASSERT_THROWS_NOTHING(HKLFilterSpaceGroup sgFilter(sg));
- }
-
- void testHKLFilterSpaceGroupDescription() {
- SpaceGroup_const_sptr sg =
- SpaceGroupFactory::Instance().createSpaceGroup("F d -3 m");
-
- HKLFilterSpaceGroup sgFilter(sg);
-
- TS_ASSERT_EQUALS(sgFilter.getDescription(),
- "(Space group: " + sg->hmSymbol() + ")");
- }
-
- void testHKLFilterSpaceGroupIsAllowed() {
- SpaceGroup_const_sptr sg =
- SpaceGroupFactory::Instance().createSpaceGroup("F d -3 m");
-
- HKLFilterSpaceGroup sgFilter(sg);
-
- TS_ASSERT(!sgFilter.isAllowed(V3D(1, 0, 0)));
- TS_ASSERT(!sgFilter.isAllowed(V3D(1, 1, 0)));
- TS_ASSERT(sgFilter.isAllowed(V3D(1, 1, 1)));
-
- TS_ASSERT(!sgFilter.isAllowed(V3D(2, 0, 0)));
- TS_ASSERT(!sgFilter.isAllowed(V3D(3, 0, 0)));
- TS_ASSERT(sgFilter.isAllowed(V3D(4, 0, 0)));
- }
-
- void testHKLFilterStructureFactorConstructor() {
- StructureFactorCalculator_sptr invalid;
- TS_ASSERT_THROWS(HKLFilterStructureFactor sfFilter(invalid),
- std::runtime_error);
-
- StructureFactorCalculator_sptr mock =
- boost::make_shared<MockStructureFactorCalculator>();
- TS_ASSERT_THROWS_NOTHING(HKLFilterStructureFactor sfFilter(mock));
- TS_ASSERT_THROWS_NOTHING(HKLFilterStructureFactor sfFilter(mock, 12.0));
- }
-
- void testHKLFilterStructureFactorDescription() {
- std::ostringstream reference;
- reference << "(F^2 > " << 1.0 << ")";
-
- StructureFactorCalculator_sptr mock =
- boost::make_shared<MockStructureFactorCalculator>();
- HKLFilterStructureFactor sfFilter(mock, 1.0);
- TS_ASSERT_EQUALS(sfFilter.getDescription(), reference.str());
- }
-
- void testHKLFilterStructureFactorIsAllowed() {
- boost::shared_ptr<MockStructureFactorCalculator> mock =
- boost::make_shared<MockStructureFactorCalculator>();
-
- EXPECT_CALL(*mock, getFSquared(_))
- .WillOnce(Return(2.0))
- .WillOnce(Return(0.5))
- .WillOnce(Return(1.0));
-
- HKLFilterStructureFactor sfFilter(mock, 1.0);
- TS_ASSERT(sfFilter.isAllowed(V3D(1, 1, 1)));
- TS_ASSERT(!sfFilter.isAllowed(V3D(1, 1, 1)));
- TS_ASSERT(!sfFilter.isAllowed(V3D(1, 1, 1)));
-
- TS_ASSERT(Mock::VerifyAndClearExpectations(mock.get()))
- }
-
-private:
- class MockStructureFactorCalculator : public StructureFactorCalculator {
- public:
- MOCK_CONST_METHOD1(getF, StructureFactor(const V3D &));
- MOCK_CONST_METHOD1(getFSquared, double(const V3D &));
- };
-};
-
-#endif /* MANTID_GEOMETRY_BASICHKLFILTERSTEST_H_ */
diff --git a/Code/Mantid/Framework/Geometry/test/HKLFilterTest.h b/Code/Mantid/Framework/Geometry/test/HKLFilterTest.h
deleted file mode 100644
index c0ef32dde759a8601d65ffdfd9fae6adc7e001e8..0000000000000000000000000000000000000000
--- a/Code/Mantid/Framework/Geometry/test/HKLFilterTest.h
+++ /dev/null
@@ -1,209 +0,0 @@
-#ifndef MANTID_GEOMETRY_HKLFILTERTEST_H_
-#define MANTID_GEOMETRY_HKLFILTERTEST_H_
-
-#include <cxxtest/TestSuite.h>
-#include <gtest/gtest.h>
-#include <gmock/gmock.h>
-
-#include "MantidGeometry/Crystal/HKLFilter.h"
-#include "MantidKernel/V3D.h"
-
-#include <boost/make_shared.hpp>
-
-using namespace Mantid::Geometry;
-using namespace Mantid::Kernel;
-
-using ::testing::_;
-using ::testing::Return;
-using ::testing::Mock;
-
-class HKLFilterTest : 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 HKLFilterTest *createSuite() { return new HKLFilterTest(); }
- static void destroySuite(HKLFilterTest *suite) { delete suite; }
-
- void testFn() {
- MockHKLFilter filter;
- EXPECT_CALL(filter, isAllowed(_))
- .Times(2)
- .WillOnce(Return(true))
- .WillRepeatedly(Return(false));
-
- std::function<bool(const V3D &)> f = filter.fn();
-
- TS_ASSERT_EQUALS(f(V3D(1, 1, 1)), true);
- TS_ASSERT_EQUALS(f(V3D(1, 1, 1)), false);
-
- TS_ASSERT(Mock::VerifyAndClearExpectations(&filter));
- }
-
- void testUnaryLogicOperation() {
- HKLFilter_const_sptr filter = boost::make_shared<MockHKLFilter>();
-
- TS_ASSERT_THROWS_NOTHING(MockHKLFilterUnaryLogicOperation op(filter));
-
- MockHKLFilterUnaryLogicOperation op(filter);
- TS_ASSERT_EQUALS(op.getOperand(), filter);
-
- HKLFilter_const_sptr invalid;
- TS_ASSERT_THROWS(MockHKLFilterUnaryLogicOperation op(invalid),
- std::runtime_error);
- }
-
- void testBinaryLogicOperation() {
- HKLFilter_const_sptr lhs = boost::make_shared<MockHKLFilter>();
- HKLFilter_const_sptr rhs = boost::make_shared<MockHKLFilter>();
-
- TS_ASSERT_THROWS_NOTHING(MockHKLFilterBinaryLogicOperation op(lhs, rhs));
-
- MockHKLFilterBinaryLogicOperation op(lhs, rhs);
- TS_ASSERT_EQUALS(op.getLHS(), lhs);
- TS_ASSERT_EQUALS(op.getRHS(), rhs);
-
- HKLFilter_const_sptr invalid;
- TS_ASSERT_THROWS(MockHKLFilterBinaryLogicOperation op(invalid, rhs),
- std::runtime_error);
- TS_ASSERT_THROWS(MockHKLFilterBinaryLogicOperation op(lhs, invalid),
- std::runtime_error);
- TS_ASSERT_THROWS(MockHKLFilterBinaryLogicOperation op(invalid, invalid),
- std::runtime_error);
- }
-
- void testHKLFilterNot() {
- boost::shared_ptr<const MockHKLFilter> filter(new MockHKLFilter);
-
- EXPECT_CALL(*filter, isAllowed(_))
- .WillOnce(Return(true))
- .WillOnce(Return(false));
-
- HKLFilterNot notFilter(filter);
-
- TS_ASSERT_EQUALS(notFilter.isAllowed(V3D(1, 1, 1)), false);
- TS_ASSERT_EQUALS(notFilter.isAllowed(V3D(1, 1, 1)), true);
-
- TS_ASSERT(Mock::VerifyAndClearExpectations(
- boost::const_pointer_cast<MockHKLFilter>(filter).get()));
- }
-
- void testHKLFilterNotOperator() {
- HKLFilter_const_sptr filter = boost::make_shared<MockHKLFilter>();
-
- HKLFilter_const_sptr notFilter = ~filter;
-
- boost::shared_ptr<const HKLFilterNot> notFilterCasted =
- boost::dynamic_pointer_cast<const HKLFilterNot>(notFilter);
- TS_ASSERT(notFilterCasted);
-
- TS_ASSERT_EQUALS(notFilterCasted->getOperand(), filter);
- }
-
- void testHKLFilterAnd() {
- boost::shared_ptr<const MockHKLFilter> lhs(new MockHKLFilter);
- EXPECT_CALL(*lhs, isAllowed(_))
- .WillOnce(Return(true))
- .WillOnce(Return(false))
- .WillOnce(Return(true));
-
- boost::shared_ptr<const MockHKLFilter> rhs(new MockHKLFilter);
- EXPECT_CALL(*rhs, isAllowed(_))
- .WillOnce(Return(true))
- .WillOnce(Return(false));
-
- HKLFilterAnd andFilter(lhs, rhs);
-
- TS_ASSERT_EQUALS(andFilter.isAllowed(V3D(1, 1, 1)), true);
- TS_ASSERT_EQUALS(andFilter.isAllowed(V3D(1, 1, 1)), false);
- TS_ASSERT_EQUALS(andFilter.isAllowed(V3D(1, 1, 1)), false);
-
- TS_ASSERT(Mock::VerifyAndClearExpectations(
- boost::const_pointer_cast<MockHKLFilter>(lhs).get()));
- TS_ASSERT(Mock::VerifyAndClearExpectations(
- boost::const_pointer_cast<MockHKLFilter>(rhs).get()));
- }
-
- void testHKLFilterAndOperator() {
- HKLFilter_const_sptr lhs = boost::make_shared<MockHKLFilter>();
- HKLFilter_const_sptr rhs = boost::make_shared<MockHKLFilter>();
-
- HKLFilter_const_sptr andFilter = lhs & rhs;
-
- boost::shared_ptr<const HKLFilterAnd> andFilterCasted =
- boost::dynamic_pointer_cast<const HKLFilterAnd>(andFilter);
-
- TS_ASSERT(andFilterCasted);
-
- TS_ASSERT_EQUALS(andFilterCasted->getLHS(), lhs);
- TS_ASSERT_EQUALS(andFilterCasted->getRHS(), rhs);
- }
-
- void testHKLFilterOr() {
- boost::shared_ptr<const MockHKLFilter> lhs(new MockHKLFilter);
- EXPECT_CALL(*lhs, isAllowed(_))
- .WillOnce(Return(true))
- .WillOnce(Return(false))
- .WillOnce(Return(true))
- .WillOnce(Return(false));
-
- boost::shared_ptr<const MockHKLFilter> rhs(new MockHKLFilter);
- EXPECT_CALL(*rhs, isAllowed(_))
- .WillOnce(Return(false))
- .WillOnce(Return(true));
-
- HKLFilterOr orFilter(lhs, rhs);
-
- TS_ASSERT_EQUALS(orFilter.isAllowed(V3D(1, 1, 1)), true);
- TS_ASSERT_EQUALS(orFilter.isAllowed(V3D(1, 1, 1)), false);
- TS_ASSERT_EQUALS(orFilter.isAllowed(V3D(1, 1, 1)), true);
- TS_ASSERT_EQUALS(orFilter.isAllowed(V3D(1, 1, 1)), true);
-
- TS_ASSERT(Mock::VerifyAndClearExpectations(
- boost::const_pointer_cast<MockHKLFilter>(lhs).get()));
- TS_ASSERT(Mock::VerifyAndClearExpectations(
- boost::const_pointer_cast<MockHKLFilter>(rhs).get()));
- }
-
- void testHKLFilterOrOperator() {
- HKLFilter_const_sptr lhs = boost::make_shared<MockHKLFilter>();
- HKLFilter_const_sptr rhs = boost::make_shared<MockHKLFilter>();
-
- HKLFilter_const_sptr orFilter = lhs | rhs;
-
- boost::shared_ptr<const HKLFilterOr> orFilterCasted =
- boost::dynamic_pointer_cast<const HKLFilterOr>(orFilter);
-
- TS_ASSERT(orFilterCasted);
-
- TS_ASSERT_EQUALS(orFilterCasted->getLHS(), lhs);
- TS_ASSERT_EQUALS(orFilterCasted->getRHS(), rhs);
- }
-
-private:
- class MockHKLFilter : public HKLFilter {
- public:
- MOCK_CONST_METHOD0(getDescription, std::string());
- MOCK_CONST_METHOD1(isAllowed, bool(const V3D &));
- };
-
- class MockHKLFilterUnaryLogicOperation : public HKLFilterUnaryLogicOperation {
- public:
- MockHKLFilterUnaryLogicOperation(const HKLFilter_const_sptr &filter)
- : HKLFilterUnaryLogicOperation(filter) {}
-
- MOCK_CONST_METHOD0(getDescription, std::string());
- MOCK_CONST_METHOD1(isAllowed, bool(const V3D &));
- };
-
- class MockHKLFilterBinaryLogicOperation
- : public HKLFilterBinaryLogicOperation {
- public:
- MockHKLFilterBinaryLogicOperation(const HKLFilter_const_sptr &lhs,
- const HKLFilter_const_sptr &rhs)
- : HKLFilterBinaryLogicOperation(lhs, rhs) {}
-
- MOCK_CONST_METHOD0(getDescription, std::string());
- MOCK_CONST_METHOD1(isAllowed, bool(const V3D &));
- };
-};
-#endif /* MANTID_GEOMETRY_HKLFILTERTEST_H_ */
diff --git a/Code/Mantid/Framework/Geometry/test/HKLGeneratorTest.h b/Code/Mantid/Framework/Geometry/test/HKLGeneratorTest.h
deleted file mode 100644
index f6cffd236d46002b8dac782b7defd1f04d12bc89..0000000000000000000000000000000000000000
--- a/Code/Mantid/Framework/Geometry/test/HKLGeneratorTest.h
+++ /dev/null
@@ -1,98 +0,0 @@
-#ifndef MANTID_GEOMETRY_HKLGENERATORTEST_H_
-#define MANTID_GEOMETRY_HKLGENERATORTEST_H_
-
-#include <cxxtest/TestSuite.h>
-#include "MantidGeometry/Crystal/HKLGenerator.h"
-
-using namespace Mantid::Geometry;
-using namespace Mantid::Kernel;
-
-class HKLGeneratorTest : 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 HKLGeneratorTest *createSuite() { return new HKLGeneratorTest(); }
- static void destroySuite(HKLGeneratorTest *suite) { delete suite; }
-
- void test_HKLGeneratorReturnsCorrectSizeSymmetricInt() {
- HKLGenerator gen(2, 2, 2);
-
- TS_ASSERT_EQUALS(gen.size(), 125);
- }
-
- void test_HKLGeneratorReturnsCorrectSizeSymmetricV3D() {
- HKLGenerator gen(V3D(2, 2, 2));
-
- TS_ASSERT_EQUALS(gen.size(), 125);
- }
-
- void test_HKLGeneratorReturnsCorrectSizeAsymmetricV3D() {
- HKLGenerator gen(V3D(-2, -1, -5), V3D(3, 4, -2));
-
- TS_ASSERT_EQUALS(gen.size(), 144);
- }
-
- void test_HKLGeneratorReturnsCorrectSizeOne() {
- HKLGenerator gen(V3D(-2, -1, -5), V3D(-2, -1, -5));
- TS_ASSERT_EQUALS(gen.size(), 1);
- }
-
- void test_beginIterator() {
- HKLGenerator gen(V3D(-2, -2, -3), V3D(1, 1, 0));
-
- HKLGenerator::const_iterator it = gen.begin();
- TS_ASSERT_EQUALS(*it, V3D(-2, -2, -3));
- }
-
- void test_endIterator() {
- HKLGenerator gen(V3D(-2, -2, -3), V3D(1, 1, 0));
-
- HKLGenerator::const_iterator it = gen.end();
- TS_ASSERT_EQUALS(*it, V3D(2, -2, -3));
- }
-
- void test_iterator_dereference() {
- HKLGenerator::const_iterator it;
- TS_ASSERT_EQUALS(*it, V3D(0, 0, 0));
- }
-
- void test_comparison() {
- HKLGenerator::const_iterator it1(V3D(-2, -3, 1));
- HKLGenerator::const_iterator it2(V3D(-2, -3, 1));
- HKLGenerator::const_iterator it3(V3D(-2, -3, 0));
-
- TS_ASSERT_EQUALS(it1, it2);
- TS_ASSERT_DIFFERS(it1, it3);
- }
-
- void test_iterator_increment() {
- HKLGenerator::const_iterator defaultIterator;
- TS_ASSERT_THROWS_NOTHING(++defaultIterator);
- }
-
- void test_iterator_dereference_range() {
- HKLGenerator::const_iterator it(V3D(-1, -1, -1), V3D(1, 1, 1));
- TS_ASSERT_EQUALS(*it, V3D(-1, -1, -1));
- ++it;
- TS_ASSERT_EQUALS(*it, V3D(-1, -1, 0));
- }
-
- void test_hkl_range() {
- HKLGenerator::const_iterator it(V3D(-1, -1, -1), V3D(1, 1, 1));
- HKLGenerator::const_iterator end(V3D(2, -1, -1));
-
- std::vector<V3D> hkls;
- std::copy(it, end, std::back_inserter(hkls));
-
- TS_ASSERT_EQUALS(hkls.size(), 27);
- TS_ASSERT_EQUALS(hkls[0], V3D(-1, -1, -1));
- TS_ASSERT_EQUALS(hkls[1], V3D(-1, -1, 0));
- TS_ASSERT_EQUALS(hkls[2], V3D(-1, -1, 1));
- TS_ASSERT_EQUALS(hkls[3], V3D(-1, 0, -1));
- TS_ASSERT_EQUALS(hkls[26], V3D(1, 1, 1));
-
- TS_ASSERT_EQUALS(std::distance(it, end), 27);
- }
-};
-
-#endif /* MANTID_GEOMETRY_HKLGENERATORTEST_H_ */
diff --git a/Code/Mantid/Framework/Geometry/test/ReflectionGeneratorTest.h b/Code/Mantid/Framework/Geometry/test/ReflectionGeneratorTest.h
deleted file mode 100644
index 9c3da2883aa0664fbd38315122247b895a5123cf..0000000000000000000000000000000000000000
--- a/Code/Mantid/Framework/Geometry/test/ReflectionGeneratorTest.h
+++ /dev/null
@@ -1,126 +0,0 @@
-#ifndef MANTID_GEOMETRY_REFLECTIONGENERATORTEST_H_
-#define MANTID_GEOMETRY_REFLECTIONGENERATORTEST_H_
-
-#include <cxxtest/TestSuite.h>
-
-#include "MantidGeometry/Crystal/ReflectionGenerator.h"
-#include "MantidGeometry/Crystal/BasicHKLFilters.h"
-
-using namespace Mantid::Geometry;
-using namespace Mantid::Kernel;
-
-class ReflectionGeneratorTest : 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 ReflectionGeneratorTest *createSuite() {
- return new ReflectionGeneratorTest();
- }
- static void destroySuite(ReflectionGeneratorTest *suite) { delete suite; }
-
- void test_getUniqueHKLs() {
- double dMin = 0.55;
- double dMax = 4.0;
-
- ReflectionGenerator generator(
- CrystalStructure("4.126 4.126 4.126", "P m -3 m", "Si 0 0 0 1.0 0.01"),
- ReflectionConditionFilter::Centering);
-
- TS_ASSERT_THROWS_NOTHING(generator.getUniqueHKLs(dMin, dMax));
-
- std::vector<V3D> peaks = generator.getUniqueHKLs(dMin, dMax);
-
- TS_ASSERT_EQUALS(peaks.size(), 68);
- TS_ASSERT_EQUALS(peaks[0], V3D(1, 1, 0));
- TS_ASSERT_EQUALS(peaks[11], V3D(3, 2, 0));
- TS_ASSERT_EQUALS(peaks[67], V3D(7, 2, 1));
-
- // make d-value list and check that peaks are within limits
- std::vector<double> peaksD = generator.getDValues(peaks);
-
- std::sort(peaksD.begin(), peaksD.end());
-
- TS_ASSERT_LESS_THAN_EQUALS(dMin, peaksD.front());
- TS_ASSERT_LESS_THAN_EQUALS(peaksD.back(), dMax);
- }
-
- void test_getHKLs() {
- double dMin = 0.55;
- double dMax = 4.0;
-
- // make a structure with P-1
- ReflectionGenerator generator(
- CrystalStructure("4.126 4.126 4.126", "P -1", "Si 0 0 0 1.0 0.01"),
- ReflectionConditionFilter::Centering);
-
- std::vector<V3D> unique = generator.getUniqueHKLs(dMin, dMax);
- std::vector<V3D> peaks = generator.getHKLs(dMin, dMax);
-
- // Because of symmetry -1, each reflection has multiplicity 2.
- TS_ASSERT_EQUALS(peaks.size(), 2 * unique.size());
- }
-
- void test_getDValues() {
- std::vector<V3D> hkls;
- hkls.push_back(V3D(1, 0, 0));
- hkls.push_back(V3D(0, 1, 0));
- hkls.push_back(V3D(0, 0, 1));
-
- ReflectionGenerator generator(
- CrystalStructure("2 3 5", "P -1", "Si 0 0 0 1.0 0.01"));
- std::vector<double> dValues = generator.getDValues(hkls);
-
- TS_ASSERT_EQUALS(dValues.size(), hkls.size());
- TS_ASSERT_EQUALS(dValues[0], 2.0);
- TS_ASSERT_EQUALS(dValues[1], 3.0);
- TS_ASSERT_EQUALS(dValues[2], 5.0);
- }
-
- void test_getUniqueHKLsStructureFactor() {
- CrystalStructure si("5.43 5.43 5.43", "F m -3 m",
- "Si 0.3 0.3 0.3 1.0 0.05");
-
- ReflectionGenerator generator(si,
- ReflectionConditionFilter::StructureFactor);
-
- std::vector<V3D> hklsCentering = generator.getUniqueHKLs(
- 0.6, 10.0, boost::make_shared<HKLFilterCentering>(si.centering()));
-
- std::vector<V3D> hklsStructureFactors = generator.getUniqueHKLs(0.6, 10.0);
-
- TS_ASSERT_EQUALS(hklsCentering.size(), hklsStructureFactors.size());
-
- for (size_t i = 0; i < hklsCentering.size(); ++i) {
- TS_ASSERT_EQUALS(hklsCentering[i], hklsStructureFactors[i]);
- }
- }
-
- void test_getUniqueHKLsHexagonal() {
- ReflectionGenerator generator(
- CrystalStructure("3.2094 3.2094 5.2108 90.0 90.0 120.0", "P 63/m m c",
- "Mg 1/3 2/3 1/4 1.0 0.005"),
- ReflectionConditionFilter::StructureFactor);
-
- std::vector<V3D> hkls = generator.getUniqueHKLs(0.5, 10.0);
-
- TS_ASSERT_EQUALS(hkls.size(), 88);
-
- std::vector<double> dValues = generator.getDValues(hkls);
- for (size_t i = 0; i < hkls.size(); ++i) {
- TS_ASSERT_LESS_THAN(0.5, dValues[i]);
- }
- }
-
- void test_getUniqueHKLsTrigonal() {
- ReflectionGenerator generator(
- CrystalStructure("4.759355 4.759355 12.99231 90.0 90.0 120.0", "R -3 c",
- "Al 0 0 0.35217 1.0 0.005; O 0.69365 0 1/4 1.0 0.005"),
- ReflectionConditionFilter::StructureFactor);
-
- std::vector<V3D> hkls = generator.getUniqueHKLs(0.885, 10.0);
-
- TS_ASSERT_EQUALS(hkls.size(), 44);
- }
-};
-
-#endif /* MANTID_GEOMETRY_REFLECTIONGENERATORTEST_H_ */
diff --git a/Code/Mantid/Framework/Geometry/test/StructureFactorCalculatorSummationTest.h b/Code/Mantid/Framework/Geometry/test/StructureFactorCalculatorSummationTest.h
deleted file mode 100644
index a1ce3c9670a57b3edd0cd2dd6302d8c27c3a33bf..0000000000000000000000000000000000000000
--- a/Code/Mantid/Framework/Geometry/test/StructureFactorCalculatorSummationTest.h
+++ /dev/null
@@ -1,75 +0,0 @@
-#ifndef MANTID_GEOMETRY_STRUCTUREFACTORCALCULATORSUMMATIONTEST_H_
-#define MANTID_GEOMETRY_STRUCTUREFACTORCALCULATORSUMMATIONTEST_H_
-
-#include <cxxtest/TestSuite.h>
-
-#include "MantidGeometry/Crystal/StructureFactorCalculatorSummation.h"
-
-#include "MantidGeometry/Crystal/BraggScattererFactory.h"
-#include "MantidGeometry/Crystal/SpaceGroupFactory.h"
-
-using namespace Mantid::Geometry;
-using namespace Mantid::Kernel;
-
-class StructureFactorCalculatorSummationTest : 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 StructureFactorCalculatorSummationTest *createSuite() {
- return new StructureFactorCalculatorSummationTest();
- }
- static void destroySuite(StructureFactorCalculatorSummationTest *suite) {
- delete suite;
- }
-
- void testEquivalentPositionsAreUsed() {
- // Approximate crystal structure of Silicon
- CrystalStructure si = getCrystalStructure();
-
- StructureFactorCalculatorSummation calculator;
- calculator.setCrystalStructure(si);
-
- // {1 0 0} reflections are not allowed because of F centering
- TS_ASSERT_LESS_THAN(calculator.getFSquared(V3D(1, 0, 0)), 1e-9);
-
- // {2 2 2} is forbidden because of Si on special position
- TS_ASSERT_LESS_THAN(calculator.getFSquared(V3D(2, 2, 2)), 1e-9);
-
- // With space group P-1, those are allowed.
- si.setSpaceGroup(SpaceGroupFactory::Instance().createSpaceGroup("P -1"));
-
- calculator.setCrystalStructure(si);
- // {1 0 0} reflections are not allowed because of F centering
- TS_ASSERT_LESS_THAN(1e-9, calculator.getFSquared(V3D(1, 0, 0)));
-
- // {2 2 2} is forbidden because of Si on special position
- TS_ASSERT_LESS_THAN(1e-9, calculator.getFSquared(V3D(2, 2, 2)));
- }
-
- void testCreateWithFactory() {
- CrystalStructure si = getCrystalStructure();
-
- StructureFactorCalculator_sptr calculator =
- StructureFactorCalculatorFactory::create<
- StructureFactorCalculatorSummation>(si);
-
- // same reflections as in testEquivalentPositionsAreUsed
- TS_ASSERT_LESS_THAN(calculator->getFSquared(V3D(1, 0, 0)), 1e-9);
- TS_ASSERT_LESS_THAN(calculator->getFSquared(V3D(2, 2, 2)), 1e-9);
- }
-
-private:
- CrystalStructure getCrystalStructure() {
- CompositeBraggScatterer_sptr scatterers = CompositeBraggScatterer::create();
- scatterers->addScatterer(BraggScattererFactory::Instance().createScatterer(
- "IsotropicAtomBraggScatterer", "Element=Si;Position=[0,0,0];U=0.05"));
-
- CrystalStructure si(
- UnitCell(5.43, 5.43, 5.43),
- SpaceGroupFactory::Instance().createSpaceGroup("F d -3 m"), scatterers);
-
- return si;
- }
-};
-
-#endif /* MANTID_GEOMETRY_STRUCTUREFACTORCALCULATORSUMMATIONTEST_H_ */
diff --git a/Code/Mantid/Framework/Geometry/test/StructureFactorCalculatorTest.h b/Code/Mantid/Framework/Geometry/test/StructureFactorCalculatorTest.h
deleted file mode 100644
index 72421449f7132c3b281a0f7873be91431a052d59..0000000000000000000000000000000000000000
--- a/Code/Mantid/Framework/Geometry/test/StructureFactorCalculatorTest.h
+++ /dev/null
@@ -1,107 +0,0 @@
-#ifndef MANTID_GEOMETRY_STRUCTUREFACTORCALCULATORTEST_H_
-#define MANTID_GEOMETRY_STRUCTUREFACTORCALCULATORTEST_H_
-
-#include <cxxtest/TestSuite.h>
-#include <gtest/gtest.h>
-#include <gmock/gmock.h>
-
-#include "MantidGeometry/Crystal/StructureFactorCalculator.h"
-#include "MantidGeometry/Crystal/SpaceGroupFactory.h"
-
-using namespace Mantid::Geometry;
-using namespace Mantid::Kernel;
-using ::testing::Mock;
-using ::testing::_;
-using ::testing::Return;
-
-class StructureFactorCalculatorTest : 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 StructureFactorCalculatorTest *createSuite() {
- return new StructureFactorCalculatorTest();
- }
- static void destroySuite(StructureFactorCalculatorTest *suite) {
- delete suite;
- }
-
- void testCrystalStructureSetHookIsCalled() {
- CrystalStructure cs(UnitCell(1, 2, 3),
- SpaceGroupFactory::Instance().createSpaceGroup("P -1"),
- CompositeBraggScatterer::create());
-
- MockStructureFactorCalculator calculator;
- EXPECT_CALL(calculator, crystalStructureSetHook(_)).Times(1);
-
- calculator.setCrystalStructure(cs);
-
- TS_ASSERT(Mock::VerifyAndClearExpectations(&calculator));
- }
-
- void testGetFSquared() {
- MockStructureFactorCalculator calculator;
-
- EXPECT_CALL(calculator, getF(_))
- .WillRepeatedly(Return(StructureFactor(2.21, 3.1)));
-
- // Check that the square of 2.21 + i * 3.1 is returned
- TS_ASSERT_DELTA(calculator.getFSquared(V3D()), 14.4941, 1e-15);
-
- TS_ASSERT(Mock::VerifyAndClearExpectations(&calculator));
- }
-
- void testGetFs() {
- MockStructureFactorCalculator calculator;
-
- int numHKLs = 10;
- EXPECT_CALL(calculator, getF(_))
- .Times(numHKLs)
- .WillRepeatedly(Return(StructureFactor(2.0, 2.0)));
-
- std::vector<V3D> hkls(numHKLs);
- std::vector<StructureFactor> sfs = calculator.getFs(hkls);
-
- TS_ASSERT_EQUALS(sfs.size(), hkls.size());
-
- for (auto sf = sfs.begin(); sf != sfs.end(); ++sf) {
- TS_ASSERT_EQUALS(*sf, StructureFactor(2.0, 2.0));
- }
-
- TS_ASSERT(Mock::VerifyAndClearExpectations(&calculator));
- }
-
- void testGetFsSquared() {
- MockStructureFactorCalculator calculator;
-
- int numHKLs = 10;
- EXPECT_CALL(calculator, getF(_))
- .Times(numHKLs)
- .WillRepeatedly(Return(StructureFactor(2.0, 2.0)));
-
- std::vector<V3D> hkls(numHKLs);
- std::vector<double> sfsSquared = calculator.getFsSquared(hkls);
-
- TS_ASSERT_EQUALS(sfsSquared.size(), hkls.size());
-
- for (auto sf = sfsSquared.begin(); sf != sfsSquared.end(); ++sf) {
- TS_ASSERT_EQUALS(*sf, 8.0);
- }
-
- TS_ASSERT(Mock::VerifyAndClearExpectations(&calculator));
- }
-
-private:
- /* This MockStructureFactorCalculator helps to test whether the
- * default implementations of the virtual methods work correctly.
- * Furthermore it is used to confirm that crystalStructureSetHook
- * is called appropriately.
- */
- class MockStructureFactorCalculator : public StructureFactorCalculator {
- public:
- MOCK_CONST_METHOD1(getF, StructureFactor(const V3D &hkl));
- MOCK_METHOD1(crystalStructureSetHook,
- void(const CrystalStructure &crystalStructure));
- };
-};
-
-#endif /* MANTID_GEOMETRY_STRUCTUREFACTORCALCULATORTEST_H_ */
diff --git a/Code/Mantid/Framework/PythonInterface/mantid/geometry/src/Exports/CrystalStructure.cpp b/Code/Mantid/Framework/PythonInterface/mantid/geometry/src/Exports/CrystalStructure.cpp
deleted file mode 100644
index daf4587a81da370e1ffd0adc07d04f7b625a99c4..0000000000000000000000000000000000000000
--- a/Code/Mantid/Framework/PythonInterface/mantid/geometry/src/Exports/CrystalStructure.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "MantidGeometry/Crystal/CrystalStructure.h"
-#include "MantidGeometry/Crystal/IsotropicAtomBraggScatterer.h"
-#include <boost/python/class.hpp>
-#include <boost/python/make_constructor.hpp>
-#include <boost/python/register_ptr_to_python.hpp>
-
-using namespace Mantid::Geometry;
-using namespace Mantid::Kernel;
-using namespace boost::python;
-
-namespace {
-SpaceGroup_sptr getSpaceGroup(CrystalStructure &self) {
- return boost::const_pointer_cast<SpaceGroup>(self.spaceGroup());
-}
-
-std::vector<std::string> getScatterers(CrystalStructure &self) {
- CompositeBraggScatterer_sptr scatterers = self.getScatterers();
-
- std::vector<std::string> scattererStrings;
- scattererStrings.reserve(scatterers->nScatterers());
-
- for (size_t i = 0; i < scatterers->nScatterers(); ++i) {
- scattererStrings.push_back(
- getIsotropicAtomBraggScattererString(scatterers->getScatterer(i)));
- }
-
- return scattererStrings;
-}
-}
-
-void export_CrystalStructure() {
- class_<CrystalStructure>("CrystalStructure", no_init)
- .def(init<const std::string &, const std::string &, const std::string &>(
- (arg("unitCell"), arg("spaceGroup"), arg("scatterers"))))
- .def("getUnitCell", &CrystalStructure::cell)
- .def("getSpaceGroup", &getSpaceGroup)
- .def("getScatterers", &getScatterers);
-}
diff --git a/Code/Mantid/Framework/PythonInterface/mantid/geometry/src/Exports/ReflectionGenerator.cpp b/Code/Mantid/Framework/PythonInterface/mantid/geometry/src/Exports/ReflectionGenerator.cpp
deleted file mode 100644
index 83882c117af6c3965b0e7ed3aae8a75d9dab063b..0000000000000000000000000000000000000000
--- a/Code/Mantid/Framework/PythonInterface/mantid/geometry/src/Exports/ReflectionGenerator.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-#include "MantidGeometry/Crystal/ReflectionGenerator.h"
-#include "MantidPythonInterface/kernel/Converters/PySequenceToVector.h"
-#include <boost/python/class.hpp>
-#include <boost/python/enum.hpp>
-#include <boost/python/list.hpp>
-
-using namespace Mantid::Geometry;
-using namespace Mantid::Kernel;
-using namespace Mantid::PythonInterface;
-using namespace boost::python;
-
-namespace {
-boost::python::list getListFromV3DVector(const std::vector<V3D> &hkls) {
- boost::python::list hklList;
- for (auto it = hkls.begin(); it != hkls.end(); ++it) {
- hklList.append(*it);
- }
- return hklList;
-}
-
-boost::python::list getHKLsDefaultFilter(ReflectionGenerator &self, double dMin,
- double dMax) {
- return getListFromV3DVector(self.getHKLs(dMin, dMax));
-}
-
-boost::python::list getHKLsUsingFilter(ReflectionGenerator &self, double dMin,
- double dMax,
- ReflectionConditionFilter filter) {
- return getListFromV3DVector(
- self.getHKLs(dMin, dMax, self.getReflectionConditionFilter(filter)));
-}
-
-boost::python::list getUniqueHKLsDefaultFilter(ReflectionGenerator &self,
- double dMin, double dMax) {
- return getListFromV3DVector(self.getUniqueHKLs(dMin, dMax));
-}
-
-boost::python::list getUniqueHKLsUsingFilter(ReflectionGenerator &self,
- double dMin, double dMax,
- ReflectionConditionFilter filter) {
- return getListFromV3DVector(self.getUniqueHKLs(
- dMin, dMax, self.getReflectionConditionFilter(filter)));
-}
-
-std::vector<double> getDValues(ReflectionGenerator &self,
- const boost::python::object &hkls) {
- Converters::PySequenceToVector<V3D> converter(hkls);
-
- return self.getDValues(converter());
-}
-
-std::vector<double> getFsSquared(ReflectionGenerator &self,
- const boost::python::object &hkls) {
- Converters::PySequenceToVector<V3D> converter(hkls);
-
- return self.getFsSquared(converter());
-}
-}
-
-void export_ReflectionGenerator() {
- enum_<ReflectionConditionFilter>("ReflectionConditionFilter")
- .value("None", ReflectionConditionFilter::None)
- .value("Centering", ReflectionConditionFilter::Centering)
- .value("SpaceGroup", ReflectionConditionFilter::SpaceGroup)
- .value("StructureFactor", ReflectionConditionFilter::StructureFactor)
- .export_values();
-
- class_<ReflectionGenerator>("ReflectionGenerator", no_init)
- .def(init<const CrystalStructure &, optional<ReflectionConditionFilter>>(
- (arg("crystalStructure"), arg("defaultFilter"))))
- .def("getHKLs", &getHKLsDefaultFilter)
- .def("getHKLsUsingFilter", &getHKLsUsingFilter)
- .def("getUniqueHKLs", &getUniqueHKLsDefaultFilter)
- .def("getUniqueHKLsUsingFilter", &getUniqueHKLsUsingFilter)
- .def("getDValues", &getDValues)
- .def("getFsSquared", &getFsSquared);
-}
diff --git a/Code/Mantid/Framework/PythonInterface/test/python/mantid/geometry/CrystalStructureTest.py b/Code/Mantid/Framework/PythonInterface/test/python/mantid/geometry/CrystalStructureTest.py
deleted file mode 100644
index 147d8e1e232adbea44574f5a908e45e4a68614ba..0000000000000000000000000000000000000000
--- a/Code/Mantid/Framework/PythonInterface/test/python/mantid/geometry/CrystalStructureTest.py
+++ /dev/null
@@ -1,59 +0,0 @@
-# pylint: disable=no-init,invalid-name,too-many-public-methods,broad-except
-import unittest
-from mantid.geometry import CrystalStructure
-
-
-class CrystalStructureTest(unittest.TestCase):
- def test_creation(self):
- # Some valid constructions
- self.assertTrue(self.createCrystalStructureOrRaise("5.43 5.43 5.43", "F d -3 m", "Al 1/3 0.454 1/12 1.0 0.01"))
- self.assertTrue(self.createCrystalStructureOrRaise("5.43 5.43 5.43", "C m m m", "Al 1/3 0.454 1/12 1.0 0.01;\n"
- "Si 2/3 0.121 1/8"))
- self.assertTrue(
- self.createCrystalStructureOrRaise("5.43 5.43 5.43 90 90 120", "R -3 c", "Al 1/3 0.454 1/12 1.0 0.01;\n"
- "Si 2/3 0.121 1/8"))
-
- # Invalid unit cell specification
- self.assertFalse(
- self.createCrystalStructureOrRaise("5.43 5.43 5.43 90.0", "C m m m", "Al 1/3 0.454 1/12 1.0 0.01"))
-
- # Invalid space group
- self.assertFalse(
- self.createCrystalStructureOrRaise("5.43 5.43 5.43", "INVALID", "Al 1/3 0.454 1/12 1.0 0.01"))
-
- # Invalid atom specification
- self.assertFalse(
- self.createCrystalStructureOrRaise("5.43 5.43 5.43", "C m c e", "Al 1/3 0"))
-
- def createCrystalStructureOrRaise(self, unitCell, spaceGroup, atomStrings):
- try:
- CrystalStructure(unitCell, spaceGroup, atomStrings)
- return True
- except Exception:
- return False
-
- def test_UnitCell(self):
- structure = CrystalStructure("5.43 5.42 5.41", "F d -3 m", "Al 1/3 0.454 1/12 1.0 0.01")
- cell = structure.getUnitCell()
-
- self.assertEqual(cell.a(), 5.43)
- self.assertEqual(cell.b(), 5.42)
- self.assertEqual(cell.c(), 5.41)
-
- def test_SpaceGroup(self):
- structure = CrystalStructure("5.43 5.42 5.41", "F d -3 m", "Al 1/3 0.454 1/12 1.0 0.01")
- spaceGroup = structure.getSpaceGroup()
-
- self.assertEqual(spaceGroup.getHMSymbol(), "F d -3 m")
-
- def test_scatterers(self):
- initialString = "Al 1/3 0.454 1/12 1 0.01;Si 0.1 0.2 0.3 0.99 0.1"
-
- structure = CrystalStructure("5.43 5.42 5.41", "F d -3 m", initialString)
- scatterers = structure.getScatterers()
-
- self.assertEqual(';'.join(scatterers), initialString)
-
-
-if __name__ == '__main__':
- unittest.main()
diff --git a/Code/Mantid/Framework/PythonInterface/test/python/mantid/geometry/ReflectionGeneratorTest.py b/Code/Mantid/Framework/PythonInterface/test/python/mantid/geometry/ReflectionGeneratorTest.py
deleted file mode 100644
index 4c942f8a7ccd0140d98864097dc3f36f1cfc7ff8..0000000000000000000000000000000000000000
--- a/Code/Mantid/Framework/PythonInterface/test/python/mantid/geometry/ReflectionGeneratorTest.py
+++ /dev/null
@@ -1,69 +0,0 @@
-# pylint: disable=no-init,invalid-name,too-many-public-methods
-import unittest
-from mantid.geometry import CrystalStructure, ReflectionGenerator, ReflectionConditionFilter
-from mantid.kernel import V3D
-import numpy as np
-
-
-class CrystalStructureTest(unittest.TestCase):
- crystalStructure = CrystalStructure("5.431 5.431 5.431", "F d -3 m", "Si 0 0 0 1.0 0.02")
-
- def test_create(self):
- generator = ReflectionGenerator(self.crystalStructure)
- generator = ReflectionGenerator(self.crystalStructure, ReflectionConditionFilter.Centering)
-
- def test_getHKLs(self):
- generator = ReflectionGenerator(self.crystalStructure)
- hkls = generator.getHKLs(1.0, 10.0)
-
- self.assertEqual(len(hkls), 138)
-
- # default is filtering by space group reflection condition
- self.assertTrue(V3D(2, 2, 2) in hkls)
- self.assertFalse(V3D(1, 0, 0) in hkls)
-
- def test_getHKLsUsingFilter(self):
- generator = ReflectionGenerator(self.crystalStructure)
- hkls = generator.getHKLsUsingFilter(1.0, 10.0, ReflectionConditionFilter.StructureFactor)
-
- self.assertEqual(len(hkls), 130)
-
- # The 222 is gone now
- self.assertFalse(V3D(2, 2, 2) in hkls)
-
- def test_getUniqueHKLs(self):
- generator = ReflectionGenerator(self.crystalStructure)
- hkls = generator.getUniqueHKLs(1.0, 10.0)
-
- self.assertEqual(len(hkls), 9)
-
- self.assertTrue(V3D(2, 2, 2) in hkls)
- self.assertFalse(V3D(1, 0, 0) in hkls)
-
- def test_getUniqueHKLsUsingFilter(self):
- generator = ReflectionGenerator(self.crystalStructure)
- hkls = generator.getUniqueHKLsUsingFilter(1.0, 10.0, ReflectionConditionFilter.StructureFactor)
-
- self.assertEqual(len(hkls), 8)
- self.assertFalse(V3D(2, 2, 2) in hkls)
-
- def test_getDValues(self):
- generator = ReflectionGenerator(self.crystalStructure)
- hkls = [V3D(1, 0, 0), V3D(1, 1, 1)]
-
- dValues = generator.getDValues(hkls)
-
- self.assertEqual(len(hkls), len(dValues))
- self.assertAlmostEqual(dValues[0], 5.431, places=10)
- self.assertAlmostEqual(dValues[1], 5.431 / np.sqrt(3.), places=10)
-
- def test_getFsSquared(self):
- generator = ReflectionGenerator(self.crystalStructure)
- hkls = generator.getUniqueHKLs(1.0, 10.0)
-
- fsSquared = generator.getFsSquared(hkls)
-
- self.assertEqual(len(fsSquared), len(hkls))
-
-if __name__ == '__main__':
- unittest.main()
diff --git a/Code/Mantid/docs/source/concepts/CrystalStructureAndReflections.rst b/Code/Mantid/docs/source/concepts/CrystalStructureAndReflections.rst
deleted file mode 100644
index 443dd594566083f6cdd9d048bc7a2e6e3d1b698d..0000000000000000000000000000000000000000
--- a/Code/Mantid/docs/source/concepts/CrystalStructureAndReflections.rst
+++ /dev/null
@@ -1,293 +0,0 @@
-.. _Crystal structure and reflections:
-
-Crystal structure and reflections
-=================================
-
-This document describes how crystal structure data can be processed and used in Mantid. For the understanding of the
-concepts of :ref:`symmetry <Symmetry groups>` and :ref:`space groups <Point and space groups>` in Mantid it may be
-useful to read those introductory articles before proceeding with this document. While there is a short introduction
-into theoretical aspects this page is not a replacement for proper introductory text books on the subject where all
-these principles are explained in great detail and on a much more general basis.
-
-Theoretical aspects
-~~~~~~~~~~~~~~~~~~~
-
-Crystal structures
-------------------
-
-A crystal is modelled as an infinitely repeating three-dimensional arrangement of scatterers, usually atoms. Due to
-the periodic nature of crystals, the entire object can be described by specifying the repeated unit and how
-it is repeated. These information are called "crystal structure" and comprise three components:
-
- 1. Lattice (describes the periodicity of the structure)
- 2. Basis (distribution of scatterers in the unit cell)
- 3. Space group (describes the symmetry of the arrangement of scatterers)
-
-The description of the basis depends on the model's level of detail. In the simplest case it could be a list of
-point scatterers that are fully characterized by three coordinates (x, y and z in terms of the lattice vectors) and
-a scattering length. In reality however, the scatterers are usually atoms that fluctuate about their average position
-due to thermal agitation. A basic way to model this motion is to assume it to be an isotropic phenomenon, allowing the
-description with one single parameter that quantifies the radius of a sphere in which the scatterer oscillates
-harmonically. This so called Debye-Waller-factor will be introduced later on.
-
-Another important parameter for a basic description of the basis is the so called occupancy. It describes the fraction
-of the total number of scatterer-positions that is actually occupied. A common example where this is required are
-unordered binary metal mixtures where the same position in the crystal structure is partly filled with two different
-atoms in a randomly distributed manner.
-
-To summarize, a very basic model of the basis comprises a list of scatterers that are in turn characterized by
-six parameters:
-
- 1. Scattering length (known for each element)
- 2. Fractional coordinate x
- 3. Fractional coordinate y
- 4. Fractional coordinate z
- 5. Occupancy of the site
- 6. Isotropic thermal displacement parameter
-
-Knowledge of the space group makes it possible to derive all scatterers in the entire unit cell. The symmetry operations
-of the space group map each scatterer-position onto a set of equivalent positions that are consequently occupied by the
-same type of scatterer as well. Since the unit cell is repeated infinitely in all three directions of space, it is
-enough to describe one unit cell. Finally, the lattice is described by six parameters as well, the lengths of the three
-lattice vectors (usually given in :math:`\mathrm{\AA{}}`) and the three angles (in degree) between these vectors.
-
-Reflections and structure factors
----------------------------------
-
-In a diffraction experiment the periodic arrangement of atoms is probed using radiation, in this case in the form of
-neutrons, of an appropriate wavelength (on the same scale of interatomic distances, typically between 0.5 and
-5 :math:`\mathrm{\AA{}}`). The incident beam interacts with the scatterers and in certain orientations the beam is
-"reflected" by a flock of lattice planes, a phenomenon which is described by Bragg's law:
-
-.. math::
- 2d\sin\theta = \lambda
-
-In this equation :math: `d` is the spacing between the lattice planes, :math:`\theta` is the angle of the incoming beam
-and the lattice plane normal and lambda is the wavelength of the radiation. In an experiment theta and lambda are
-usually limited, thus they are limiting the range of interplanar spacings that can be probed. In Bragg's law the lattice
-plane families are only described by one parameter, the interplanar distance. But each lattice plane family also has an
-orientation in space which can be described by the plane's normal vector. Usually the vector is given in terms of the
-reciprocal lattice of the structure, where it is reduced to three integers H, K, L, the so called Miller indices. With
-knowledge of the :ref:`unit cell <Lattice>` (and thus the :math:`\mathbf{B}`-matrix), the interplanar spacing can also
-be computed like this:
-
-.. math::
- d = \frac{1}{\left|\mathbf{B}\cdot\mathbf{h}\right|}
-
-The parameters taken into account so far determine the geometric characteristics of Bragg-reflections, i.e. their
-position on a detector and their time of flight. But besides these, each reflection also has an intensity. The
-intensity is proportional to the squared structure factor, which depends on the kind and arrangement of scatterers in
-the unit cell. The structure factor is a complex number and can be calculated for a certain HKL by summing the
-contributions of all N atoms j in the unit cell:
-
-.. math::
- F_{\mathbf{h}} = \sum\limits_{j}^{N}b_j\exp\left(2\pi i \mathbf{h} \cdot \mathbf{x}_j\right)
-
-In the above equation :math:`b` is the scattering length, :math:`\mathbf{h}` is the Miller index triplet HKL and
-:math:`\mathbf{x}` contains the fractional coordinates of the j-th atom. To take into account isotropic thermal
-motion of atoms, the term is multiplied with the Debye-Waller factor:
-
-.. math::
- F_{\mathbf{h}} = \sum\limits_{j}^{N}b_j\exp\left(2\pi i \mathbf{h} \cdot \mathbf{x}_j\right)
- \exp\left(-2\pi^2 U/d_{\mathbf{h}}^2\right)
-
-Here, :math:`U` is the isotropic atomic displacement parameter, usually given in :math:`\mathrm{\AA{}}^2` and
-:math:`d` is the lattice spacing discussed above. There are other, more complex models to describe the movement of
-atoms, taking into account anisotropic movement and also anharmonic effects.
-
-Implementation in Mantid
-~~~~~~~~~~~~~~~~~~~~~~~~
-
-The concepts described above are available through the Python interface of Mantid. Crystal structures are represented
-by a class that stores the three necessary pieces of information. Objects of that class can be created by supplying
-string representations of those three arguments.
-
-.. testcode:: ExCrystalStructureConstruction
-
- from mantid.geometry import CrystalStructure
-
- silicon = CrystalStructure("5.431 5.431 5.431", "F d -3 m", "Si 0 0 0 1.0 0.05")
-
- unitCell = silicon.getUnitCell()
- print 'Crystal structure of silicon:'
- print ' Unit cell:', unitCell.a(), unitCell.b(), unitCell.c(), unitCell.alpha(), unitCell.beta(), unitCell.gamma()
-
- spaceGroup = silicon.getSpaceGroup()
- print ' Space group:', spaceGroup.getHMSymbol()
- print ' Point group:', spaceGroup.getPointGroup().getHMSymbol()
-
- scatterers = silicon.getScatterers()
- print ' Total number of scatterers:', len(scatterers)
-
- for i, scatterer in enumerate(scatterers):
- print ' ' + str(i) + ':', scatterer
-
-The above script produces the following output:
-
-.. testoutput:: ExCrystalStructureConstruction
-
- Crystal structure of silicon:
- Unit cell: 5.431 5.431 5.431 90.0 90.0 90.0
- Space group: F d -3 m
- Point group: m-3m
- Total number of scatterers: 1
- 0: Si 0 0 0 1 0.05
-
-In general, the unit cell must be specified using either 3 or 6 space-separated floating point numbers, representing
-the three axis lengths and the three angles between them. The list of scatterers is required to be a semi-colon
-separated list of strings which contain the following information: Element symbol, x, y, z (fractional coordinates),
-occupancy (between 0 and 1) and isotropic atomic displacement parameter. The fractional coordinates can also be given
-as fractions (for example :math:`1/2` or :math:`1/3`) and for giving the coordinates in hexagonal or trigonal structures
-this is highly recommended as there may be precision problems with decimal numbers.
-
-While the CrystalStructure class is storing information, there is another class that makes use of these information to
-generate reflections and calculate structure factors. This class is called ReflectionGenerator and can be constructed
-from a CrystalStructure-object:
-
-.. testcode:: ExReflectionGeneratorConstruction
-
- from mantid.geometry import CrystalStructure, ReflectionGenerator
- from mantid.kernel import V3D
-
- silicon = CrystalStructure("5.431 5.431 5.431", "F d -3 m", "Si 0 0 0 1.0 0.05")
- generator = ReflectionGenerator(silicon)
-
- # Create list of unique reflections between 0.7 and 3.0 Angstrom
- hkls = generator.getUniqueHKLs(0.7, 3.0)
-
- print 'There are', len(hkls), 'unique reflections for Si in the specified resolution range.'
- print 'The reflection [222] is' + (' not' if not V3D(2, 2, 2) in hkls else '') + ' contained in the list.'
-
-.. testoutput:: ExReflectionGeneratorConstruction
-
- There are 20 unique reflections for Si in the specified resolution range.
- The reflection [222] is contained in the list.
-
-Checking the reflection conditions of space group :math:`Fd\bar{3}m` (origin choice 1) in the International Tables for
-Crystallography shows that if an atom is on the 8a position, additional conditions apply (:math:`h=2n+1` or
-:math:`h+k+l=4n` for general reflections). Using these additional conditions, the 222 reflection should in fact
-not be in the list. This can be verified by calculating structure factors for the list of reflections and check if
-there are very small values present.
-
-.. testcode:: ExReflectionGeneratorViolations
-
- from mantid.geometry import CrystalStructure, ReflectionGenerator
- import numpy as np
-
- silicon = CrystalStructure("5.431 5.431 5.431", "F d -3 m", "Si 0 0 0 1.0 0.05")
- generator = ReflectionGenerator(silicon)
-
- # Create list of unique reflections between 0.7 and 3.0 Angstrom
- hkls = generator.getUniqueHKLs(0.7, 3.0)
-
- # Calculate structure factors for those HKLs
- fSquared = generator.getFsSquared(hkls)
-
- # Find HKLs with very small structure factors:
- zeroFSquared = [(hkl, sf) for hkl, sf in zip(hkls, fSquared) if sf < 1e-9]
-
- print 'HKL F^2'
- for hkl, sf in zeroFSquared:
- print hkl, ' ', np.round(sf, 2)
-
-The output of the above script should show three reflections with very small values for :math:`F^2`. Their indices
-violate the special conditions mentioned in the previous paragraph, so the reflections are actually extinct:
-
-.. testoutput:: ExReflectionGeneratorViolations
-
- HKL F^2
- [2,2,2] 0.0
- [4,4,2] 0.0
- [6,2,2] 0.0
-
-Those three reflections are included in the list of unique HKLs, because the standard method to determine whether a
-reflection is allowed or not uses the space group symmetry which only reflects the general conditions listed in ITA.
-It is however possible to exclude those reflections at the cost of more computations by making use of the structure
-factor calculation. This can either be done by passing an additional enum-value of the type ReflectionConditionFilter
-to the constructor of ReflectionGenerator or by passing it to the actual generator function:
-
-.. testcode:: ExReflectionGeneratorSF
-
- from mantid.geometry import CrystalStructure, ReflectionGenerator, ReflectionConditionFilter
- from mantid.kernel import V3D
-
- silicon = CrystalStructure("5.431 5.431 5.431", "F d -3 m", "Si 0 0 0 1.0 0.05")
- generator = ReflectionGenerator(silicon)
-
- # Create list of unique reflections between 0.7 and 3.0 Angstrom, use structure factors for filtering
- hkls = generator.getUniqueHKLsUsingFilter(0.7, 3.0, ReflectionConditionFilter.StructureFactor)
-
- print 'There are', len(hkls), 'unique reflections for Si in the specified resolution range.'
- print 'The reflection [222] is' + (' not' if not V3D(2, 2, 2) in hkls else '') + ' contained in the list.'
-
-With this option, the three reflections from the example above are missing and as an indicator, the [222] reflection
-is actually checked:
-
-.. testoutput:: ExReflectionGeneratorSF
-
- There are 17 unique reflections for Si in the specified resolution range.
- The reflection [222] is not contained in the list.
-
-Other options for filtering are Centering and None. If the latter one is used the reflections are only filtered
-according to their :math:`d`-value to fit the specified range.
-
-Another capability of ReflectionGenerator is the calculation of :math:`d`-values for a list of HKLs, very similar
-to the process for :math:`F^2`:
-
-.. testcode:: ExReflectionGeneratorCalculateD
-
- from mantid.geometry import CrystalStructure, ReflectionGenerator, ReflectionConditionFilter
- import numpy as np
-
- silicon = CrystalStructure("5.431 5.431 5.431", "F d -3 m", "Si 0 0 0 1.0 0.05")
- generator = ReflectionGenerator(silicon)
-
- # Create list of unique reflections between 0.7 and 3.0 Angstrom
- hkls = generator.getUniqueHKLsUsingFilter(0.7, 3.0, ReflectionConditionFilter.StructureFactor)
-
- # Calculate d and F^2
- dValues = generator.getDValues(hkls)
- fSquared = generator.getFsSquared(hkls)
-
- pg = silicon.getSpaceGroup().getPointGroup()
-
- # Make list of tuples and sort by d-values, descending, include point group for multiplicity.
- reflections = sorted([(hkl, d, fsq, len(pg.getEquivalents(hkl))) for hkl, d, fsq in zip(hkls, dValues, fSquared)],
- key=lambda x: x[1], reverse=True)
-
- print '{0:<8}{1:>8}{2:>8}{3:>4}'.format('HKL', 'd', 'F^2', 'M')
- for reflection in reflections:
- print '{0!s:<8}{1:>8.5f}{2:>8.2f}{3:>4}'.format(*reflection)
-
-This script will print a table with the reflections including their :math:`d`-value, :math:`F^2` and multiplicity due to point group
-symmetry:
-
-.. testoutput:: ExReflectionGeneratorCalculateD
-
- HKL d F^2 M
- [2,2,0] 1.92015 645.02 12
- [3,1,1] 1.63751 263.85 24
- [4,0,0] 1.35775 377.63 6
- [3,3,1] 1.24596 154.47 24
- [4,2,2] 1.10860 221.08 24
- [3,3,3] 1.04520 90.43 8
- [5,1,1] 1.04520 90.43 24
- [4,4,0] 0.96007 129.43 12
- [5,3,1] 0.91801 52.94 48
- [6,2,0] 0.85872 75.78 24
- [5,3,3] 0.82822 31.00 24
- [4,4,4] 0.78390 44.36 8
- [5,5,1] 0.76049 18.15 24
- [7,1,1] 0.76049 18.15 24
- [6,4,2] 0.72575 25.97 48
- [5,5,3] 0.70706 10.62 24
- [7,3,1] 0.70706 10.62 48
-
-Further reading
-~~~~~~~~~~~~~~~
-
-This concept page explains what's available in the Python interface. Some underlying parts may be interesting for C++
-developers, as the concepts of generating and filtering HKLs are pretty much hidden behind the ReflectionGenerator class
-in the Python interface. More detail is available in the generated C++ documentation.
-
-.. categories:: Concepts