38#include "MantidHistogramData/HistogramDx.h"
39#include "MantidHistogramData/LinearGenerator.h"
40#include "MantidIndexing/IndexInfo.h"
62using Mantid::Types::Core::DateAndTime;
63using Mantid::Types::Event::TofEvent;
69 : peakCentre(peakCentre_),
sigma(sigma_),
height(height_), fitStatus(fitStatus_) {}
73 : workspaceIndex(
index), peakCentre(peakCentre_),
sigma(sigma_),
height(height_), fitStatus(fitStatus_) {}
93template <
typename YType,
typename EType> Histogram
createHisto(
bool isHistogram, YType &&yAxis, EType &&eAxis) {
96 const size_t yValsSize = yAxis.size();
98 BinEdges xAxis(yValsSize + 1, LinearGenerator(1, 1));
99 Histogram histo{std::move(xAxis), std::forward<YType>(yAxis), std::forward<EType>(eAxis)};
102 Points xAxis(yValsSize, LinearGenerator(1, 1));
103 Histogram pointsHisto{std::move(xAxis), std::forward<YType>(yAxis), std::forward<EType>(eAxis)};
110 MersenneTwister randomGen(DateAndTime::getCurrentTime().nanoseconds(), 0, std::numeric_limits<int>::max());
112 auto randFunc = [&randomGen] {
return randomGen.
nextValue(); };
113 Counts counts(size, randFunc);
114 CountStandardDeviations errorVals(size, randFunc);
116 auto retVal = std::make_shared<Workspace2D>();
117 retVal->initialize(1,
createHisto(isHisto, counts, errorVals));
122 Counts yVals(size,
value);
123 CountStandardDeviations errVals(size,
error);
125 auto retVal = std::make_shared<Workspace2D>();
126 retVal->initialize(1,
createHisto(isHisto, yVals, errVals));
133 auto dx1 = Kernel::make_cow<HistogramData::HistogramDx>(size, xError);
134 ws->setSharedDx(0, dx1);
139 BinEdges xVals(size + 1, LinearGenerator(1, 1));
141 CountStandardDeviations errVals(size);
143 auto retVal = std::make_shared<Workspace2D>();
144 retVal->initialize(1,
createHisto(isHisto, yVals, errVals));
160 for (
int workspaceIndex = 0; workspaceIndex < nhist; workspaceIndex++) {
161 std::vector<double> yValues(numBoundaries,
static_cast<double>(workspaceIndex));
162 out->mutableY(workspaceIndex) = yValues;
171 auto newAxis = std::make_unique<NumericAxis>(nHist);
172 auto newAxisRaw = newAxis.get();
173 outputWS->replaceAxis(1, std::move(newAxis));
174 newAxisRaw->unit() = std::make_shared<Units::Degrees>();
175 for (
int i = 0; i < nHist; ++i) {
176 newAxisRaw->setValue(i, i + 1);
197 const std::set<int64_t> &maskedWorkspaceIndices,
double xVal,
double yVal,
198 double eVal,
bool hasDx =
false) {
199 auto x1 = Kernel::make_cow<HistogramData::HistogramX>(isHist ? nBins + 1 : nBins, LinearGenerator(xVal, 1.0));
200 Counts y1(nBins, yVal);
201 CountStandardDeviations e1(nBins, eVal);
202 auto dx = Kernel::make_cow<HistogramData::HistogramDx>(nBins, yVal);
203 auto retVal = std::make_shared<Workspace2D>();
204 retVal->initialize(nHist,
createHisto(isHist, y1, e1));
205 for (
int i = 0; i < nHist; i++) {
206 retVal->setSharedX(i, x1);
208 retVal->setSharedDx(i, dx);
209 retVal->getSpectrum(i).setDetectorID(i);
210 retVal->getSpectrum(i).setSpectrumNo(i);
212 retVal =
maskSpectra(retVal, maskedWorkspaceIndices);
217 double yVal,
double eVal,
double dxVal,
218 const std::set<int64_t> &maskedWorkspaceIndices) {
220 PointStandardDeviations dx1(nBins, dxVal);
221 for (
int i = 0; i < nHist; i++) {
222 ws->setPointStandardDeviations(i, dx1);
228 const std::set<int64_t> &maskedWorkspaceIndices,
bool hasDx) {
233 const std::set<int64_t> &maskedWorkspaceIndices,
bool hasDx) {
238 const auto nhist =
static_cast<int>(
workspace->getNumberHistograms());
239 if (
workspace->getInstrument()->nelements() == 0) {
241 auto instrument = std::make_shared<Instrument>();
244 std::string xmlShape =
"<sphere id=\"shape\"> ";
245 xmlShape += R
"(<centre x="0.0" y="0.0" z="0.0" /> )";
246 xmlShape += "<radius val=\"0.05\" /> ";
247 xmlShape +=
"</sphere>";
248 xmlShape +=
"<algebra val=\"shape\" /> ";
252 for (
int i = 0; i < nhist; ++i) {
255 instrument->add(det);
256 instrument->markAsDetector(det);
261 workspace->setIndexInfo(Indexing::IndexInfo(nhist));
264 auto &spectrumInfo =
workspace->mutableSpectrumInfo();
265 for (
const auto index : maskedWorkspaceIndices)
266 spectrumInfo.setMasked(
index,
true);
274 auto group = std::make_shared<WorkspaceGroup>();
276 for (
int i = 0; i < nEntries; ++i) {
278 std::ostringstream os;
279 os << stem <<
"_" << i;
281 group->add(os.str());
290 BinEdges
x(numVals + 1, LinearGenerator(x0, deltax));
291 Counts
y(numVals, 2);
292 CountStandardDeviations e(numVals, M_SQRT2);
293 return create<Workspace2D>(nhist, Histogram(
x,
y, e));
300 Points
x(numVals, LinearGenerator(x0, deltax));
301 Counts
y(numVals, 2);
302 CountStandardDeviations e(numVals, M_SQRT2);
303 return create<Workspace2D>(nhist, Histogram(
x,
y, e));
314 BinEdges
x(xBoundaries, xBoundaries + numBoundaries);
315 const int numBins = numBoundaries - 1;
316 Counts
y(numBins, 2);
317 CountStandardDeviations e(numBins, M_SQRT2);
318 auto dx = Kernel::make_cow<HistogramData::HistogramDx>(numBins, LinearGenerator(0.1, .1));
319 auto retVal = std::make_shared<Workspace2D>();
321 for (
int i = 0; i < nhist; i++) {
322 retVal->setBinEdges(i,
x);
324 retVal->setSharedDx(i, dx);
337 const size_t seed(12345);
339 for (
size_t iSpec = 0; iSpec < ws->getNumberHistograms(); iSpec++) {
340 auto &mutableY = ws->mutableY(iSpec);
341 auto &mutableE = ws->mutableE(iSpec);
342 for (
size_t i = 0; i < mutableY.size(); i++) {
343 mutableY[i] += noise * randGen.
nextValue();
344 mutableE[i] += noise;
356 bool isHistogram,
const std::string &instrumentName,
bool hasDx) {
357 if (includeMonitors && nhist < 2) {
358 throw std::invalid_argument(
"Attempting to 2 include monitors for a "
359 "workspace with fewer than 2 histograms");
369 space->setTitle(
"Test histogram");
370 space->getAxis(0)->setUnit(
"TOF");
371 space->setYUnit(
"Counts");
383 size_t startTime,
size_t firstInterval,
384 bool includeMonitors,
bool startYNegative,
386 const std::string &instrumentName) {
393 std::vector<double> timeRanges;
394 for (
size_t i = 0; i < nTimeIndexes; ++i) {
395 timeRanges.emplace_back(
double(i + firstInterval));
398 builder.setTimeRanges(DateAndTime(
int(startTime), 0), timeRanges);
400 return builder.buildWorkspace();
410 const int nbins,
const double x0,
const double deltax,
411 const std::string &instrumentName,
412 const std::string &xunit) {
419 return inputWorkspace;
436 ws->setInstrument(inst);
437 ws->getAxis(0)->setUnit(
"dSpacing");
438 for (
size_t wi = 0; wi < ws->getNumberHistograms(); wi++) {
439 ws->getSpectrum(wi).setDetectorID(
detid_t(numPixels * numPixels + wi));
440 ws->getSpectrum(wi).setSpectrumNo(
specnum_t(wi));
461 ws->setInstrument(inst);
464 const auto &xVals = ws->x(0);
465 const size_t xSize = xVals.size();
466 auto ax0 = std::make_unique<NumericAxis>(xSize);
467 ax0->setUnit(
"dSpacing");
468 for (
size_t i = 0; i < xSize; i++) {
469 ax0->setValue(i, xVals[i]);
471 ws->replaceAxis(0, std::move(ax0));
474 const auto detIds = inst->getDetectorIDs();
475 for (
int wi = 0; wi < static_cast<int>(ws->getNumberHistograms()); ++wi) {
476 ws->getSpectrum(wi).clearDetectorIDs();
478 ws->getSpectrum(wi).clear(
true);
479 ws->getSpectrum(wi).setDetectorID(detIds[wi]);
498 ws->setInstrument(inst);
501 const auto &xVals = ws->x(0);
502 const size_t xSize = xVals.size();
503 auto ax0 = std::make_unique<NumericAxis>(xSize);
504 ax0->setUnit(
"dSpacing");
505 for (
size_t i = 0; i < xSize; i++) {
506 ax0->setValue(i, xVals[i]);
508 ws->replaceAxis(0, std::move(ax0));
511 const auto detIds = inst->getDetectorIDs();
512 for (
int wi = 0; wi < static_cast<int>(ws->getNumberHistograms()); ++wi) {
513 ws->getSpectrum(wi).clearDetectorIDs();
515 ws->getSpectrum(wi).clear(
true);
516 ws->getSpectrum(wi).setDetectorID(detIds[wi]);
523 const int DETECTORS_PER_BANK(9);
525 V3D srcPos(0., 0., -10.), samplePos;
529 ws->setInstrument(inst);
531 std::vector<detid_t> detectorIds = inst->getDetectorIDs();
534 assert(detectorIds.size() == ws->getNumberHistograms());
537 for (
size_t wi = 0; wi < ws->getNumberHistograms(); wi++) {
538 ws->getSpectrum(wi).clearDetectorIDs();
540 ws->getSpectrum(wi).clear(
true);
541 ws->getSpectrum(wi).setDetectorID(detectorIds[wi]);
556 const double deltaX) {
582 const V3D &slit2Pos,
const double vg1,
583 const double vg2,
const V3D &sourcePos,
584 const V3D &monitorPos,
const V3D &samplePos,
585 const V3D &detectorPos,
const int nBins,
586 const double deltaX) {
588 instrument->setReferenceFrame(
589 std::make_shared<ReferenceFrame>(PointingAlong::Y, PointingAlong::X, Handedness::Left,
"0,0,0"));
602 pmap.addDouble(slit1,
"vertical gap", vg1);
603 pmap.addDouble(slit2,
"vertical gap", vg2);
605 workspace->getSpectrum(0).setDetectorID(2);
606 workspace->getSpectrum(1).setDetectorID(1);
630 const double startX,
const double detSize,
const V3D &slit1Pos,
const V3D &slit2Pos,
const double vg1,
631 const double vg2,
const V3D &sourcePos,
const V3D &monitorPos,
const V3D &samplePos,
const V3D &detectorCenterPos,
632 const int nSpectra,
const int nBins,
const double deltaX) {
634 instrument->setReferenceFrame(
635 std::make_shared<ReferenceFrame>(PointingAlong::Y , PointingAlong::X , Handedness::Left,
"0,0,0"));
642 const double minY = detectorCenterPos.
Y() - detSize * (nDet - 1) / 2.;
643 for (
int i = 0; i < nDet; ++i) {
644 const double y = minY + i * detSize;
645 const V3D pos{detectorCenterPos.
X(),
y, detectorCenterPos.
Z()};
654 pmap.addDouble(slit1,
"vertical gap", vg1);
655 pmap.addDouble(slit2,
"vertical gap", vg2);
656 for (
int i = 0; i <
nSpectra; ++i) {
657 workspace->getSpectrum(i).setDetectorID(i + 1);
663 const V3D &sourcePosition,
const std::vector<V3D> &detectorPositions) {
665 instrument->setReferenceFrame(std::make_shared<ReferenceFrame>(
Y,
X,
Left,
"0,0,0"));
670 for (
int i = 0; i < static_cast<int>(detectorPositions.size()); ++i) {
671 std::stringstream buffer;
672 buffer <<
"detector_" << i;
676 workspace->getSpectrum(i).addDetectorID(i);
683 return std::make_shared<WorkspaceSingleValue>(
value, sqrt(
value));
687 return std::make_shared<WorkspaceSingleValue>(
value,
error);
693 ew->mutableRun().integrateProtonCharge();
715 int eventPattern,
int start_at_pixelID) {
717 DateAndTime(
"2010-01-01T00:00:00"));
724 double binDelta,
int eventPattern,
int start_at_pixelID,
725 DateAndTime run_start) {
730 auto retVal = std::make_shared<EventWorkspace>();
731 retVal->initialize(numPixels, 1, 1);
736 size_t workspaceIndex = 0;
737 for (
int pix = start_at_pixelID + 0; pix < start_at_pixelID + numPixels; pix++) {
738 EventList &el = retVal->getSpectrum(workspaceIndex);
743 if (eventPattern == 1)
744 el += TofEvent((pix + i + 0.5) * binDelta, run_start +
double(i));
745 else if (eventPattern == 2)
747 el += TofEvent((i + 0.5) * binDelta, run_start +
double(i));
748 el += TofEvent((i + 0.5) * binDelta, run_start +
double(i));
749 }
else if (eventPattern == 3)
751 el += TofEvent((i + 0.5) * binDelta, run_start +
double(i));
752 }
else if (eventPattern == 4)
755 for (
int q = 0; q < pix; q++)
756 el += TofEvent((i + 0.5) * binDelta, run_start +
double(i));
763 retVal->setAllX(BinEdges(numBins, LinearGenerator(x0, binDelta)));
774 auto retVal = std::make_shared<EventWorkspace>();
775 retVal->initialize(groups.size(), 2, 1);
777 for (
size_t g = 0; g < groups.size(); g++) {
778 retVal->getSpectrum(g).clearDetectorIDs();
779 std::vector<int> dets = groups[g];
780 for (
auto det : dets) {
781 for (
int i = 0; i < numBins; i++)
782 retVal->getSpectrum(g) += TofEvent((i + 0.5) * binDelta, 1);
783 retVal->getSpectrum(g).addDetectorID(det);
788 retVal->setAllX(BinEdges(numBins, LinearGenerator(0.0, binDelta)));
790 for (
size_t g = 0; g < groups.size(); g++) {
792 const double x0 = xOffset *
static_cast<double>(g);
793 retVal->setX(g, make_cow<HistogramX>(numBins, LinearGenerator(x0, binDelta)));
809 auto retVal = std::make_shared<EventWorkspace>();
810 retVal->initialize(numpixels, numbins, numbins - 1);
813 auto pAxis0 = std::make_unique<NumericAxis>(numbins);
816 HistogramData::BinEdges axis(numbins, LinearGenerator(0.0, bin_delta));
817 for (
int i = 0; i < static_cast<int>(numbins); ++i) {
818 pAxis0->setValue(i, axis[i]);
820 pAxis0->setUnit(
"TOF");
822 MersenneTwister randomGen(DateAndTime::getCurrentTime().nanoseconds(), 0, std::numeric_limits<int>::max());
824 for (
size_t i = 0; i < numpixels; i++) {
827 for (std::size_t ie = 0; ie < numbins; ie++) {
829 events += TofEvent(
static_cast<double>(randomGen.
nextValue()),
static_cast<int64_t
>(randomGen.
nextValue()));
833 retVal->setAllX(axis);
834 retVal->replaceAxis(0, std::move(pAxis0));
847 for (
int g = 0; g < static_cast<int>(numHist); g++) {
848 auto &spec = retVal->getSpectrum(g);
849 for (
int i = 1; i <= 9; i++)
850 spec.addDetectorID(g * 9 + i);
851 spec.setSpectrumNo(g + 1);
853 return std::dynamic_pointer_cast<MatrixWorkspace>(retVal);
859 size_t numHist = RootOfNumHist * RootOfNumHist;
862 for (
int g = 0; g < static_cast<int>(numHist); g++) {
863 auto &spec = retVal->getSpectrum(g);
864 spec.addDetectorID(g + 1);
865 for (
int i = 1; i <= 9; i++)
866 spec.addDetectorID(g * 9 + i);
867 spec.setSpectrumNo(g + 1);
869 return std::dynamic_pointer_cast<MatrixWorkspace>(retVal);
875 const size_t numHists = ws->getNumberHistograms();
876 for (
size_t i = 0; i < numHists; ++i) {
877 std::cout <<
"Histogram " << i <<
" = ";
878 const auto &
y = ws->y(i);
879 for (
size_t j = 0; j <
y.size(); ++j) {
880 std::cout <<
y[j] <<
" ";
890 const size_t numHists = ws->getNumberHistograms();
891 for (
size_t i = 0; i < numHists; ++i) {
892 std::cout <<
"Histogram " << i <<
" = ";
893 const auto &
x = ws->x(i);
894 for (
size_t j = 0; j <
x.size(); ++j) {
895 std::cout <<
x[j] <<
" ";
904 const size_t numHists = ws->getNumberHistograms();
905 for (
size_t i = 0; i < numHists; ++i) {
906 std::cout <<
"Histogram " << i <<
" = ";
907 const auto &e = ws->e(i);
908 for (
size_t j = 0; j < e.size(); ++j) {
909 std::cout << e[j] <<
" ";
925 tsp->
addValue(
"2011-05-24T00:00:00", val);
939 ws->mutableSample().setOrientedLattice(std::make_unique<OrientedLattice>(a, b, c, 90., 90., 90.));
956 ws->mutableRun().setGoniometer(gm,
true);
961 bool has_oriented_lattice) {
962 auto rHist =
static_cast<size_t>(std::sqrt(
static_cast<double>(numPixels)));
963 while (rHist * rHist < numPixels)
967 auto pAxis0 = std::make_unique<NumericAxis>(numBins);
968 for (
size_t i = 0; i < numBins; i++) {
969 double dE = -1.0 +
static_cast<double>(i) * 0.8;
970 pAxis0->setValue(i, dE);
972 pAxis0->setUnit(
"DeltaE");
973 ws->replaceAxis(0, std::move(pAxis0));
974 if (has_oriented_lattice) {
975 ws->mutableSample().setOrientedLattice(std::make_unique<OrientedLattice>(1, 1, 1, 90., 90., 90.));
982 ws->mutableRun().setGoniometer(gm,
true);
998 const std::vector<double> &polar,
999 const std::vector<double> &azimutal,
size_t numBins,
1000 double Emin,
double Emax,
double Ei) {
1002 std::set<int64_t> maskedWorkspaceIndices;
1003 size_t numPixels = L2.size();
1011 for (
int g = 0; g < static_cast<int>(numPixels); g++) {
1012 auto &spec = ws->getSpectrum(g);
1015 spec.setDetectorID(g + 1);
1018 spec.setSpectrumNo(g + 1);
1024 const double dE = (Emax - Emin) /
static_cast<double>(numBins);
1025 for (
size_t j = 0; j < numPixels; j++) {
1026 std::vector<double> E_transfer;
1027 E_transfer.reserve(numBins);
1028 for (
size_t i = 0; i <= numBins; i++) {
1029 E_transfer.emplace_back(Emin +
static_cast<double>(i) * dE);
1031 ws->mutableX(j) = E_transfer;
1035 auto pAxis0 = std::make_unique<NumericAxis>(numBins);
1036 const auto &E_transfer = ws->x(0);
1037 for (
size_t i = 0; i < numBins; i++) {
1038 double E = 0.5 * (E_transfer[i] + E_transfer[i + 1]);
1039 pAxis0->setValue(i, E);
1042 pAxis0->setUnit(
"DeltaE");
1044 ws->replaceAxis(0, std::move(pAxis0));
1047 ws->mutableSample().setOrientedLattice(std::make_unique<OrientedLattice>(1, 1, 1, 90., 90., 90.));
1058 ws->mutableRun().setGoniometer(gm,
true);
1076 outputWS->initialize(sourceWS->getInstrument()->getDetectorIDs(
true).size(), 1, 1);
1080 outputWS->setYUnit(
"Counts");
1081 outputWS->setTitle(
"Empty_Title");
1084 int runnumber = sourceWS->getRunNumber();
1085 outputWS->mutableRun().addProperty(
"run_number", runnumber);
1087 std::string runstartstr = sourceWS->run().getProperty(
"run_start")->value();
1088 outputWS->mutableRun().addProperty(
"run_start", runstartstr);
1093 loadInst->setPropertyValue(
"InstrumentName", sourceWS->getInstrument()->getName());
1096 loadInst->executeAsChildAlg();
1099 outputWS->populateInstrumentParameters();
1104 outputWS->getInstrument()->getDetectors(detector_map);
1107 detid2det_map::iterator it;
1109 for (it = detector_map.begin(); it != detector_map.end(); ++it)
1110 if (it->first > detid_max)
1111 detid_max = it->first;
1114 size_t workspaceIndex = 0;
1115 const auto &detectorInfo = outputWS->detectorInfo();
1116 for (it = detector_map.begin(); it != detector_map.end(); ++it) {
1117 if (!detectorInfo.isMonitor(detectorInfo.indexOf(it->first))) {
1118 auto &spec = outputWS->getSpectrum(workspaceIndex);
1119 spec.addDetectorID(it->first);
1121 spec.setSpectrumNo(
specnum_t(workspaceIndex + 1));
1122 workspaceIndex += 1;
1135 std::vector<double> qbins{0.0, 1.0, 4.0};
1136 std::vector<double> qaxis;
1140 const int numHist = numY - 1;
1142 outputWS->initialize(numHist, numX, numX - 1);
1146 outputWS->setYUnit(
"Counts");
1147 outputWS->setTitle(
"Empty_Title");
1150 HistogramData::BinEdges x1{-3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0};
1153 auto verticalAxis = std::make_unique<NumericAxis>(numY);
1156 for (
int i = 0; i < numHist; ++i) {
1157 outputWS->setBinEdges(i, x1);
1158 verticalAxis->setValue(i, qaxis[i]);
1161 verticalAxis->setValue(numHist, qaxis[numHist]);
1165 verticalAxis->title() =
"|Q|";
1166 outputWS->replaceAxis(1, std::move(verticalAxis));
1169 outputWS->getAxis(0)->title() =
"Energy transfer";
1197 outputWS->finalize();
1200 for (
int i = 0; i < numHist; ++i) {
1201 auto &mutableE = outputWS->mutableE(i);
1202 for (
int j = 0; j < numX - 1; ++j) {
1203 mutableE[j] = std::sqrt(mutableE[j]);
1206 outputWS->setSqrdErrors(
false);
1223template <
typename T>
1226 for (
const double val : values) {
1227 destination[startingIndex +
index] = val;
1233 auto peaksWS = std::make_shared<PeaksWorkspace>();
1235 peaksWS->setInstrument(inst);
1237 for (
int i = 0; i < numPeaks; ++i) {
1238 Peak peak(inst, i, i + 0.5);
1239 peaksWS->addPeak(peak);
1242 if (createOrientedLattice) {
1243 peaksWS->mutableSample().setOrientedLattice(std::make_unique<OrientedLattice>());
1251 throw std::invalid_argument(
"UB matrix is not 3x3");
1255 peaksWS->mutableSample().getOrientedLattice().setUB(ubMat);
1259void create2DAngles(std::vector<double> &L2, std::vector<double> &polar, std::vector<double> &azim,
size_t nPolar,
1260 size_t nAzim,
double polStart,
double polEnd,
double azimStart,
double azimEnd) {
1261 size_t nDet = nPolar * nAzim;
1262 L2.resize(nDet, 10);
1266 double dPolar = (polEnd - polStart) /
static_cast<double>(nDet - 1);
1267 double dAzim = (azimEnd - azimEnd) /
static_cast<double>(nDet - 1);
1268 for (
size_t i = 0; i < nPolar; i++) {
1269 for (
size_t j = 0; j < nAzim; j++) {
1270 polar[i * nPolar + j] = polStart + dPolar *
static_cast<double>(i);
1271 azim[i * nPolar + j] = azimStart + dAzim *
static_cast<double>(j);
1278 auto wsIndexColumn = ws->addColumn(
"int",
"WorkspaceIndex");
1279 auto centreColumn = ws->addColumn(
"double",
"PeakCentre");
1280 auto centreErrorColumn = ws->addColumn(
"double",
"PeakCentreError");
1281 auto sigmaColumn = ws->addColumn(
"double",
"Sigma");
1282 auto sigmaErrorColumn = ws->addColumn(
"double",
"SigmaError");
1283 auto heightColumn = ws->addColumn(
"double",
"Height");
1284 auto heightErrorColumn = ws->addColumn(
"double",
"HeightError");
1285 auto chiSqColumn = ws->addColumn(
"double",
"chiSq");
1286 auto statusColumn = ws->addColumn(
"str",
"FitStatus");
1287 for (
size_t i = 0; i != rows.size(); ++i) {
1288 const auto &row = rows[i];
1289 if (row.workspaceIndex < 0) {
1290 wsIndexColumn->cell<
int>(i) =
static_cast<int>(i);
1292 wsIndexColumn->cell<
int>(i) = row.workspaceIndex;
1294 centreColumn->cell<
double>(i) = row.peakCentre;
1295 centreErrorColumn->cell<
double>(i) = row.peakCentreError;
1296 sigmaColumn->cell<
double>(i) = row.sigma;
1297 sigmaErrorColumn->cell<
double>(i) = row.sigmaError;
1298 heightColumn->cell<
double>(i) = row.height;
1299 heightErrorColumn->cell<
double>(i) = row.heightError;
1300 chiSqColumn->cell<
double>(i) = row.chiSq;
1306 int maskedWorkspaceIndex,
int maskedBinIndex) {
1308 ws->flagMasked(maskedWorkspaceIndex, maskedBinIndex);
double value
The value of the point.
IPeaksWorkspace_sptr workspace
std::map< DeltaEMode::Type, std::string > index
#define UNUSED_ARG(x)
Function arguments are sometimes unused in certain implmentations but are required for documentation ...
double lower
lower and upper bounds on the multiplier, if known
Base class from which all concrete algorithm classes should be derived.
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.
void addDetectorID(const detid_t detID)
Add a detector ID to the set of detector IDs.
void setDetectorID(const detid_t detID)
Clear the list of detector IDs, then add one.
void setSpectrumNo(specnum_t num)
Sets the the spectrum number of this spectrum.
void addProperty(Kernel::Property *prop, bool overwrite=false)
Add data to the object in the form of a property.
Helper class for reporting progress from algorithms.
This class stores information regarding an experimental run as a series of log entries.
This class is intended to fulfill the design specified in <https://github.com/mantidproject/documents...
Structure describing a single-crystal peak.
ScanningWorkspaceBuilder : This is a helper class to make it easy to build a scanning workspace (a wo...
void setPos(double, double, double) override
Set the IComponent position, x, y, z respective to parent (if present)
This class represents a detector - i.e.
Class to represent a particular goniometer setting, which is described by the rotation matrix.
void makeUniversalGoniometer()
Make a default universal goniometer with phi,chi,omega angles according to SNS convention.
Class originally intended to be used with the DataHandling 'LoadInstrument' algorithm.
std::shared_ptr< CSGObject > createShape(Poco::XML::Element *pElem)
Creates a geometric object from a DOM-element-node pointing to an element whose child nodes contain t...
size_t numRows() const
Return the number of rows in the matrix.
size_t numCols() const
Return the number of columns in the matrix.
This implements the the Mersenne Twister 19937 pseudo-random number generator algorithm as a specialz...
double nextValue() override
Generate the next random number in the sequence within the given range default range.
OptionalBool : Tri-state bool.
The concrete, templated class for properties.
static T & Instance()
Return a reference to the Singleton instance, creating it if it does not already exist Creation is do...
A specialised Property class for holding a series of time-value pairs.
void addValue(const Types::Core::DateAndTime &time, const TYPE &value)
Add a value to the map using a DateAndTime object.
constexpr double X() const noexcept
Get x.
constexpr double Y() const noexcept
Get y.
constexpr double Z() const noexcept
Get z.
Implements a copy on write data template.
StubAlgorithm(size_t nSteps=100)
Mantid::Geometry::Instrument_sptr createCylInstrumentWithDetInGivenPositions(const std::vector< double > &L2, const std::vector< double > &polar, const std::vector< double > &azim)
create instrument with cylindrical detectors located in specific angular positions
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)
Create an test instrument with n panels of 9 cylindrical detectors, a source and a sample position.
Mantid::Geometry::Instrument_sptr createTestInstrumentRectangular(int num_banks, int pixels, double pixelSpacing=0.008, double bankDistanceFromSample=5.0, bool addMonitor=false)
Create a test instrument with n panels of rectangular detectors, pixels*pixels in size,...
Mantid::Geometry::Instrument_sptr createTestInstrumentRectangular2(int num_banks, int pixels, double pixelSpacing=0.008)
Create an test instrument with n panels of rectangular detectors, pixels*pixels in size,...
void addMonitor(Mantid::Geometry::Instrument_sptr &instrument, const Mantid::Kernel::V3D &position, const int ID, const std::string &name)
Adds a monitor to an instrument.
void addSource(Mantid::Geometry::Instrument_sptr &instrument, const Mantid::Kernel::V3D &position, const std::string &name)
Adds a source to an instrument.
void addFullInstrumentToWorkspace(Mantid::API::MatrixWorkspace &workspace, bool includeMonitors, bool startYNegative, const std::string &instrumentName)
void addInstrumentWithGeographicalDetectorsToWorkspace(Mantid::API::MatrixWorkspace &workspace, const int nlat, const int nlong, const double anginc, const std::string &instrumentName)
void addSample(Mantid::Geometry::Instrument_sptr &instrument, const Mantid::Kernel::V3D &position, const std::string &name)
Adds a sample to an instrument.
Mantid::Geometry::Component * addComponent(Mantid::Geometry::Instrument_sptr &instrument, const Mantid::Kernel::V3D &position, const std::string &name)
Adds a component to an instrument.
void addDetector(Mantid::Geometry::Instrument_sptr &instrument, const Mantid::Kernel::V3D &position, const int ID, const std::string &name, Mantid::Geometry::ObjCompAssembly *compAss=nullptr)
Adds a detector to an instrument.
std::shared_ptr< WorkspaceGroup > WorkspaceGroup_sptr
shared pointer to Mantid::API::WorkspaceGroup
std::shared_ptr< ITableWorkspace > ITableWorkspace_sptr
shared pointer to Mantid::API::ITableWorkspace
std::shared_ptr< const MatrixWorkspace > MatrixWorkspace_const_sptr
shared pointer to the matrix workspace base class (const version)
std::shared_ptr< Algorithm > Algorithm_sptr
Typedef for a shared pointer to an Algorithm.
static MatrixWorkspace_sptr createWorkspaceSingleValue(const double &rhsValue)
Creates a temporary single value workspace the error is set to zero.
std::shared_ptr< MatrixWorkspace > MatrixWorkspace_sptr
shared pointer to the matrix workspace base class
std::size_t numEvents(::NeXus::File &file, bool &hasTotalCounts, bool &oldNeXusFileNames, const std::string &prefix, const NexusHDF5Descriptor &descriptor)
Get the number of events in the currently opened group.
std::shared_ptr< WorkspaceSingleValue > WorkspaceSingleValue_sptr
shared pointer to the WorkspaceSingleValue class
std::shared_ptr< const EventWorkspace > EventWorkspace_const_sptr
shared pointer to a const Workspace2D
std::shared_ptr< Workspace2D > Workspace2D_sptr
shared pointer to Mantid::DataObjects::Workspace2D
std::shared_ptr< RebinnedOutput > RebinnedOutput_sptr
shared pointer to the RebinnedOutput class
std::shared_ptr< PeaksWorkspace > PeaksWorkspace_sptr
Typedef for a shared pointer to a peaks workspace.
std::shared_ptr< EventWorkspace > EventWorkspace_sptr
shared pointer to the EventWorkspace class
std::shared_ptr< Instrument > Instrument_sptr
Shared pointer to an instrument object.
int MANTID_KERNEL_DLL createAxisFromRebinParams(const std::vector< double > ¶ms, std::vector< double > &xnew, const bool resize_xnew=true, const bool full_bins_only=false, const double xMinHint=std::nan(""), const double xMaxHint=std::nan(""), const bool useReverseLogarithmic=false, const double power=-1)
Creates a new output X array given a 'standard' set of rebinning parameters.
Helper class which provides the Collimation Length for SANS instruments.
int32_t detid_t
Typedef for a detector ID.
std::map< detid_t, Geometry::IDetector_const_sptr > detid2det_map
Typedef of a map from detector ID to detector shared pointer.
std::vector< double > MantidVec
typedef for the data storage used in Mantid matrix workspaces
int32_t specnum_t
Typedef for a spectrum Number.
Mantid::DataObjects::Workspace2D_sptr create2DWorkspaceWhereYIsWorkspaceIndex(int nhist, int numBoundaries)
Create a Workspace2D where the Y value at each bin is == to the workspace index.
Mantid::DataObjects::Workspace2D_sptr create1DWorkspaceConstant(int size, double value, double error, bool isHisto)
void setOrientedLattice(const Mantid::API::MatrixWorkspace_sptr &ws, double a, double b, double c)
Sets the OrientedLattice in the crystal as an crystal with given lattice lengths, angles of 90 deg.
Mantid::DataObjects::Workspace2D_sptr create2DWorkspaceWithRectangularInstrument(int numBanks, int numPixels, int numBins)
Create an Workspace2D with an instrument that contains RectangularDetector's.
void createInstrumentForWorkspaceWithDistances(const Mantid::API::MatrixWorkspace_sptr &workspace, const Mantid::Kernel::V3D &samplePosition, const Mantid::Kernel::V3D &sourcePosition, const std::vector< Mantid::Kernel::V3D > &detectorPositions)
Mantid::DataObjects::Workspace2D_sptr create2DWorkspaceWithGeographicalDetectors(const int nlat, const int nlong, const double anginc, int nbins, const double x0=0.5, const double deltax=1.0, const std::string &instrumentName=std::string("testInst"), const std::string &xunit=std::string("Momentum"))
Create an Workspace2D with an instrument that contains detectors arranged at even latitude/longitude ...
Mantid::API::MatrixWorkspace_sptr create2DWorkspaceWithReflectometryInstrumentMultiDetector(const double startX=0.0, const double detSize=0.0, const Mantid::Kernel::V3D &slit1Pos=Mantid::Kernel::V3D(0, 0, 0), const Mantid::Kernel::V3D &slit2Pos=Mantid::Kernel::V3D(0, 0, 1), const double vg1=0.5, const double vg2=1.0, const Mantid::Kernel::V3D &sourcePos=Mantid::Kernel::V3D(0, 0, 0), const Mantid::Kernel::V3D &monitorPos=Mantid::Kernel::V3D(14, 0, 0), const Mantid::Kernel::V3D &samplePos=Mantid::Kernel::V3D(15, 0, 0), const Mantid::Kernel::V3D &detectorCenterPos=Mantid::Kernel::V3D(20,(20 - 15), 0), const int nSpectra=4, const int nBins=20, const double deltaX=5000.0)
Create a 2D workspace with one monitor and three detectors based around a virtual reflectometry instr...
void displayData(const Mantid::API::MatrixWorkspace_const_sptr &ws)
Mantid::API::MatrixWorkspace_sptr createProcessedInelasticWS(const std::vector< double > &L2, const std::vector< double > &polar, const std::vector< double > &azimutal, size_t numBins=4, double Emin=-10, double Emax=10, double Ei=11)
Create a workspace with all components needed for inelastic analysis and 3 detectors in specific plac...
void displayDataY(const Mantid::API::MatrixWorkspace_const_sptr &ws)
Mantid::DataObjects::WorkspaceSingleValue_sptr createWorkspaceSingleValueWithError(double value, double error)
void create2DAngles(std::vector< double > &L2, std::vector< double > &polar, std::vector< double > &azim, size_t nPolar=10, size_t nAzim=10, double polStart=0, double polEnd=90, double azimStart=-30, double azimEnd=30)
Mantid::DataObjects::Workspace2D_sptr create1DWorkspaceConstantWithXerror(int size, double value, double error, double xError, bool isHisto=true)
Mantid::DataObjects::Workspace2D_sptr create2DWorkspaceBinned(size_t nhist, size_t numVals, double x0=0.0, double deltax=1.0)
Create a 2D workspace with this many histograms and bins.
void populateWsWithInitList(T &destination, size_t startingIndex, const std::initializer_list< double > &values)
Populates a mutable reference from initializer list starting at user specified index.
Mantid::DataObjects::Workspace2D_sptr create2DWorkspaceNonUniformlyBinned(int nhist, const int numBoundaries, const double xBoundaries[], bool hasDx=false)
Create a 2D workspace with this many histograms and bins.
Mantid::DataObjects::EventWorkspace_sptr createEventWorkspaceWithFullInstrument(int numBanks, int numPixels, bool clearEvents=true)
Create an Eventworkspace with an instrument that contains RectangularDetector's.
Mantid::DataObjects::Workspace2D_sptr create1DWorkspaceFib(int size, bool isHisto)
std::shared_ptr< Mantid::DataObjects::PeaksWorkspace > createPeaksWorkspace(const int numPeaks, const bool createOrientedLattice=false)
Create a simple peaks workspace containing the given number of peaks.
void addNoise(const Mantid::API::MatrixWorkspace_sptr &ws, double noise, const double lower=-0.5, const double upper=0.5)
Add random noise to the signalcreate2DWorkspaceWithFullInstrument.
Mantid::API::ITableWorkspace_sptr createEPPTableWorkspace(const std::vector< EPPTableRow > &rows)
Create a table workspace corresponding to what the FindEPP algorithm gives.
void removeWS(const std::string &name)
Deletes a workspace.
void displayDataE(const Mantid::API::MatrixWorkspace_const_sptr &ws)
Mantid::HistogramData::Histogram createHisto(bool isHistogram, YType &&yAxis, EType &&eAxis)
Creates and returns point or bin based histograms with the data specified in parameters.
Mantid::DataObjects::Workspace2D_sptr create2DWorkspaceWithValuesAndXerror(int64_t nHist, int64_t nBins, bool isHist, double xVal, double yVal, double eVal, double dxVal, const std::set< int64_t > &maskedWorkspaceIndices=std::set< int64_t >())
Mantid::API::WorkspaceGroup_sptr createWorkspaceGroup(int nEntries, int nHist, int nBins, const std::string &stem)
Create a WorkspaceGroup with N workspaces and the specified parameters.
Mantid::DataObjects::Workspace2D_sptr create2DWorkspace154(int64_t nHist, int64_t nBins, bool isHist=false, const std::set< int64_t > &maskedWorkspaceIndices=std::set< int64_t >(), bool hasDx=false)
Mantid::DataObjects::EventWorkspace_sptr createRandomEventWorkspace(size_t numbins, size_t numpixels, double bin_delta=1.0)
Create an event workspace with randomized TOF and pulsetimes.
Mantid::API::MatrixWorkspace_sptr create2DWorkspaceWithReflectometryInstrument(const double startX=0.0, const Mantid::Kernel::V3D &slit1Pos=Mantid::Kernel::V3D(0, 0, 0), const Mantid::Kernel::V3D &slit2Pos=Mantid::Kernel::V3D(0, 0, 1), const double vg1=0.5, const double vg2=1.0, const Mantid::Kernel::V3D &sourcePos=Mantid::Kernel::V3D(0, 0, 0), const Mantid::Kernel::V3D &monitorPos=Mantid::Kernel::V3D(14, 0, 0), const Mantid::Kernel::V3D &samplePos=Mantid::Kernel::V3D(15, 0, 0), const Mantid::Kernel::V3D &detectorPos=Mantid::Kernel::V3D(20,(20 - 15), 0), const int nBins=100, const double deltaX=2000.0)
Create a 2D workspace with one detector and one monitor based around a virtual reflectometry instrume...
Mantid::DataObjects::EventWorkspace_sptr createEventWorkspaceWithStartTime(int numPixels, int numBins, int numEvents=100, double x0=0.0, double binDelta=1.0, int eventPattern=1, int start_at_pixelID=0, Mantid::Types::Core::DateAndTime run_start=Mantid::Types::Core::DateAndTime("2010-01-01T00:00:00"))
void addTSPEntry(Mantid::API::Run &runInfo, const std::string &name, double val)
Utility function to add a TimeSeriesProperty with a name and value.
Mantid::DataObjects::EventWorkspace_sptr createEventWorkspace()
Create event workspace with: 500 pixels 1000 histogrammed bins.
Mantid::DataObjects::EventWorkspace_sptr createEventWorkspace3(const Mantid::DataObjects::EventWorkspace_const_sptr &sourceWS, const std::string &wsname, Mantid::API::Algorithm *alg)
Mantid::API::MatrixWorkspace_sptr create2DDetectorScanWorkspaceWithFullInstrument(int nhist, int nbins, size_t nTimeIndexes, size_t startTime=0, size_t firstInterval=1, bool includeMonitors=false, bool startYNegative=false, bool isHistogram=true, const std::string &instrumentName=std::string("testInst"))
Create a workspace as for create2DWorkspaceWithFullInstrument, but including time indexing,...
Mantid::API::MatrixWorkspace_sptr createProcessedWorkspaceWithCylComplexInstrument(size_t numPixels=100, size_t numBins=20, bool has_oriented_lattice=true)
Mantid::DataObjects::Workspace2D_sptr create2DWorkspace123(int64_t nHist, int64_t nBins, bool isHist=false, const std::set< int64_t > &maskedWorkspaceIndices=std::set< int64_t >(), bool hasDx=false)
Mantid::DataObjects::Workspace2D_sptr maskSpectra(Mantid::DataObjects::Workspace2D_sptr workspace, const std::set< int64_t > &maskedWorkspaceIndices)
Workspace2D_sptr create2DWorkspaceWithValues(int64_t nHist, int64_t nBins, bool isHist, const std::set< int64_t > &maskedWorkspaceIndices, double xVal, double yVal, double eVal, bool hasDx=false)
create2DWorkspaceWithValues
DataObjects::Workspace2D_sptr reflectometryWorkspace(const double startX, const int nSpectra, const int nBins, const double deltaX)
Creates a binned 2DWorkspace with title and TOF x-axis and counts y-axis.
Mantid::DataObjects::RebinnedOutput_sptr createRebinnedOutputWorkspace()
Function to create a fixed RebinnedOutput workspace.
Mantid::DataObjects::Workspace2D_sptr create2DWorkspaceThetaVsTOF(int nHist, int nBins)
Create a test workspace with a Theta numeric axis instead of a spectrum axis the values run from 1 to...
void displayDataX(const Mantid::API::MatrixWorkspace_const_sptr &ws)
Mantid::DataObjects::Workspace2D_sptr create1DWorkspaceRand(int size, bool isHisto)
Mantid::API::MatrixWorkspace_sptr createGroupedWorkspace2DWithRingsAndBoxes(size_t RootOfNumHist=10, int numBins=10, double binDelta=1.0)
Mantid::DataObjects::Workspace2D_sptr create2DWorkspace123WithMaskedBin(int numHist, int numBins, int maskedWorkspaceIndex, int maskedBinIndex)
void setGoniometer(const Mantid::API::MatrixWorkspace_sptr &ws, double phi, double chi, double omega)
Create a default universal goniometer and set its angles.
Mantid::DataObjects::EventWorkspace_sptr createGroupedEventWorkspace(std::vector< std::vector< int > > groups, int numBins, double binDelta=1., double xOffset=0.)
Create event workspace, with several detector IDs in one event list.
Mantid::DataObjects::EventWorkspace_sptr createEventWorkspaceWithNonUniformInstrument(int numBanks, bool clearEvents)
Creates an event workspace with instrument which consists of cylindrical detectors.
Mantid::DataObjects::Workspace2D_sptr create2DWorkspaceWithFullInstrument(int nhist, int nbins, bool includeMonitors=false, bool startYNegative=false, bool isHistogram=true, const std::string &instrumentName=std::string("testInst"), bool hasDx=false)
Create a test workspace with a fully defined instrument.
Mantid::DataObjects::EventWorkspace_sptr createEventWorkspaceWithFullInstrument2(int numBanks, int numPixels, bool clearEvents=true)
Create an Eventworkspace with instrument 2.0 that contains RectangularDetector's.
Mantid::DataObjects::EventWorkspace_sptr createEventWorkspace2(int numPixels=50, int numBins=100)
Create event workspace with: 50 pixels 100 histogrammed bins from 0.0 in steps of 1....
Mantid::DataObjects::Workspace2D_sptr create2DWorkspace(size_t nhist, size_t numBoundaries)
Mantid::API::MatrixWorkspace_sptr createGroupedWorkspace2D(size_t numHist, int numBins, double binDelta)
Create Workspace2d, with numHist spectra, each with 9 detectors, with IDs 1-9, 10-18,...
void eventWorkspace_Finalize(const Mantid::DataObjects::EventWorkspace_sptr &ew)
Perform some finalization on event workspace stuff.
Mantid::DataObjects::Workspace2D_sptr create2DWorkspacePoints(size_t nhist, size_t numVals, double x0=0.0, double deltax=1.0)
Create a 2D workspace with this many point-histograms and bins.
Generate a tableworkspace to store the calibration results.
EPPTableRow()=default
Construct a row with the default values.
FitStatus
FindEPP algorithm fitting success status.
Create a Fibonacci series.