/**
* Run instead of exec when operating on groups
*/
bool SaveNXTomo::processGroups() {
try {
std::string name = getPropertyValue("InputWorkspaces");
WorkspaceGroup_sptr groupWS =
AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>(name);
for (int i = 0; i < groupWS->getNumberOfEntries(); ++i) {
m_workspaces.push_back(
boost::dynamic_pointer_cast<Workspace2D>(groupWS->getItem(i)));
}
} catch (...) {
}
if (m_workspaces.size() != 0)
processAll();
return true;
}
/**
* Executes the algorithm
*/
void PlotAsymmetryByLogValue::exec()
{
m_forward_list = getProperty("ForwardSpectra");
m_backward_list = getProperty("BackwardSpectra");
m_autogroup = ( m_forward_list.size() == 0 && m_backward_list.size() == 0);
//double alpha = getProperty("Alpha");
std::string logName = getProperty("LogValue");
int red = getProperty("Red");
int green = getProperty("Green");
std::string stype = getProperty("Type");
m_int = stype == "Integral";
std::string firstFN = getProperty("FirstRun");
std::string lastFN = getProperty("LastRun");
std::string ext = firstFN.substr(firstFN.find_last_of("."));
firstFN.erase(firstFN.size()-4);
lastFN.erase(lastFN.size()-4);
std::string fnBase = firstFN;
size_t i = fnBase.size()-1;
while(isdigit(fnBase[i])) i--;
if (i == fnBase.size()-1)
{
g_log.error("File name must end with a number.");
throw Exception::FileError("File name must end with a number.",firstFN);
}
fnBase.erase(i+1);
firstFN.erase(0,fnBase.size());
lastFN.erase(0,fnBase.size());
size_t is = atoi(firstFN.c_str()); // starting run number
size_t ie = atoi(lastFN.c_str()); // last run number
int w = static_cast<int>(firstFN.size());
// The number of runs
size_t npoints = ie - is + 1;
// Create the 2D workspace for the output
int nplots = green != EMPTY_INT() ? 4 : 1;
MatrixWorkspace_sptr outWS = WorkspaceFactory::Instance().create("Workspace2D",
nplots, // the number of plots
npoints, // the number of data points on a plot
npoints // it's not a histogram
);
TextAxis* tAxis = new TextAxis(nplots);
if (nplots == 1)
{
tAxis->setLabel(0,"Asymmetry");
}
else
{
tAxis->setLabel(0,"Red-Green");
tAxis->setLabel(1,"Red");
tAxis->setLabel(2,"Green");
tAxis->setLabel(3,"Red+Green");
}
outWS->replaceAxis(1,tAxis);
Progress progress(this,0,1,ie-is+2);
for(size_t i=is; i<=ie; i++)
{
std::ostringstream fn,fnn;
fnn << std::setw(w) << std::setfill('0') << i ;
fn << fnBase << fnn.str() << ext;
// Load a muon nexus file with auto_group set to true
IAlgorithm_sptr loadNexus = createChildAlgorithm("LoadMuonNexus");
loadNexus->setPropertyValue("Filename", fn.str());
loadNexus->setPropertyValue("OutputWorkspace","tmp"+fnn.str());
if (m_autogroup)
loadNexus->setPropertyValue("AutoGroup","1");
loadNexus->execute();
std::string wsProp = "OutputWorkspace";
DataObjects::Workspace2D_sptr ws_red;
DataObjects::Workspace2D_sptr ws_green;
// Run through the periods of the loaded file and do calculations on the selected ones
Workspace_sptr tmp = loadNexus->getProperty(wsProp);
WorkspaceGroup_sptr wsGroup = boost::dynamic_pointer_cast<WorkspaceGroup>(tmp);
if (!wsGroup)
{
ws_red = boost::dynamic_pointer_cast<DataObjects::Workspace2D>(tmp);
TimeSeriesProperty<double>* logp =
dynamic_cast<TimeSeriesProperty<double>*>(ws_red->run().getLogData(logName));
if (!logp)
{
throw std::invalid_argument("Log "+logName+" does not exist or not a double type");
}
double Y,E;
calcIntAsymmetry(ws_red,Y,E);
outWS->dataY(0)[i-is] = Y;
outWS->dataX(0)[i-is] = logp->lastValue();
outWS->dataE(0)[i-is] = E;
}
else
{
for( int period = 1; period <= wsGroup->getNumberOfEntries(); ++period )
{
std::stringstream suffix;
suffix << period;
wsProp = "OutputWorkspace_" + suffix.str();// form the property name for higher periods
// Do only one period
if (green == EMPTY_INT() && period == red)
{
Workspace_sptr tmpff = loadNexus->getProperty(wsProp);
ws_red = boost::dynamic_pointer_cast<DataObjects::Workspace2D>(tmpff);
TimeSeriesProperty<double>* logp =
dynamic_cast<TimeSeriesProperty<double>*>(ws_red->run().getLogData(logName));
if (!logp)
{
throw std::invalid_argument("Log "+logName+" does not exist or not a double type");
}
double Y,E;
calcIntAsymmetry(ws_red,Y,E);
outWS->dataY(0)[i-is] = Y;
outWS->dataX(0)[i-is] = logp->lastValue();
outWS->dataE(0)[i-is] = E;
}
else // red & green
{
if (period == red)
{
Workspace_sptr temp = loadNexus->getProperty(wsProp);
ws_red = boost::dynamic_pointer_cast<Workspace2D>(temp);
}
if (period == green)
{
Workspace_sptr temp = loadNexus->getProperty(wsProp);
ws_green = boost::dynamic_pointer_cast<Workspace2D>(temp);
}
}
}
// red & green claculation
if (green != EMPTY_INT())
{
if (!ws_red || !ws_green)
throw std::invalid_argument("Red or green period is out of range");
TimeSeriesProperty<double>* logp =
dynamic_cast<TimeSeriesProperty<double>*>(ws_red->run().getLogData(logName));
if (!logp)
{
throw std::invalid_argument("Log "+logName+" does not exist or not a double type");
}
double Y,E;
double Y1,E1;
calcIntAsymmetry(ws_red,Y,E);
calcIntAsymmetry(ws_green,Y1,E1);
outWS->dataY(1)[i-is] = Y;
outWS->dataX(1)[i-is] = logp->lastValue();
outWS->dataE(1)[i-is] = E;
outWS->dataY(2)[i-is] = Y1;
outWS->dataX(2)[i-is] = logp->lastValue();
outWS->dataE(2)[i-is] = E1;
outWS->dataY(3)[i-is] = Y + Y1;
outWS->dataX(3)[i-is] = logp->lastValue();
outWS->dataE(3)[i-is] = sqrt(E*E+E1*E1);
// move to last for safety since some grouping takes place in the
// calcIntAsymmetry call below
calcIntAsymmetry(ws_red,ws_green,Y,E);
outWS->dataY(0)[i-is] = Y;
outWS->dataX(0)[i-is] = logp->lastValue();
outWS->dataE(0)[i-is] = E;
}
else if (!ws_red)
throw std::invalid_argument("Red period is out of range");
}
progress.report();
}
outWS->getAxis(0)->title() = logName;
outWS->setYUnitLabel("Asymmetry");
// Assign the result to the output workspace property
setProperty("OutputWorkspace", outWS);
}
WorkspaceGroup_sptr PolarizationCorrection::execPA(WorkspaceGroup_sptr inWS) {
if (isPropertyDefault(cAlphaLabel())) {
throw std::invalid_argument("Must provide as input for PA: " +
cAlphaLabel());
}
if (isPropertyDefault(cApLabel())) {
throw std::invalid_argument("Must provide as input for PA: " + cApLabel());
}
size_t itemIndex = 0;
MatrixWorkspace_sptr Ipp =
boost::dynamic_pointer_cast<MatrixWorkspace>(inWS->getItem(itemIndex++));
MatrixWorkspace_sptr Ipa =
boost::dynamic_pointer_cast<MatrixWorkspace>(inWS->getItem(itemIndex++));
MatrixWorkspace_sptr Iap =
boost::dynamic_pointer_cast<MatrixWorkspace>(inWS->getItem(itemIndex++));
MatrixWorkspace_sptr Iaa =
boost::dynamic_pointer_cast<MatrixWorkspace>(inWS->getItem(itemIndex++));
Ipp->setTitle("Ipp");
Iaa->setTitle("Iaa");
Ipa->setTitle("Ipa");
Iap->setTitle("Iap");
auto cropAlg = this->createChildAlgorithm("CropWorkspace");
cropAlg->initialize();
cropAlg->setProperty("InputWorkspace", Ipp);
cropAlg->setProperty("EndWorkspaceIndex", 0);
cropAlg->execute();
MatrixWorkspace_sptr croppedIpp = cropAlg->getProperty("OutputWorkspace");
MatrixWorkspace_sptr ones = copyShapeAndFill(croppedIpp, 1.0);
// The ones workspace is now identical to the input workspaces in x, but has 1
// as y values. It can therefore be used to build real polynomial functions.
const VecDouble c_rho = getProperty(crhoLabel());
const VecDouble c_alpha = getProperty(cAlphaLabel());
const VecDouble c_pp = getProperty(cppLabel());
const VecDouble c_ap = getProperty(cApLabel());
const auto rho = this->execPolynomialCorrection(
ones, c_rho); // Execute polynomial expression
const auto pp = this->execPolynomialCorrection(
ones, c_pp); // Execute polynomial expression
const auto alpha = this->execPolynomialCorrection(
ones, c_alpha); // Execute polynomial expression
const auto ap = this->execPolynomialCorrection(
ones, c_ap); // Execute polynomial expression
const auto A0 = (Iaa * pp * ap) + (ap * Ipa * rho * pp) +
(ap * Iap * alpha * pp) + (Ipp * ap * alpha * rho * pp);
const auto A1 = pp * Iaa;
const auto A2 = pp * Iap;
const auto A3 = ap * Iaa;
const auto A4 = ap * Ipa;
const auto A5 = ap * alpha * Ipp;
const auto A6 = ap * alpha * Iap;
const auto A7 = pp * rho * Ipp;
const auto A8 = pp * rho * Ipa;
const auto D = pp * ap * (rho + alpha + 1.0 + (rho * alpha));
const auto nIpp =
(A0 - A1 + A2 - A3 + A4 + A5 - A6 + A7 - A8 + Ipp + Iaa - Ipa - Iap) / D;
const auto nIaa =
(A0 + A1 - A2 + A3 - A4 - A5 + A6 - A7 + A8 + Ipp + Iaa - Ipa - Iap) / D;
const auto nIpa =
(A0 - A1 + A2 + A3 - A4 - A5 + A6 + A7 - A8 - Ipp - Iaa + Ipa + Iap) / D;
const auto nIap =
(A0 + A1 - A2 - A3 + A4 + A5 - A6 - A7 + A8 - Ipp - Iaa + Ipa + Iap) / D;
WorkspaceGroup_sptr dataOut = boost::make_shared<WorkspaceGroup>();
dataOut->addWorkspace(nIpp);
dataOut->addWorkspace(nIpa);
dataOut->addWorkspace(nIap);
dataOut->addWorkspace(nIaa);
size_t totalGroupEntries(dataOut->getNumberOfEntries());
for (size_t i = 1; i < totalGroupEntries; i++) {
auto alg = this->createChildAlgorithm("ReplaceSpecialValues");
alg->setProperty("InputWorkspace", dataOut->getItem(i));
alg->setProperty("OutputWorkspace", "dataOut_" + std::to_string(i));
alg->setProperty("NaNValue", 0.0);
alg->setProperty("NaNError", 0.0);
alg->setProperty("InfinityValue", 0.0);
alg->setProperty("InfinityError", 0.0);
alg->execute();
}
// Preserve the history of the inside workspaces
nIpp->history().addHistory(Ipp->getHistory());
nIaa->history().addHistory(Iaa->getHistory());
nIpa->history().addHistory(Ipa->getHistory());
nIap->history().addHistory(Iap->getHistory());
return dataOut;
}
WorkspaceGroup_sptr
PolarizationCorrectionFredrikze::execPA(WorkspaceGroup_sptr inWS) {
size_t itemIndex = 0;
MatrixWorkspace_sptr Ipp =
boost::dynamic_pointer_cast<MatrixWorkspace>(inWS->getItem(itemIndex++));
MatrixWorkspace_sptr Ipa =
boost::dynamic_pointer_cast<MatrixWorkspace>(inWS->getItem(itemIndex++));
MatrixWorkspace_sptr Iap =
boost::dynamic_pointer_cast<MatrixWorkspace>(inWS->getItem(itemIndex++));
MatrixWorkspace_sptr Iaa =
boost::dynamic_pointer_cast<MatrixWorkspace>(inWS->getItem(itemIndex++));
Ipp->setTitle("Ipp");
Iaa->setTitle("Iaa");
Ipa->setTitle("Ipa");
Iap->setTitle("Iap");
const auto rho = this->getEfficiencyWorkspace(crhoLabel);
const auto pp = this->getEfficiencyWorkspace(cppLabel);
const auto alpha = this->getEfficiencyWorkspace(cAlphaLabel);
const auto ap = this->getEfficiencyWorkspace(cApLabel);
const auto A0 = (Iaa * pp * ap) + (Ipa * ap * rho * pp) +
(Iap * ap * alpha * pp) + (Ipp * ap * alpha * rho * pp);
const auto A1 = Iaa * pp;
const auto A2 = Iap * pp;
const auto A3 = Iaa * ap;
const auto A4 = Ipa * ap;
const auto A5 = Ipp * ap * alpha;
const auto A6 = Iap * ap * alpha;
const auto A7 = Ipp * pp * rho;
const auto A8 = Ipa * pp * rho;
const auto D = pp * ap * (rho + alpha + 1.0 + (rho * alpha));
const auto nIpp =
(A0 - A1 + A2 - A3 + A4 + A5 - A6 + A7 - A8 + Ipp + Iaa - Ipa - Iap) / D;
const auto nIaa =
(A0 + A1 - A2 + A3 - A4 - A5 + A6 - A7 + A8 + Ipp + Iaa - Ipa - Iap) / D;
const auto nIap =
(A0 - A1 + A2 + A3 - A4 - A5 + A6 + A7 - A8 - Ipp - Iaa + Ipa + Iap) / D;
const auto nIpa =
(A0 + A1 - A2 - A3 + A4 + A5 - A6 - A7 + A8 - Ipp - Iaa + Ipa + Iap) / D;
WorkspaceGroup_sptr dataOut = boost::make_shared<WorkspaceGroup>();
dataOut->addWorkspace(nIpp);
dataOut->addWorkspace(nIpa);
dataOut->addWorkspace(nIap);
dataOut->addWorkspace(nIaa);
size_t totalGroupEntries(dataOut->getNumberOfEntries());
for (size_t i = 1; i < totalGroupEntries; i++) {
auto alg = this->createChildAlgorithm("ReplaceSpecialValues");
alg->setProperty("InputWorkspace", dataOut->getItem(i));
alg->setProperty("OutputWorkspace", "dataOut_" + std::to_string(i));
alg->setProperty("NaNValue", 0.0);
alg->setProperty("NaNError", 0.0);
alg->setProperty("InfinityValue", 0.0);
alg->setProperty("InfinityError", 0.0);
alg->execute();
}
// Preserve the history of the inside workspaces
nIpp->history().addHistory(Ipp->getHistory());
nIaa->history().addHistory(Iaa->getHistory());
nIpa->history().addHistory(Ipa->getHistory());
nIap->history().addHistory(Iap->getHistory());
return dataOut;
}
