void SaveNISTDAT::exec()
{
MatrixWorkspace_const_sptr inputWS = getProperty("InputWorkspace");
std::string filename = getPropertyValue("Filename");
// prepare to save to file
std::ofstream out_File(filename.c_str());
if (!out_File)
{
g_log.error("Failed to open file:" + filename);
throw Exception::FileError("Failed to open file:" , filename);
}
out_File << "Data columns Qx - Qy - I(Qx,Qy) - err(I)\r\n";
out_File << "ASCII data\r\n";
// Set up the progress reporting object
Progress progress(this,0.0,1.0,2);
progress.report("Save I(Qx,Qy)");
if ( inputWS->axes() > 1 && inputWS->getAxis(1)->isNumeric() )
{
const Axis& axis = *inputWS->getAxis(1);
for (size_t i = 0; i < axis.length()-1; i++)
{
const double qy = (axis(i)+axis(i+1))/2.0;
const MantidVec& XIn = inputWS->readX(i);
const MantidVec& YIn = inputWS->readY(i);
const MantidVec& EIn = inputWS->readE(i);
for ( size_t j = 0; j < XIn.size()-1; j++)
{
// Exclude NaNs
if (YIn[j]==YIn[j])
{
out_File << (XIn[j]+XIn[j+1])/2.0;
out_File << " " << qy;
out_File << " " << YIn[j];
out_File << " " << EIn[j] << "\r\n";
}
}
}
}
out_File.close();
progress.report("Save I(Qx,Qy)");
}
/** Executes the algorithm
*
* @throw runtime_error Thrown if algorithm cannot execute
*/
void Max::exec()
{
// Try and retrieve the optional properties
m_MinRange = getProperty("RangeLower");
m_MaxRange = getProperty("RangeUpper");
m_MinSpec = getProperty("StartWorkspaceIndex");
m_MaxSpec = getProperty("EndWorkspaceIndex");
// Get the input workspace
MatrixWorkspace_const_sptr localworkspace = getProperty("InputWorkspace");
const int numberOfSpectra = static_cast<int>(localworkspace->getNumberHistograms());
// Check 'StartSpectrum' is in range 0-numberOfSpectra
if ( m_MinSpec > numberOfSpectra )
{
g_log.warning("StartSpectrum out of range! Set to 0.");
m_MinSpec = 0;
}
if ( isEmpty(m_MaxSpec) ) m_MaxSpec = numberOfSpectra-1;
if ( m_MaxSpec > numberOfSpectra-1 || m_MaxSpec < m_MinSpec )
{
g_log.warning("EndSpectrum out of range! Set to max detector number");
m_MaxSpec = numberOfSpectra;
}
if ( m_MinRange > m_MaxRange )
{
g_log.warning("Range_upper is less than Range_lower. Will integrate up to frame maximum.");
m_MaxRange = 0.0;
}
// Create the 1D workspace for the output
MatrixWorkspace_sptr outputWorkspace = API::WorkspaceFactory::Instance().create(localworkspace,m_MaxSpec-m_MinSpec+1,2,1);
Progress progress(this,0,1,(m_MaxSpec-m_MinSpec+1));
PARALLEL_FOR2(localworkspace,outputWorkspace)
// Loop over spectra
for (int i = m_MinSpec; i <= m_MaxSpec; ++i)
{
PARALLEL_START_INTERUPT_REGION
int newindex=i-m_MinSpec;
if (localworkspace->axes() > 1)
{
outputWorkspace->getAxis(1)->spectraNo(newindex) = localworkspace->getAxis(1)->spectraNo(i);
}
// Retrieve the spectrum into a vector
const MantidVec& X = localworkspace->readX(i);
const MantidVec& Y = localworkspace->readY(i);
// Find the range [min,max]
MantidVec::const_iterator lowit, highit;
if (m_MinRange == EMPTY_DBL()) lowit=X.begin();
else lowit=std::lower_bound(X.begin(),X.end(),m_MinRange);
if (m_MaxRange == EMPTY_DBL()) highit=X.end();
else highit=std::find_if(lowit,X.end(),std::bind2nd(std::greater<double>(),m_MaxRange));
// If range specified doesn't overlap with this spectrum then bail out
if ( lowit == X.end() || highit == X.begin() ) continue;
highit--; // Upper limit is the bin before, i.e. the last value smaller than MaxRange
MantidVec::difference_type distmin=std::distance(X.begin(),lowit);
MantidVec::difference_type distmax=std::distance(X.begin(),highit);
// Find the max element
MantidVec::const_iterator maxY=std::max_element(Y.begin()+distmin,Y.begin()+distmax);
MantidVec::difference_type d=std::distance(Y.begin(),maxY);
// X boundaries for the max element
outputWorkspace->dataX(newindex)[0]=*(X.begin()+d);
outputWorkspace->dataX(newindex)[1]=*(X.begin()+d+1); //This is safe since X is of dimension Y+1
outputWorkspace->dataY(newindex)[0]=*maxY;
progress.report();
PARALLEL_END_INTERUPT_REGION
}
PARALLEL_CHECK_INTERUPT_REGION
// Assign it to the output workspace property
setProperty("OutputWorkspace",outputWorkspace);
return;
}
/** Executes the rebin algorithm
*
* @throw runtime_error Thrown if the bin range does not intersect the range of the input workspace
*/
void Rebin::exec()
{
// Get the input workspace
MatrixWorkspace_const_sptr inputWS = getProperty("InputWorkspace");
MatrixWorkspace_sptr outputWS = getProperty("OutputWorkspace");
// Are we preserving event workspace-iness?
bool PreserveEvents = getProperty("PreserveEvents");
// Rebinning in-place
bool inPlace = (inputWS == outputWS);
// retrieve the properties
const std::vector<double> rb_params=getProperty("Params");
const bool dist = inputWS->isDistribution();
const bool isHist = inputWS->isHistogramData();
// workspace independent determination of length
const int histnumber = static_cast<int>(inputWS->getNumberHistograms());
MantidVecPtr XValues_new;
// create new output X axis
const int ntcnew = VectorHelper::createAxisFromRebinParams(rb_params, XValues_new.access());
//---------------------------------------------------------------------------------
//Now, determine if the input workspace is actually an EventWorkspace
EventWorkspace_const_sptr eventInputWS = boost::dynamic_pointer_cast<const EventWorkspace>(inputWS);
if (eventInputWS != NULL)
{
//------- EventWorkspace as input -------------------------------------
EventWorkspace_sptr eventOutputWS = boost::dynamic_pointer_cast<EventWorkspace>(outputWS);
if (inPlace && PreserveEvents)
{
// -------------Rebin in-place, preserving events ----------------------------------------------
// This only sets the X axis. Actual rebinning will be done upon data access.
eventOutputWS->setAllX(XValues_new);
this->setProperty("OutputWorkspace", boost::dynamic_pointer_cast<MatrixWorkspace>(eventOutputWS));
}
else if (!inPlace && PreserveEvents)
{
// -------- NOT in-place, but you want to keep events for some reason. ----------------------
// Must copy the event workspace to a new EventWorkspace (and bin that).
//Make a brand new EventWorkspace
eventOutputWS = boost::dynamic_pointer_cast<EventWorkspace>(
API::WorkspaceFactory::Instance().create("EventWorkspace", inputWS->getNumberHistograms(), 2, 1));
//Copy geometry over.
API::WorkspaceFactory::Instance().initializeFromParent(inputWS, eventOutputWS, false);
//You need to copy over the data as well.
eventOutputWS->copyDataFrom( (*eventInputWS) );
// This only sets the X axis. Actual rebinning will be done upon data access.
eventOutputWS->setAllX(XValues_new);
//Cast to the matrixOutputWS and save it
this->setProperty("OutputWorkspace", boost::dynamic_pointer_cast<MatrixWorkspace>(eventOutputWS));
}
else
{
//--------- Different output, OR you're inplace but not preserving Events --- create a Workspace2D -------
g_log.information() << "Creating a Workspace2D from the EventWorkspace " << eventInputWS->getName() << ".\n";
//Create a Workspace2D
// This creates a new Workspace2D through a torturous route using the WorkspaceFactory.
// The Workspace2D is created with an EMPTY CONSTRUCTOR
outputWS = WorkspaceFactory::Instance().create("Workspace2D",histnumber,ntcnew,ntcnew-1);
WorkspaceFactory::Instance().initializeFromParent(inputWS, outputWS, true);
//Initialize progress reporting.
Progress prog(this,0.0,1.0, histnumber);
//Go through all the histograms and set the data
PARALLEL_FOR3(inputWS, eventInputWS, outputWS)
for (int i=0; i < histnumber; ++i)
{
PARALLEL_START_INTERUPT_REGION
//Set the X axis for each output histogram
outputWS->setX(i, XValues_new);
//Get a const event list reference. eventInputWS->dataY() doesn't work.
const EventList& el = eventInputWS->getEventList(i);
MantidVec y_data, e_data;
// The EventList takes care of histogramming.
el.generateHistogram(*XValues_new, y_data, e_data);
//Copy the data over.
outputWS->dataY(i).assign(y_data.begin(), y_data.end());
outputWS->dataE(i).assign(e_data.begin(), e_data.end());
//Report progress
prog.report(name());
PARALLEL_END_INTERUPT_REGION
}
PARALLEL_CHECK_INTERUPT_REGION
//Copy all the axes
for (int i=1; i<inputWS->axes(); i++)
{
outputWS->replaceAxis( i, inputWS->getAxis(i)->clone(outputWS.get()) );
outputWS->getAxis(i)->unit() = inputWS->getAxis(i)->unit();
}
//Copy the units over too.
for (int i=0; i < outputWS->axes(); ++i)
outputWS->getAxis(i)->unit() = inputWS->getAxis(i)->unit();
outputWS->setYUnit(eventInputWS->YUnit());
outputWS->setYUnitLabel(eventInputWS->YUnitLabel());
// Assign it to the output workspace property
setProperty("OutputWorkspace", outputWS);
}
} // END ---- EventWorkspace
