/**
* Handles the JumpFit algorithm finishing, used to plot fit in miniplot.
*
* @param error True if the algorithm failed, false otherwise
*/
void JumpFit::fitAlgDone(bool error)
{
// Ignore errors
if(error)
return;
std::string outWsName = fitAlg->getPropertyValue("Output") + "_Workspace";
MatrixWorkspace_sptr outputWorkspace = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(outWsName);
TextAxis* axis = dynamic_cast<TextAxis*>(outputWorkspace->getAxis(1));
for(unsigned int histIndex = 0; histIndex < outputWorkspace->getNumberHistograms(); histIndex++)
{
QString specName = QString::fromStdString(axis->label(histIndex));
if(specName == "Calc")
{
plotMiniPlot(outputWorkspace, histIndex, "JumpFitPlot", specName);
m_curves[specName]->setPen(QColor(Qt::red));
}
if(specName == "Diff")
{
plotMiniPlot(outputWorkspace, histIndex, "JumpFitPlot", specName);
m_curves[specName]->setPen(QColor(Qt::green));
}
}
replot("JumpFitPlot");
}
/** Construct output
*/
Workspace2D_sptr RefinePowderInstrumentParameters2::genOutputWorkspace(FunctionDomain1DVector domain,
FunctionValues rawvalues)
{
// 1. Create and set up output workspace
size_t lenx = m_dataWS->readX(m_wsIndex).size();
size_t leny = m_dataWS->readY(m_wsIndex).size();
Workspace2D_sptr outws = boost::dynamic_pointer_cast<Workspace2D>
(WorkspaceFactory::Instance().create("Workspace2D", 6, lenx, leny));
outws->getAxis(0)->setUnit("dSpacing");
TextAxis* taxis = new TextAxis(outws->getNumberHistograms());
taxis->setLabel(0, "Data");
taxis->setLabel(1, "Model");
taxis->setLabel(2, "DiffDM");
taxis->setLabel(3, "Start");
taxis->setLabel(4, "DiffDS");
taxis->setLabel(5, "Zdiff");
outws->replaceAxis(1, taxis);
// 3. Re-calculate values
FunctionValues funcvalues(domain);
m_positionFunc->function(domain, funcvalues);
// 4. Add values
// a) X axis
for (size_t iws = 0; iws < outws->getNumberHistograms(); ++iws)
{
MantidVec& vecX = outws->dataX(iws);
for (size_t n = 0; n < lenx; ++n)
vecX[n] = domain[n];
}
// b) Y axis
const MantidVec& dataY = m_dataWS->readY(m_wsIndex);
for (size_t i = 0; i < domain.size(); ++i)
{
outws->dataY(0)[i] = dataY[i];
outws->dataY(1)[i] = funcvalues[i];
outws->dataY(2)[i] = dataY[i] - funcvalues[i];
outws->dataY(3)[i] = rawvalues[i];
outws->dataY(4)[i] = dataY[i] - rawvalues[i];
}
// 5. Zscore
vector<double> zscore = Kernel::getZscore(outws->readY(2));
for (size_t i = 0; i < domain.size(); ++i)
outws->dataY(5)[i] = zscore[i];
return outws;
}
/** Populate output workspace with results
* @param outWS :: [input/output] Output workspace to populate
* @param nplots :: [input] Number of histograms
*/
void PlotAsymmetryByLogValue::populateOutputWorkspace(
MatrixWorkspace_sptr &outWS, int nplots) {
TextAxis *tAxis = new TextAxis(nplots);
if (nplots == 1) {
size_t i = 0;
for (auto it = m_logValue.begin(); it != m_logValue.end(); ++it) {
outWS->dataX(0)[i] = it->second;
outWS->dataY(0)[i] = m_redY[it->first];
outWS->dataE(0)[i] = m_redE[it->first];
i++;
}
tAxis->setLabel(0, "Asymmetry");
} else {
size_t i = 0;
for (auto it = m_logValue.begin(); it != m_logValue.end(); ++it) {
outWS->dataX(0)[i] = it->second;
outWS->dataY(0)[i] = m_diffY[it->first];
outWS->dataE(0)[i] = m_diffE[it->first];
outWS->dataX(1)[i] = it->second;
outWS->dataY(1)[i] = m_redY[it->first];
outWS->dataE(1)[i] = m_redE[it->first];
outWS->dataX(2)[i] = it->second;
outWS->dataY(2)[i] = m_greenY[it->first];
outWS->dataE(2)[i] = m_greenE[it->first];
outWS->dataX(3)[i] = it->second;
outWS->dataY(3)[i] = m_sumY[it->first];
outWS->dataE(3)[i] = m_sumE[it->first];
i++;
}
tAxis->setLabel(0, "Red-Green");
tAxis->setLabel(1, "Red");
tAxis->setLabel(2, "Green");
tAxis->setLabel(3, "Red+Green");
}
outWS->replaceAxis(1, tAxis);
outWS->getAxis(0)->title() = m_logName;
outWS->setYUnitLabel("Asymmetry");
}
/**
* 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);
}
