/** * Fit peak without background i.e, with background removed * inspired from FitPowderDiffPeaks.cpp * copied from PoldiPeakDetection2.cpp * @param workspaceindex :: indice of the row to use @param center :: gaussian parameter - center @param sigma :: gaussian parameter - width @param height :: gaussian parameter - height @param startX :: fit range - start X value @param endX :: fit range - end X value @returns A boolean status flag, true for fit success, false else */ bool ConvertEmptyToTof::doFitGaussianPeak(int workspaceindex, double ¢er, double &sigma, double &height, double startX, double endX) { g_log.debug("Calling doFitGaussianPeak..."); // 1. Estimate sigma = sigma * 0.5; // 2. Use factory to generate Gaussian auto temppeak = API::FunctionFactory::Instance().createFunction("Gaussian"); auto gaussianpeak = boost::dynamic_pointer_cast<API::IPeakFunction>(temppeak); gaussianpeak->setHeight(height); gaussianpeak->setCentre(center); gaussianpeak->setFwhm(sigma); // 3. Constraint double centerleftend = center - sigma * 0.5; double centerrightend = center + sigma * 0.5; std::ostringstream os; os << centerleftend << " < PeakCentre < " << centerrightend; auto *centerbound = API::ConstraintFactory::Instance().createInitialized( gaussianpeak.get(), os.str(), false); gaussianpeak->addConstraint(centerbound); g_log.debug("Calling createChildAlgorithm : Fit..."); // 4. Fit API::IAlgorithm_sptr fitalg = createChildAlgorithm("Fit", -1, -1, true); fitalg->initialize(); fitalg->setProperty( "Function", boost::dynamic_pointer_cast<API::IFunction>(gaussianpeak)); fitalg->setProperty("InputWorkspace", m_inputWS); fitalg->setProperty("WorkspaceIndex", workspaceindex); fitalg->setProperty("Minimizer", "Levenberg-MarquardtMD"); fitalg->setProperty("CostFunction", "Least squares"); fitalg->setProperty("MaxIterations", 1000); fitalg->setProperty("Output", "FitGaussianPeak"); fitalg->setProperty("StartX", startX); fitalg->setProperty("EndX", endX); // 5. Result bool successfulfit = fitalg->execute(); if (!fitalg->isExecuted() || !successfulfit) { // Early return due to bad fit g_log.warning() << "Fitting Gaussian peak for peak around " << gaussianpeak->centre() << '\n'; return false; } // 6. Get result center = gaussianpeak->centre(); height = gaussianpeak->height(); double fwhm = gaussianpeak->fwhm(); return fwhm > 0.0; }
/** Fit function * Minimizer: "Levenberg-MarquardtMD"/"Simplex" */ bool RefinePowderInstrumentParameters2::doFitFunction(IFunction_sptr function, Workspace2D_sptr dataws, int wsindex, string minimizer, int numiters, double& chi2, string& fitstatus) { // 0. Debug output stringstream outss; outss << "Fit function: " << m_positionFunc->asString() << endl << "Data To Fit: \n"; for (size_t i = 0; i < dataws->readX(0).size(); ++i) outss << dataws->readX(wsindex)[i] << "\t\t" << dataws->readY(wsindex)[i] << "\t\t" << dataws->readE(wsindex)[i] << "\n"; g_log.information() << outss.str(); // 1. Create and setup fit algorithm API::IAlgorithm_sptr fitalg = createChildAlgorithm("Fit", 0.0, 0.2, true); fitalg->initialize(); fitalg->setProperty("Function", function); fitalg->setProperty("InputWorkspace", dataws); fitalg->setProperty("WorkspaceIndex", wsindex); fitalg->setProperty("Minimizer", minimizer); fitalg->setProperty("CostFunction", "Least squares"); fitalg->setProperty("MaxIterations", numiters); fitalg->setProperty("CalcErrors", true); // 2. Fit bool successfulfit = fitalg->execute(); if (!fitalg->isExecuted() || ! successfulfit) { // Early return due to bad fit g_log.warning("Fitting to instrument geometry function failed. "); chi2 = DBL_MAX; fitstatus = "Minimizer throws exception."; return false; } // 3. Understand solution chi2 = fitalg->getProperty("OutputChi2overDoF"); string tempfitstatus = fitalg->getProperty("OutputStatus"); fitstatus = tempfitstatus; bool goodfit = fitstatus.compare("success") == 0; stringstream dbss; dbss << "Fit Result (GSL): Chi^2 = " << chi2 << "; Fit Status = " << fitstatus << ", Return Bool = " << goodfit << std::endl; vector<string> funcparnames = function->getParameterNames(); for (size_t i = 0; i < funcparnames.size(); ++i) dbss << funcparnames[i] << " = " << setw(20) << function->getParameter(funcparnames[i]) << " +/- " << function->getError(i) << "\n"; g_log.debug() << dbss.str(); return goodfit; }
std::string FrameworkManagerProxy::createAlgorithmDocs(const std::string& algName, const int version) { const std::string EOL="\n"; API::IAlgorithm_sptr algm = API::AlgorithmManager::Instance().createUnmanaged(algName, version); algm->initialize(); // Put in the quick overview message std::stringstream buffer; std::string temp = algm->getOptionalMessage(); if (temp.size() > 0) buffer << temp << EOL << EOL; // get a sorted copy of the properties PropertyVector properties(algm->getProperties()); std::sort(properties.begin(), properties.end(), PropertyOrdering()); // generate the sanitized names StringVector names(properties.size()); size_t numProps = properties.size(); for ( size_t i = 0; i < numProps; ++i) { names[i] = removeCharacters(properties[i]->name(), ""); } buffer << "Property descriptions: " << EOL << EOL; // write the actual property descriptions Mantid::Kernel::Property *prop; for ( size_t i = 0; i < numProps; ++i) { prop = properties[i]; buffer << names[i] << "(" << Mantid::Kernel::Direction::asText(prop->direction()); if (!prop->isValid().empty()) buffer << ":req"; buffer << ") *" << prop->type() << "* "; std::set<std::string> allowed = prop->allowedValues(); if (!prop->documentation().empty() || !allowed.empty()) { buffer << " " << prop->documentation(); if (!allowed.empty()) { buffer << " [" << Kernel::Strings::join(allowed.begin(), allowed.end(), ", "); buffer << "]"; } buffer << EOL; if( i < numProps - 1 ) buffer << EOL; } } return buffer.str(); }
/** * Create the concrete instance use for the actual loading. * @param startProgress :: The percentage progress value of the overall * algorithm where this child algorithm starts * @param endProgress :: The percentage progress value of the overall * algorithm where this child algorithm ends * @param logging :: Set to false to disable logging from the child algorithm */ API::IAlgorithm_sptr Load::createLoader(const double startProgress, const double endProgress, const bool logging) const { std::string name = getPropertyValue("LoaderName"); int version = getProperty("LoaderVersion"); API::IAlgorithm_sptr loader = API::AlgorithmManager::Instance().createUnmanaged(name, version); loader->initialize(); if (!loader) { throw std::runtime_error("Cannot create loader for \"" + getPropertyValue("Filename") + "\""); } setUpLoader(loader, startProgress, endProgress, logging); return loader; }
/** * Gaussian fit to determine peak position if no user position given. * * @return :: detector position of the peak: Gaussian fit and position * of the maximum (serves as start value for the optimization) */ double LoadILLReflectometry::reflectometryPeak() { if (!isDefault("BeamCentre")) { return getProperty("BeamCentre"); } size_t startIndex; size_t endIndex; std::tie(startIndex, endIndex) = fitIntegrationWSIndexRange(*m_localWorkspace); IAlgorithm_sptr integration = createChildAlgorithm("Integration"); integration->initialize(); integration->setProperty("InputWorkspace", m_localWorkspace); integration->setProperty("OutputWorkspace", "__unused_for_child"); integration->setProperty("StartWorkspaceIndex", static_cast<int>(startIndex)); integration->setProperty("EndWorkspaceIndex", static_cast<int>(endIndex)); integration->execute(); MatrixWorkspace_sptr integralWS = integration->getProperty("OutputWorkspace"); IAlgorithm_sptr transpose = createChildAlgorithm("Transpose"); transpose->initialize(); transpose->setProperty("InputWorkspace", integralWS); transpose->setProperty("OutputWorkspace", "__unused_for_child"); transpose->execute(); integralWS = transpose->getProperty("OutputWorkspace"); rebinIntegralWorkspace(*integralWS); // determine initial height: maximum value const auto maxValueIt = std::max_element(integralWS->y(0).cbegin(), integralWS->y(0).cend()); const double height = *maxValueIt; // determine initial centre: index of the maximum value const size_t maxIndex = std::distance(integralWS->y(0).cbegin(), maxValueIt); const double centreByMax = static_cast<double>(maxIndex); g_log.debug() << "Peak maximum position: " << centreByMax << '\n'; // determine sigma const auto &ys = integralWS->y(0); auto lessThanHalfMax = [height](const double x) { return x < 0.5 * height; }; using IterType = HistogramData::HistogramY::const_iterator; std::reverse_iterator<IterType> revMaxValueIt{maxValueIt}; auto revMinFwhmIt = std::find_if(revMaxValueIt, ys.crend(), lessThanHalfMax); auto maxFwhmIt = std::find_if(maxValueIt, ys.cend(), lessThanHalfMax); std::reverse_iterator<IterType> revMaxFwhmIt{maxFwhmIt}; if (revMinFwhmIt == ys.crend() || maxFwhmIt == ys.cend()) { g_log.warning() << "Couldn't determine fwhm of beam, using position of max " "value as beam center.\n"; return centreByMax; } const double fwhm = static_cast<double>(std::distance(revMaxFwhmIt, revMinFwhmIt) + 1); g_log.debug() << "Initial fwhm (full width at half maximum): " << fwhm << '\n'; // generate Gaussian auto func = API::FunctionFactory::Instance().createFunction("CompositeFunction"); auto sum = boost::dynamic_pointer_cast<API::CompositeFunction>(func); func = API::FunctionFactory::Instance().createFunction("Gaussian"); auto gaussian = boost::dynamic_pointer_cast<API::IPeakFunction>(func); gaussian->setHeight(height); gaussian->setCentre(centreByMax); gaussian->setFwhm(fwhm); sum->addFunction(gaussian); func = API::FunctionFactory::Instance().createFunction("LinearBackground"); func->setParameter("A0", 0.); func->setParameter("A1", 0.); sum->addFunction(func); // call Fit child algorithm API::IAlgorithm_sptr fit = createChildAlgorithm("Fit"); fit->initialize(); fit->setProperty("Function", boost::dynamic_pointer_cast<API::IFunction>(sum)); fit->setProperty("InputWorkspace", integralWS); fit->setProperty("StartX", centreByMax - 3 * fwhm); fit->setProperty("EndX", centreByMax + 3 * fwhm); fit->execute(); const std::string fitStatus = fit->getProperty("OutputStatus"); if (fitStatus != "success") { g_log.warning("Fit not successful, using position of max value.\n"); return centreByMax; } const auto centre = gaussian->centre(); g_log.debug() << "Sigma: " << gaussian->fwhm() << '\n'; g_log.debug() << "Estimated peak position: " << centre << '\n'; return centre; }
/** * Creates a managed version of a specified algorithm. * @param algName :: The name of the algorithm to execute. * @param version :: The version number (default=-1=highest version). * @return Pointer to algorithm. **/ API::IAlgorithm_sptr FrameworkManagerProxy::createUnmanagedAlgorithm(const std::string& algName, const int version) { API::IAlgorithm_sptr alg = API::AlgorithmManager::Instance().createUnmanaged(algName, version); alg->initialize(); return alg; }
void GoniometerAnglesFromPhiRotation::exec() { PeaksWorkspace_sptr PeaksRun1 = getProperty("PeaksWorkspace1"); PeaksWorkspace_sptr PeaksRun2 = getProperty("PeaksWorkspace2"); double Tolerance = getProperty("Tolerance"); Kernel::Matrix<double> Gon1(3, 3); Kernel::Matrix<double> Gon2(3, 3); if (!CheckForOneRun(PeaksRun1, Gon1) || !CheckForOneRun(PeaksRun2, Gon2)) { g_log.error("Each peaks workspace MUST have only one run"); throw std::invalid_argument("Each peaks workspace MUST have only one run"); } Kernel::Matrix<double> UB1; bool Run1HasOrientedLattice = true; if (!PeaksRun1->sample().hasOrientedLattice()) { Run1HasOrientedLattice = false; const std::string fft("FindUBUsingFFT"); API::IAlgorithm_sptr findUB = this->createChildAlgorithm(fft); findUB->initialize(); findUB->setProperty<PeaksWorkspace_sptr>("PeaksWorkspace", getProperty("PeaksWorkspace1")); findUB->setProperty("MIND", static_cast<double>(getProperty("MIND"))); findUB->setProperty("MAXD", static_cast<double>(getProperty("MAXD"))); findUB->setProperty("Tolerance", Tolerance); findUB->executeAsChildAlg(); if (!PeaksRun1->sample().hasOrientedLattice()) { g_log.notice(std::string("Could not find UB for ") + std::string(PeaksRun1->getName())); throw std::invalid_argument(std::string("Could not find UB for ") + std::string(PeaksRun1->getName())); } } //-------------get UB raw :No goniometer---------------- UB1 = PeaksRun1->sample().getOrientedLattice().getUB(); UB1 = getUBRaw(UB1, Gon1); int N1; double avErrIndx, avErrAll; IndexRaw(PeaksRun1, UB1, N1, avErrIndx, avErrAll, Tolerance); if (N1 < .6 * PeaksRun1->getNumberPeaks()) { g_log.notice(std::string("UB did not index well for ") + std::string(PeaksRun1->getName())); throw std::invalid_argument(std::string("UB did not index well for ") + std::string(PeaksRun1->getName())); } //---------------------------------------------- Geometry::OrientedLattice lat2 = PeaksRun1->sample().getOrientedLattice(); lat2.setUB(UB1); PeaksRun2->mutableSample().setOrientedLattice(&lat2); if (!Run1HasOrientedLattice) PeaksRun1->mutableSample().setOrientedLattice(nullptr); double dphi = static_cast<double>(getProperty("Phi2")) - static_cast<double>(getProperty("Run1Phi")); Kernel::Matrix<double> Gon22(3, 3, true); for (int i = 0; i < PeaksRun2->getNumberPeaks(); i++) { PeaksRun2->getPeak(i).setGoniometerMatrix(Gon22); } int RunNum = PeaksRun2->getPeak(0).getRunNumber(); std::string RunNumStr = std::to_string(RunNum); int Npeaks = PeaksRun2->getNumberPeaks(); // n indexed, av err, phi, chi,omega std::array<double, 5> MinData = {{0., 0., 0., 0., 0.}}; MinData[0] = 0.0; std::vector<V3D> directionList = IndexingUtils::MakeHemisphereDirections(50); API::FrameworkManager::Instance(); for (auto dir : directionList) for (int sgn = 1; sgn > -2; sgn -= 2) { dir.normalize(); Quat Q(sgn * dphi, dir); Q.normalize(); Kernel::Matrix<double> Rot(Q.getRotation()); int Nindexed; double dummyAvErrIndx, dummyAvErrAll; IndexRaw(PeaksRun2, Rot * UB1, Nindexed, dummyAvErrIndx, dummyAvErrAll, Tolerance); if (Nindexed > MinData[0]) { MinData[0] = Nindexed; MinData[1] = sgn; MinData[2] = dir[0]; MinData[3] = dir[1]; MinData[4] = dir[2]; } } g_log.debug() << "Best direction unOptimized is (" << (MinData[1] * MinData[2]) << "," << (MinData[1] * MinData[3]) << "," << (MinData[1] * MinData[4]) << ")\n"; //----------------------- Optimize around best---------------------------- auto ws = createWorkspace<Workspace2D>(1, 3 * Npeaks, 3 * Npeaks); MantidVec Xvals; for (int i = 0; i < Npeaks; ++i) { Xvals.push_back(i); Xvals.push_back(i); Xvals.push_back(i); } ws->setPoints(0, Xvals); //--------------------Set up other Fit function arguments------------------ V3D dir(MinData[2], MinData[3], MinData[4]); dir.normalize(); Quat Q(MinData[1] * dphi, dir); Q.normalize(); Kernel::Matrix<double> Rot(Q.getRotation()); Goniometer Gon(Rot); std::vector<double> omchiphi = Gon.getEulerAngles("yzy"); MinData[2] = omchiphi[2]; MinData[3] = omchiphi[1]; MinData[4] = omchiphi[0]; std::string FunctionArgs = "name=PeakHKLErrors, PeakWorkspaceName=" + PeaksRun2->getName() + ",OptRuns=" + RunNumStr + ",phi" + RunNumStr + "=" + boost::lexical_cast<std::string>(MinData[2]) + ",chi" + RunNumStr + "=" + boost::lexical_cast<std::string>(MinData[3]) + ",omega" + RunNumStr + "=" + boost::lexical_cast<std::string>(MinData[4]); std::string Constr = boost::lexical_cast<std::string>(MinData[2] - 5) + "<phi" + RunNumStr + "<" + boost::lexical_cast<std::string>(MinData[2] + 5); Constr += "," + boost::lexical_cast<std::string>(MinData[3] - 5) + "<chi" + RunNumStr + "<" + boost::lexical_cast<std::string>(MinData[3] + 5) + ","; Constr += boost::lexical_cast<std::string>(MinData[4] - 5) + "<omega" + RunNumStr + "<" + boost::lexical_cast<std::string>(MinData[4] + 5); std::string Ties = "SampleXOffset=0.0,SampleYOffset=0.0,SampleZOffset=0.0," "GonRotx=0.0,GonRoty=0.0,GonRotz=0.0"; boost::shared_ptr<Algorithm> Fit = createChildAlgorithm("Fit"); Fit->initialize(); Fit->setProperty("Function", FunctionArgs); Fit->setProperty("Ties", Ties); Fit->setProperty("Constraints", Constr); Fit->setProperty("InputWorkspace", ws); Fit->setProperty("CreateOutput", true); std::string outputName = "out"; Fit->setProperty("Output", outputName); Fit->executeAsChildAlg(); boost::shared_ptr<API::ITableWorkspace> results = Fit->getProperty("OutputParameters"); double chisq = Fit->getProperty("OutputChi2overDoF"); MinData[0] = chisq; MinData[2] = results->Double(6, 1); MinData[3] = results->Double(7, 1); MinData[4] = results->Double(8, 1); g_log.debug() << "Best direction Optimized is (" << (MinData[2]) << "," << (MinData[3]) << "," << (MinData[4]) << ")\n"; // ---------------------Find number indexed ----------------------- Quat Q1 = Quat(MinData[4], V3D(0, 1, 0)) * Quat(MinData[3], V3D(0, 0, 1)) * Quat(MinData[2], V3D(0, 1, 0)); int Nindexed; Kernel::Matrix<double> Mk(Q1.getRotation()); IndexRaw(PeaksRun2, Mk * UB1, Nindexed, avErrIndx, avErrAll, Tolerance); //------------------------------------ Convert/Save Results //----------------------------- double deg, ax1, ax2, ax3; Q1.getAngleAxis(deg, ax1, ax2, ax3); if (dphi * deg < 0) { deg = -deg; ax1 = -ax1; ax2 = -ax2; ax3 = -ax3; } double phi2 = static_cast<double>(getProperty("Run1Phi")) + dphi; double chi2 = acos(ax2) / M_PI * 180; double omega2 = atan2(ax3, -ax1) / M_PI * 180; g_log.notice() << "============================ Results ============================\n"; g_log.notice() << " phi,chi, and omega= (" << phi2 << "," << chi2 << "," << omega2 << ")\n"; g_log.notice() << " #indexed =" << Nindexed << '\n'; g_log.notice() << " ==============================================\n"; setProperty("Phi2", phi2); setProperty("Chi2", chi2); setProperty("Omega2", omega2); setProperty("NIndexed", Nindexed); setProperty("AvErrIndex", avErrIndx); setProperty("AvErrAll", avErrAll); Q1 = Quat(omega2, V3D(0, 1, 0)) * Quat(chi2, V3D(0, 0, 1)) * Quat(phi2, V3D(0, 1, 0)); Kernel::Matrix<double> Gon2a(Q1.getRotation()); for (int i = 0; i < PeaksRun2->getNumberPeaks(); i++) { PeaksRun2->getPeak(i).setGoniometerMatrix(Gon2a); } OrientedLattice latt2(PeaksRun2->mutableSample().getOrientedLattice()); // Kernel::Matrix<double> UB = latt2.getUB(); Rot.Invert(); Gon2a.Invert(); latt2.setUB(Gon2a * Mk * UB1); PeaksRun2->mutableSample().setOrientedLattice(&latt2); }
/** * Executes the algorithm */ void PlotPeakByLogValue::exec() { // Create a list of the input workspace const std::vector<InputData> wsNames = makeNames(); std::string fun = getPropertyValue("Function"); //int wi = getProperty("WorkspaceIndex"); std::string logName = getProperty("LogValue"); bool sequential = getPropertyValue("FitType") == "Sequential"; bool isDataName = false; // if true first output column is of type string and is the data source name ITableWorkspace_sptr result = WorkspaceFactory::Instance().createTable("TableWorkspace"); if (logName == "SourceName") { result->addColumn("str","Source name"); isDataName = true; } else if (logName.empty()) { result->addColumn("double","axis-1"); } else { result->addColumn("double",logName); } // Create an instance of the fitting function to obtain the names of fitting parameters IFitFunction* ifun = FunctionFactory::Instance().createInitialized(fun); if (!ifun) { throw std::invalid_argument("Fitting function failed to initialize"); } for(size_t iPar=0;iPar<ifun->nParams();++iPar) { result->addColumn("double",ifun->parameterName(iPar)); result->addColumn("double",ifun->parameterName(iPar)+"_Err"); } result->addColumn("double","Chi_squared"); delete ifun; setProperty("OutputWorkspace",result); double dProg = 1./static_cast<double>(wsNames.size()); double Prog = 0.; for(int i=0;i<static_cast<int>(wsNames.size());++i) { InputData data = getWorkspace(wsNames[i]); if (!data.ws) { g_log.warning() << "Cannot access workspace " << wsNames[i].name << '\n'; continue; } if (data.i < 0 && data.indx.empty()) { g_log.warning() << "Zero spectra selected for fitting in workspace " << wsNames[i].name << '\n'; continue; } int j,jend; if (data.i >= 0) { j = data.i; jend = j + 1; } else {// no need to check data.indx.empty() j = data.indx.front(); jend = data.indx.back() + 1; } dProg /= abs(jend - j); for(;j < jend;++j) { // Find the log value: it is either a log-file value or simply the workspace number double logValue; if (logName.empty()) { API::Axis* axis = data.ws->getAxis(1); logValue = (*axis)(j); } else if (logName != "SourceName") { Kernel::Property* prop = data.ws->run().getLogData(logName); if (!prop) { throw std::invalid_argument("Log value "+logName+" does not exist"); } TimeSeriesProperty<double>* logp = dynamic_cast<TimeSeriesProperty<double>*>(prop); logValue = logp->lastValue(); } std::string resFun = fun; std::vector<double> errors; double chi2; try { // Fit the function API::IAlgorithm_sptr fit = createSubAlgorithm("Fit"); fit->initialize(); fit->setProperty("InputWorkspace",data.ws); //fit->setPropertyValue("InputWorkspace",data.ws->getName()); fit->setProperty("WorkspaceIndex",j); fit->setPropertyValue("Function",fun); fit->setPropertyValue("StartX",getPropertyValue("StartX")); fit->setPropertyValue("EndX",getPropertyValue("EndX")); fit->setPropertyValue("Minimizer",getPropertyValue("Minimizer")); fit->setPropertyValue("CostFunction",getPropertyValue("CostFunction")); fit->execute(); resFun = fit->getPropertyValue("Function"); errors = fit->getProperty("Errors"); chi2 = fit->getProperty("OutputChi2overDoF"); } catch(...) { g_log.error("Error in Fit subalgorithm"); throw; } if (sequential) { fun = resFun; } // Extract the fitted parameters and put them into the result table TableRow row = result->appendRow(); if (isDataName) { row << wsNames[i].name; } else { row << logValue; } ifun = FunctionFactory::Instance().createInitialized(resFun); for(size_t iPar=0;iPar<ifun->nParams();++iPar) { row << ifun->getParameter(iPar) << errors[iPar]; } row << chi2; delete ifun; Prog += dProg; progress(Prog); interruption_point(); } // for(;j < jend;++j) } }
/** Get a workspace identified by an InputData structure. * @param data :: InputData with name and either spec or i fields defined. * @return InputData structure with the ws field set if everything was OK. */ PlotPeakByLogValue::InputData PlotPeakByLogValue::getWorkspace(const InputData& data) { InputData out(data); if (API::AnalysisDataService::Instance().doesExist(data.name)) { DataObjects::Workspace2D_sptr ws = boost::dynamic_pointer_cast<DataObjects::Workspace2D>( API::AnalysisDataService::Instance().retrieve(data.name)); if (ws) { out.ws = ws; } else { return data; } } else { std::ifstream fil(data.name.c_str()); if (!fil) { g_log.warning() << "File "<<data.name<<" does not exist\n"; return data; } fil.close(); std::string::size_type i = data.name.find_last_of('.'); if (i == std::string::npos) { g_log.warning() << "Cannot open file "<<data.name<<"\n"; return data; } std::string ext = data.name.substr(i); try { API::IAlgorithm_sptr load = createSubAlgorithm("Load"); load->initialize(); load->setPropertyValue("FileName",data.name); load->execute(); if (load->isExecuted()) { API::Workspace_sptr rws = load->getProperty("OutputWorkspace"); if (rws) { DataObjects::Workspace2D_sptr ws = boost::dynamic_pointer_cast<DataObjects::Workspace2D>(rws); if (ws) { out.ws = ws; } else { API::WorkspaceGroup_sptr gws = boost::dynamic_pointer_cast<API::WorkspaceGroup>(rws); if (gws) { std::vector<std::string> wsNames = gws->getNames(); std::string propName = "OUTPUTWORKSPACE_" + boost::lexical_cast<std::string>(data.period); if (load->existsProperty(propName)) { Workspace_sptr rws1 = load->getProperty(propName); out.ws = boost::dynamic_pointer_cast<DataObjects::Workspace2D>(rws1); } } } } } } catch(std::exception& e) { g_log.error(e.what()); return data; } } if (!out.ws) return data; API::Axis* axis = out.ws->getAxis(1); if (axis->isSpectra()) {// spectra axis if (out.spec < 0) { if (out.i >= 0) { out.spec = axis->spectraNo(out.i); } else {// i < 0 && spec < 0 => use start and end for(size_t i=0;i<axis->length();++i) { double s = double(axis->spectraNo(i)); if (s >= out.start && s <= out.end) { out.indx.push_back(static_cast<int>(i)); } } } } else { for(size_t i=0;i<axis->length();++i) { int j = axis->spectraNo(i); if (j == out.spec) { out.i = static_cast<int>(i); break; } } } if (out.i < 0 && out.indx.empty()) { return data; } } else {// numeric axis out.spec = -1; if (out.i >= 0) { out.indx.clear(); } else { if (out.i < -1) { out.start = (*axis)(0); out.end = (*axis)(axis->length()-1); } for(size_t i=0;i<axis->length();++i) { double s = (*axis)(i); if (s >= out.start && s <= out.end) { out.indx.push_back(static_cast<int>(i)); } } } } return out; }
void MaskBinsFromTable::exec() { MatrixWorkspace_sptr inputWS = getProperty("InputWorkspace"); DataObjects::TableWorkspace_sptr paramWS = getProperty("MaskingInformation"); // 1. Check input table workspace and column order g_log.debug() << "Lines of parameters workspace = " << paramWS->rowCount() << std::endl; bool colname_specx = false; if (!paramWS) { throw std::invalid_argument("Input table workspace is not accepted."); } else { std::vector<std::string> colnames = paramWS->getColumnNames(); // check colum name order if (colnames.size() < 3) { g_log.error() << "Input MaskingInformation table workspace has fewer than 3 columns. " << colnames.size() << " columns indeed" << std::endl; throw std::invalid_argument("MaskingInformation (TableWorkspace) has too few columns."); } if (colnames[0].compare("XMin") == 0) { // 1. Style XMin, XMax, SpectraList. Check rest if (colnames[1].compare("XMax") != 0 || colnames[2].compare("SpectraList") != 0) { g_log.error() << "INput MaskingInformation table workspace has wrong column order. " << std::endl; throw std::invalid_argument("MaskingInformation (TableWorkspace) has too few columns."); } } else if (colnames[0].compare("SpectraList") == 0) { // 2. Style SpectraList, XMin, XMax colname_specx = true; if (colnames[1].compare("XMin") != 0 || colnames[2].compare("XMax") != 0) { g_log.error() << "INput MaskingInformation table workspace has wrong column order. " << std::endl; throw std::invalid_argument("MaskingInformation (TableWorkspace) has too few columns."); } } else { g_log.error() << "INput MaskingInformation table workspace has wrong column order. " << std::endl; throw std::invalid_argument("MaskingInformation (TableWorkspace) has too few columns."); } } // 2. Loop over all rows bool firstloop = true; API::MatrixWorkspace_sptr outputws = this->getProperty("OutputWorkspace"); for (size_t ib = 0; ib < paramWS->rowCount(); ++ib) { API::TableRow therow = paramWS->getRow(ib); double xmin, xmax; std::string speclist; if (colname_specx) { therow >> speclist >> xmin >> xmax; } else { therow >> xmin >> xmax >> speclist; } g_log.debug() << "Row " << ib << " XMin = " << xmin << " XMax = " << xmax << " SpectraList = " << speclist << std::endl; API::IAlgorithm_sptr maskbins = this->createChildAlgorithm("MaskBins", 0, 0.3, true); maskbins->initialize(); if (firstloop) { maskbins->setProperty("InputWorkspace", inputWS); firstloop = false; } else { maskbins->setProperty("InputWorkspace", outputws); } maskbins->setProperty("OutputWorkspace", outputws); maskbins->setPropertyValue("SpectraList", speclist); maskbins->setProperty("XMin", xmin); maskbins->setProperty("XMax", xmax); bool isexec = maskbins->execute(); if (!isexec) { g_log.error() << "MaskBins() is not executed for row " << ib << std::endl; throw std::runtime_error("MaskBins() is not executed"); } outputws = maskbins->getProperty("OutputWorkspace"); if (!outputws) { g_log.error() << "OutputWorkspace is not retrieved for row " << ib << ". " << std::endl; throw std::runtime_error("OutputWorkspace is not got from MaskBins"); } }