/** Executes the algorithm */
void FilterBadPulses::exec()
{
// the input workspace into the event workspace we already know it is
EventWorkspace_sptr inputWS = this->getProperty("InputWorkspace");
// get the proton charge exists in the run object
const API::Run& runlogs = inputWS->run();
if (!runlogs.hasProperty("proton_charge"))
{
throw std::runtime_error("Failed to find \"proton_charge\" in sample logs");
}
Kernel::TimeSeriesProperty<double> * pcharge_log
= dynamic_cast<Kernel::TimeSeriesProperty<double> *>( runlogs.getLogData("proton_charge") );
Kernel::TimeSeriesPropertyStatistics stats = pcharge_log->getStatistics();
// set the range
double min_percent = this->getProperty("LowerCutoff");
min_percent *= .01; // convert it to a percentage (0<x<1)
double min_pcharge = stats.mean * min_percent;
double max_pcharge = stats.maximum * 1.1; // make sure everything high is in
if (min_pcharge >= max_pcharge) {
throw std::runtime_error("proton_charge window filters out all of the data");
}
this->g_log.information() << "Filtering pcharge outside of " << min_pcharge
<< " to " << max_pcharge << std::endl;
size_t inputNumEvents = inputWS->getNumberEvents();
// sub-algorithme does all of the actual work - do not set the output workspace
IAlgorithm_sptr filterAlgo = createSubAlgorithm("FilterByLogValue", 0., 1.);
filterAlgo->setProperty("InputWorkspace", inputWS);
filterAlgo->setProperty("LogName", "proton_charge");
filterAlgo->setProperty("MinimumValue", min_pcharge);
filterAlgo->setProperty("MaximumValue", max_pcharge);
filterAlgo->execute();
// just grab the child's output workspace
EventWorkspace_sptr outputWS = filterAlgo->getProperty("OutputWorkspace");
size_t outputNumEvents = outputWS->getNumberEvents();
this->setProperty("OutputWorkspace", outputWS);
// log the number of events deleted
double percent = static_cast<double>(inputNumEvents - outputNumEvents)
/ static_cast<double>(inputNumEvents);
percent *= 100.;
if (percent > 10.)
{
this->g_log.warning() << "Deleted " << (inputNumEvents - outputNumEvents)
<< " of " << inputNumEvents
<< " events (" << static_cast<int>(percent) << "%)\n";
}
else
{
this->g_log.information() << "Deleted " << (inputNumEvents - outputNumEvents)
<< " of " << inputNumEvents
<< " events (" << static_cast<int>(percent) << "%)\n";
}
}
/** Executes the algorithm
* @throw Exception::FileError If the grouping file cannot be opened or read
* successfully
* @throw runtime_error If unable to run one of the Child Algorithms
* successfully
*/
void AlignAndFocusPowder::exec() {
// retrieve the properties
m_inputW = getProperty("InputWorkspace");
m_inputEW = boost::dynamic_pointer_cast<EventWorkspace>(m_inputW);
m_instName = m_inputW->getInstrument()->getName();
m_instName =
Kernel::ConfigService::Instance().getInstrument(m_instName).shortName();
std::string calFilename = getPropertyValue("CalFileName");
std::string groupFilename = getPropertyValue("GroupFilename");
m_calibrationWS = getProperty("CalibrationWorkspace");
m_maskWS = getProperty("MaskWorkspace");
m_groupWS = getProperty("GroupingWorkspace");
DataObjects::TableWorkspace_sptr maskBinTableWS = getProperty("MaskBinTable");
m_l1 = getProperty("PrimaryFlightPath");
specids = getProperty("SpectrumIDs");
l2s = getProperty("L2");
tths = getProperty("Polar");
phis = getProperty("Azimuthal");
m_params = getProperty("Params");
dspace = getProperty("DSpacing");
auto dmin = getVecPropertyFromPmOrSelf("DMin", m_dmins);
auto dmax = getVecPropertyFromPmOrSelf("DMax", m_dmaxs);
LRef = getProperty("UnwrapRef");
DIFCref = getProperty("LowResRef");
minwl = getProperty("CropWavelengthMin");
maxwl = getProperty("CropWavelengthMax");
if (maxwl == 0.)
maxwl = EMPTY_DBL(); // python can only specify 0 for unused
tmin = getProperty("TMin");
tmax = getProperty("TMax");
m_preserveEvents = getProperty("PreserveEvents");
m_resampleX = getProperty("ResampleX");
// determine some bits about d-space and binning
if (m_resampleX != 0) {
m_params.clear(); // ignore the normal rebin parameters
} else if (m_params.size() == 1) {
if (dmax > 0.)
dspace = true;
else
dspace = false;
}
if (dspace) {
if (m_params.size() == 1 && dmax > 0) {
double step = m_params[0];
m_params.clear();
if (step > 0 || dmin > 0) {
m_params.push_back(dmin);
m_params.push_back(step);
m_params.push_back(dmax);
g_log.information() << "d-Spacing Binning: " << m_params[0] << " "
<< m_params[1] << " " << m_params[2] << "\n";
}
}
} else {
if (m_params.size() == 1 && tmax > 0) {
double step = m_params[0];
if (step > 0 || tmin > 0) {
m_params[0] = tmin;
m_params.push_back(step);
m_params.push_back(tmax);
g_log.information() << "TOF Binning: " << m_params[0] << " "
<< m_params[1] << " " << m_params[2] << "\n";
}
}
}
xmin = 0.;
xmax = 0.;
if (tmin > 0.) {
xmin = tmin;
}
if (tmax > 0.) {
xmax = tmax;
}
if (!dspace && m_params.size() == 3) {
xmin = m_params[0];
xmax = m_params[2];
}
// Low resolution
int lowresoffset = getProperty("LowResSpectrumOffset");
if (lowresoffset < 0) {
m_processLowResTOF = false;
} else {
m_processLowResTOF = true;
m_lowResSpecOffset = static_cast<size_t>(lowresoffset);
}
loadCalFile(calFilename, groupFilename);
// Now setup the output workspace
m_outputW = getProperty("OutputWorkspace");
if (m_inputEW) {
if (m_outputW != m_inputW) {
m_outputEW = m_inputEW->clone();
}
m_outputEW = boost::dynamic_pointer_cast<EventWorkspace>(m_outputW);
} else {
if (m_outputW != m_inputW) {
m_outputW = WorkspaceFactory::Instance().create(m_inputW);
}
}
if (m_processLowResTOF) {
if (!m_inputEW) {
throw std::runtime_error(
"Input workspace is not EventWorkspace. It is not supported now.");
} else {
// Make a brand new EventWorkspace
m_lowResEW = boost::dynamic_pointer_cast<EventWorkspace>(
WorkspaceFactory::Instance().create(
"EventWorkspace", m_inputEW->getNumberHistograms(), 2, 1));
// Cast to the matrixOutputWS and save it
m_lowResW = boost::dynamic_pointer_cast<MatrixWorkspace>(m_lowResEW);
// m_lowResW->setName(lowreswsname);
}
}
// set up a progress bar with the "correct" number of steps
m_progress = new Progress(this, 0., 1., 22);
if (m_inputEW) {
double tolerance = getProperty("CompressTolerance");
if (tolerance > 0.) {
g_log.information() << "running CompressEvents(Tolerance=" << tolerance
<< ") started at "
<< Kernel::DateAndTime::getCurrentTime() << "\n";
API::IAlgorithm_sptr compressAlg = createChildAlgorithm("CompressEvents");
compressAlg->setProperty("InputWorkspace", m_outputEW);
compressAlg->setProperty("OutputWorkspace", m_outputEW);
compressAlg->setProperty("OutputWorkspace", m_outputEW);
compressAlg->setProperty("Tolerance", tolerance);
compressAlg->executeAsChildAlg();
m_outputEW = compressAlg->getProperty("OutputWorkspace");
m_outputW = boost::dynamic_pointer_cast<MatrixWorkspace>(m_outputEW);
} else {
g_log.information() << "Not compressing event list\n";
doSortEvents(m_outputW); // still sort to help some thing out
}
}
m_progress->report();
if (xmin > 0. || xmax > 0.) {
double tempmin;
double tempmax;
m_outputW->getXMinMax(tempmin, tempmax);
g_log.information() << "running CropWorkspace(TOFmin=" << xmin
<< ", TOFmax=" << xmax << ") started at "
<< Kernel::DateAndTime::getCurrentTime() << "\n";
API::IAlgorithm_sptr cropAlg = createChildAlgorithm("CropWorkspace");
cropAlg->setProperty("InputWorkspace", m_outputW);
cropAlg->setProperty("OutputWorkspace", m_outputW);
if ((xmin > 0.) && (xmin > tempmin))
cropAlg->setProperty("Xmin", xmin);
if ((xmax > 0.) && (xmax < tempmax))
cropAlg->setProperty("Xmax", xmax);
cropAlg->executeAsChildAlg();
m_outputW = cropAlg->getProperty("OutputWorkspace");
m_outputEW = boost::dynamic_pointer_cast<EventWorkspace>(m_outputW);
}
m_progress->report();
// filter the input events if appropriate
double removePromptPulseWidth = getProperty("RemovePromptPulseWidth");
if (removePromptPulseWidth > 0.) {
m_outputEW = boost::dynamic_pointer_cast<EventWorkspace>(m_outputW);
if (m_outputEW->getNumberEvents() > 0) {
g_log.information() << "running RemovePromptPulse(Width="
<< removePromptPulseWidth << ") started at "
<< Kernel::DateAndTime::getCurrentTime() << "\n";
API::IAlgorithm_sptr filterPAlg =
createChildAlgorithm("RemovePromptPulse");
filterPAlg->setProperty("InputWorkspace", m_outputW);
filterPAlg->setProperty("OutputWorkspace", m_outputW);
filterPAlg->setProperty("Width", removePromptPulseWidth);
filterPAlg->executeAsChildAlg();
m_outputW = filterPAlg->getProperty("OutputWorkspace");
m_outputEW = boost::dynamic_pointer_cast<EventWorkspace>(m_outputW);
} else {
g_log.information("skipping RemovePromptPulse on empty EventWorkspace");
}
}
m_progress->report();
if (maskBinTableWS) {
g_log.information() << "running MaskBinsFromTable started at "
<< Kernel::DateAndTime::getCurrentTime() << "\n";
API::IAlgorithm_sptr alg = createChildAlgorithm("MaskBinsFromTable");
alg->setProperty("InputWorkspace", m_outputW);
alg->setProperty("OutputWorkspace", m_outputW);
alg->setProperty("MaskingInformation", maskBinTableWS);
alg->executeAsChildAlg();
m_outputW = alg->getProperty("OutputWorkspace");
m_outputEW = boost::dynamic_pointer_cast<EventWorkspace>(m_outputW);
}
m_progress->report();
if (m_maskWS) {
g_log.information() << "running MaskDetectors started at "
<< Kernel::DateAndTime::getCurrentTime() << "\n";
API::IAlgorithm_sptr maskAlg = createChildAlgorithm("MaskDetectors");
maskAlg->setProperty("Workspace", m_outputW);
maskAlg->setProperty("MaskedWorkspace", m_maskWS);
maskAlg->executeAsChildAlg();
Workspace_sptr tmpW = maskAlg->getProperty("Workspace");
m_outputW = boost::dynamic_pointer_cast<MatrixWorkspace>(tmpW);
m_outputEW = boost::dynamic_pointer_cast<EventWorkspace>(m_outputW);
}
m_progress->report();
if (!dspace)
m_outputW = rebin(m_outputW);
m_progress->report();
if (m_calibrationWS) {
g_log.information() << "running AlignDetectors started at "
<< Kernel::DateAndTime::getCurrentTime() << "\n";
API::IAlgorithm_sptr alignAlg = createChildAlgorithm("AlignDetectors");
alignAlg->setProperty("InputWorkspace", m_outputW);
alignAlg->setProperty("OutputWorkspace", m_outputW);
alignAlg->setProperty("CalibrationWorkspace", m_calibrationWS);
alignAlg->executeAsChildAlg();
m_outputW = alignAlg->getProperty("OutputWorkspace");
} else {
m_outputW = convertUnits(m_outputW, "dSpacing");
}
m_progress->report();
if (LRef > 0. || minwl > 0. || DIFCref > 0. || (!isEmpty(maxwl))) {
m_outputW = convertUnits(m_outputW, "TOF");
}
m_progress->report();
// Beyond this point, low resolution TOF workspace is considered.
if (LRef > 0.) {
g_log.information() << "running UnwrapSNS(LRef=" << LRef << ",Tmin=" << tmin
<< ",Tmax=" << tmax << ") started at "
<< Kernel::DateAndTime::getCurrentTime() << "\n";
API::IAlgorithm_sptr removeAlg = createChildAlgorithm("UnwrapSNS");
removeAlg->setProperty("InputWorkspace", m_outputW);
removeAlg->setProperty("OutputWorkspace", m_outputW);
removeAlg->setProperty("LRef", LRef);
if (tmin > 0.)
removeAlg->setProperty("Tmin", tmin);
if (tmax > tmin)
removeAlg->setProperty("Tmax", tmax);
removeAlg->executeAsChildAlg();
m_outputW = removeAlg->getProperty("OutputWorkspace");
}
m_progress->report();
if (minwl > 0. || (!isEmpty(maxwl))) { // just crop the worksapce
// turn off the low res stuff
m_processLowResTOF = false;
EventWorkspace_sptr ews =
boost::dynamic_pointer_cast<EventWorkspace>(m_outputW);
if (ews)
g_log.information() << "Number of events = " << ews->getNumberEvents()
<< ". ";
g_log.information("\n");
m_outputW = convertUnits(m_outputW, "Wavelength");
g_log.information() << "running CropWorkspace(WavelengthMin=" << minwl;
if (!isEmpty(maxwl))
g_log.information() << ", WavelengthMax=" << maxwl;
g_log.information() << ") started at "
<< Kernel::DateAndTime::getCurrentTime() << "\n";
API::IAlgorithm_sptr removeAlg = createChildAlgorithm("CropWorkspace");
removeAlg->setProperty("InputWorkspace", m_outputW);
removeAlg->setProperty("OutputWorkspace", m_outputW);
removeAlg->setProperty("XMin", minwl);
removeAlg->setProperty("XMax", maxwl);
removeAlg->executeAsChildAlg();
m_outputW = removeAlg->getProperty("OutputWorkspace");
if (ews)
g_log.information() << "Number of events = " << ews->getNumberEvents()
<< ".\n";
} else if (DIFCref > 0.) {
g_log.information() << "running RemoveLowResTof(RefDIFC=" << DIFCref
<< ",K=3.22) started at "
<< Kernel::DateAndTime::getCurrentTime() << "\n";
EventWorkspace_sptr ews =
boost::dynamic_pointer_cast<EventWorkspace>(m_outputW);
if (ews)
g_log.information() << "Number of events = " << ews->getNumberEvents()
<< ". ";
g_log.information("\n");
API::IAlgorithm_sptr removeAlg = createChildAlgorithm("RemoveLowResTOF");
removeAlg->setProperty("InputWorkspace", m_outputW);
removeAlg->setProperty("OutputWorkspace", m_outputW);
removeAlg->setProperty("ReferenceDIFC", DIFCref);
removeAlg->setProperty("K", 3.22);
if (tmin > 0.)
removeAlg->setProperty("Tmin", tmin);
if (m_processLowResTOF)
removeAlg->setProperty("LowResTOFWorkspace", m_lowResW);
removeAlg->executeAsChildAlg();
m_outputW = removeAlg->getProperty("OutputWorkspace");
if (m_processLowResTOF)
m_lowResW = removeAlg->getProperty("LowResTOFWorkspace");
}
m_progress->report();
EventWorkspace_sptr ews =
boost::dynamic_pointer_cast<EventWorkspace>(m_outputW);
if (ews) {
size_t numhighevents = ews->getNumberEvents();
if (m_processLowResTOF) {
EventWorkspace_sptr lowes =
boost::dynamic_pointer_cast<EventWorkspace>(m_lowResW);
size_t numlowevents = lowes->getNumberEvents();
g_log.information() << "Number of high TOF events = " << numhighevents
<< "; "
<< "Number of low TOF events = " << numlowevents
<< ".\n";
}
}
m_progress->report();
// Convert units
if (LRef > 0. || minwl > 0. || DIFCref > 0. || (!isEmpty(maxwl))) {
m_outputW = convertUnits(m_outputW, "dSpacing");
if (m_processLowResTOF)
m_lowResW = convertUnits(m_lowResW, "dSpacing");
}
m_progress->report();
if (dspace) {
m_outputW = rebin(m_outputW);
if (m_processLowResTOF)
m_lowResW = rebin(m_lowResW);
}
m_progress->report();
doSortEvents(m_outputW);
if (m_processLowResTOF)
doSortEvents(m_lowResW);
m_progress->report();
// Diffraction focus
m_outputW = diffractionFocus(m_outputW);
if (m_processLowResTOF)
m_lowResW = diffractionFocus(m_lowResW);
m_progress->report();
doSortEvents(m_outputW);
if (m_processLowResTOF)
doSortEvents(m_lowResW);
m_progress->report();
// this next call should probably be in for rebin as well
// but it changes the system tests
if (dspace && m_resampleX != 0) {
m_outputW = rebin(m_outputW);
if (m_processLowResTOF)
m_lowResW = rebin(m_lowResW);
}
m_progress->report();
// edit the instrument geometry
if (m_groupWS &&
(m_l1 > 0 || !tths.empty() || !l2s.empty() || !phis.empty())) {
size_t numreg = m_outputW->getNumberHistograms();
try {
// set up the vectors for doing everything
auto specidsSplit = splitVectors(specids, numreg, "specids");
auto tthsSplit = splitVectors(tths, numreg, "two-theta");
auto l2sSplit = splitVectors(l2s, numreg, "L2");
auto phisSplit = splitVectors(phis, numreg, "phi");
// Edit instrument
m_outputW = editInstrument(m_outputW, tthsSplit.reg, specidsSplit.reg,
l2sSplit.reg, phisSplit.reg);
if (m_processLowResTOF) {
m_lowResW = editInstrument(m_lowResW, tthsSplit.low, specidsSplit.low,
l2sSplit.low, phisSplit.low);
}
} catch (std::runtime_error &e) {
g_log.warning("Not editing instrument geometry:");
g_log.warning(e.what());
}
}
m_progress->report();
// Conjoin 2 workspaces if there is low resolution
if (m_processLowResTOF) {
m_outputW = conjoinWorkspaces(m_outputW, m_lowResW, m_lowResSpecOffset);
}
m_progress->report();
// Convert units to TOF
m_outputW = convertUnits(m_outputW, "TOF");
m_progress->report();
// compress again if appropriate
double tolerance = getProperty("CompressTolerance");
m_outputEW = boost::dynamic_pointer_cast<EventWorkspace>(m_outputW);
if ((m_outputEW) && (tolerance > 0.)) {
g_log.information() << "running CompressEvents(Tolerance=" << tolerance
<< ") started at "
<< Kernel::DateAndTime::getCurrentTime() << "\n";
API::IAlgorithm_sptr compressAlg = createChildAlgorithm("CompressEvents");
compressAlg->setProperty("InputWorkspace", m_outputEW);
compressAlg->setProperty("OutputWorkspace", m_outputEW);
compressAlg->setProperty("OutputWorkspace", m_outputEW);
compressAlg->setProperty("Tolerance", tolerance);
compressAlg->executeAsChildAlg();
m_outputEW = compressAlg->getProperty("OutputWorkspace");
m_outputW = boost::dynamic_pointer_cast<MatrixWorkspace>(m_outputEW);
}
m_progress->report();
if ((!m_params.empty()) && (m_params.size() != 1)) {
m_params.erase(m_params.begin());
m_params.pop_back();
}
if (!m_dmins.empty())
m_dmins.clear();
if (!m_dmaxs.empty())
m_dmaxs.clear();
m_outputW = rebin(m_outputW);
m_progress->report();
// return the output workspace
setProperty("OutputWorkspace", m_outputW);
}
/// Executes the algorithm for events
void UnaryOperation::execEvent() {
g_log.information("Processing event workspace");
const MatrixWorkspace_const_sptr matrixInputWS =
this->getProperty(inputPropName());
EventWorkspace_const_sptr inputWS =
boost::dynamic_pointer_cast<const EventWorkspace>(matrixInputWS);
// generate the output workspace pointer
API::MatrixWorkspace_sptr matrixOutputWS =
this->getProperty(outputPropName());
EventWorkspace_sptr outputWS;
if (matrixOutputWS == matrixInputWS) {
outputWS = boost::dynamic_pointer_cast<EventWorkspace>(matrixOutputWS);
} else {
// Make a brand new EventWorkspace
outputWS = boost::dynamic_pointer_cast<EventWorkspace>(
API::WorkspaceFactory::Instance().create(
"EventWorkspace", inputWS->getNumberHistograms(), 2, 1));
// Copy geometry over.
API::WorkspaceFactory::Instance().initializeFromParent(inputWS, outputWS,
false);
// You need to copy over the data as well.
outputWS->copyDataFrom((*inputWS));
// Cast to the matrixOutputWS and save it
matrixOutputWS = boost::dynamic_pointer_cast<MatrixWorkspace>(outputWS);
this->setProperty("OutputWorkspace", matrixOutputWS);
}
// Now fetch any properties defined by concrete algorithm
retrieveProperties();
int64_t numHistograms = static_cast<int64_t>(inputWS->getNumberHistograms());
API::Progress prog = API::Progress(this, 0.0, 1.0, numHistograms);
PARALLEL_FOR1(outputWS)
for (int64_t i = 0; i < numHistograms; ++i) {
PARALLEL_START_INTERUPT_REGION
// switch to weighted events if needed, and use the appropriate helper
// function
EventList *evlist = outputWS->getEventListPtr(i);
switch (evlist->getEventType()) {
case TOF:
// Switch to weights if needed.
evlist->switchTo(WEIGHTED);
/* no break */
// Fall through
case WEIGHTED:
unaryOperationEventHelper(evlist->getWeightedEvents());
break;
case WEIGHTED_NOTIME:
unaryOperationEventHelper(evlist->getWeightedEventsNoTime());
break;
}
prog.report();
PARALLEL_END_INTERUPT_REGION
}
PARALLEL_CHECK_INTERUPT_REGION
outputWS->clearMRU();
if (inputWS->getNumberEvents() != outputWS->getNumberEvents()) {
g_log.information() << "Number of events has changed!!!" << std::endl;
}
}
/** Execute the algorithm.
*/
void IntegrateEllipsoids::exec() {
// get the input workspace
MatrixWorkspace_sptr wksp = getProperty("InputWorkspace");
EventWorkspace_sptr eventWS =
boost::dynamic_pointer_cast<EventWorkspace>(wksp);
Workspace2D_sptr histoWS = boost::dynamic_pointer_cast<Workspace2D>(wksp);
if (!eventWS && !histoWS) {
throw std::runtime_error("IntegrateEllipsoids needs either a "
"EventWorkspace or Workspace2D as input.");
}
// error out if there are not events
if (eventWS && eventWS->getNumberEvents() <= 0) {
throw std::runtime_error(
"IntegrateEllipsoids does not work for empty event lists");
}
PeaksWorkspace_sptr in_peak_ws = getProperty("PeaksWorkspace");
if (!in_peak_ws) {
throw std::runtime_error("Could not read the peaks workspace");
}
double radius = getProperty("RegionRadius");
int numSigmas = getProperty("NumSigmas");
double cutoffIsigI = getProperty("CutoffIsigI");
bool specify_size = getProperty("SpecifySize");
double peak_radius = getProperty("PeakSize");
double back_inner_radius = getProperty("BackgroundInnerSize");
double back_outer_radius = getProperty("BackgroundOuterSize");
bool hkl_integ = getProperty("IntegrateInHKL");
bool integrateEdge = getProperty("IntegrateIfOnEdge");
if (!integrateEdge) {
// This only fails in the unit tests which say that MaskBTP is not
// registered
try {
runMaskDetectors(in_peak_ws, "Tube", "edges");
runMaskDetectors(in_peak_ws, "Pixel", "edges");
} catch (...) {
g_log.error("Can't execute MaskBTP algorithm for this instrument to set "
"edge for IntegrateIfOnEdge option");
}
calculateE1(in_peak_ws->detectorInfo()); // fill E1Vec for use in detectorQ
}
Mantid::DataObjects::PeaksWorkspace_sptr peak_ws =
getProperty("OutputWorkspace");
if (peak_ws != in_peak_ws) {
peak_ws = in_peak_ws->clone();
}
// get UBinv and the list of
// peak Q's for the integrator
std::vector<Peak> &peaks = peak_ws->getPeaks();
size_t n_peaks = peak_ws->getNumberPeaks();
size_t indexed_count = 0;
std::vector<V3D> peak_q_list;
std::vector<std::pair<double, V3D>> qList;
std::vector<V3D> hkl_vectors;
for (size_t i = 0; i < n_peaks; i++) // Note: we skip un-indexed peaks
{
V3D hkl(peaks[i].getH(), peaks[i].getK(), peaks[i].getL());
if (Geometry::IndexingUtils::ValidIndex(hkl, 1.0)) // use tolerance == 1 to
// just check for (0,0,0)
{
peak_q_list.emplace_back(peaks[i].getQLabFrame());
qList.emplace_back(1., V3D(peaks[i].getQLabFrame()));
V3D miller_ind(static_cast<double>(boost::math::iround<double>(hkl[0])),
static_cast<double>(boost::math::iround<double>(hkl[1])),
static_cast<double>(boost::math::iround<double>(hkl[2])));
hkl_vectors.push_back(miller_ind);
indexed_count++;
}
}
if (indexed_count < 3) {
throw std::runtime_error(
"At least three linearly independent indexed peaks are needed.");
}
// Get UB using indexed peaks and
// lab-Q vectors
Matrix<double> UB(3, 3, false);
Geometry::IndexingUtils::Optimize_UB(UB, hkl_vectors, peak_q_list);
Matrix<double> UBinv(UB);
UBinv.Invert();
UBinv *= (1.0 / (2.0 * M_PI));
std::vector<double> PeakRadiusVector(n_peaks, peak_radius);
std::vector<double> BackgroundInnerRadiusVector(n_peaks, back_inner_radius);
std::vector<double> BackgroundOuterRadiusVector(n_peaks, back_outer_radius);
if (specify_size) {
if (back_outer_radius > radius)
throw std::runtime_error(
"BackgroundOuterSize must be less than or equal to the RegionRadius");
if (back_inner_radius >= back_outer_radius)
throw std::runtime_error(
"BackgroundInnerSize must be less BackgroundOuterSize");
if (peak_radius > back_inner_radius)
throw std::runtime_error(
"PeakSize must be less than or equal to the BackgroundInnerSize");
}
// make the integrator
Integrate3DEvents integrator(qList, UBinv, radius);
// get the events and add
// them to the inegrator
// set up a descripter of where we are going
this->initTargetWSDescr(wksp);
// set up the progress bar
const size_t numSpectra = wksp->getNumberHistograms();
Progress prog(this, 0.5, 1.0, numSpectra);
if (eventWS) {
// process as EventWorkspace
qListFromEventWS(integrator, prog, eventWS, UBinv, hkl_integ);
} else {
// process as Workspace2D
qListFromHistoWS(integrator, prog, histoWS, UBinv, hkl_integ);
}
double inti;
double sigi;
std::vector<double> principalaxis1, principalaxis2, principalaxis3;
V3D peak_q;
for (size_t i = 0; i < n_peaks; i++) {
V3D hkl(peaks[i].getH(), peaks[i].getK(), peaks[i].getL());
if (Geometry::IndexingUtils::ValidIndex(hkl, 1.0)) {
peak_q = peaks[i].getQLabFrame();
std::vector<double> axes_radii;
Mantid::Geometry::PeakShape_const_sptr shape =
integrator.ellipseIntegrateEvents(
E1Vec, peak_q, specify_size, peak_radius, back_inner_radius,
back_outer_radius, axes_radii, inti, sigi);
peaks[i].setIntensity(inti);
peaks[i].setSigmaIntensity(sigi);
peaks[i].setPeakShape(shape);
if (axes_radii.size() == 3) {
if (inti / sigi > cutoffIsigI || cutoffIsigI == EMPTY_DBL()) {
principalaxis1.push_back(axes_radii[0]);
principalaxis2.push_back(axes_radii[1]);
principalaxis3.push_back(axes_radii[2]);
}
}
} else {
peaks[i].setIntensity(0.0);
peaks[i].setSigmaIntensity(0.0);
}
}
if (principalaxis1.size() > 1) {
size_t histogramNumber = 3;
Workspace_sptr wsProfile = WorkspaceFactory::Instance().create(
"Workspace2D", histogramNumber, principalaxis1.size(),
principalaxis1.size());
Workspace2D_sptr wsProfile2D =
boost::dynamic_pointer_cast<Workspace2D>(wsProfile);
AnalysisDataService::Instance().addOrReplace("EllipsoidAxes", wsProfile2D);
for (size_t j = 0; j < principalaxis1.size(); j++) {
wsProfile2D->dataX(0)[j] = static_cast<double>(j);
wsProfile2D->dataY(0)[j] = principalaxis1[j];
wsProfile2D->dataE(0)[j] = std::sqrt(principalaxis1[j]);
wsProfile2D->dataX(1)[j] = static_cast<double>(j);
wsProfile2D->dataY(1)[j] = principalaxis2[j];
wsProfile2D->dataE(1)[j] = std::sqrt(principalaxis2[j]);
wsProfile2D->dataX(2)[j] = static_cast<double>(j);
wsProfile2D->dataY(2)[j] = principalaxis3[j];
wsProfile2D->dataE(2)[j] = std::sqrt(principalaxis3[j]);
}
Statistics stats1 = getStatistics(principalaxis1);
g_log.notice() << "principalaxis1: "
<< " mean " << stats1.mean << " standard_deviation "
<< stats1.standard_deviation << " minimum " << stats1.minimum
<< " maximum " << stats1.maximum << " median "
<< stats1.median << "\n";
Statistics stats2 = getStatistics(principalaxis2);
g_log.notice() << "principalaxis2: "
<< " mean " << stats2.mean << " standard_deviation "
<< stats2.standard_deviation << " minimum " << stats2.minimum
<< " maximum " << stats2.maximum << " median "
<< stats2.median << "\n";
Statistics stats3 = getStatistics(principalaxis3);
g_log.notice() << "principalaxis3: "
<< " mean " << stats3.mean << " standard_deviation "
<< stats3.standard_deviation << " minimum " << stats3.minimum
<< " maximum " << stats3.maximum << " median "
<< stats3.median << "\n";
if (cutoffIsigI != EMPTY_DBL()) {
principalaxis1.clear();
principalaxis2.clear();
principalaxis3.clear();
specify_size = true;
peak_radius = std::max(std::max(stats1.mean, stats2.mean), stats3.mean) +
numSigmas * std::max(std::max(stats1.standard_deviation,
stats2.standard_deviation),
stats3.standard_deviation);
back_inner_radius = peak_radius;
back_outer_radius =
peak_radius *
1.25992105; // A factor of 2 ^ (1/3) will make the background
// shell volume equal to the peak region volume.
V3D peak_q;
for (size_t i = 0; i < n_peaks; i++) {
V3D hkl(peaks[i].getH(), peaks[i].getK(), peaks[i].getL());
if (Geometry::IndexingUtils::ValidIndex(hkl, 1.0)) {
peak_q = peaks[i].getQLabFrame();
std::vector<double> axes_radii;
integrator.ellipseIntegrateEvents(
E1Vec, peak_q, specify_size, peak_radius, back_inner_radius,
back_outer_radius, axes_radii, inti, sigi);
peaks[i].setIntensity(inti);
peaks[i].setSigmaIntensity(sigi);
if (axes_radii.size() == 3) {
principalaxis1.push_back(axes_radii[0]);
principalaxis2.push_back(axes_radii[1]);
principalaxis3.push_back(axes_radii[2]);
}
} else {
peaks[i].setIntensity(0.0);
peaks[i].setSigmaIntensity(0.0);
}
}
if (principalaxis1.size() > 1) {
size_t histogramNumber = 3;
Workspace_sptr wsProfile2 = WorkspaceFactory::Instance().create(
"Workspace2D", histogramNumber, principalaxis1.size(),
principalaxis1.size());
Workspace2D_sptr wsProfile2D2 =
boost::dynamic_pointer_cast<Workspace2D>(wsProfile2);
AnalysisDataService::Instance().addOrReplace("EllipsoidAxes_2ndPass",
wsProfile2D2);
for (size_t j = 0; j < principalaxis1.size(); j++) {
wsProfile2D2->dataX(0)[j] = static_cast<double>(j);
wsProfile2D2->dataY(0)[j] = principalaxis1[j];
wsProfile2D2->dataE(0)[j] = std::sqrt(principalaxis1[j]);
wsProfile2D2->dataX(1)[j] = static_cast<double>(j);
wsProfile2D2->dataY(1)[j] = principalaxis2[j];
wsProfile2D2->dataE(1)[j] = std::sqrt(principalaxis2[j]);
wsProfile2D2->dataX(2)[j] = static_cast<double>(j);
wsProfile2D2->dataY(2)[j] = principalaxis3[j];
wsProfile2D2->dataE(2)[j] = std::sqrt(principalaxis3[j]);
}
}
}
}
// This flag is used by the PeaksWorkspace to evaluate whether it has been
// integrated.
peak_ws->mutableRun().addProperty("PeaksIntegrated", 1, true);
// These flags are specific to the algorithm.
peak_ws->mutableRun().addProperty("PeakRadius", PeakRadiusVector, true);
peak_ws->mutableRun().addProperty("BackgroundInnerRadius",
BackgroundInnerRadiusVector, true);
peak_ws->mutableRun().addProperty("BackgroundOuterRadius",
BackgroundOuterRadiusVector, true);
setProperty("OutputWorkspace", peak_ws);
}
void CorrectKiKf::execEvent()
{
g_log.information("Processing event workspace");
const MatrixWorkspace_const_sptr matrixInputWS = this->getProperty("InputWorkspace");
EventWorkspace_const_sptr inputWS= boost::dynamic_pointer_cast<const EventWorkspace>(matrixInputWS);
// generate the output workspace pointer
API::MatrixWorkspace_sptr matrixOutputWS = this->getProperty("OutputWorkspace");
EventWorkspace_sptr outputWS;
if (matrixOutputWS == matrixInputWS)
outputWS = boost::dynamic_pointer_cast<EventWorkspace>(matrixOutputWS);
else
{
//Make a brand new EventWorkspace
outputWS = boost::dynamic_pointer_cast<EventWorkspace>(
API::WorkspaceFactory::Instance().create("EventWorkspace", inputWS->getNumberHistograms(), 2, 1));
//Copy geometry over.
API::WorkspaceFactory::Instance().initializeFromParent(inputWS, outputWS, false);
//You need to copy over the data as well.
outputWS->copyDataFrom( (*inputWS) );
//Cast to the matrixOutputWS and save it
matrixOutputWS = boost::dynamic_pointer_cast<MatrixWorkspace>(outputWS);
this->setProperty("OutputWorkspace", matrixOutputWS);
}
const std::string emodeStr = getProperty("EMode");
double efixedProp = getProperty("EFixed"),efixed;
if( efixedProp == EMPTY_DBL() )
{
if (emodeStr == "Direct")
{
// Check if it has been store on the run object for this workspace
if( this->inputWS->run().hasProperty("Ei"))
{
Kernel::Property* eiprop = this->inputWS->run().getProperty("Ei");
efixedProp = boost::lexical_cast<double>(eiprop->value());
g_log.debug() << "Using stored Ei value " << efixedProp << "\n";
}
else
{
throw std::invalid_argument("No Ei value has been set or stored within the run information.");
}
}
else
{
// If not specified, will try to get Ef from the parameter file for indirect geometry,
// but it will be done for each spectrum separately, in case of different analyzer crystals
}
}
// Get the parameter map
const ParameterMap& pmap = outputWS->constInstrumentParameters();
int64_t numHistograms = static_cast<int64_t>(inputWS->getNumberHistograms());
API::Progress prog = API::Progress(this, 0.0, 1.0, numHistograms);
PARALLEL_FOR1(outputWS)
for (int64_t i=0; i < numHistograms; ++i)
{
PARALLEL_START_INTERUPT_REGION
double Efi = 0;
// Now get the detector object for this histogram to check if monitor
// or to get Ef for indirect geometry
if (emodeStr == "Indirect")
{
if ( efixedProp != EMPTY_DBL()) Efi = efixedProp;
else try
{
IDetector_const_sptr det = inputWS->getDetector(i);
if (!det->isMonitor())
{
try
{
Parameter_sptr par = pmap.getRecursive(det.get(),"Efixed");
if (par)
{
Efi = par->value<double>();
g_log.debug() << "Detector: " << det->getID() << " EFixed: " << Efi << "\n";
}
}
catch (std::runtime_error&) { /* Throws if a DetectorGroup, use single provided value */ }
}
}
catch(std::runtime_error&) { g_log.information() << "Workspace Index " << i << ": cannot find detector" << "\n"; }
}
if (emodeStr == "Indirect") efixed=Efi;
else efixed=efixedProp;
//Do the correction
EventList *evlist=outputWS->getEventListPtr(i);
switch (evlist->getEventType())
{
case TOF:
//Switch to weights if needed.
evlist->switchTo(WEIGHTED);
/* no break */
// Fall through
case WEIGHTED:
correctKiKfEventHelper(evlist->getWeightedEvents(), efixed,emodeStr);
break;
case WEIGHTED_NOTIME:
correctKiKfEventHelper(evlist->getWeightedEventsNoTime(), efixed,emodeStr);
break;
}
prog.report();
PARALLEL_END_INTERUPT_REGION
}
PARALLEL_CHECK_INTERUPT_REGION
outputWS->clearMRU();
if (inputWS->getNumberEvents( ) != outputWS->getNumberEvents( ))
{
g_log.information() <<"Ef <= 0 or Ei <= 0 for "<<inputWS->getNumberEvents( )-outputWS->getNumberEvents( )<<" events, out of "<<inputWS->getNumberEvents( )<<std::endl;
if ( efixedProp == EMPTY_DBL()) g_log.information()<<"Try to set fixed energy"<<std::endl ;
}
}
/** Execute the algorithm.
*/
void IntegrateEllipsoids::exec()
{
// get the input workspace
EventWorkspace_sptr wksp = getProperty("InputWorkspace");
// this only works for unweighted events
if (wksp->getEventType() != API::TOF)
{
throw std::runtime_error("IntegrateEllipsoids only works for raw events");
}
// error out if there are not events
if (wksp->getNumberEvents() <= 0)
{
throw std::runtime_error("IntegrateEllipsoids does not work for empty event lists");
}
PeaksWorkspace_sptr in_peak_ws;
in_peak_ws = boost::dynamic_pointer_cast<PeaksWorkspace>(
AnalysisDataService::Instance().retrieve( getProperty("PeaksWorkspace")) );
if (!in_peak_ws)
{
throw std::runtime_error("Could not read the peaks workspace");
}
Mantid::DataObjects::PeaksWorkspace_sptr peak_ws = getProperty("OutputWorkspace");
if ( peak_ws != in_peak_ws )
{
peak_ws = in_peak_ws->clone();
}
// get UBinv and the list of
// peak Q's for the integrator
std::vector<Peak> & peaks = peak_ws->getPeaks();
size_t n_peaks = peak_ws->getNumberPeaks();
size_t indexed_count = 0;
std::vector<V3D> peak_q_list;
std::vector<V3D> hkl_vectors;
for ( size_t i = 0; i < n_peaks; i++ ) // Note: we skip un-indexed peaks
{
V3D hkl( peaks[i].getH(), peaks[i].getK(), peaks[i].getL() );
if ( Geometry::IndexingUtils::ValidIndex( hkl, 1.0 ) ) // use tolerance == 1 to
// just check for (0,0,0)
{
peak_q_list.push_back( V3D( peaks[i].getQLabFrame() ) );
V3D miller_ind( (double)boost::math::iround<double>(hkl[0]),
(double)boost::math::iround<double>(hkl[1]),
(double)boost::math::iround<double>(hkl[2]) );
hkl_vectors.push_back( V3D(miller_ind) );
indexed_count++;
}
}
if ( indexed_count < 3 )
{
throw std::runtime_error(
"At least three linearly independent indexed peaks are needed.");
}
// Get UB using indexed peaks and
// lab-Q vectors
Matrix<double> UB(3,3,false);
Geometry::IndexingUtils::Optimize_UB( UB, hkl_vectors, peak_q_list );
Matrix<double> UBinv( UB );
UBinv.Invert();
UBinv *= (1.0/(2.0 * M_PI));
double radius = getProperty( "RegionRadius" );
bool specify_size = getProperty( "SpecifySize" );
double peak_radius = getProperty( "PeakSize" );
double back_inner_radius = getProperty( "BackgroundInnerSize" );
double back_outer_radius = getProperty( "BackgroundOuterSize" );
if ( specify_size )
{
if ( back_outer_radius > radius )
throw std::runtime_error("BackgroundOuterSize must be less than or equal to the RegionRadius");
if ( back_inner_radius >= back_outer_radius )
throw std::runtime_error("BackgroundInnerSize must be less BackgroundOuterSize");
if ( peak_radius > back_inner_radius )
throw std::runtime_error("PeakSize must be less than or equal to the BackgroundInnerSize");
}
// make the integrator
Integrate3DEvents integrator( peak_q_list, UBinv, radius );
// get the events and add
// them to the inegrator
// set up a descripter of where we are going
this->initTargetWSDescr(wksp);
// units conersion helper
UnitsConversionHelper unitConv;
unitConv.initialize(m_targWSDescr, "Momentum");
// initialize the MD coordinates conversion class
MDTransf_sptr q_converter = MDTransfFactory::Instance().create(m_targWSDescr.AlgID);
q_converter->initialize(m_targWSDescr);
// set up the progress bar
const size_t numSpectra = wksp->getNumberHistograms();
Progress prog(this, 0.5, 1.0, numSpectra);
// loop through the eventlists
std::vector<double> buffer(DIMS);
std::vector<V3D> event_qs;
for (std::size_t i = 0; i < numSpectra; ++i)
{
// get a reference to the event list
const EventList& events = wksp->getEventList(i);
// check to see if the event list is empty
if (events.empty())
{
prog.report();
continue; // nothing to do
}
// update which pixel is being converted
std::vector<coord_t>locCoord(DIMS, 0.);
unitConv.updateConversion(i);
q_converter->calcYDepCoordinates(locCoord, i);
// loop over the events
double signal(1.); // ignorable garbage
double errorSq(1.); // ignorable garbage
const std::vector<TofEvent>& raw_events = events.getEvents();
event_qs.clear();
for (auto event = raw_events.begin(); event != raw_events.end(); ++event)
{
double val = unitConv.convertUnits( event->tof() );
q_converter->calcMatrixCoord( val, locCoord, signal, errorSq );
for ( size_t dim = 0; dim < DIMS; ++dim )
{
buffer[dim] = locCoord[dim];
}
V3D q_vec( buffer[0], buffer[1], buffer[2] );
event_qs.push_back( q_vec );
} // end of loop over events in list
integrator.addEvents( event_qs );
prog.report();
} // end of loop over spectra
double inti;
double sigi;
for ( size_t i = 0; i < n_peaks; i++ )
{
V3D hkl( peaks[i].getH(), peaks[i].getK(), peaks[i].getL() );
if ( Geometry::IndexingUtils::ValidIndex( hkl, 1.0 ) )
{
V3D peak_q( peaks[i].getQLabFrame() );
integrator.ellipseIntegrateEvents( peak_q,
specify_size, peak_radius, back_inner_radius, back_outer_radius,
inti, sigi );
peaks[i].setIntensity( inti );
peaks[i].setSigmaIntensity( sigi );
}
else
{
peaks[i].setIntensity( 0.0 );
peaks[i].setSigmaIntensity( 0.0 );
}
}
peak_ws->mutableRun().addProperty("PeaksIntegrated", 1, true);
setProperty("OutputWorkspace", peak_ws);
}
/** Execute the algorithm.
*/
void IntegrateEllipsoids::exec() {
// get the input workspace
MatrixWorkspace_sptr wksp = getProperty("InputWorkspace");
EventWorkspace_sptr eventWS =
boost::dynamic_pointer_cast<EventWorkspace>(wksp);
Workspace2D_sptr histoWS = boost::dynamic_pointer_cast<Workspace2D>(wksp);
if (!eventWS && !histoWS) {
throw std::runtime_error("IntegrateEllipsoids needs either a "
"EventWorkspace or Workspace2D as input.");
}
// error out if there are not events
if (eventWS && eventWS->getNumberEvents() <= 0) {
throw std::runtime_error(
"IntegrateEllipsoids does not work for empty event lists");
}
PeaksWorkspace_sptr in_peak_ws = getProperty("PeaksWorkspace");
if (!in_peak_ws) {
throw std::runtime_error("Could not read the peaks workspace");
}
double radius_m = getProperty("RegionRadius");
double radius_s = getProperty("SatelliteRegionRadius");
int numSigmas = getProperty("NumSigmas");
double cutoffIsigI = getProperty("CutoffIsigI");
bool specify_size = getProperty("SpecifySize");
double peak_radius = getProperty("PeakSize");
double sate_peak_radius = getProperty("SatellitePeakSize");
double back_inner_radius = getProperty("BackgroundInnerSize");
double sate_back_inner_radius = getProperty("SatelliteBackgroundInnerSize");
double back_outer_radius = getProperty("BackgroundOuterSize");
double sate_back_outer_radius = getProperty("SatelliteBackgroundOuterSize");
bool hkl_integ = getProperty("IntegrateInHKL");
bool integrateEdge = getProperty("IntegrateIfOnEdge");
bool adaptiveQBackground = getProperty("AdaptiveQBackground");
double adaptiveQMultiplier = getProperty("AdaptiveQMultiplier");
double adaptiveQBackgroundMultiplier = 0.0;
bool useOnePercentBackgroundCorrection =
getProperty("UseOnePercentBackgroundCorrection");
if (adaptiveQBackground)
adaptiveQBackgroundMultiplier = adaptiveQMultiplier;
if (!integrateEdge) {
// This only fails in the unit tests which say that MaskBTP is not
// registered
try {
runMaskDetectors(in_peak_ws, "Tube", "edges");
runMaskDetectors(in_peak_ws, "Pixel", "edges");
} catch (...) {
g_log.error("Can't execute MaskBTP algorithm for this instrument to set "
"edge for IntegrateIfOnEdge option");
}
calculateE1(in_peak_ws->detectorInfo()); // fill E1Vec for use in detectorQ
}
Mantid::DataObjects::PeaksWorkspace_sptr peak_ws =
getProperty("OutputWorkspace");
if (peak_ws != in_peak_ws)
peak_ws = in_peak_ws->clone();
// get UBinv and the list of
// peak Q's for the integrator
std::vector<Peak> &peaks = peak_ws->getPeaks();
size_t n_peaks = peak_ws->getNumberPeaks();
size_t indexed_count = 0;
std::vector<V3D> peak_q_list;
std::vector<std::pair<double, V3D>> qList;
std::vector<V3D> hkl_vectors;
std::vector<V3D> mnp_vectors;
int ModDim = 0;
for (size_t i = 0; i < n_peaks; i++) // Note: we skip un-indexed peaks
{
V3D hkl(peaks[i].getIntHKL());
V3D mnp(peaks[i].getIntMNP());
if (mnp[0] != 0 && ModDim == 0)
ModDim = 1;
if (mnp[1] != 0 && ModDim == 1)
ModDim = 2;
if (mnp[2] != 0 && ModDim == 2)
ModDim = 3;
// use tolerance == 1 to just check for (0,0,0,0,0,0)
if (Geometry::IndexingUtils::ValidIndex(hkl, 1.0)) {
peak_q_list.emplace_back(peaks[i].getQLabFrame());
qList.emplace_back(1., V3D(peaks[i].getQLabFrame()));
hkl_vectors.push_back(hkl);
mnp_vectors.push_back(mnp);
indexed_count++;
}
}
if (indexed_count < 3)
throw std::runtime_error(
"At least three linearly independent indexed peaks are needed.");
// Get UB using indexed peaks and
// lab-Q vectors
Matrix<double> UB(3, 3, false);
Matrix<double> modUB(3, 3, false);
Matrix<double> modHKL(3, 3, false);
Geometry::IndexingUtils::Optimize_6dUB(UB, modUB, hkl_vectors, mnp_vectors,
ModDim, peak_q_list);
int maxOrder = 0;
bool CT = false;
if (peak_ws->sample().hasOrientedLattice()) {
OrientedLattice lattice = peak_ws->mutableSample().getOrientedLattice();
lattice.setUB(UB);
lattice.setModUB(modUB);
modHKL = lattice.getModHKL();
maxOrder = lattice.getMaxOrder();
CT = lattice.getCrossTerm();
}
Matrix<double> UBinv(UB);
UBinv.Invert();
UBinv *= (1.0 / (2.0 * M_PI));
std::vector<double> PeakRadiusVector(n_peaks, peak_radius);
std::vector<double> BackgroundInnerRadiusVector(n_peaks, back_inner_radius);
std::vector<double> BackgroundOuterRadiusVector(n_peaks, back_outer_radius);
if (specify_size) {
if (back_outer_radius > radius_m)
throw std::runtime_error(
"BackgroundOuterSize must be less than or equal to the RegionRadius");
if (back_inner_radius >= back_outer_radius)
throw std::runtime_error(
"BackgroundInnerSize must be less BackgroundOuterSize");
if (peak_radius > back_inner_radius)
throw std::runtime_error(
"PeakSize must be less than or equal to the BackgroundInnerSize");
}
// make the integrator
Integrate3DEvents integrator(qList, hkl_vectors, mnp_vectors, UBinv, modHKL,
radius_m, radius_s, maxOrder, CT,
useOnePercentBackgroundCorrection);
// get the events and add
// them to the inegrator
// set up a descripter of where we are going
this->initTargetWSDescr(wksp);
// set up the progress bar
const size_t numSpectra = wksp->getNumberHistograms();
Progress prog(this, 0.5, 1.0, numSpectra);
if (eventWS) {
// process as EventWorkspace
qListFromEventWS(integrator, prog, eventWS, UBinv, hkl_integ);
} else {
// process as Workspace2D
qListFromHistoWS(integrator, prog, histoWS, UBinv, hkl_integ);
}
double inti;
double sigi;
std::vector<double> principalaxis1, principalaxis2, principalaxis3;
std::vector<double> sateprincipalaxis1, sateprincipalaxis2,
sateprincipalaxis3;
for (size_t i = 0; i < n_peaks; i++) {
const V3D hkl(peaks[i].getIntHKL());
const V3D mnp(peaks[i].getIntMNP());
if (Geometry::IndexingUtils::ValidIndex(hkl, 1.0) ||
Geometry::IndexingUtils::ValidIndex(mnp, 1.0)) {
const V3D peak_q = peaks[i].getQLabFrame();
// modulus of Q
const double lenQpeak = adaptiveQMultiplier != 0.0 ? peak_q.norm() : 0.0;
double adaptiveRadius = adaptiveQMultiplier * lenQpeak + peak_radius;
if (mnp != V3D(0, 0, 0))
adaptiveRadius = adaptiveQMultiplier * lenQpeak + sate_peak_radius;
if (adaptiveRadius <= 0.0) {
g_log.error() << "Error: Radius for integration sphere of peak " << i
<< " is negative = " << adaptiveRadius << '\n';
peaks[i].setIntensity(0.0);
peaks[i].setSigmaIntensity(0.0);
PeakRadiusVector[i] = 0.0;
BackgroundInnerRadiusVector[i] = 0.0;
BackgroundOuterRadiusVector[i] = 0.0;
continue;
}
double adaptiveBack_inner_radius;
double adaptiveBack_outer_radius;
if (mnp == V3D(0, 0, 0)) {
adaptiveBack_inner_radius =
adaptiveQBackgroundMultiplier * lenQpeak + back_inner_radius;
adaptiveBack_outer_radius =
adaptiveQBackgroundMultiplier * lenQpeak + back_outer_radius;
} else {
adaptiveBack_inner_radius =
adaptiveQBackgroundMultiplier * lenQpeak + sate_back_inner_radius;
adaptiveBack_outer_radius =
adaptiveQBackgroundMultiplier * lenQpeak + sate_back_outer_radius;
}
PeakRadiusVector[i] = adaptiveRadius;
BackgroundInnerRadiusVector[i] = adaptiveBack_inner_radius;
BackgroundOuterRadiusVector[i] = adaptiveBack_outer_radius;
std::vector<double> axes_radii;
Mantid::Geometry::PeakShape_const_sptr shape =
integrator.ellipseIntegrateModEvents(
E1Vec, peak_q, hkl, mnp, specify_size, adaptiveRadius,
adaptiveBack_inner_radius, adaptiveBack_outer_radius, axes_radii,
inti, sigi);
peaks[i].setIntensity(inti);
peaks[i].setSigmaIntensity(sigi);
peaks[i].setPeakShape(shape);
if (axes_radii.size() == 3) {
if (inti / sigi > cutoffIsigI || cutoffIsigI == EMPTY_DBL()) {
if (mnp == V3D(0, 0, 0)) {
principalaxis1.push_back(axes_radii[0]);
principalaxis2.push_back(axes_radii[1]);
principalaxis3.push_back(axes_radii[2]);
} else {
sateprincipalaxis1.push_back(axes_radii[0]);
sateprincipalaxis2.push_back(axes_radii[1]);
sateprincipalaxis3.push_back(axes_radii[2]);
}
}
}
} else {
peaks[i].setIntensity(0.0);
peaks[i].setSigmaIntensity(0.0);
}
}
if (principalaxis1.size() > 1) {
Statistics stats1 = getStatistics(principalaxis1);
g_log.notice() << "principalaxis1: "
<< " mean " << stats1.mean << " standard_deviation "
<< stats1.standard_deviation << " minimum " << stats1.minimum
<< " maximum " << stats1.maximum << " median "
<< stats1.median << "\n";
Statistics stats2 = getStatistics(principalaxis2);
g_log.notice() << "principalaxis2: "
<< " mean " << stats2.mean << " standard_deviation "
<< stats2.standard_deviation << " minimum " << stats2.minimum
<< " maximum " << stats2.maximum << " median "
<< stats2.median << "\n";
Statistics stats3 = getStatistics(principalaxis3);
g_log.notice() << "principalaxis3: "
<< " mean " << stats3.mean << " standard_deviation "
<< stats3.standard_deviation << " minimum " << stats3.minimum
<< " maximum " << stats3.maximum << " median "
<< stats3.median << "\n";
if (sateprincipalaxis1.size() > 1) {
Statistics satestats1 = getStatistics(sateprincipalaxis1);
g_log.notice() << "sateprincipalaxis1: "
<< " mean " << satestats1.mean << " standard_deviation "
<< satestats1.standard_deviation << " minimum "
<< satestats1.minimum << " maximum " << satestats1.maximum
<< " median " << satestats1.median << "\n";
Statistics satestats2 = getStatistics(sateprincipalaxis2);
g_log.notice() << "sateprincipalaxis2: "
<< " mean " << satestats2.mean << " standard_deviation "
<< satestats2.standard_deviation << " minimum "
<< satestats2.minimum << " maximum " << satestats2.maximum
<< " median " << satestats2.median << "\n";
Statistics satestats3 = getStatistics(sateprincipalaxis3);
g_log.notice() << "sateprincipalaxis3: "
<< " mean " << satestats3.mean << " standard_deviation "
<< satestats3.standard_deviation << " minimum "
<< satestats3.minimum << " maximum " << satestats3.maximum
<< " median " << satestats3.median << "\n";
}
constexpr size_t histogramNumber = 3;
Workspace_sptr wsProfile = WorkspaceFactory::Instance().create(
"Workspace2D", histogramNumber, principalaxis1.size(),
principalaxis1.size());
Workspace2D_sptr wsProfile2D =
boost::dynamic_pointer_cast<Workspace2D>(wsProfile);
AnalysisDataService::Instance().addOrReplace("EllipsoidAxes", wsProfile2D);
// set output workspace
Points points(principalaxis1.size(), LinearGenerator(0, 1));
wsProfile2D->setHistogram(0, points, Counts(std::move(principalaxis1)));
wsProfile2D->setHistogram(1, points, Counts(std::move(principalaxis2)));
wsProfile2D->setHistogram(2, points, Counts(std::move(principalaxis3)));
if (cutoffIsigI != EMPTY_DBL()) {
principalaxis1.clear();
principalaxis2.clear();
principalaxis3.clear();
sateprincipalaxis1.clear();
sateprincipalaxis2.clear();
sateprincipalaxis3.clear();
specify_size = true;
peak_radius = std::max(std::max(stats1.mean, stats2.mean), stats3.mean) +
numSigmas * std::max(std::max(stats1.standard_deviation,
stats2.standard_deviation),
stats3.standard_deviation);
back_inner_radius = peak_radius;
back_outer_radius = peak_radius * 1.25992105; // A factor of 2 ^ (1/3)
// will make the background
// shell volume equal to the peak region volume.
for (size_t i = 0; i < n_peaks; i++) {
V3D hkl(peaks[i].getIntHKL());
V3D mnp(peaks[i].getIntMNP());
if (Geometry::IndexingUtils::ValidIndex(hkl, 1.0) ||
Geometry::IndexingUtils::ValidIndex(mnp, 1.0)) {
const V3D peak_q = peaks[i].getQLabFrame();
std::vector<double> axes_radii;
integrator.ellipseIntegrateModEvents(
E1Vec, peak_q, hkl, mnp, specify_size, peak_radius,
back_inner_radius, back_outer_radius, axes_radii, inti, sigi);
peaks[i].setIntensity(inti);
peaks[i].setSigmaIntensity(sigi);
if (axes_radii.size() == 3) {
if (mnp == V3D(0, 0, 0)) {
principalaxis1.push_back(axes_radii[0]);
principalaxis2.push_back(axes_radii[1]);
principalaxis3.push_back(axes_radii[2]);
} else {
sateprincipalaxis1.push_back(axes_radii[0]);
sateprincipalaxis2.push_back(axes_radii[1]);
sateprincipalaxis3.push_back(axes_radii[2]);
}
}
} else {
peaks[i].setIntensity(0.0);
peaks[i].setSigmaIntensity(0.0);
}
}
if (principalaxis1.size() > 1) {
Workspace_sptr wsProfile2 = WorkspaceFactory::Instance().create(
"Workspace2D", histogramNumber, principalaxis1.size(),
principalaxis1.size());
Workspace2D_sptr wsProfile2D2 =
boost::dynamic_pointer_cast<Workspace2D>(wsProfile2);
AnalysisDataService::Instance().addOrReplace("EllipsoidAxes_2ndPass",
wsProfile2D2);
Points profilePoints(principalaxis1.size(), LinearGenerator(0, 1));
wsProfile2D->setHistogram(0, profilePoints,
Counts(std::move(principalaxis1)));
wsProfile2D->setHistogram(1, profilePoints,
Counts(std::move(principalaxis2)));
wsProfile2D->setHistogram(2, profilePoints,
Counts(std::move(principalaxis3)));
}
}
}
// This flag is used by the PeaksWorkspace to evaluate whether it has been
// integrated.
peak_ws->mutableRun().addProperty("PeaksIntegrated", 1, true);
// These flags are specific to the algorithm.
peak_ws->mutableRun().addProperty("PeakRadius", PeakRadiusVector, true);
peak_ws->mutableRun().addProperty("BackgroundInnerRadius",
BackgroundInnerRadiusVector, true);
peak_ws->mutableRun().addProperty("BackgroundOuterRadius",
BackgroundOuterRadiusVector, true);
setProperty("OutputWorkspace", peak_ws);
}
