ComponentCreationHelper.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2010 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
/*********************************************************************************
 *  PLEASE READ THIS!!!!!!!
 *
 *  This header MAY NOT be included in any test from a package below Geometry
 *    (e.g. Kernel).
 *  Conversely, this file (and its cpp) MAY NOT be modified to use anything from
 *a
 *  package higher than Geometry (e.g. API, DataObjects, ...)
 *********************************************************************************/
#pragma once
 
#include "MantidGeometry/Instrument.h"
#include "MantidGeometry/Instrument/Detector.h"
#include "MantidGeometry/Objects/CSGObject.h"
#include "MantidKernel/V3D.h"
#include <memory>
 
// Forward declarations
namespace Mantid {
namespace Kernel {
class Quat;
}
namespace Geometry {
class CompAssembly;
class ObjComponent;
class DetectorGroup;
class DetectorsRing;
class IDetector;
class Instrument;
} // namespace Geometry
} // namespace Mantid
 
namespace ComponentCreationHelper {
 
//----------------------------------------------------------------------------------------------
 
void addSampleToInstrument(Mantid::Geometry::Instrument_sptr &instrument, const Mantid::Kernel::V3D &samplePos);
 
void addSourceToInstrument(Mantid::Geometry::Instrument_sptr &instrument, const Mantid::Kernel::V3D &sourcePos,
                           const std::string &name = "moderator");
 
std::string cappedCylinderXML(double radius, double height, const Mantid::Kernel::V3D &baseCentre,
                              const Mantid::Kernel::V3D &axis, const std::string &id);
 
std::shared_ptr<Mantid::Geometry::CSGObject> createCappedCylinder(double radius, double height,
                                                                  const Mantid::Kernel::V3D &baseCentre,
                                                                  const Mantid::Kernel::V3D &axis,
                                                                  const std::string &id);
std::string hollowCylinderXML(double innerRadius, double outerRadius, double height,
                              const Mantid::Kernel::V3D &baseCentre, const Mantid::Kernel::V3D &axis,
                              const std::string &id);
std::shared_ptr<Mantid::Geometry::CSGObject> createHollowCylinder(double innerRadius, double outerRadius, double height,
                                                                  const Mantid::Kernel::V3D &baseCentre,
                                                                  const Mantid::Kernel::V3D &axis,
                                                                  const std::string &id);
std::string sphereXML(double radius, const Mantid::Kernel::V3D &centre, const std::string &id);
std::shared_ptr<Mantid::Geometry::CSGObject>
createSphere(double radius, const Mantid::Kernel::V3D &centre = Mantid::Kernel::V3D(), const std::string &id = "sp-1");
std::string cuboidXML(double xHalfLength, double yHalfLength = -1.0, double zHalfLength = -1.0,
                      const Mantid::Kernel::V3D &centre = {0.0, 0.0, 0.0}, const std::string &id = "detector-shape");
std::shared_ptr<Mantid::Geometry::CSGObject> createCuboid(double xHalfLength, double yHalfLength = -1.0,
                                                          double zHalfLength = -1.0,
                                                          const Mantid::Kernel::V3D &centre = {0.0, 0.0, 0.0},
                                                          const std::string &id = "detector-shape");
std::shared_ptr<Mantid::Geometry::CSGObject> createCuboid(double xHalfLength, double yHalfLength, double zHalfLength,
                                                          double angle, const Mantid::Kernel::V3D &axis);
std::shared_ptr<Mantid::Geometry::CompAssembly> createTestAssemblyOfFourCylinders();
std::shared_ptr<Mantid::Geometry::CSGObject>
createHollowShell(double innerRadius, double outerRadius, const Mantid::Kernel::V3D &centre = Mantid::Kernel::V3D());
std::shared_ptr<Mantid::Geometry::DetectorGroup> createDetectorGroupWith5CylindricalDetectors();
std::shared_ptr<Mantid::Geometry::DetectorGroup>
createDetectorGroupWithNCylindricalDetectorsWithGaps(unsigned int nDet = 4, double gap = 0.01);
std::shared_ptr<Mantid::Geometry::DetectorGroup>
createRingOfCylindricalDetectors(const double R_min = 4.5, const double R_max = 5, const double z000000000000000 = 4);
 
std::vector<std::unique_ptr<Mantid::Geometry::IDetector>>
createVectorOfCylindricalDetectors(const double R_min = 4.5, const double R_max = 5, const double z000000000000000 = 4);
 
Mantid::Geometry::Instrument_sptr
createCylInstrumentWithVerticalOffsetsSpecified(size_t nTubes, std::vector<double> verticalOffsets, size_t nDetsPerTube,
                                                double xMin, double xMax, double yMin, double yMax);
 
Mantid::Geometry::Instrument_sptr createCylInstrumentWithDetInGivenPositions(const std::vector<double> &L2,
                                                                             const std::vector<double> &polar,
                                                                             const std::vector<double> &azim);
Mantid::Geometry::Instrument_sptr
createTestInstrumentCylindrical(int num_banks,
                                const Mantid::Kernel::V3D &sourcePos = Mantid::Kernel::V3D(0.0, 0.0, -10.),
                                const Mantid::Kernel::V3D &samplePos = Mantid::Kernel::V3D(),
                                const double cylRadius = 0.004, const double cylHeight = 0.0002);
 
void addRectangularBank(Mantid::Geometry::Instrument &testInstrument, int idStart, int pixels, double pixelSpacing,
                        const std::string &bankName, const Mantid::Kernel::V3D &bankPos,
                        const Mantid::Kernel::Quat &bankRot);
 
Mantid::Geometry::Instrument_sptr createTestInstrumentRectangular(int num_banks, int pixels,
                                                                  double pixelSpacing = 0.008,
                                                                  double bankDistanceFromSample = 5.0,
                                                                  bool addMonitor = false);
 
Mantid::Geometry::Instrument_sptr createTestInstrumentRectangular2(int num_banks, int pixels,
                                                                   double pixelSpacing = 0.008);
 
Mantid::Geometry::Instrument_sptr createTestUnnamedRectangular2(int num_banks, int pixels, double pixelSpacing = 0.008);
 
Mantid::Geometry::Instrument_sptr createEmptyInstrument();
 
Mantid::Geometry::Instrument_sptr createMinimalInstrument(const Mantid::Kernel::V3D &sourcePos,
                                                          const Mantid::Kernel::V3D &samplePos,
                                                          const Mantid::Kernel::V3D &detectorPos);
 
Mantid::Geometry::Instrument_sptr createMinimalInstrumentWithMonitor(const Mantid::Kernel::V3D &monitorPos,
                                                                     const Mantid::Kernel::Quat &monitorRot);
 
// creates a minimal instrument with optional source, sample, and detector.
Mantid::Geometry::Instrument_sptr createInstrumentWithOptionalComponents(bool haveSource, bool haveSample,
                                                                         bool haveDetector);
 
Mantid::Geometry::Instrument_sptr createSimpleInstrumentWithRotation(
    const Mantid::Kernel::V3D &sourcePos, const Mantid::Kernel::V3D &samplePos, const Mantid::Kernel::V3D &detectorPos,
    const Mantid::Kernel::Quat &relativeBankRotation, const Mantid::Kernel::Quat &relativeDetRotation,
    const Mantid::Kernel::V3D &detOffset = Mantid::Kernel::V3D(0, 0, 0));
 
Mantid::Geometry::Instrument_sptr
createInstrumentWithSourceRotation(const Mantid::Kernel::V3D &sourcePos, const Mantid::Kernel::V3D &samplePos,
                                   const Mantid::Kernel::V3D &detectorPos,
                                   const Mantid::Kernel::Quat &relativeSourceRotation);
 
Mantid::Geometry::Instrument_sptr sansInstrument(const Mantid::Kernel::V3D &sourcePos,
                                                 const Mantid::Kernel::V3D &samplePos,
                                                 const Mantid::Kernel::V3D &trolley1Pos,
                                                 const Mantid::Kernel::V3D &trolley2Pos);
 
Mantid::Geometry::Instrument_sptr
createInstrumentWithPSDTubes(const size_t nTubes = 3, const size_t nPixelsPerTube = 50, const bool mirrorTubes = false);
} // namespace ComponentCreationHelper