/** 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); }