dc/d95/SCDCalibratePanels_8cpp_source.html

// Mantid Repository : https://github.com/mantidproject/mantid

//

// Copyright &copy; 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 "MantidCrystal/SCDCalibratePanels.h"

#include "MantidAPI/AlgorithmManager.h"

#include "MantidAPI/AnalysisDataService.h"

#include "MantidAPI/ConstraintFactory.h"

#include "MantidAPI/FileProperty.h"

#include "MantidAPI/FunctionFactory.h"

#include "MantidAPI/IFunction.h"

#include "MantidAPI/IFunction1D.h"

#include "MantidAPI/Run.h"

#include "MantidAPI/Sample.h"

#include "MantidAPI/WorkspaceFactory.h"

#include "MantidCrystal/CalibrationHelpers.h"

#include "MantidCrystal/SCDPanelErrors.h"

#include "MantidCrystal/SelectCellWithForm.h"

#include "MantidDataObjects/Peak.h"

#include "MantidGeometry/Crystal/EdgePixel.h"

#include "MantidGeometry/Crystal/IndexingUtils.h"

#include "MantidGeometry/Crystal/OrientedLattice.h"

#include "MantidGeometry/Crystal/ReducedCell.h"

#include "MantidGeometry/Instrument/ComponentInfo.h"

#include "MantidKernel/BoundedValidator.h"

#include "MantidKernel/EnabledWhenProperty.h"

#include "MantidKernel/ListValidator.h"

#include <boost/container/flat_set.hpp>

#include <boost/math/special_functions/round.hpp>

#include <fstream>

#include <sstream>


using namespace Mantid::DataObjects;

using namespace Mantid::API;

using namespace std;

using namespace Mantid::Geometry;

using namespace Mantid::Kernel;


namespace Mantid::Crystal {


DECLARE_ALGORITHM(SCDCalibratePanels)


// Default constructor


SCDCalibratePanels::SCDCalibratePanels() {

  useAlgorithm("SCDCalibratePanels", 2);

  deprecatedDate("2025-05-27");

}


const std::string SCDCalibratePanels::name() const { return "SCDCalibratePanels"; }


int SCDCalibratePanels::version() const { return 1; }


const std::string SCDCalibratePanels::category() const { return "Crystal\\Corrections"; }


void SCDCalibratePanels::exec() {

  PeaksWorkspace_sptr peaksWs = getProperty("PeakWorkspace");

  // We must sort the peaks

  std::vector<std::pair<std::string, bool>> criteria{{"BankName", true}};

  peaksWs->sort(criteria);

  // Remove peaks on edge

  int edge = this->getProperty("EdgePixels");

  Geometry::Instrument_const_sptr inst = peaksWs->getInstrument();

  Geometry::ComponentInfo const &compInfo = peaksWs->componentInfo();

  if (edge > 0) {

    std::vector<Peak> &peaks = peaksWs->getPeaks();

    auto it = std::remove_if(peaks.begin(), peaks.end(), [edge, &compInfo](const Peak &pk) {

      return edgePixel(compInfo, pk.getBankName(), pk.getCol(), pk.getRow(), edge);

    });

    peaks.erase(it, peaks.end());

  }

  findU(peaksWs);


  auto nPeaks = static_cast<int>(peaksWs->getNumberPeaks());

  bool changeL1 = getProperty("ChangeL1");

  bool changeT0 = getProperty("ChangeT0");

  bool bankPanels = getProperty("CalibrateBanks");

  bool snapPanels = getProperty("CalibrateSNAPPanels");


  if (changeT0)

    findT0(nPeaks, peaksWs);

  if (changeL1)

    findL1(nPeaks, peaksWs);


  boost::container::flat_set<string> MyBankNames;

  boost::container::flat_set<string> MyPanels;

  if (snapPanels) {

    MyPanels.insert("East");

    MyPanels.insert("West");

    int maxRecurseDepth = 4;


    PRAGMA_OMP(parallel for schedule(dynamic, 1) )

    for (int num = 1; num < 64; ++num) {

      PARALLEL_START_INTERRUPT_REGION

      std::ostringstream mess;

      mess << "bank" << num;

      IComponent_const_sptr comp = inst->getComponentByName(mess.str(), maxRecurseDepth);

      PARALLEL_CRITICAL(MyBankNames)

      if (comp)

        MyBankNames.insert(mess.str());

      PARALLEL_END_INTERRUPT_REGION

    }

    PARALLEL_CHECK_INTERRUPT_REGION

  } else {

    for (int i = 0; i < nPeaks; ++i) {

      std::string bankName = peaksWs->getPeak(i).getBankName();

      if (bankName != "None")

        MyBankNames.insert(bankName);

    }

  }


  std::vector<std::string> fit_workspaces(MyBankNames.size() + MyPanels.size(), "fit_");

  std::vector<std::string> parameter_workspaces(MyBankNames.size() + MyPanels.size(), "params_");

  int bankAndPanelCount = 0;

  for (const auto &MyPanel : MyPanels) {

    fit_workspaces[bankAndPanelCount] += MyPanel;

    parameter_workspaces[bankAndPanelCount] += MyPanel;

    bankAndPanelCount++;

  }

  if (snapPanels) {

    findL2(MyPanels, peaksWs);

    ITableWorkspace_sptr results = AnalysisDataService::Instance().retrieveWS<ITableWorkspace>("params_West");

    double delta = results->cell<double>(4, 1);

    g_log.notice() << "For west rotation change det_arc1 " << delta << " degrees\n";

    results = AnalysisDataService::Instance().retrieveWS<ITableWorkspace>("params_East");

    delta = results->cell<double>(4, 1);

    g_log.notice() << "For east rotation change det_arc2 " << delta << " degrees\n";

  }


  for (const auto &MyBankName : MyBankNames) {

    fit_workspaces[bankAndPanelCount] += MyBankName;

    parameter_workspaces[bankAndPanelCount] += MyBankName;

    bankAndPanelCount++;

  }

  if (bankPanels) {

    findL2(MyBankNames, peaksWs);

  }


  // remove skipped banks

  for (int j = bankAndPanelCount - 1; j >= 0; j--) {

    if (!AnalysisDataService::Instance().doesExist(fit_workspaces[j]))

      fit_workspaces.erase(fit_workspaces.begin() + j);

    if (!AnalysisDataService::Instance().doesExist(parameter_workspaces[j]))

      parameter_workspaces.erase(parameter_workspaces.begin() + j);

  }


  // Try again to optimize L1

  if (changeL1) {

    findL1(nPeaks, peaksWs);

    parameter_workspaces.emplace_back("params_L1");

    fit_workspaces.emplace_back("fit_L1");

  }

  // Add T0 files to groups

  if (changeT0) {

    parameter_workspaces.emplace_back("params_T0");

    fit_workspaces.emplace_back("fit_T0");

  }

  std::sort(parameter_workspaces.begin(), parameter_workspaces.end());

  std::sort(fit_workspaces.begin(), fit_workspaces.end());


  // collect output of fit for each spectrum into workspace groups

  auto groupAlg = AlgorithmManager::Instance().createUnmanaged("GroupWorkspaces");

  groupAlg->initialize();

  groupAlg->setProperty("InputWorkspaces", parameter_workspaces);

  groupAlg->setProperty("OutputWorkspace", "Fit_Parameters");

  groupAlg->execute();


  groupAlg = AlgorithmManager::Instance().createUnmanaged("GroupWorkspaces");

  groupAlg->initialize();

  groupAlg->setProperty("InputWorkspaces", fit_workspaces);

  groupAlg->setProperty("OutputWorkspace", "Fit_Residuals");

  groupAlg->execute();


  // Use new instrument for PeaksWorkspace

  Geometry::Instrument_sptr inst2 = std::const_pointer_cast<Geometry::Instrument>(peaksWs->getInstrument());

  Geometry::OrientedLattice lattice0 = peaksWs->mutableSample().getOrientedLattice();

  PARALLEL_FOR_IF(Kernel::threadSafe(*peaksWs))

  for (int i = 0; i < nPeaks; i++) {

    PARALLEL_START_INTERRUPT_REGION

    DataObjects::Peak &peak = peaksWs->getPeak(i);

    try {

      peak.setInstrument(inst2);

    } catch (const std::exception &exc) {

      g_log.notice() << "Problem in applying calibration to peak " << i << " : " << exc.what() << "\n";

    }

    PARALLEL_END_INTERRUPT_REGION

  }

  PARALLEL_CHECK_INTERRUPT_REGION


  // Find U again for optimized geometry and index peaks

  findU(peaksWs);

  // Save as DetCal and XML if requested

  string DetCalFileName = getProperty("DetCalFilename");

  API::Run &run = peaksWs->mutableRun();

  double T0 = 0.0;

  if (run.hasProperty("T0")) {

    T0 = run.getPropertyValueAsType<double>("T0");

  }

  saveIsawDetCal(inst2, MyBankNames, T0, DetCalFileName);

  string XmlFileName = getProperty("XmlFilename");

  saveXmlFile(XmlFileName, MyBankNames, *inst2);

  // create table of theoretical vs calculated

  //----------------- Calculate & Create Calculated vs Theoretical

  // workspaces------------------,);

  MatrixWorkspace_sptr ColWksp =

      Mantid::API::WorkspaceFactory::Instance().create("Workspace2D", MyBankNames.size(), nPeaks, nPeaks);

  ColWksp->setInstrument(inst2);

  MatrixWorkspace_sptr RowWksp =

      Mantid::API::WorkspaceFactory::Instance().create("Workspace2D", MyBankNames.size(), nPeaks, nPeaks);

  RowWksp->setInstrument(inst2);

  MatrixWorkspace_sptr TofWksp =

      Mantid::API::WorkspaceFactory::Instance().create("Workspace2D", MyBankNames.size(), nPeaks, nPeaks);

  TofWksp->setInstrument(inst2);

  OrientedLattice lattice = peaksWs->mutableSample().getOrientedLattice();

  const DblMatrix &UB = lattice.getUB();

  // sort again since edge peaks can trace to other banks

  peaksWs->sort(criteria);

  PARALLEL_FOR_IF(Kernel::threadSafe(*ColWksp, *RowWksp, *TofWksp))

  for (int i = 0; i < static_cast<int>(MyBankNames.size()); ++i) {

    PARALLEL_START_INTERRUPT_REGION

    const std::string &bankName = *std::next(MyBankNames.begin(), i);

    size_t k = bankName.find_last_not_of("0123456789");

    int bank = 0;

    if (k < bankName.length())

      bank = boost::lexical_cast<int>(bankName.substr(k + 1));

    ColWksp->getSpectrum(i).setSpectrumNo(specnum_t(bank));

    RowWksp->getSpectrum(i).setSpectrumNo(specnum_t(bank));

    TofWksp->getSpectrum(i).setSpectrumNo(specnum_t(bank));

    auto &ColX = ColWksp->mutableX(i);

    auto &ColY = ColWksp->mutableY(i);

    auto &RowX = RowWksp->mutableX(i);

    auto &RowY = RowWksp->mutableY(i);

    auto &TofX = TofWksp->mutableX(i);

    auto &TofY = TofWksp->mutableY(i);

    int icount = 0;

    for (int j = 0; j < nPeaks; j++) {

      Peak peak = peaksWs->getPeak(j);

      if (peak.getBankName() == bankName) {

        try {

          V3D q_lab = (peak.getGoniometerMatrix() * UB) * peak.getHKL() * M_2_PI;

          Peak theoretical(peak.getInstrument(), q_lab);

          ColX[icount] = peak.getCol();

          ColY[icount] = theoretical.getCol();

          RowX[icount] = peak.getRow();

          RowY[icount] = theoretical.getRow();

          TofX[icount] = peak.getTOF();

          TofY[icount] = theoretical.getTOF();

        } catch (...) {

          // g_log.debug() << "Problem only in printing peaks\n";

        }

        icount++;

      }

    }

    PARALLEL_END_INTERRUPT_REGION

  }

  PARALLEL_CHECK_INTERRUPT_REGION


  string colFilename = getProperty("ColFilename");

  string rowFilename = getProperty("RowFilename");

  string tofFilename = getProperty("TofFilename");

  saveNexus(colFilename, ColWksp);

  saveNexus(rowFilename, RowWksp);

  saveNexus(tofFilename, TofWksp);

}


void SCDCalibratePanels::saveNexus(const std::string &outputFile, const MatrixWorkspace_sptr &outputWS) {

  auto save = createChildAlgorithm("SaveNexus");

  save->setProperty("InputWorkspace", outputWS);

  save->setProperty("FileName", outputFile);

  save->execute();

}


void SCDCalibratePanels::findL1(int nPeaks, const DataObjects::PeaksWorkspace_sptr &peaksWs) {

  MatrixWorkspace_sptr L1WS = std::dynamic_pointer_cast<MatrixWorkspace>(

      API::WorkspaceFactory::Instance().create("Workspace2D", 1, 3 * nPeaks, 3 * nPeaks));


  IAlgorithm_sptr fitL1_alg;

  try {

    fitL1_alg = createChildAlgorithm("Fit", -1, -1, false);

  } catch (Exception::NotFoundError &) {

    g_log.error("Can't locate Fit algorithm");

    throw;

  }

  std::ostringstream fun_str;

  fun_str << "name=SCDPanelErrors,Workspace=" << peaksWs->getName() << ",Bank=moderator";

  std::ostringstream tie_str;

  tie_str << "XShift=0.0,YShift=0.0,XRotate=0.0,YRotate=0.0,ZRotate=0.0,"

             "ScaleWidth=1.0,ScaleHeight=1.0,T0Shift ="

          << mT0;

  fitL1_alg->setPropertyValue("Function", fun_str.str());

  fitL1_alg->setProperty("Ties", tie_str.str());

  fitL1_alg->setProperty("InputWorkspace", L1WS);

  fitL1_alg->setProperty("CreateOutput", true);

  fitL1_alg->setProperty("Output", "fit");

  fitL1_alg->executeAsChildAlg();

  std::string fitL1Status = fitL1_alg->getProperty("OutputStatus");

  double chisqL1 = fitL1_alg->getProperty("OutputChi2overDoF");

  MatrixWorkspace_sptr fitL1 = fitL1_alg->getProperty("OutputWorkspace");

  AnalysisDataService::Instance().addOrReplace("fit_L1", fitL1);

  ITableWorkspace_sptr paramsL1 = fitL1_alg->getProperty("OutputParameters");

  AnalysisDataService::Instance().addOrReplace("params_L1", paramsL1);

  double deltaL1 = paramsL1->getRef<double>("Value", 2);

  SCDPanelErrors com;

  com.moveDetector(0.0, 0.0, deltaL1, 0.0, 0.0, 0.0, 1.0, 1.0, "moderator", peaksWs);

  g_log.notice() << "L1 = " << -peaksWs->getInstrument()->getSource()->getPos().Z() << "  " << fitL1Status

                 << " Chi2overDoF " << chisqL1 << "\n";

}


void SCDCalibratePanels::findT0(int nPeaks, const DataObjects::PeaksWorkspace_sptr &peaksWs) {

  MatrixWorkspace_sptr T0WS = std::dynamic_pointer_cast<MatrixWorkspace>(

      API::WorkspaceFactory::Instance().create("Workspace2D", 1, 3 * nPeaks, 3 * nPeaks));


  IAlgorithm_sptr fitT0_alg;

  try {

    fitT0_alg = createChildAlgorithm("Fit", -1, -1, false);

  } catch (Exception::NotFoundError &) {

    g_log.error("Can't locate Fit algorithm");

    throw;

  }

  std::ostringstream fun_str;

  fun_str << "name=SCDPanelErrors,Workspace=" << peaksWs->getName() << ",Bank=none";

  std::ostringstream tie_str;

  tie_str << "XShift=0.0,YShift=0.0,ZShift=0.0,XRotate=0.0,YRotate=0.0,ZRotate=0.0,"

             "ScaleWidth=1.0,ScaleHeight=1.0";

  fitT0_alg->setPropertyValue("Function", fun_str.str());

  fitT0_alg->setProperty("Ties", tie_str.str());

  fitT0_alg->setProperty("InputWorkspace", T0WS);

  fitT0_alg->setProperty("CreateOutput", true);

  fitT0_alg->setProperty("Output", "fit");

  // Does not converge with derviative minimizers

  fitT0_alg->setProperty("Minimizer", "Simplex");

  fitT0_alg->setProperty("MaxIterations", 1000);

  fitT0_alg->executeAsChildAlg();

  std::string fitT0Status = fitT0_alg->getProperty("OutputStatus");

  double chisqT0 = fitT0_alg->getProperty("OutputChi2overDoF");

  MatrixWorkspace_sptr fitT0 = fitT0_alg->getProperty("OutputWorkspace");

  AnalysisDataService::Instance().addOrReplace("fit_T0", fitT0);

  ITableWorkspace_sptr paramsT0 = fitT0_alg->getProperty("OutputParameters");

  AnalysisDataService::Instance().addOrReplace("params_T0", paramsT0);

  mT0 = paramsT0->getRef<double>("Value", 8);

  API::Run &run = peaksWs->mutableRun();

  // set T0 in the run parameters adding to value in peaks file

  double oldT0 = 0.0;

  if (run.hasProperty("T0")) {

    oldT0 = run.getPropertyValueAsType<double>("T0");

  }

  run.addProperty<double>("T0", mT0 + oldT0, true);

  g_log.notice() << "T0 = " << mT0 << "  " << fitT0Status << " Chi2overDoF " << chisqT0 << "\n";

  for (int i = 0; i < peaksWs->getNumberPeaks(); i++) {

    DataObjects::Peak &peak = peaksWs->getPeak(i);


    Units::Wavelength wl;


    wl.initialize(peak.getL1(), 0, {{UnitParams::l2, peak.getL2()}, {UnitParams::twoTheta, peak.getScattering()}});

    peak.setWavelength(wl.singleFromTOF(peak.getTOF() + mT0));

  }

}


void SCDCalibratePanels::findU(const DataObjects::PeaksWorkspace_sptr &peaksWs) {

  IAlgorithm_sptr ub_alg;

  try {

    ub_alg = createChildAlgorithm("CalculateUMatrix", -1, -1, false);

  } catch (Exception::NotFoundError &) {

    g_log.error("Can't locate CalculateUMatrix algorithm");

    throw;

  }

  double a = getProperty("a");

  double b = getProperty("b");

  double c = getProperty("c");

  double alpha = getProperty("alpha");

  double beta = getProperty("beta");

  double gamma = getProperty("gamma");

  if ((a == EMPTY_DBL() || b == EMPTY_DBL() || c == EMPTY_DBL() || alpha == EMPTY_DBL() || beta == EMPTY_DBL() ||

       gamma == EMPTY_DBL()) &&

      peaksWs->sample().hasOrientedLattice()) {

    OrientedLattice latt = peaksWs->mutableSample().getOrientedLattice();

    a = latt.a();

    b = latt.b();

    c = latt.c();

    alpha = latt.alpha();

    beta = latt.beta();

    gamma = latt.gamma();

  }

  ub_alg->setProperty("PeaksWorkspace", peaksWs);

  ub_alg->setProperty("a", a);

  ub_alg->setProperty("b", b);

  ub_alg->setProperty("c", c);

  ub_alg->setProperty("alpha", alpha);

  ub_alg->setProperty("beta", beta);

  ub_alg->setProperty("gamma", gamma);

  ub_alg->executeAsChildAlg();


  // Reindex peaks with new UB

  auto alg = createChildAlgorithm("IndexPeaks");

  alg->setPropertyValue("PeaksWorkspace", peaksWs->getName());

  alg->setProperty("Tolerance", 0.15);

  alg->executeAsChildAlg();

  int numIndexed = alg->getProperty("NumIndexed");

  g_log.notice() << "Number Indexed = " << numIndexed << "\n";

  g_log.notice() << peaksWs->sample().getOrientedLattice().getUB() << "\n";

}


void SCDCalibratePanels::saveIsawDetCal(std::shared_ptr<Instrument> &instrument,

                                        boost::container::flat_set<string> &AllBankName, double T0,

                                        const string &filename) {

  // having a filename triggers doing the work

  if (filename.empty())

    return;


  g_log.notice() << "Saving DetCal file in " << filename << "\n";


  // create a workspace to pass to SaveIsawDetCal

  const size_t number_spectra = instrument->getNumberDetectors();

  DataObjects::Workspace2D_sptr wksp = std::dynamic_pointer_cast<DataObjects::Workspace2D>(

      WorkspaceFactory::Instance().create("Workspace2D", number_spectra, 2, 1));

  wksp->setInstrument(instrument);

  wksp->rebuildSpectraMapping(true /* include monitors */);


  // convert the bank names into a vector

  std::vector<string> banknames(AllBankName.begin(), AllBankName.end());


  // call SaveIsawDetCal

  auto alg = createChildAlgorithm("SaveIsawDetCal");

  alg->setProperty("InputWorkspace", wksp);

  alg->setProperty("Filename", filename);

  alg->setProperty("TimeOffset", T0);

  alg->setProperty("BankNames", banknames);

  alg->executeAsChildAlg();

}


void SCDCalibratePanels::init() {

  declareProperty(std::make_unique<WorkspaceProperty<PeaksWorkspace>>("PeakWorkspace", "", Kernel::Direction::InOut),

                  "Workspace of Indexed Peaks");


  auto mustBePositive = std::make_shared<BoundedValidator<double>>();

  mustBePositive->setLower(0.0);


  declareProperty("a", EMPTY_DBL(), mustBePositive,

                  "Lattice Parameter a (Leave empty to use lattice constants "

                  "in peaks workspace)");

  declareProperty("b", EMPTY_DBL(), mustBePositive,

                  "Lattice Parameter b (Leave empty to use lattice constants "

                  "in peaks workspace)");

  declareProperty("c", EMPTY_DBL(), mustBePositive,

                  "Lattice Parameter c (Leave empty to use lattice constants "

                  "in peaks workspace)");

  declareProperty("alpha", EMPTY_DBL(), mustBePositive,

                  "Lattice Parameter alpha in degrees (Leave empty to use "

                  "lattice constants in peaks workspace)");

  declareProperty("beta", EMPTY_DBL(), mustBePositive,

                  "Lattice Parameter beta in degrees (Leave empty to use "

                  "lattice constants in peaks workspace)");

  declareProperty("gamma", EMPTY_DBL(), mustBePositive,

                  "Lattice Parameter gamma in degrees (Leave empty to use "

                  "lattice constants in peaks workspace)");

  declareProperty("ChangeL1", true, "Change the L1(source to sample) distance");

  declareProperty("ChangeT0", false, "Change the T0 (initial TOF)");

  declareProperty("ChangePanelSize", true,

                  "Change the height and width of the "

                  "detectors.  Implemented only for "

                  "RectangularDetectors.");


  declareProperty("EdgePixels", 0, "Remove peaks that are at pixels this close to edge. ");

  declareProperty("CalibrateBanks", true, "Calibrate the panels of the banks.");

  declareProperty("CalibrateSNAPPanels", false,

                  "Calibrate the 3 X 3 panels of the "

                  "sides of SNAP.");


  // ---------- outputs

  const std::vector<std::string> detcalExts{".DetCal", ".Det_Cal"};

  declareProperty(

      std::make_unique<FileProperty>("DetCalFilename", "SCDCalibrate.DetCal", FileProperty::Save, detcalExts),

      "Path to an ISAW-style .detcal file to save.");


  declareProperty(std::make_unique<FileProperty>("XmlFilename", "", FileProperty::OptionalSave, ".xml"),

                  "Path to an Mantid .xml description(for LoadParameterFile) file to "

                  "save.");


  declareProperty(std::make_unique<FileProperty>("ColFilename", "ColCalcvsTheor.nxs", FileProperty::Save, ".nxs"),

                  "Path to a NeXus file comparing calculated and theoretical "

                  "column of each peak.");


  declareProperty(std::make_unique<FileProperty>("RowFilename", "RowCalcvsTheor.nxs", FileProperty::Save, ".nxs"),

                  "Path to a NeXus file comparing calculated and theoretical "

                  "row of each peak.");


  declareProperty(std::make_unique<FileProperty>("TofFilename", "TofCalcvsTheor.nxs", FileProperty::Save, ".nxs"),

                  "Path to a NeXus file comparing calculated and theoretical "

                  "TOF of each peak.");


  const string OUTPUTS("Outputs");

  setPropertyGroup("DetCalFilename", OUTPUTS);

  setPropertyGroup("XmlFilename", OUTPUTS);

  setPropertyGroup("ColFilename", OUTPUTS);

  setPropertyGroup("RowFilename", OUTPUTS);

  setPropertyGroup("TofFilename", OUTPUTS);

}


void writeXmlParameter(ofstream &ostream, const string &name, const double value) {

  ostream << "  <parameter name =\"" << name << "\"><value val=\"" << value << "\" /> </parameter>\n";

}


void SCDCalibratePanels::saveXmlFile(const string &FileName, const boost::container::flat_set<string> &AllBankNames,

                                     const Instrument &instrument) const {

  if (FileName.empty())

    return;


  g_log.notice() << "Saving parameter file as " << FileName << "\n";


  // create the file and add the header

  ofstream oss3(FileName.c_str());

  oss3 << "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n";

  oss3 << " <parameter-file instrument=\"" << instrument.getName() << "\" valid-from=\""

       << instrument.getValidFromDate().toISO8601String() << "\">\n";

  ParameterMap_sptr pmap = instrument.getParameterMap();


  // write out the detector banks

  for (auto bankName : AllBankNames) {

    if (instrument.getName().compare("CORELLI") == 0.0)

      bankName.append("/sixteenpack");

    oss3 << "<component-link name=\"" << bankName << "\">\n";

    std::shared_ptr<const IComponent> bank = instrument.getComponentByName(bankName);


    Quat relRot = bank->getRelativeRot();


    std::vector<double> relRotAngles = relRot.getEulerAngles("XYZ");


    writeXmlParameter(oss3, "rotx", relRotAngles[0]);

    writeXmlParameter(oss3, "roty", relRotAngles[1]);

    writeXmlParameter(oss3, "rotz", relRotAngles[2]);


    V3D pos1 = bank->getRelativePos();

    writeXmlParameter(oss3, "x", pos1.X());

    writeXmlParameter(oss3, "y", pos1.Y());

    writeXmlParameter(oss3, "z", pos1.Z());


    vector<double> oldScalex = pmap->getDouble(bank->getName(), string("scalex"));

    vector<double> oldScaley = pmap->getDouble(bank->getName(), string("scaley"));


    double scalex, scaley;

    if (!oldScalex.empty())

      scalex = oldScalex[0];

    else

      scalex = 1.;


    if (!oldScaley.empty())

      scaley = oldScaley[0];

    else

      scaley = 1.;


    oss3 << R"(  <parameter name ="scalex"><value val=")" << scalex << "\" /> </parameter>\n";

    oss3 << R"(  <parameter name ="scaley"><value val=")" << scaley << "\" /> </parameter>\n";

    oss3 << "</component-link>\n";

  } // for each bank in the group


  // write out the source

  IComponent_const_sptr source = instrument.getSource();


  oss3 << "<component-link name=\"" << source->getName() << "\">\n";

  V3D sourceRelPos = source->getRelativePos();


  writeXmlParameter(oss3, "x", sourceRelPos.X());

  writeXmlParameter(oss3, "y", sourceRelPos.Y());

  writeXmlParameter(oss3, "z", sourceRelPos.Z());

  oss3 << "</component-link>\n";

  oss3 << "</parameter-file>\n";


  // flush and close the file

  oss3.flush();

  oss3.close();

}


void SCDCalibratePanels::findL2(boost::container::flat_set<string> MyBankNames,

                                const DataObjects::PeaksWorkspace_sptr &peaksWs) {

  bool changeSize = getProperty("ChangePanelSize");

  Geometry::Instrument_const_sptr inst = peaksWs->getInstrument();


  PARALLEL_FOR_IF(Kernel::threadSafe(*peaksWs))

  for (int bankIndex = 0; bankIndex < static_cast<int>(MyBankNames.size()); ++bankIndex) {

    PARALLEL_START_INTERRUPT_REGION

    const std::string &iBank = *std::next(MyBankNames.begin(), bankIndex);

    const std::string bankName = "__PWS_" + iBank;

    PeaksWorkspace_sptr local = peaksWs->clone();

    AnalysisDataService::Instance().addOrReplace(bankName, local);

    std::vector<Peak> &localPeaks = local->getPeaks();

    auto lit = std::remove_if(localPeaks.begin(), localPeaks.end(), [&iBank](const Peak &pk) {

      std::string name = pk.getBankName();

      IComponent_const_sptr det = pk.getInstrument()->getComponentByName(name);

      if (det && iBank.substr(0, 4) != "bank") {

        IComponent_const_sptr parent = det->getParent();

        if (parent) {

          IComponent_const_sptr grandparent = parent->getParent();

          if (grandparent) {

            name = grandparent->getName();

          }

        }

      }


      return name != iBank;

    });

    localPeaks.erase(lit, localPeaks.end());


    int nBankPeaks = local->getNumberPeaks();

    if (nBankPeaks < 6) {

      g_log.notice() << "Too few peaks for " << iBank << "\n";

      continue;

    }


    MatrixWorkspace_sptr q3DWS = std::dynamic_pointer_cast<MatrixWorkspace>(

        API::WorkspaceFactory::Instance().create("Workspace2D", 1, 3 * nBankPeaks, 3 * nBankPeaks));


    auto &outSpec = q3DWS->getSpectrum(0);

    auto &yVec = outSpec.mutableY();

    auto &eVec = outSpec.mutableE();

    auto &xVec = outSpec.mutableX();

    yVec = 0.0;


    for (int i = 0; i < nBankPeaks; i++) {

      const DataObjects::Peak &peak = local->getPeak(i);

      // 1/sigma is considered the weight for the fit

      double weight = 1.;                // default is even weighting

      if (peak.getSigmaIntensity() > 0.) // prefer weight by sigmaI

        weight = 1.0 / peak.getSigmaIntensity();

      else if (peak.getIntensity() > 0.) // next favorite weight by I

        weight = 1.0 / peak.getIntensity();

      else if (peak.getBinCount() > 0.) // then by counts in peak centre

        weight = 1.0 / peak.getBinCount();

      for (int j = 0; j < 3; j++) {

        int k = i * 3 + j;

        xVec[k] = k;

        eVec[k] = weight;

      }

    }


    IAlgorithm_sptr fit_alg;

    try {

      fit_alg = createChildAlgorithm("Fit", -1, -1, false);

    } catch (Exception::NotFoundError &) {

      g_log.error("Can't locate Fit algorithm");

      throw;

    }

    std::ostringstream fun_str;

    fun_str << "name=SCDPanelErrors,Workspace=" + bankName << ",Bank=" << iBank;

    fit_alg->setPropertyValue("Function", fun_str.str());

    std::ostringstream tie_str;

    tie_str << "ScaleWidth=1.0,ScaleHeight=1.0,T0Shift =" << mT0;

    fit_alg->setProperty("Ties", tie_str.str());

    fit_alg->setProperty("InputWorkspace", q3DWS);

    fit_alg->setProperty("CreateOutput", true);

    fit_alg->setProperty("Output", "fit");

    fit_alg->executeAsChildAlg();

    std::string fitStatus = fit_alg->getProperty("OutputStatus");

    double fitChisq = fit_alg->getProperty("OutputChi2overDoF");

    g_log.notice() << iBank << "  " << fitStatus << " Chi2overDoF " << fitChisq << "\n";

    MatrixWorkspace_sptr fitWS = fit_alg->getProperty("OutputWorkspace");

    AnalysisDataService::Instance().addOrReplace("fit_" + iBank, fitWS);

    ITableWorkspace_sptr paramsWS = fit_alg->getProperty("OutputParameters");

    AnalysisDataService::Instance().addOrReplace("params_" + iBank, paramsWS);

    double xShift = paramsWS->getRef<double>("Value", 0);

    double yShift = paramsWS->getRef<double>("Value", 1);

    double zShift = paramsWS->getRef<double>("Value", 2);

    double xRotate = paramsWS->getRef<double>("Value", 3);

    double yRotate = paramsWS->getRef<double>("Value", 4);

    double zRotate = paramsWS->getRef<double>("Value", 5);

    double scaleWidth = 1.0;

    double scaleHeight = 1.0;

    // Scaling only implemented for Rectangular Detectors

    Geometry::IComponent_const_sptr comp = peaksWs->getInstrument()->getComponentByName(iBank);

    std::shared_ptr<const Geometry::RectangularDetector> rectDet =

        std::dynamic_pointer_cast<const Geometry::RectangularDetector>(comp);

    if (rectDet && changeSize) {

      IAlgorithm_sptr fit2_alg;

      try {

        fit2_alg = createChildAlgorithm("Fit", -1, -1, false);

      } catch (Exception::NotFoundError &) {

        g_log.error("Can't locate Fit algorithm");

        throw;

      }

      fit2_alg->setPropertyValue("Function", fun_str.str());

      std::ostringstream tie_str2;

      tie_str2 << "XShift=" << xShift << ",YShift=" << yShift << ",ZShift=" << zShift << ",XRotate=" << xRotate

               << ",YRotate=" << yRotate << ",ZRotate=" << zRotate << ",T0Shift =" << mT0;

      fit2_alg->setProperty("Ties", tie_str2.str());

      fit2_alg->setProperty("InputWorkspace", q3DWS);

      fit2_alg->setProperty("CreateOutput", true);

      fit2_alg->setProperty("Output", "fit");

      fit2_alg->executeAsChildAlg();

      std::string fit2Status = fit2_alg->getProperty("OutputStatus");

      double fit2Chisq = fit2_alg->getProperty("OutputChi2overDoF");

      g_log.notice() << iBank << "  " << fit2Status << " Chi2overDoF " << fit2Chisq << "\n";

      fitWS = fit2_alg->getProperty("OutputWorkspace");

      AnalysisDataService::Instance().addOrReplace("fit_" + iBank, fitWS);

      paramsWS = fit2_alg->getProperty("OutputParameters");

      AnalysisDataService::Instance().addOrReplace("params_" + iBank, paramsWS);

      scaleWidth = paramsWS->getRef<double>("Value", 6);

      scaleHeight = paramsWS->getRef<double>("Value", 7);

    }

    AnalysisDataService::Instance().remove(bankName);

    SCDPanelErrors det;

    det.moveDetector(xShift, yShift, zShift, xRotate, yRotate, zRotate, scaleWidth, scaleHeight, iBank, peaksWs);

    PARALLEL_END_INTERRUPT_REGION

  }

  PARALLEL_CHECK_INTERRUPT_REGION

}


} // namespace Mantid::Crystal

name
std::string name
Definition Run.cpp:60

AlgorithmManager.h

DECLARE_ALGORITHM
#define DECLARE_ALGORITHM(classname)
Definition Algorithm.h:538

AnalysisDataService.h

BoundedValidator.h

CalibrationHelpers.h

ComponentInfo.h

ConstraintFactory.h

EdgePixel.h

EnabledWhenProperty.h

FileProperty.h

value
double value
The value of the point.
Definition FitMW.cpp:51

FunctionFactory.h

IFunction1D.h

IFunction.h

numIndexed
int numIndexed
Definition IndexPeaks.cpp:135

IndexingUtils.h

ListValidator.h

PARALLEL_START_INTERRUPT_REGION
#define PARALLEL_START_INTERRUPT_REGION
Begins a block to skip processing is the algorithm has been interupted Note the end of the block if n...
Definition MultiThreaded.h:94

PARALLEL_CRITICAL
#define PARALLEL_CRITICAL(name)
Definition MultiThreaded.h:224

PARALLEL_END_INTERRUPT_REGION
#define PARALLEL_END_INTERRUPT_REGION
Ends a block to skip processing is the algorithm has been interupted Note the start of the block if n...
Definition MultiThreaded.h:102

PARALLEL_FOR_IF
#define PARALLEL_FOR_IF(condition)
Empty definitions - to enable set your complier to enable openMP.
Definition MultiThreaded.h:218

PRAGMA_OMP
#define PRAGMA_OMP(expression)
Definition MultiThreaded.h:234

PARALLEL_CHECK_INTERRUPT_REGION
#define PARALLEL_CHECK_INTERRUPT_REGION
Adds a check after a Parallel region to see if it was interupted.
Definition MultiThreaded.h:117

OrientedLattice.h

Peak.h

ReducedCell.h

Run.h

SCDCalibratePanels.h

SCDPanelErrors.h

Sample.h

SelectCellWithForm.h

WorkspaceFactory.h

Mantid::API::Algorithm::declareProperty
void declareProperty(std::unique_ptr< Kernel::Property > p, const std::string &doc="") override
Add a property to the list of managed properties.
Definition Algorithm.cpp:1803

Mantid::API::Algorithm::getProperty
TypedValue getProperty(const std::string &name) const override
Get the value of a property.
Definition Algorithm.cpp:1966

Mantid::API::Algorithm::createChildAlgorithm
virtual std::shared_ptr< Algorithm > createChildAlgorithm(const std::string &name, const double startProgress=-1., const double endProgress=-1., const bool enableLogging=true, const int &version=-1)
Create a Child Algorithm.
Definition Algorithm.cpp:860

Mantid::API::Algorithm::g_log
Kernel::Logger & g_log
Definition Algorithm.h:422

Mantid::API::FileProperty::OptionalSave
@ OptionalSave
to specify a file to write to but an empty string is
Definition FileProperty.h:50

Mantid::API::FileProperty::Save
@ Save
to specify a file to write to, the file may or may not exist
Definition FileProperty.h:49

Mantid::API::ITableWorkspace
ITableWorkspace is an implementation of Workspace in which the data are organised in columns of same ...
Definition ITableWorkspace.h:101

Mantid::API::ITableWorkspace::cell
T & cell(size_t row, size_t col)
Get the reference to the element in row row and column col.
Definition ITableWorkspace.h:209

Mantid::API::LogManager::hasProperty
bool hasProperty(const std::string &name) const
Does the property exist on the object.
Definition LogManager.cpp:365

Mantid::API::LogManager::getPropertyValueAsType
HeldType getPropertyValueAsType(const std::string &name) const
Get the value of a property as the given TYPE.
Definition LogManager.cpp:468

Mantid::API::Run
This class stores information regarding an experimental run as a series of log entries.
Definition Run.h:35

Mantid::API::WorkspaceProperty
A property class for workspaces.
Definition WorkspaceProperty.h:58

Mantid::Crystal::SCDCalibratePanels
SCDCalibratePanels calibrates instrument parameters for Rectangular Detectors.
Definition SCDCalibratePanels.h:30

Mantid::Crystal::SCDCalibratePanels::saveXmlFile
void saveXmlFile(const std::string &FileName, const boost::container::flat_set< std::string > &AllBankNames, const Geometry::Instrument &instrument) const
Saves the new instrument to an xml file that can be used with the LoadParameterFile Algorithm.
Definition SCDCalibratePanels.cpp:514

Mantid::Crystal::SCDCalibratePanels::init
void init() override
Virtual method - must be overridden by concrete algorithm.
Definition SCDCalibratePanels.cpp:442

Mantid::Crystal::SCDCalibratePanels::name
const std::string name() const override
function to return a name of the algorithm, must be overridden in all algorithms
Definition SCDCalibratePanels.cpp:51

Mantid::Crystal::SCDCalibratePanels::findT0
void findT0(int nPeaks, const DataObjects::PeaksWorkspace_sptr &peaksWs)
Function to optimize T0.
Definition SCDCalibratePanels.cpp:310

Mantid::Crystal::SCDCalibratePanels::findL2
void findL2(boost::container::flat_set< std::string > MyBankNames, const DataObjects::PeaksWorkspace_sptr &peaksWs)
Function to optimize L2.
Definition SCDCalibratePanels.cpp:583

Mantid::Crystal::SCDCalibratePanels::version
int version() const override
Algorithm's version for identification overriding a virtual method.
Definition SCDCalibratePanels.cpp:53

Mantid::Crystal::SCDCalibratePanels::saveIsawDetCal
void saveIsawDetCal(std::shared_ptr< Geometry::Instrument > &instrument, boost::container::flat_set< std::string > &AllBankName, double T0, const std::string &filename)
Really this is the operator SaveIsawDetCal but only the results of the given banks are saved.
Definition SCDCalibratePanels.cpp:414

Mantid::Crystal::SCDCalibratePanels::findU
void findU(const DataObjects::PeaksWorkspace_sptr &peaksWs)
Function to calculate U.
Definition SCDCalibratePanels.cpp:360

Mantid::Crystal::SCDCalibratePanels::exec
void exec() override
Virtual method - must be overridden by concrete algorithm.
Definition SCDCalibratePanels.cpp:57

Mantid::Crystal::SCDCalibratePanels::saveNexus
void saveNexus(const std::string &outputFile, const API::MatrixWorkspace_sptr &outputWS)
save workspaces
Definition SCDCalibratePanels.cpp:267

Mantid::Crystal::SCDCalibratePanels::findL1
void findL1(int nPeaks, const DataObjects::PeaksWorkspace_sptr &peaksWs)
Function to optimize L1.
Definition SCDCalibratePanels.cpp:274

Mantid::Crystal::SCDCalibratePanels::mT0
double mT0
Definition SCDCalibratePanels.h:70

Mantid::Crystal::SCDCalibratePanels::category
const std::string category() const override
Algorithm's category for identification overriding a virtual method.
Definition SCDCalibratePanels.cpp:55

Mantid::Crystal::SCDPanelErrors
Definition SCDPanelErrors.h:24

Mantid::Crystal::SCDPanelErrors::moveDetector
void moveDetector(double x, double y, double z, double rotx, double roty, double rotz, double scalex, double scaley, std::string detname, const API::Workspace_sptr &inputW) const
Move detectors with parameters.
Definition SCDPanelErrors.cpp:75

Mantid::DataObjects::BasePeak::getIntensity
double getIntensity() const override
Return the integrated peak intensity.
Definition BasePeak.cpp:184

Mantid::DataObjects::BasePeak::getSigmaIntensity
double getSigmaIntensity() const override
Return the error on the integrated peak intensity.
Definition BasePeak.cpp:187

Mantid::DataObjects::BasePeak::getHKL
Mantid::Kernel::V3D getHKL() const override
Return the HKL vector.
Definition BasePeak.cpp:102

Mantid::DataObjects::BasePeak::getBinCount
double getBinCount() const override
Return the # of counts in the bin at its peak.
Definition BasePeak.cpp:181

Mantid::DataObjects::BasePeak::getGoniometerMatrix
Mantid::Kernel::Matrix< double > getGoniometerMatrix() const override
Get the goniometer rotation matrix at which this peak was measured.
Definition BasePeak.cpp:209

Mantid::DataObjects::Peak
Structure describing a single-crystal peak.
Definition Peak.h:34

Mantid::DataObjects::Peak::getCol
int getCol() const override
For RectangularDetectors only, returns the column (x) of the pixel of the detector or -1 if not found...
Definition Peak.cpp:335

Mantid::DataObjects::Peak::getInstrument
Geometry::Instrument_const_sptr getInstrument() const
Return a shared ptr to the instrument for this peak.
Definition Peak.cpp:320

Mantid::DataObjects::Peak::getRow
int getRow() const override
For RectangularDetectors only, returns the row (y) of the pixel of the detector or -1 if not found.
Definition Peak.cpp:326

Mantid::DataObjects::Peak::setWavelength
void setWavelength(double wavelength) override
Set the incident wavelength of the neutron.
Definition Peak.cpp:188

Mantid::DataObjects::Peak::getL1
double getL1() const override
Return the L1 flight path length (source to sample), in meters.
Definition Peak.cpp:724

Mantid::DataObjects::Peak::getTOF
double getTOF() const override
Calculate the time of flight (in microseconds) of the neutrons for this peak, using the geometry of t...
Definition Peak.cpp:373

Mantid::DataObjects::Peak::getL2
double getL2() const override
Return the L2 flight path length (sample to detector), in meters.
Definition Peak.cpp:728

Mantid::DataObjects::Peak::getBankName
const std::string & getBankName() const
Find the name of the bank that is the parent of the detector.
Definition Peak.cpp:347

Mantid::DataObjects::Peak::setInstrument
void setInstrument(const Geometry::Instrument_const_sptr &inst)
Set the instrument (and save the source/sample pos).
Definition Peak.cpp:294

Mantid::DataObjects::Peak::getScattering
double getScattering() const override
Calculate the scattering angle of the peak
Definition Peak.cpp:391

Mantid::Geometry::CompAssembly::getComponentByName
std::shared_ptr< const IComponent > getComponentByName(const std::string &cname, int nlevels=0) const override
Returns a pointer to the first component of assembly encountered with the given name.
Definition CompAssembly.cpp:262

Mantid::Geometry::ComponentInfo
ComponentInfo : Provides a component centric view on to the instrument.
Definition ComponentInfo.h:41

Mantid::Geometry::Component::getName
std::string getName() const override
Get the IComponent name.
Definition Component.cpp:175

Mantid::Geometry::Instrument
Base Instrument Class.
Definition Instrument.h:48

Mantid::Geometry::Instrument::getSource
IComponent_const_sptr getSource() const
Gets a pointer to the source.
Definition Instrument.cpp:328

Mantid::Geometry::Instrument::getParameterMap
std::shared_ptr< ParameterMap > getParameterMap() const
Pointer to the NOT const ParameterMap holding the parameters of the modified instrument components.
Definition Instrument.cpp:135

Mantid::Geometry::Instrument::getValidFromDate
Types::Core::DateAndTime getValidFromDate() const
Definition Instrument.h:171

Mantid::Geometry::OrientedLattice
Class to implement UB matrix.
Definition OrientedLattice.h:21

Mantid::Geometry::OrientedLattice::getUB
const Kernel::DblMatrix & getUB() const
Get the UB matrix.
Definition OrientedLattice.cpp:95

Mantid::Geometry::UnitCell::alpha
double alpha() const
Get lattice parameter.
Definition UnitCell.cpp:133

Mantid::Geometry::UnitCell::a
double a(int nd) const
Get lattice parameter a1-a3 as function of index (0-2)
Definition UnitCell.cpp:94

Mantid::Geometry::UnitCell::c
double c() const
Get lattice parameter.
Definition UnitCell.cpp:128

Mantid::Geometry::UnitCell::beta
double beta() const
Get lattice parameter.
Definition UnitCell.cpp:138

Mantid::Geometry::UnitCell::b
double b() const
Get lattice parameter.
Definition UnitCell.cpp:123

Mantid::Geometry::UnitCell::gamma
double gamma() const
Get lattice parameter.
Definition UnitCell.cpp:143

Mantid::Kernel::Exception::NotFoundError
Exception for when an item is not found in a collection.
Definition Exception.h:145

Mantid::Kernel::IPropertyManager::setPropertyGroup
void setPropertyGroup(const std::string &name, const std::string &group)
Set the group for a given property.
Definition IPropertyManager.h:335

Mantid::Kernel::Logger::notice
void notice(const std::string &msg)
Logs at notice level.
Definition Logger.cpp:126

Mantid::Kernel::Logger::error
void error(const std::string &msg)
Logs at error level.
Definition Logger.cpp:108

Mantid::Kernel::Matrix< double >

Mantid::Kernel::Quat
Class for quaternions.
Definition Quat.h:39

Mantid::Kernel::Quat::getEulerAngles
std::vector< double > getEulerAngles(const std::string &convention) const
Calculate the Euler angles that are equivalent to this Quaternion.
Definition Quat.cpp:729

Mantid::Kernel::SingletonHolder::Instance
static T & Instance()
Return a reference to the Singleton instance, creating it if it does not already exist Creation is do...
Definition SingletonHolder.h:91

Mantid::Kernel::Unit::initialize
void initialize(const double &_l1, const int &_emode, const UnitParametersMap &params)
Initialize the unit to perform conversion using singleToTof() and singleFromTof()
Definition Unit.cpp:133

Mantid::Kernel::Units::Wavelength
Wavelength in Angstrom.
Definition Unit.h:267

Mantid::Kernel::Units::Wavelength::singleFromTOF
double singleFromTOF(const double tof) const override
Convert a single tof value to this unit.
Definition Unit.cpp:394

Mantid::Kernel::V3D
Class for 3D vectors.
Definition V3D.h:34

Mantid::Kernel::V3D::X
constexpr double X() const noexcept
Get x.
Definition V3D.h:238

Mantid::Kernel::V3D::Y
constexpr double Y() const noexcept
Get y.
Definition V3D.h:239

Mantid::Kernel::V3D::Z
constexpr double Z() const noexcept
Get z.
Definition V3D.h:240

Mantid::API
Definition AbsorptionCorrection.h:20

Mantid::API::IAlgorithm_sptr
std::shared_ptr< IAlgorithm > IAlgorithm_sptr
shared pointer to Mantid::API::IAlgorithm
Definition IAlgorithm_fwd.h:20

Mantid::API::ITableWorkspace_sptr
std::shared_ptr< ITableWorkspace > ITableWorkspace_sptr
shared pointer to Mantid::API::ITableWorkspace
Definition ITableWorkspace_fwd.h:20

Mantid::API::MatrixWorkspace_sptr
std::shared_ptr< MatrixWorkspace > MatrixWorkspace_sptr
shared pointer to the matrix workspace base class
Definition MatrixWorkspace.h:586

Mantid::Crystal
Definition AddPeakHKL.h:13

Mantid::Crystal::writeXmlParameter
void writeXmlParameter(ofstream &ostream, const string &name, const double value)
Definition SCDCalibratePanels.cpp:510

Mantid::DataObjects
Definition ConjoinWorkspaces.h:17

Mantid::DataObjects::PeaksWorkspace_sptr
std::shared_ptr< PeaksWorkspace > PeaksWorkspace_sptr
Typedef for a shared pointer to a peaks workspace.
Definition SaveIsawPeaks.h:18

Mantid::DataObjects::Workspace2D_sptr
std::shared_ptr< Workspace2D > Workspace2D_sptr
shared pointer to Mantid::DataObjects::Workspace2D
Definition Workspace2D_fwd.h:19

Mantid::DataObjects::create
std::unique_ptr< T > create(const P &parent, const IndexArg &indexArg, const HistArg &histArg)
This is the create() method that all the other create() methods call.
Definition WorkspaceCreation.h:132

Mantid::Geometry
Definition AbsorptionCorrection.h:23

Mantid::Geometry::IComponent_const_sptr
std::shared_ptr< const IComponent > IComponent_const_sptr
Typdef of a shared pointer to a const IComponent.
Definition IComponent.h:167

Mantid::Geometry::ParameterMap_sptr
std::shared_ptr< ParameterMap > ParameterMap_sptr
ParameterMap shared pointer typedef.
Definition ParameterMap.h:335

Mantid::Geometry::Instrument_const_sptr
std::shared_ptr< const Instrument > Instrument_const_sptr
Shared pointer to an const instrument object.
Definition Instrument_fwd.h:23

Mantid::Geometry::Instrument_sptr
std::shared_ptr< Instrument > Instrument_sptr
Shared pointer to an instrument object.
Definition Instrument_fwd.h:21

Mantid::Kernel
Definition AnnularRingAbsorption.h:15

Mantid::Kernel::threadSafe
std::enable_if< std::is_pointer< Arg >::value, bool >::type threadSafe(Arg workspace)
Thread-safety check Checks the workspace to ensure it is suitable for multithreaded access.
Definition MultiThreaded.h:22

Mantid::Kernel::UnitParams::delta
@ delta

Mantid::specnum_t
int32_t specnum_t
Typedef for a spectrum Number.
Definition IDTypes.h:14

Mantid::EMPTY_DBL
constexpr double EMPTY_DBL() noexcept
Returns what we consider an "empty" double within a property.
Definition EmptyValues.h:42

pmap
Generate a tableworkspace to store the calibration results.

scalex
adjust instrument component position and orientation

scaley
: detector size scale at y-direction

std
STL namespace.

Mantid::Kernel::Direction::InOut
@ InOut
Both an input & output workspace.
Definition Property.h:55