/** * Determine the instrument from the various input parameters. * * @return The correct instrument. */ Instrument_const_sptr CreateChunkingFromInstrument::getInstrument() { // try the input workspace MatrixWorkspace_sptr inWS = getProperty(PARAM_IN_WKSP); if (inWS) { return inWS->getInstrument(); } // temporary workspace to hang everything else off of MatrixWorkspace_sptr tempWS(new Workspace2D()); // name of the instrument string instName = getPropertyValue(PARAM_INST_NAME); // see if there is an input file string filename = getPropertyValue(PARAM_IN_FILE); if (!filename.empty()) { string top_entry_name("entry"); // TODO make more flexible // get the instrument name from the filename size_t n = filename.rfind('/'); if (n != std::string::npos) { std::string temp = filename.substr(n + 1, filename.size() - n - 1); n = temp.find('_'); if (n != std::string::npos && n > 0) { instName = temp.substr(0, n); } } // read information from the nexus file itself try { NeXus::File nxsfile(filename); // get the run start time string start_time; nxsfile.openGroup(top_entry_name, "NXentry"); nxsfile.readData("start_time", start_time); tempWS->mutableRun().addProperty( "run_start", DateAndTime(start_time).toISO8601String(), true); // get the instrument name nxsfile.openGroup("instrument", "NXinstrument"); nxsfile.readData("name", instName); nxsfile.closeGroup(); // Test if IDF exists in file, move on quickly if not nxsfile.openPath("instrument/instrument_xml"); nxsfile.close(); IAlgorithm_sptr loadInst = createChildAlgorithm("LoadIDFFromNexus", 0.0, 0.2); // Now execute the Child Algorithm. Catch and log any error, but don't // stop. try { loadInst->setPropertyValue("Filename", filename); loadInst->setProperty<MatrixWorkspace_sptr>("Workspace", tempWS); loadInst->setPropertyValue("InstrumentParentPath", top_entry_name); loadInst->execute(); } catch (std::invalid_argument &) { g_log.error("Invalid argument to LoadIDFFromNexus Child Algorithm "); } catch (std::runtime_error &) { g_log.debug("No instrument definition found in " + filename + " at " + top_entry_name + "/instrument"); } if (loadInst->isExecuted()) return tempWS->getInstrument(); else g_log.information("No IDF loaded from Nexus file."); } catch (::NeXus::Exception &) { g_log.information("No instrument definition found in " + filename + " at " + top_entry_name + "/instrument"); } } // run LoadInstrument if other methods have not run string instFilename = getPropertyValue(PARAM_INST_FILE); Algorithm_sptr childAlg = createChildAlgorithm("LoadInstrument", 0.0, 0.2); childAlg->setProperty<MatrixWorkspace_sptr>("Workspace", tempWS); childAlg->setPropertyValue("Filename", instFilename); childAlg->setPropertyValue("InstrumentName", instName); childAlg->executeAsChildAlg(); return tempWS->getInstrument(); }
/** Execute the algorithm. */ void LoadLiveData::exec() { // The full, post-processed output workspace m_outputWS = this->getProperty("OutputWorkspace"); // Validate inputs if (this->hasPostProcessing()) { if (this->getPropertyValue("AccumulationWorkspace").empty()) throw std::invalid_argument("Must specify the AccumulationWorkspace " "parameter if using PostProcessing."); // The accumulated but not post-processed output workspace m_accumWS = this->getProperty("AccumulationWorkspace"); } else { // No post-processing, so the accumulation and output are the same m_accumWS = m_outputWS; } // Get or create the live listener ILiveListener_sptr listener = this->getLiveListener(); // Do we need to reset the data? bool dataReset = listener->dataReset(); // The listener returns a MatrixWorkspace containing the chunk of live data. Workspace_sptr chunkWS; bool dataNotYetGiven = true; while (dataNotYetGiven) { try { chunkWS = listener->extractData(); dataNotYetGiven = false; } catch (Exception::NotYet &ex) { g_log.warning() << "The " << listener->name() << " is not ready to return data: " << ex.what() << "\n"; g_log.warning() << "Trying again in 10 seconds - cancel the algorithm to stop.\n"; const int tenSeconds = 40; for (int i = 0; i < tenSeconds; ++i) { Poco::Thread::sleep(10000 / tenSeconds); // 250 ms this->interruption_point(); } } } // TODO: Have the ILiveListener tell me exactly the time stamp DateAndTime lastTimeStamp = DateAndTime::getCurrentTime(); this->setPropertyValue("LastTimeStamp", lastTimeStamp.toISO8601String()); // Now we process the chunk Workspace_sptr processed = this->processChunk(chunkWS); bool PreserveEvents = this->getProperty("PreserveEvents"); EventWorkspace_sptr processedEvent = boost::dynamic_pointer_cast<EventWorkspace>(processed); if (!PreserveEvents && processedEvent) { // Convert the monitor workspace, if there is one and it's necessary MatrixWorkspace_sptr monitorWS = processedEvent->monitorWorkspace(); auto monitorEventWS = boost::dynamic_pointer_cast<EventWorkspace>(monitorWS); if (monitorEventWS) { auto monAlg = this->createChildAlgorithm("ConvertToMatrixWorkspace"); monAlg->setProperty("InputWorkspace", monitorEventWS); monAlg->executeAsChildAlg(); if (!monAlg->isExecuted()) g_log.error( "Failed to convert monitors from events to histogram form."); monitorWS = monAlg->getProperty("OutputWorkspace"); } // Now do the main workspace Algorithm_sptr alg = this->createChildAlgorithm("ConvertToMatrixWorkspace"); alg->setProperty("InputWorkspace", processedEvent); std::string outputName = "__anonymous_livedata_convert_" + this->getPropertyValue("OutputWorkspace"); alg->setPropertyValue("OutputWorkspace", outputName); alg->execute(); if (!alg->isExecuted()) throw std::runtime_error("Error when calling ConvertToMatrixWorkspace " "(since PreserveEvents=False). See log."); // Replace the "processed" workspace with the converted one. MatrixWorkspace_sptr temp = alg->getProperty("OutputWorkspace"); if (monitorWS) temp->setMonitorWorkspace(monitorWS); // Set back the monitor workspace processed = temp; } // How do we accumulate the data? std::string accum = this->getPropertyValue("AccumulationMethod"); // If the AccumulationWorkspace does not exist, we always replace the // AccumulationWorkspace. // Also, if the listener said we are resetting the data, then we clear out the // old. if (!m_accumWS || dataReset) accum = "Replace"; g_log.notice() << "Performing the " << accum << " operation.\n"; // Perform the accumulation and set the AccumulationWorkspace workspace if (accum == "Replace") this->replaceChunk(processed); else if (accum == "Append") this->appendChunk(processed); else // Default to Add. this->addChunk(processed); // At this point, m_accumWS is set. if (this->hasPostProcessing()) { // ----------- Run post-processing ------------- this->runPostProcessing(); // Set both output workspaces this->setProperty("AccumulationWorkspace", m_accumWS); this->setProperty("OutputWorkspace", m_outputWS); doSortEvents(m_outputWS); } else { // ----------- No post-processing ------------- m_outputWS = m_accumWS; // We DO NOT set AccumulationWorkspace. this->setProperty("OutputWorkspace", m_outputWS); } // Output group requires some additional handling WorkspaceGroup_sptr out_gws = boost::dynamic_pointer_cast<WorkspaceGroup>(m_outputWS); if (out_gws) { size_t n = static_cast<size_t>(out_gws->getNumberOfEntries()); for (size_t i = 0; i < n; ++i) { auto ws = out_gws->getItem(i); std::string itemName = ws->name(); std::string wsName = getPropertyValue("OutputWorkspace") + "_" + std::to_string(i + 1); if (wsName != itemName) { if (AnalysisDataService::Instance().doesExist(itemName)) { // replace the temporary name with the proper one AnalysisDataService::Instance().rename(itemName, wsName); } } else { // touch the workspace in the ADS to issue a notification to update the // GUI AnalysisDataService::Instance().addOrReplace(itemName, ws); } } } }
/** Process groups. Groups are processed differently depending on transmission * runs and polarization analysis. If transmission run is a matrix workspace, it * will be applied to each of the members in the input workspace group. If * transmission run is a workspace group, the behaviour is different depending * on polarization analysis. If polarization analysis is off (i.e. * 'PolarizationAnalysis' is set to 'None') each item in the transmission group * is associated with the corresponding item in the input workspace group. If * polarization analysis is on (i.e. 'PolarizationAnalysis' is 'PA' or 'PNR') * items in the transmission group will be summed to produce a matrix workspace * that will be applied to each of the items in the input workspace group. See * documentation of this algorithm for more details. */ bool ReflectometryReductionOneAuto2::processGroups() { // this algorithm effectively behaves as MultiPeriodGroupAlgorithm m_usingBaseProcessGroups = true; // Get our input workspace group auto group = AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>( getPropertyValue("InputWorkspace")); // Get name of IvsQ workspace (native binning) const std::string outputIvsQ = getPropertyValue("OutputWorkspace"); // Get name of IvsQ (native binning) workspace const std::string outputIvsQBinned = getPropertyValue("OutputWorkspaceBinned"); // Get name of IvsLam workspace const std::string outputIvsLam = getPropertyValue("OutputWorkspaceWavelength"); // Create a copy of ourselves Algorithm_sptr alg = createChildAlgorithm(name(), -1, -1, isLogging(), version()); alg->setChild(false); alg->setRethrows(true); // Copy all the non-workspace properties over const std::vector<Property *> props = getProperties(); for (auto &prop : props) { if (prop) { IWorkspaceProperty *wsProp = dynamic_cast<IWorkspaceProperty *>(prop); if (!wsProp) alg->setPropertyValue(prop->name(), prop->value()); } } const bool polarizationAnalysisOn = getPropertyValue("PolarizationAnalysis") != "None"; // Check if the transmission runs are groups or not const std::string firstTrans = getPropertyValue("FirstTransmissionRun"); WorkspaceGroup_sptr firstTransG; MatrixWorkspace_sptr firstTransSum; if (!firstTrans.empty()) { auto firstTransWS = AnalysisDataService::Instance().retrieveWS<Workspace>(firstTrans); firstTransG = boost::dynamic_pointer_cast<WorkspaceGroup>(firstTransWS); if (!firstTransG) { alg->setProperty("FirstTransmissionRun", firstTrans); } else if (polarizationAnalysisOn) { firstTransSum = sumTransmissionWorkspaces(firstTransG); } } const std::string secondTrans = getPropertyValue("SecondTransmissionRun"); WorkspaceGroup_sptr secondTransG; MatrixWorkspace_sptr secondTransSum; if (!secondTrans.empty()) { auto secondTransWS = AnalysisDataService::Instance().retrieveWS<Workspace>(secondTrans); secondTransG = boost::dynamic_pointer_cast<WorkspaceGroup>(secondTransWS); if (!secondTransG) { alg->setProperty("SecondTransmissionRun", secondTrans); } else if (polarizationAnalysisOn) { secondTransSum = sumTransmissionWorkspaces(secondTransG); } } std::vector<std::string> IvsQGroup, IvsQUnbinnedGroup, IvsLamGroup; // Execute algorithm over each group member for (size_t i = 0; i < group->size(); ++i) { const std::string IvsQName = outputIvsQ + "_" + std::to_string(i + 1); const std::string IvsQBinnedName = outputIvsQBinned + "_" + std::to_string(i + 1); const std::string IvsLamName = outputIvsLam + "_" + std::to_string(i + 1); if (firstTransG) { if (!polarizationAnalysisOn) alg->setProperty("FirstTransmissionRun", firstTransG->getItem(i)->getName()); else alg->setProperty("FirstTransmissionRun", firstTransSum); } if (secondTransG) { if (!polarizationAnalysisOn) alg->setProperty("SecondTransmissionRun", secondTransG->getItem(i)->getName()); else alg->setProperty("SecondTransmissionRun", secondTransSum); } alg->setProperty("InputWorkspace", group->getItem(i)->getName()); alg->setProperty("OutputWorkspace", IvsQName); alg->setProperty("OutputWorkspaceBinned", IvsQBinnedName); alg->setProperty("OutputWorkspaceWavelength", IvsLamName); alg->execute(); IvsQGroup.push_back(IvsQName); IvsQUnbinnedGroup.push_back(IvsQBinnedName); IvsLamGroup.push_back(IvsLamName); } // Group the IvsQ and IvsLam workspaces Algorithm_sptr groupAlg = createChildAlgorithm("GroupWorkspaces"); groupAlg->setChild(false); groupAlg->setRethrows(true); groupAlg->setProperty("InputWorkspaces", IvsLamGroup); groupAlg->setProperty("OutputWorkspace", outputIvsLam); groupAlg->execute(); groupAlg->setProperty("InputWorkspaces", IvsQGroup); groupAlg->setProperty("OutputWorkspace", outputIvsQ); groupAlg->execute(); groupAlg->setProperty("InputWorkspaces", IvsQUnbinnedGroup); groupAlg->setProperty("OutputWorkspace", outputIvsQBinned); groupAlg->execute(); // Set other properties so they can be updated in the Reflectometry interface setPropertyValue("ThetaIn", alg->getPropertyValue("ThetaIn")); setPropertyValue("MomentumTransferMin", alg->getPropertyValue("MomentumTransferMin")); setPropertyValue("MomentumTransferMax", alg->getPropertyValue("MomentumTransferMax")); setPropertyValue("MomentumTransferStep", alg->getPropertyValue("MomentumTransferStep")); setPropertyValue("ScaleFactor", alg->getPropertyValue("ScaleFactor")); if (!polarizationAnalysisOn) { // No polarization analysis. Reduction stops here setPropertyValue("OutputWorkspace", outputIvsQ); setPropertyValue("OutputWorkspaceBinned", outputIvsQBinned); setPropertyValue("OutputWorkspaceWavelength", outputIvsLam); return true; } if (!group->isMultiperiod()) { g_log.warning("Polarization corrections can only be performed on " "multiperiod workspaces."); setPropertyValue("OutputWorkspace", outputIvsQ); setPropertyValue("OutputWorkspaceBinned", outputIvsQBinned); setPropertyValue("OutputWorkspaceWavelength", outputIvsLam); return true; } Algorithm_sptr polAlg = createChildAlgorithm("PolarizationCorrection"); polAlg->setChild(false); polAlg->setRethrows(true); polAlg->setProperty("InputWorkspace", outputIvsLam); polAlg->setProperty("OutputWorkspace", outputIvsLam); polAlg->setProperty("PolarizationAnalysis", getPropertyValue("PolarizationAnalysis")); polAlg->setProperty("CPp", getPropertyValue("CPp")); polAlg->setProperty("CRho", getPropertyValue("CRho")); polAlg->setProperty("CAp", getPropertyValue("CAp")); polAlg->setProperty("CAlpha", getPropertyValue("CAlpha")); polAlg->execute(); // Now we've overwritten the IvsLam workspaces, we'll need to recalculate // the IvsQ ones alg->setProperty("FirstTransmissionRun", ""); alg->setProperty("SecondTransmissionRun", ""); alg->setProperty("CorrectionAlgorithm", "None"); alg->setProperty("ThetaIn", Mantid::EMPTY_DBL()); alg->setProperty("ProcessingInstructions", "0"); for (size_t i = 0; i < group->size(); ++i) { const std::string IvsQName = outputIvsQ + "_" + std::to_string(i + 1); const std::string IvsQBinnedName = outputIvsQBinned + "_" + std::to_string(i + 1); const std::string IvsLamName = outputIvsLam + "_" + std::to_string(i + 1); alg->setProperty("InputWorkspace", IvsLamName); alg->setProperty("OutputWorkspace", IvsQName); alg->setProperty("OutputWorkspaceBinned", IvsQBinnedName); alg->setProperty("OutputWorkspaceWavelength", IvsLamName); alg->execute(); } setPropertyValue("OutputWorkspace", outputIvsQ); setPropertyValue("OutputWorkspaceBinned", outputIvsQBinned); setPropertyValue("OutputWorkspaceWavelength", outputIvsLam); return true; }
/* Executes the underlying algorithm to create the MVP model. @param factory : visualisation factory to use. @param loadingProgressUpdate : Handler for GUI updates while algorithm progresses. @param drawingProgressUpdate : Handler for GUI updates while vtkDataSetFactory::create occurs. */ vtkSmartPointer<vtkDataSet> EventNexusLoadingPresenter::execute(vtkDataSetFactory *factory, ProgressAction &loadingProgressUpdate, ProgressAction &drawingProgressUpdate) { using namespace Mantid::API; using namespace Mantid::Geometry; this->m_view->getLoadInMemory(); // TODO, nexus reader algorithm currently has // no use of this. if (this->shouldLoad()) { Poco::NObserver<ProgressAction, Mantid::API::Algorithm::ProgressNotification> observer(loadingProgressUpdate, &ProgressAction::handler); AnalysisDataService::Instance().remove("MD_EVENT_WS_ID"); Algorithm_sptr loadAlg = AlgorithmManager::Instance().createUnmanaged("LoadEventNexus"); loadAlg->initialize(); loadAlg->setChild(true); loadAlg->setPropertyValue("Filename", this->m_filename); loadAlg->setPropertyValue("OutputWorkspace", "temp_ws"); loadAlg->addObserver(observer); loadAlg->executeAsChildAlg(); loadAlg->removeObserver(observer); Workspace_sptr temp = loadAlg->getProperty("OutputWorkspace"); IEventWorkspace_sptr tempWS = boost::dynamic_pointer_cast<IEventWorkspace>(temp); Algorithm_sptr convertAlg = AlgorithmManager::Instance().createUnmanaged( "ConvertToDiffractionMDWorkspace", 1); convertAlg->initialize(); convertAlg->setChild(true); convertAlg->setProperty("InputWorkspace", tempWS); convertAlg->setProperty<bool>("ClearInputWorkspace", false); convertAlg->setProperty<bool>("LorentzCorrection", true); convertAlg->setPropertyValue("OutputWorkspace", "converted_ws"); convertAlg->addObserver(observer); convertAlg->executeAsChildAlg(); convertAlg->removeObserver(observer); IMDEventWorkspace_sptr outWS = convertAlg->getProperty("OutputWorkspace"); AnalysisDataService::Instance().addOrReplace("MD_EVENT_WS_ID", outWS); } Workspace_sptr result = AnalysisDataService::Instance().retrieve("MD_EVENT_WS_ID"); Mantid::API::IMDEventWorkspace_sptr eventWs = boost::dynamic_pointer_cast<Mantid::API::IMDEventWorkspace>(result); m_wsTypeName = eventWs->id(); factory->setRecursionDepth(this->m_view->getRecursionDepth()); auto visualDataSet = factory->oneStepCreate( eventWs, drawingProgressUpdate); // HACK: progressUpdate should be // argument for drawing! this->extractMetadata(*eventWs); this->appendMetadata(visualDataSet, eventWs->getName()); return visualDataSet; }
bool ReflectometryReductionOneAuto::processGroups() { auto group = AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>( getPropertyValue("InputWorkspace")); const std::string outputIvsQ = this->getPropertyValue("OutputWorkspace"); const std::string outputIvsLam = this->getPropertyValue("OutputWorkspaceWavelength"); // Create a copy of ourselves Algorithm_sptr alg = this->createChildAlgorithm( this->name(), -1, -1, this->isLogging(), this->version()); alg->setChild(false); alg->setRethrows(true); // Copy all the non-workspace properties over std::vector<Property *> props = this->getProperties(); for (auto prop = props.begin(); prop != props.end(); ++prop) { if (*prop) { IWorkspaceProperty *wsProp = dynamic_cast<IWorkspaceProperty *>(*prop); if (!wsProp) alg->setPropertyValue((*prop)->name(), (*prop)->value()); } } // Check if the transmission runs are groups or not const std::string firstTrans = this->getPropertyValue("FirstTransmissionRun"); WorkspaceGroup_sptr firstTransG; if (!firstTrans.empty()) { auto firstTransWS = AnalysisDataService::Instance().retrieveWS<Workspace>(firstTrans); firstTransG = boost::dynamic_pointer_cast<WorkspaceGroup>(firstTransWS); if (!firstTransG) alg->setProperty("FirstTransmissionRun", firstTrans); else if (group->size() != firstTransG->size()) throw std::runtime_error("FirstTransmissionRun WorkspaceGroup must be " "the same size as the InputWorkspace " "WorkspaceGroup"); } const std::string secondTrans = this->getPropertyValue("SecondTransmissionRun"); WorkspaceGroup_sptr secondTransG; if (!secondTrans.empty()) { auto secondTransWS = AnalysisDataService::Instance().retrieveWS<Workspace>(secondTrans); secondTransG = boost::dynamic_pointer_cast<WorkspaceGroup>(secondTransWS); if (!secondTransG) alg->setProperty("SecondTransmissionRun", secondTrans); else if (group->size() != secondTransG->size()) throw std::runtime_error("SecondTransmissionRun WorkspaceGroup must be " "the same size as the InputWorkspace " "WorkspaceGroup"); } std::vector<std::string> IvsQGroup, IvsLamGroup; // Execute algorithm over each group member (or period, if this is // multiperiod) size_t numMembers = group->size(); for (size_t i = 0; i < numMembers; ++i) { const std::string IvsQName = outputIvsQ + "_" + boost::lexical_cast<std::string>(i + 1); const std::string IvsLamName = outputIvsLam + "_" + boost::lexical_cast<std::string>(i + 1); alg->setProperty("InputWorkspace", group->getItem(i)->name()); alg->setProperty("OutputWorkspace", IvsQName); alg->setProperty("OutputWorkspaceWavelength", IvsLamName); // Handle transmission runs if (firstTransG) alg->setProperty("FirstTransmissionRun", firstTransG->getItem(i)->name()); if (secondTransG) alg->setProperty("SecondTransmissionRun", secondTransG->getItem(i)->name()); alg->execute(); IvsQGroup.push_back(IvsQName); IvsLamGroup.push_back(IvsLamName); // We use the first group member for our thetaout value if (i == 0) this->setPropertyValue("ThetaOut", alg->getPropertyValue("ThetaOut")); } // Group the IvsQ and IvsLam workspaces Algorithm_sptr groupAlg = this->createChildAlgorithm("GroupWorkspaces"); groupAlg->setChild(false); groupAlg->setRethrows(true); groupAlg->setProperty("InputWorkspaces", IvsLamGroup); groupAlg->setProperty("OutputWorkspace", outputIvsLam); groupAlg->execute(); groupAlg->setProperty("InputWorkspaces", IvsQGroup); groupAlg->setProperty("OutputWorkspace", outputIvsQ); groupAlg->execute(); // If this is a multiperiod workspace and we have polarization corrections // enabled if (this->getPropertyValue("PolarizationAnalysis") != noPolarizationCorrectionMode()) { if (group->isMultiperiod()) { // Perform polarization correction over the IvsLam group Algorithm_sptr polAlg = this->createChildAlgorithm("PolarizationCorrection"); polAlg->setChild(false); polAlg->setRethrows(true); polAlg->setProperty("InputWorkspace", outputIvsLam); polAlg->setProperty("OutputWorkspace", outputIvsLam); polAlg->setProperty("PolarizationAnalysis", this->getPropertyValue("PolarizationAnalysis")); polAlg->setProperty("CPp", this->getPropertyValue(cppLabel())); polAlg->setProperty("CRho", this->getPropertyValue(crhoLabel())); polAlg->setProperty("CAp", this->getPropertyValue(cApLabel())); polAlg->setProperty("CAlpha", this->getPropertyValue(cAlphaLabel())); polAlg->execute(); // Now we've overwritten the IvsLam workspaces, we'll need to recalculate // the IvsQ ones alg->setProperty("FirstTransmissionRun", ""); alg->setProperty("SecondTransmissionRun", ""); for (size_t i = 0; i < numMembers; ++i) { const std::string IvsQName = outputIvsQ + "_" + boost::lexical_cast<std::string>(i + 1); const std::string IvsLamName = outputIvsLam + "_" + boost::lexical_cast<std::string>(i + 1); alg->setProperty("InputWorkspace", IvsLamName); alg->setProperty("OutputWorkspace", IvsQName); alg->setProperty("OutputWorkspaceWavelength", IvsLamName); alg->execute(); } } else { g_log.warning("Polarization corrections can only be performed on " "multiperiod workspaces."); } } // We finished successfully this->setPropertyValue("OutputWorkspace", outputIvsQ); this->setPropertyValue("OutputWorkspaceWavelength", outputIvsLam); setExecuted(true); notificationCenter().postNotification( new FinishedNotification(this, isExecuted())); return true; }
bool ReflectometryReductionOneAuto::processGroups() { // isPolarizationCorrectionOn is used to decide whether // we should process our Transmission WorkspaceGroup members // as individuals (not multiperiod) when PolarizationCorrection is off, // or sum over all of the workspaces in the group // and used that sum as our TransmissionWorkspace when PolarizationCorrection // is on. const bool isPolarizationCorrectionOn = this->getPropertyValue("PolarizationAnalysis") != noPolarizationCorrectionMode(); // Get our input workspace group auto group = AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>( getPropertyValue("InputWorkspace")); // Get name of IvsQ workspace const std::string outputIvsQ = this->getPropertyValue("OutputWorkspace"); // Get name of IvsLam workspace const std::string outputIvsLam = this->getPropertyValue("OutputWorkspaceWavelength"); // Create a copy of ourselves Algorithm_sptr alg = this->createChildAlgorithm( this->name(), -1, -1, this->isLogging(), this->version()); alg->setChild(false); alg->setRethrows(true); // Copy all the non-workspace properties over std::vector<Property *> props = this->getProperties(); for (auto &prop : props) { if (prop) { IWorkspaceProperty *wsProp = dynamic_cast<IWorkspaceProperty *>(prop); if (!wsProp) alg->setPropertyValue(prop->name(), prop->value()); } } // Check if the transmission runs are groups or not const std::string firstTrans = this->getPropertyValue("FirstTransmissionRun"); WorkspaceGroup_sptr firstTransG; if (!firstTrans.empty()) { auto firstTransWS = AnalysisDataService::Instance().retrieveWS<Workspace>(firstTrans); firstTransG = boost::dynamic_pointer_cast<WorkspaceGroup>(firstTransWS); if (!firstTransG) { // we only have one transmission workspace, so we use it as it is. alg->setProperty("FirstTransmissionRun", firstTrans); } else if (group->size() != firstTransG->size() && !isPolarizationCorrectionOn) { // if they are not the same size then we cannot associate a transmission // group workspace member with every input group workpspace member. throw std::runtime_error("FirstTransmissionRun WorkspaceGroup must be " "the same size as the InputWorkspace " "WorkspaceGroup"); } } const std::string secondTrans = this->getPropertyValue("SecondTransmissionRun"); WorkspaceGroup_sptr secondTransG; if (!secondTrans.empty()) { auto secondTransWS = AnalysisDataService::Instance().retrieveWS<Workspace>(secondTrans); secondTransG = boost::dynamic_pointer_cast<WorkspaceGroup>(secondTransWS); if (!secondTransG) // we only have one transmission workspace, so we use it as it is. alg->setProperty("SecondTransmissionRun", secondTrans); else if (group->size() != secondTransG->size() && !isPolarizationCorrectionOn) { // if they are not the same size then we cannot associate a transmission // group workspace member with every input group workpspace member. throw std::runtime_error("SecondTransmissionRun WorkspaceGroup must be " "the same size as the InputWorkspace " "WorkspaceGroup"); } } std::vector<std::string> IvsQGroup, IvsLamGroup; // Execute algorithm over each group member (or period, if this is // multiperiod) size_t numMembers = group->size(); for (size_t i = 0; i < numMembers; ++i) { const std::string IvsQName = outputIvsQ + "_" + boost::lexical_cast<std::string>(i + 1); const std::string IvsLamName = outputIvsLam + "_" + boost::lexical_cast<std::string>(i + 1); // If our transmission run is a group and PolarizationCorrection is on // then we sum our transmission group members. // // This is done inside of the for loop to avoid the wrong workspace being // used when these arguments are passed through to the exec() method. // If this is not set in the loop, exec() will fetch the first workspace // from the specified Transmission Group workspace that the user entered. if (firstTransG && isPolarizationCorrectionOn) { auto firstTransmissionSum = sumOverTransmissionGroup(firstTransG); alg->setProperty("FirstTransmissionRun", firstTransmissionSum); } if (secondTransG && isPolarizationCorrectionOn) { auto secondTransmissionSum = sumOverTransmissionGroup(secondTransG); alg->setProperty("SecondTransmissionRun", secondTransmissionSum); } // Otherwise, if polarization correction is off, we process them // using one transmission group member at a time. if (firstTransG && !isPolarizationCorrectionOn) // polarization off alg->setProperty("FirstTransmissionRun", firstTransG->getItem(i)->name()); if (secondTransG && !isPolarizationCorrectionOn) // polarization off alg->setProperty("SecondTransmissionRun", secondTransG->getItem(i)->name()); alg->setProperty("InputWorkspace", group->getItem(i)->name()); alg->setProperty("OutputWorkspace", IvsQName); alg->setProperty("OutputWorkspaceWavelength", IvsLamName); alg->execute(); MatrixWorkspace_sptr tempFirstTransWS = alg->getProperty("FirstTransmissionRun"); IvsQGroup.push_back(IvsQName); IvsLamGroup.push_back(IvsLamName); // We use the first group member for our thetaout value if (i == 0) this->setPropertyValue("ThetaOut", alg->getPropertyValue("ThetaOut")); } // Group the IvsQ and IvsLam workspaces Algorithm_sptr groupAlg = this->createChildAlgorithm("GroupWorkspaces"); groupAlg->setChild(false); groupAlg->setRethrows(true); groupAlg->setProperty("InputWorkspaces", IvsLamGroup); groupAlg->setProperty("OutputWorkspace", outputIvsLam); groupAlg->execute(); groupAlg->setProperty("InputWorkspaces", IvsQGroup); groupAlg->setProperty("OutputWorkspace", outputIvsQ); groupAlg->execute(); // If this is a multiperiod workspace and we have polarization corrections // enabled if (isPolarizationCorrectionOn) { if (group->isMultiperiod()) { // Perform polarization correction over the IvsLam group Algorithm_sptr polAlg = this->createChildAlgorithm("PolarizationCorrection"); polAlg->setChild(false); polAlg->setRethrows(true); polAlg->setProperty("InputWorkspace", outputIvsLam); polAlg->setProperty("OutputWorkspace", outputIvsLam); polAlg->setProperty("PolarizationAnalysis", this->getPropertyValue("PolarizationAnalysis")); polAlg->setProperty("CPp", this->getPropertyValue(cppLabel())); polAlg->setProperty("CRho", this->getPropertyValue(crhoLabel())); polAlg->setProperty("CAp", this->getPropertyValue(cApLabel())); polAlg->setProperty("CAlpha", this->getPropertyValue(cAlphaLabel())); polAlg->execute(); // Now we've overwritten the IvsLam workspaces, we'll need to recalculate // the IvsQ ones alg->setProperty("FirstTransmissionRun", ""); alg->setProperty("SecondTransmissionRun", ""); for (size_t i = 0; i < numMembers; ++i) { const std::string IvsQName = outputIvsQ + "_" + boost::lexical_cast<std::string>(i + 1); const std::string IvsLamName = outputIvsLam + "_" + boost::lexical_cast<std::string>(i + 1); alg->setProperty("InputWorkspace", IvsLamName); alg->setProperty("OutputWorkspace", IvsQName); alg->setProperty("CorrectionAlgorithm", "None"); alg->setProperty("OutputWorkspaceWavelength", IvsLamName); alg->execute(); } } else { g_log.warning("Polarization corrections can only be performed on " "multiperiod workspaces."); } } // We finished successfully this->setPropertyValue("OutputWorkspace", outputIvsQ); this->setPropertyValue("OutputWorkspaceWavelength", outputIvsLam); setExecuted(true); notificationCenter().postNotification( new FinishedNotification(this, isExecuted())); return true; }
/** Execute the algorithm. */ void CreateGroupingWorkspace::exec() { MatrixWorkspace_sptr inWS = getProperty("InputWorkspace"); std::string InstrumentName = getPropertyValue("InstrumentName"); std::string InstrumentFilename = getPropertyValue("InstrumentFilename"); std::string OldCalFilename = getPropertyValue("OldCalFilename"); std::string GroupNames = getPropertyValue("GroupNames"); std::string grouping = getPropertyValue("GroupDetectorsBy"); int numGroups = getProperty("FixedGroupCount"); std::string componentName = getPropertyValue("ComponentName"); // Some validation int numParams = 0; if (inWS) numParams++; if (!InstrumentName.empty()) numParams++; if (!InstrumentFilename.empty()) numParams++; if (numParams > 1) throw std::invalid_argument("You must specify exactly ONE way to get an " "instrument (workspace, instrument name, or " "IDF file). You specified more than one."); if (numParams == 0) throw std::invalid_argument("You must specify exactly ONE way to get an " "instrument (workspace, instrument name, or " "IDF file). You specified none."); if (!OldCalFilename.empty() && !GroupNames.empty()) throw std::invalid_argument("You must specify either to use the " "OldCalFilename parameter OR GroupNames but " "not both!"); bool sortnames = false; // ---------- Get the instrument one of 3 ways --------------------------- Instrument_const_sptr inst; if (inWS) { inst = inWS->getInstrument(); } else { Algorithm_sptr childAlg = createChildAlgorithm("LoadInstrument", 0.0, 0.2); MatrixWorkspace_sptr tempWS = boost::make_shared<Workspace2D>(); childAlg->setProperty<MatrixWorkspace_sptr>("Workspace", tempWS); childAlg->setPropertyValue("Filename", InstrumentFilename); childAlg->setProperty("RewriteSpectraMap", Mantid::Kernel::OptionalBool(true)); childAlg->setPropertyValue("InstrumentName", InstrumentName); childAlg->executeAsChildAlg(); inst = tempWS->getInstrument(); } if (GroupNames.empty() && OldCalFilename.empty()) { if (grouping.compare("All") == 0) { GroupNames = inst->getName(); } else if (inst->getName().compare("SNAP") == 0 && grouping.compare("Group") == 0) { GroupNames = "East,West"; } else { sortnames = true; GroupNames = ""; int maxRecurseDepth = this->getProperty("MaxRecursionDepth"); // cppcheck-suppress syntaxError PRAGMA_OMP(parallel for schedule(dynamic, 1) ) for (int num = 0; num < 300; ++num) { PARALLEL_START_INTERUPT_REGION std::ostringstream mess; mess << grouping << num; IComponent_const_sptr comp = inst->getComponentByName(mess.str(), maxRecurseDepth); PARALLEL_CRITICAL(GroupNames) if (comp) GroupNames += mess.str() + ","; PARALLEL_END_INTERUPT_REGION } PARALLEL_CHECK_INTERUPT_REGION } } // --------------------------- Create the output -------------------------- auto outWS = boost::make_shared<GroupingWorkspace>(inst); this->setProperty("OutputWorkspace", outWS); // This will get the grouping std::map<detid_t, int> detIDtoGroup; Progress prog(this, 0.2, 1.0, outWS->getNumberHistograms()); // Make the grouping one of three ways: if (!GroupNames.empty()) detIDtoGroup = makeGroupingByNames(GroupNames, inst, prog, sortnames); else if (!OldCalFilename.empty()) detIDtoGroup = readGroupingFile(OldCalFilename, prog); else if ((numGroups > 0) && !componentName.empty()) detIDtoGroup = makeGroupingByNumGroups(componentName, numGroups, inst, prog); g_log.information() << detIDtoGroup.size() << " entries in the detectorID-to-group map.\n"; setProperty("NumberGroupedSpectraResult", static_cast<int>(detIDtoGroup.size())); if (detIDtoGroup.empty()) { g_log.warning() << "Creating empty group workspace\n"; setProperty("NumberGroupsResult", static_cast<int>(0)); } else { size_t numNotFound = 0; // Make the groups, if any std::map<detid_t, int>::const_iterator it_end = detIDtoGroup.end(); std::map<detid_t, int>::const_iterator it; std::unordered_set<int> groupCount; for (it = detIDtoGroup.begin(); it != it_end; ++it) { int detID = it->first; int group = it->second; groupCount.insert(group); try { outWS->setValue(detID, double(group)); } catch (std::invalid_argument &) { numNotFound++; } } setProperty("NumberGroupsResult", static_cast<int>(groupCount.size())); if (numNotFound > 0) g_log.warning() << numNotFound << " detector IDs (out of " << detIDtoGroup.size() << ") were not found in the instrument\n."; } }