InstrumentCreationHelper.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 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 +
#include "MantidFrameworkTestHelpers/InstrumentCreationHelper.h"
 
#include "MantidAPI/Axis.h"
#include "MantidAPI/MatrixWorkspace.h"
#include "MantidGeometry/Instrument/Detector.h"
#include "MantidGeometry/Instrument/ReferenceFrame.h"
 
using namespace Mantid;
using namespace Mantid::Kernel;
using namespace Mantid::Geometry;
using namespace Mantid::API;
 
namespace InstrumentCreationHelper {
 
void addFullInstrumentToWorkspace(MatrixWorkspace &workspace, bool includeMonitors, bool startYNegative,
                                  const std::string &instrumentName) {
  auto instrument = std::make_shared<Instrument>(instrumentName);
  instrument->setReferenceFrame(std::make_shared<ReferenceFrame>(Y, Z, Right, ""));
 
  const double pixelRadius(0.05);
  auto pixelShape =
      ComponentCreationHelper::createCappedCylinder(pixelRadius, 0.02, V3D(0.0, 0.0, 0.0), V3D(0., 1.0, 0.), "tube");
 
  const double detZPos(5.0);
  // Careful! Do not use size_t or auto, the unsigned will break the -=2 below.
  auto ndets = static_cast<int>(workspace.getNumberHistograms());
  if (includeMonitors)
    ndets -= 2;
  for (int i = 0; i < ndets; ++i) {
    std::ostringstream lexer;
    lexer << "pixel-" << i << ")";
    Detector *physicalPixel =
        new Detector(lexer.str(), workspace.getAxis(1)->spectraNo(i), pixelShape, instrument.get());
    int ycount(i);
    if (startYNegative)
      ycount -= 1;
    const double ypos = ycount * 2.0 * pixelRadius;
    physicalPixel->setPos(0.0, ypos, detZPos);
    instrument->add(physicalPixel);
    instrument->markAsDetector(physicalPixel);
    instrument->setXmlText("Fake XML");
    workspace.getSpectrum(i).setDetectorID(physicalPixel->getID());
  }
 
  // Monitors last
  if (includeMonitors) // These occupy the last 2 spectra
  {
    Detector *monitor1 = new Detector("mon1", workspace.getAxis(1)->spectraNo(ndets), IObject_sptr(), instrument.get());
    monitor1->setPos(0.0, 0.0, -9.0);
    instrument->add(monitor1);
    instrument->markAsMonitor(monitor1);
    workspace.getSpectrum(ndets).setDetectorID(ndets + 1);
 
    Detector *monitor2 =
        new Detector("mon2", workspace.getAxis(1)->spectraNo(ndets) + 1, IObject_sptr(), instrument.get());
    monitor2->setPos(0.0, 0.0, -2.0);
    instrument->add(monitor2);
    instrument->markAsMonitor(monitor2);
    workspace.getSpectrum(ndets + 1).setDetectorID(ndets + 2);
  }
 
  // Define a source and sample position
  // Define a source component
  ObjComponent *source =
      new ObjComponent("moderator", ComponentCreationHelper::createSphere(0.1, V3D(0, 0, 0), "1"), instrument.get());
  source->setPos(V3D(0.0, 0.0, -20.0));
  instrument->add(source);
  instrument->markAsSource(source);
 
  // Define a sample position
  Component *sample = new Component("samplePos", instrument.get());
  instrument->setPos(0.0, 0.0, 0.0);
  instrument->add(sample);
  instrument->markAsSamplePos(sample);
  // chopper position
  Component *chop_pos = new Component("chopper-position", Kernel::V3D(0, 0, -10), instrument.get());
  instrument->add(chop_pos);
  workspace.setInstrument(instrument);
}
 
void addInstrumentWithGeographicalDetectorsToWorkspace(Mantid::API::MatrixWorkspace &workspace, const int nlat,
                                                       const int nlong, const double anginc,
                                                       const std::string &instrumentName) {
  V3D samplePosition(0., 0., 0.);
  V3D sourcePosition(0., 0., -14.);
 
  Instrument_sptr instrument = std::make_shared<Instrument>(instrumentName);
  instrument->setReferenceFrame(
      std::make_shared<ReferenceFrame>(Mantid::Geometry::Y, Mantid::Geometry::Z, Right, "0,0,0"));
 
  InstrumentCreationHelper::addSource(instrument, sourcePosition, "source");
  InstrumentCreationHelper::addSample(instrument, samplePosition, "sample");
 
  auto compAss = new ObjCompAssembly("detector-stage");
  // set up detectors with even spacing in latitude and longitude (to match geographical angles
  // approach used in the spatial interpolation\sparse instrument functionality)
  int i = 0;
  constexpr double deg2rad = M_PI / 180.0;
  const double angincRad = anginc * deg2rad;
  constexpr double R = 1.0;
  for (int lat = 0; lat < nlat; ++lat) {
    for (int lng = 0; lng < nlong; ++lng) {
      std::stringstream buffer;
      buffer << "detector_" << i;
      V3D detPos;
      auto latrad = lat * angincRad;
      auto longrad = lng * angincRad;
      detPos[1] = R * sin(latrad);
      const double ct = R * cos(latrad);
      detPos[2] = ct * cos(longrad);
      detPos[0] = ct * sin(longrad);
 
      InstrumentCreationHelper::addDetector(instrument, detPos, i, buffer.str(), compAss);
      // Link it to the workspace
      workspace.getSpectrum(i).addDetectorID(i);
      i++;
    }
  }
  instrument->add(compAss);
  workspace.setInstrument(instrument);
}
 
Component *addComponent(Mantid::Geometry::Instrument_sptr &instrument, const Mantid::Kernel::V3D &position,
                        const std::string &name) {
  auto *component = new Component(name);
  component->setPos(position);
  instrument->add(component);
  return component;
}
 
void addSample(Mantid::Geometry::Instrument_sptr &instrument, const Mantid::Kernel::V3D &position,
               const std::string &name) {
  auto sample = addComponent(instrument, position, name);
  instrument->markAsSamplePos(sample);
}
 
void addSource(Mantid::Geometry::Instrument_sptr &instrument, const Mantid::Kernel::V3D &position,
               const std::string &name) {
  auto source = addComponent(instrument, position, name);
  instrument->markAsSource(source);
}
 
void addMonitor(Mantid::Geometry::Instrument_sptr &instrument, const Mantid::Kernel::V3D &position, const int ID,
                const std::string &name) {
  auto *monitor = new Detector(name, ID, nullptr);
  monitor->setPos(position);
  instrument->add(monitor);
  instrument->markAsMonitor(monitor);
}
 
void addDetector(Mantid::Geometry::Instrument_sptr &instrument, const Mantid::Kernel::V3D &position, const int ID,
                 const std::string &name, Mantid::Geometry::ObjCompAssembly *compAss) {
  // Where 0.01 is half detector width etc.
  Detector *detector = new Detector(name, ID, ComponentCreationHelper::createCuboid(0.01, 0.02, 0.03), nullptr);
  detector->setPos(position);
  instrument->markAsDetector(detector);
  if (compAss) {
    compAss->add(detector);
  } else {
    instrument->add(detector);
  }
}
} // namespace InstrumentCreationHelper