API::MatrixWorkspace_sptr ScaleX::createOutputWS(API::MatrixWorkspace_sptr input)
{
//Check whether input = output to see whether a new workspace is required.
if (getPropertyValue("InputWorkspace") == getPropertyValue("OutputWorkspace"))
{
//Overwrite the original
return input;
}
else
{
//Create new workspace for output from old
API::MatrixWorkspace_sptr output = API::WorkspaceFactory::Instance().create(input);
output->isDistribution(input->isDistribution());
return output;
}
}
/** Execute the algorithm.
*/
void ReflectometrySumInQ::exec() {
API::MatrixWorkspace_sptr inWS;
Indexing::SpectrumIndexSet indices;
std::tie(inWS, indices) =
getWorkspaceAndIndices<API::MatrixWorkspace>(Prop::INPUT_WS);
auto outWS = sumInQ(*inWS, indices);
if (inWS->isDistribution()) {
API::WorkspaceHelpers::makeDistribution(outWS);
}
setProperty(Prop::OUTPUT_WS, outWS);
}
/**
* Convert to a distribution
* @param workspace :: The input workspace to convert to a count rate
* @return distribution workspace with equiv. data
*/
API::MatrixWorkspace_sptr DetectorDiagnostic::convertToRate(API::MatrixWorkspace_sptr workspace)
{
if( workspace->isDistribution() )
{
g_log.information() << "Workspace already contains a count rate, nothing to do.\n";
return workspace;
}
g_log.information("Calculating time averaged count rates");
// get percentage completed estimates for now, t0 and when we've finished t1
double t0 = m_fracDone, t1 = advanceProgress(RTGetRate);
IAlgorithm_sptr childAlg = createChildAlgorithm("ConvertToDistribution", t0, t1);
childAlg->setProperty<MatrixWorkspace_sptr>("Workspace", workspace);
// Now execute the Child Algorithm but allow any exception to bubble up
childAlg->execute();
return childAlg->getProperty("Workspace");
}
void Divide::setOutputUnits(const API::MatrixWorkspace_const_sptr lhs,const API::MatrixWorkspace_const_sptr rhs,API::MatrixWorkspace_sptr out)
{
if ( rhs->YUnit().empty() || !WorkspaceHelpers::matchingBins(lhs,rhs,true) )
{
// Do nothing
}
// If the Y units match, then the output will be a distribution and will be dimensionless
else if ( lhs->YUnit() == rhs->YUnit() && rhs->blocksize() > 1 )
{
out->setYUnit("");
out->isDistribution(true);
}
// Else we need to set the unit that results from the division
else
{
if ( ! lhs->YUnit().empty() ) out->setYUnit(lhs->YUnit() + "/" + rhs->YUnit());
else out->setYUnit("1/" + rhs->YUnit());
}
}
void Multiply::setOutputUnits(const API::MatrixWorkspace_const_sptr lhs,const API::MatrixWorkspace_const_sptr rhs,API::MatrixWorkspace_sptr out)
{
if ( !lhs->isDistribution() || !rhs->isDistribution() ) out->isDistribution(false);
}
/** Executes the rebin algorithm
*
* @throw runtime_error Thrown if
*/
void Rebunch::exec()
{
// retrieve the properties
int n_bunch=getProperty("NBunch");
// Get the input workspace
MatrixWorkspace_const_sptr inputW = getProperty("InputWorkspace");
bool dist = inputW->isDistribution();
// workspace independent determination of length
int histnumber = static_cast<int>(inputW->size()/inputW->blocksize());
/*
const std::vector<double>& Xold = inputW->readX(0);
const std::vector<double>& Yold = inputW->readY(0);
int size_x=Xold.size();
int size_y=Yold.size();
*/
int size_x = static_cast<int>(inputW->readX(0).size());
int size_y = static_cast<int>(inputW->readY(0).size());
//signal is the same length for histogram and point data
int ny=(size_y/n_bunch);
if(size_y%n_bunch >0)ny+=1;
// default is for hist
int nx=ny+1;
bool point=false;
if (size_x==size_y)
{
point=true;
nx=ny;
}
// make output Workspace the same type is the input, but with new length of signal array
API::MatrixWorkspace_sptr outputW = API::WorkspaceFactory::Instance().create(inputW,histnumber,nx,ny);
int progress_step = histnumber / 100;
if (progress_step == 0) progress_step = 1;
PARALLEL_FOR2(inputW,outputW)
for (int hist=0; hist < histnumber;hist++)
{
PARALLEL_START_INTERUPT_REGION
// Ensure that axis information are copied to the output workspace if the axis exists
try
{
outputW->getAxis(1)->spectraNo(hist)=inputW->getAxis(1)->spectraNo(hist);
}
catch( Exception::IndexError& )
{
// Not a Workspace2D
}
// get const references to input Workspace arrays (no copying)
const MantidVec& XValues = inputW->readX(hist);
const MantidVec& YValues = inputW->readY(hist);
const MantidVec& YErrors = inputW->readE(hist);
//get references to output workspace data (no copying)
MantidVec& XValues_new=outputW->dataX(hist);
MantidVec& YValues_new=outputW->dataY(hist);
MantidVec& YErrors_new=outputW->dataE(hist);
// output data arrays are implicitly filled by function
if(point)
{
rebunch_point(XValues,YValues,YErrors,XValues_new,YValues_new,YErrors_new,n_bunch);
}
else
{
rebunch_hist(XValues,YValues,YErrors,XValues_new,YValues_new,YErrors_new,n_bunch, dist);
}
if (hist % progress_step == 0)
{
progress(double(hist)/histnumber);
interruption_point();
}
PARALLEL_END_INTERUPT_REGION
}
PARALLEL_CHECK_INTERUPT_REGION
outputW->isDistribution(dist);
// Copy units
if (outputW->getAxis(0)->unit().get())
outputW->getAxis(0)->unit() = inputW->getAxis(0)->unit();
try
{
if (inputW->getAxis(1)->unit().get())
outputW->getAxis(1)->unit() = inputW->getAxis(1)->unit();
}
catch(Exception::IndexError&) {
// OK, so this isn't a Workspace2D
}
// Assign it to the output workspace property
setProperty("OutputWorkspace",outputW);
return;
}
void LoadDaveGrp::exec()
{
const std::string filename = this->getProperty("Filename");
int yLength = 0;
MantidVec *xAxis = new MantidVec();
MantidVec *yAxis = new MantidVec();
std::vector<MantidVec *> data;
std::vector<MantidVec *> errors;
this->ifile.open(filename.c_str());
if (this->ifile.is_open())
{
// Size of x axis
this->getAxisLength(this->xLength);
// Size of y axis
this->getAxisLength(yLength);
// This is also the number of groups (spectra)
this->nGroups = yLength;
// Read in the x axis values
this->getAxisValues(xAxis, static_cast<std::size_t>(this->xLength));
// Read in the y axis values
this->getAxisValues(yAxis, static_cast<std::size_t>(yLength));
// Read in the data
this->getData(data, errors);
}
this->ifile.close();
// Scale the x-axis if it is in micro-eV to get it to meV
const bool isUeV = this->getProperty("IsMicroEV");
if (isUeV)
{
MantidVec::iterator iter;
for (iter = xAxis->begin(); iter != xAxis->end(); ++iter)
{
*iter /= 1000.0;
}
}
// Create workspace
API::MatrixWorkspace_sptr outputWorkspace = \
boost::dynamic_pointer_cast<API::MatrixWorkspace>\
(API::WorkspaceFactory::Instance().create("Workspace2D", this->nGroups,
this->xLength, yLength));
// Force the workspace to be a distribution
outputWorkspace->isDistribution(true);
// Set the x-axis units
outputWorkspace->getAxis(0)->unit() = Kernel::UnitFactory::Instance().create(this->getProperty("XAxisUnits"));
API::Axis* const verticalAxis = new API::NumericAxis(yLength);
// Set the y-axis units
verticalAxis->unit() = Kernel::UnitFactory::Instance().create(this->getProperty("YAxisUnits"));
outputWorkspace->replaceAxis(1, verticalAxis);
for(int i = 0; i < this->nGroups; i++)
{
outputWorkspace->dataX(i) = *xAxis;
outputWorkspace->dataY(i) = *data[i];
outputWorkspace->dataE(i) = *errors[i];
verticalAxis->setValue(i, yAxis->at(i));
delete data[i];
delete errors[i];
}
delete xAxis;
delete yAxis;
outputWorkspace->mutableRun().addProperty("Filename",filename);
this->setProperty("OutputWorkspace", outputWorkspace);
}
/** Executes the regroup algorithm
*
* @throw runtime_error Thrown if
*/
void Regroup::exec()
{
// retrieve the properties
std::vector<double> rb_params=getProperty("Params");
// Get the input workspace
MatrixWorkspace_const_sptr inputW = getProperty("InputWorkspace");
// can work only if all histograms have the same boundaries
if (!API::WorkspaceHelpers::commonBoundaries(inputW))
{
g_log.error("Histograms with different boundaries");
throw std::runtime_error("Histograms with different boundaries");
}
bool dist = inputW->isDistribution();
int histnumber = static_cast<int>(inputW->getNumberHistograms());
MantidVecPtr XValues_new;
const MantidVec & XValues_old = inputW->readX(0);
std::vector<int> xoldIndex;// indeces of new x in XValues_old
// create new output X axis
int ntcnew = newAxis(rb_params,XValues_old,XValues_new.access(),xoldIndex);
// make output Workspace the same type is the input, but with new length of signal array
API::MatrixWorkspace_sptr outputW = API::WorkspaceFactory::Instance().create(inputW,histnumber,ntcnew,ntcnew-1);
int progress_step = histnumber / 100;
if (progress_step == 0) progress_step = 1;
for (int hist=0; hist < histnumber;hist++)
{
// get const references to input Workspace arrays (no copying)
const MantidVec& XValues = inputW->readX(hist);
const MantidVec& YValues = inputW->readY(hist);
const MantidVec& YErrors = inputW->readE(hist);
//get references to output workspace data (no copying)
MantidVec& YValues_new=outputW->dataY(hist);
MantidVec& YErrors_new=outputW->dataE(hist);
// output data arrays are implicitly filled by function
rebin(XValues,YValues,YErrors,xoldIndex,YValues_new,YErrors_new, dist);
outputW->setX(hist,XValues_new);
if (hist % progress_step == 0)
{
progress(double(hist)/histnumber);
interruption_point();
}
}
outputW->isDistribution(dist);
// Copy units
if (outputW->getAxis(0)->unit().get())
outputW->getAxis(0)->unit() = inputW->getAxis(0)->unit();
try
{
if (inputW->getAxis(1)->unit().get())
outputW->getAxis(1)->unit() = inputW->getAxis(1)->unit();
}
catch(Exception::IndexError) {
// OK, so this isn't a Workspace2D
}
// Assign it to the output workspace property
setProperty("OutputWorkspace",outputW);
return;
}
/** Executes the algorithm
*
* @throw Exception::FileError If the grouping file cannot be opened or read successfully
* @throw runtime_error If unable to run one of the sub-algorithms successfully
*/
void DiffractionFocussing::exec()
{
// retrieve the properties
std::string groupingFileName=getProperty("GroupingFileName");
// Get the input workspace
MatrixWorkspace_sptr inputW = getProperty("InputWorkspace");
bool dist = inputW->isDistribution();
//do this first to check that a valid file is available before doing any work
std::multimap<int64_t,int64_t> detectorGroups;// <group, UDET>
if (!readGroupingFile(groupingFileName, detectorGroups))
{
throw Exception::FileError("Error reading .cal file",groupingFileName);
}
//Convert to d-spacing units
API::MatrixWorkspace_sptr tmpW = convertUnitsToDSpacing(inputW);
//Rebin to a common set of bins
RebinWorkspace(tmpW);
std::set<int64_t> groupNumbers;
for(std::multimap<int64_t,int64_t>::const_iterator d = detectorGroups.begin();d!=detectorGroups.end();d++)
{
if (groupNumbers.find(d->first) == groupNumbers.end())
{
groupNumbers.insert(d->first);
}
}
int iprogress = 0;
int iprogress_count = static_cast<int>(groupNumbers.size());
int iprogress_step = iprogress_count / 100;
if (iprogress_step == 0) iprogress_step = 1;
std::vector<int64_t> resultIndeces;
for(std::set<int64_t>::const_iterator g = groupNumbers.begin();g!=groupNumbers.end();g++)
{
if (iprogress++ % iprogress_step == 0)
{
progress(0.68 + double(iprogress)/iprogress_count/3);
}
std::multimap<int64_t,int64_t>::const_iterator from = detectorGroups.lower_bound(*g);
std::multimap<int64_t,int64_t>::const_iterator to = detectorGroups.upper_bound(*g);
std::vector<detid_t> detectorList;
for(std::multimap<int64_t,int64_t>::const_iterator d = from;d!=to;d++)
detectorList.push_back(static_cast<detid_t>(d->second));
// Want version 1 of GroupDetectors here
API::IAlgorithm_sptr childAlg = createSubAlgorithm("GroupDetectors",-1.0,-1.0,true,1);
childAlg->setProperty("Workspace", tmpW);
childAlg->setProperty< std::vector<detid_t> >("DetectorList",detectorList);
childAlg->executeAsSubAlg();
try
{
// get the index of the combined spectrum
int ri = childAlg->getProperty("ResultIndex");
if (ri >= 0)
{
resultIndeces.push_back(ri);
}
}
catch(...)
{
throw std::runtime_error("Unable to get Properties from GroupDetectors sub-algorithm");
}
}
// Discard left-over spectra, but print warning message giving number discarded
int discarded = 0;
const int64_t oldHistNumber = tmpW->getNumberHistograms();
API::Axis *spectraAxis = tmpW->getAxis(1);
for(int64_t i=0; i < oldHistNumber; i++)
if ( spectraAxis->spectraNo(i) >= 0 && find(resultIndeces.begin(),resultIndeces.end(),i) == resultIndeces.end())
{
++discarded;
}
g_log.warning() << "Discarded " << discarded << " spectra that were not assigned to any group" << std::endl;
// Running GroupDetectors leads to a load of redundant spectra
// Create a new workspace that's the right size for the meaningful spectra and copy them in
int64_t newSize = tmpW->blocksize();
API::MatrixWorkspace_sptr outputW = API::WorkspaceFactory::Instance().create(tmpW,resultIndeces.size(),newSize+1,newSize);
// Copy units
outputW->getAxis(0)->unit() = tmpW->getAxis(0)->unit();
outputW->getAxis(1)->unit() = tmpW->getAxis(1)->unit();
API::Axis *spectraAxisNew = outputW->getAxis(1);
for(int64_t hist=0; hist < static_cast<int64_t>(resultIndeces.size()); hist++)
{
int64_t i = resultIndeces[hist];
double spNo = static_cast<double>(spectraAxis->spectraNo(i));
MantidVec &tmpE = tmpW->dataE(i);
MantidVec &outE = outputW->dataE(hist);
MantidVec &tmpY = tmpW->dataY(i);
MantidVec &outY = outputW->dataY(hist);
MantidVec &tmpX = tmpW->dataX(i);
MantidVec &outX = outputW->dataX(hist);
outE.assign(tmpE.begin(),tmpE.end());
outY.assign(tmpY.begin(),tmpY.end());
outX.assign(tmpX.begin(),tmpX.end());
spectraAxisNew->setValue(hist,spNo);
spectraAxis->setValue(i,-1);
}
progress(1.);
outputW->isDistribution(dist);
// Assign it to the output workspace property
setProperty("OutputWorkspace",outputW);
return;
}