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