/** Makes a workspace with the total solid angle all the detectors in each spectrum cover from the sample
* note returns an empty shared pointer on failure, uses the SolidAngle algorithm
* @param firstSpec :: the index number of the first histogram to analyse
* @param lastSpec :: the index number of the last histogram to analyse
* @return A pointer to the workspace (or an empty pointer)
*/
API::MatrixWorkspace_sptr MedianDetectorTest::getSolidAngles(int firstSpec, int lastSpec )
{
g_log.debug("Calculating solid angles");
// get percentage completed estimates for now, t0 and when we've finished t1
double t0 = m_fracDone, t1 = advanceProgress(RTGetSolidAngle);
IAlgorithm_sptr childAlg = createChildAlgorithm("SolidAngle", t0, t1, true);
childAlg->setProperty( "InputWorkspace", m_inputWS);
childAlg->setProperty( "StartWorkspaceIndex", firstSpec );
childAlg->setProperty( "EndWorkspaceIndex", lastSpec );
try
{
// Execute the Child Algorithm, it could throw a runtime_error at this point which would abort execution
childAlg->execute();
if ( ! childAlg->isExecuted() )
{
throw std::runtime_error("Unexpected problem calculating solid angles");
}
}
//catch all exceptions because the solid angle calculation is optional
catch(std::exception&)
{
g_log.warning(
"Precision warning: Can't find detector geometry " + name() +
" will continue with the solid angles of all spectra set to the same value" );
failProgress(RTGetSolidAngle);
//The return is an empty workspace pointer, which must be handled by the calling function
MatrixWorkspace_sptr empty;
//function returns normally
return empty;
}
return childAlg->getProperty("OutputWorkspace");
}
void LoadNexus::runLoadTOFRawNexus() {
IAlgorithm_sptr loadNexusPro =
createChildAlgorithm("LoadTOFRawNexus", 0., 1.);
// Pass through the same input filename
loadNexusPro->setPropertyValue("Filename", m_filename);
// Set the workspace property
std::string outputWorkspace = "OutputWorkspace";
loadNexusPro->setPropertyValue(outputWorkspace, m_workspace);
// Get the array passed in the spectrum_list, if an empty array was passed use
// the default
std::vector<int> specList = getProperty("SpectrumList");
if (!specList.empty())
loadNexusPro->setPropertyValue("SpectrumList",
getPropertyValue("SpectrumList"));
//
int specMax = getProperty("SpectrumMax");
if (specMax != Mantid::EMPTY_INT()) {
loadNexusPro->setPropertyValue("SpectrumMax",
getPropertyValue("SpectrumMax"));
loadNexusPro->setPropertyValue("SpectrumMin",
getPropertyValue("SpectrumMin"));
}
// Now execute the Child Algorithm. Catch and log any error, but don't stop.
try {
loadNexusPro->execute();
} catch (std::runtime_error &) {
g_log.error("Unable to successfully run LoadTOFRawNexus Child Algorithm");
}
if (!loadNexusPro->isExecuted())
g_log.error("Unable to successfully run LoadTOFRawNexus Child Algorithm");
setOutputWorkspace(loadNexusPro);
}
/** Set goniometer to matrix workspace and get its rotation matrix R (from
* Q-sample to Q-lab
* and output 1/R
* @brief ConvertCWSDExpToMomentum::setupTransferMatrix
* @param dataws :: matrix workspace containing sample rotation angles
* @param rotationMatrix :: output as matrix 1/R to convert from Q-lab to
* Q-sample
*/
void ConvertCWSDExpToMomentum::setupTransferMatrix(
API::MatrixWorkspace_sptr dataws, Kernel::DblMatrix &rotationMatrix) {
// Check sample logs
if (!dataws->run().hasProperty("_omega") ||
!dataws->run().hasProperty("_chi") || !dataws->run().hasProperty("_phi"))
throw std::runtime_error(
"Data workspace does not have sample log _phi, _chi or _omega. "
"Unable to set goniometer and calcualte roation matrix R.");
// Call algorithm SetGoniometer
IAlgorithm_sptr setalg = createChildAlgorithm("SetGoniometer");
setalg->initialize();
setalg->setProperty("Workspace", dataws);
setalg->setProperty("Axis0", "_omega,0,1,0,-1");
setalg->setProperty("Axis1", "_chi,0,0,1,-1");
setalg->setProperty("Axis2", "_phi,0,1,0,-1");
setalg->execute();
if (setalg->isExecuted()) {
rotationMatrix = dataws->run().getGoniometer().getR();
g_log.debug() << "Ratation matrix: " << rotationMatrix.str() << "\n";
rotationMatrix.Invert();
g_log.debug() << "Ratation matrix: " << rotationMatrix.str() << "\n";
} else
throw std::runtime_error("Unable to set Goniometer.");
return;
}
/**
* Replots the energy mini plot
*/
void ISISCalibration::calPlotEnergy()
{
if ( ! m_uiForm.leRunNo->isValid() )
{
emit showMessageBox("Run number not valid.");
return;
}
QString files = m_uiForm.leRunNo->getFilenames().join(",");
QFileInfo fi(m_uiForm.leRunNo->getFirstFilename());
QString detRange = QString::number(m_dblManager->value(m_properties["ResSpecMin"])) + ","
+ QString::number(m_dblManager->value(m_properties["ResSpecMax"]));
IAlgorithm_sptr reductionAlg = AlgorithmManager::Instance().create("ISISIndirectEnergyTransfer");
reductionAlg->initialize();
reductionAlg->setProperty("Instrument", getInstrumentConfiguration()->getInstrumentName().toStdString());
reductionAlg->setProperty("Analyser", getInstrumentConfiguration()->getAnalyserName().toStdString());
reductionAlg->setProperty("Reflection", getInstrumentConfiguration()->getReflectionName().toStdString());
reductionAlg->setProperty("InputFiles", files.toStdString());
reductionAlg->setProperty("OutputWorkspace", "__IndirectCalibration_reduction");
reductionAlg->setProperty("SpectraRange", detRange.toStdString());
reductionAlg->execute();
if(!reductionAlg->isExecuted())
{
g_log.warning("Could not generate energy preview plot.");
return;
}
WorkspaceGroup_sptr reductionOutputGroup = AnalysisDataService::Instance().retrieveWS<WorkspaceGroup>("__IndirectCalibration_reduction");
if(reductionOutputGroup->size() == 0)
{
g_log.warning("No result workspaces, cannot plot energy preview.");
return;
}
MatrixWorkspace_sptr energyWs = boost::dynamic_pointer_cast<MatrixWorkspace>(reductionOutputGroup->getItem(0));
if(!energyWs)
{
g_log.warning("No result workspaces, cannot plot energy preview.");
return;
}
const Mantid::MantidVec & dataX = energyWs->readX(0);
QPair<double, double> range(dataX.front(), dataX.back());
auto resBackground = m_uiForm.ppResolution->getRangeSelector("ResBackground");
setPlotPropertyRange(resBackground, m_properties["ResStart"], m_properties["ResEnd"], range);
m_uiForm.ppResolution->clear();
m_uiForm.ppResolution->addSpectrum("Energy", energyWs, 0);
m_uiForm.ppResolution->resizeX();
calSetDefaultResolution(energyWs);
m_uiForm.ppResolution->replot();
}
void SaveNexus::runSaveNexusProcessed() {
IAlgorithm_sptr saveNexusPro =
createChildAlgorithm("SaveNexusProcessed", 0.0, 1.0, true);
// Pass through the same output filename
saveNexusPro->setPropertyValue("Filename", m_filename);
// Set the workspace property
std::string inputWorkspace = "InputWorkspace";
saveNexusPro->setProperty(inputWorkspace, m_inputWorkspace);
//
std::vector<int> specList = getProperty("WorkspaceIndexList");
if (!specList.empty())
saveNexusPro->setPropertyValue("WorkspaceIndexList",
getPropertyValue("WorkspaceIndexList"));
//
int specMax = getProperty("WorkspaceIndexMax");
if (specMax != Mantid::EMPTY_INT()) {
saveNexusPro->setPropertyValue("WorkspaceIndexMax",
getPropertyValue("WorkspaceIndexMax"));
saveNexusPro->setPropertyValue("WorkspaceIndexMin",
getPropertyValue("WorkspaceIndexMin"));
}
std::string title = getProperty("Title");
if (!title.empty())
saveNexusPro->setPropertyValue("Title", getPropertyValue("Title"));
// Pass through the append property
saveNexusPro->setProperty<bool>("Append", getProperty("Append"));
// If we're tracking history, add the entry before we save it to file
if (trackingHistory()) {
m_history->fillAlgorithmHistory(
this, Mantid::Kernel::DateAndTime::getCurrentTime(), 0,
Algorithm::g_execCount);
if (!isChild()) {
m_inputWorkspace->history().addHistory(m_history);
}
// this is a child algorithm, but we still want to keep the history.
else if (isRecordingHistoryForChild() && m_parentHistory) {
m_parentHistory->addChildHistory(m_history);
}
}
// Now execute the Child Algorithm. Catch and log any error, but don't stop.
try {
saveNexusPro->execute();
} catch (std::runtime_error &) {
g_log.error(
"Unable to successfully run SaveNexusprocessed Child Algorithm");
}
if (!saveNexusPro->isExecuted())
g_log.error(
"Unable to successfully run SaveNexusProcessed Child Algorithm");
//
progress(1);
}
/** Set up grouping workspace
*/
void LoadVulcanCalFile::setupGroupingWorkspace() {
// Get the right group option for CreateGroupingWorkspace
string groupdetby = "";
switch (m_groupingType) {
case VULCAN_OFFSET_BANK:
groupdetby = "bank";
break;
case VULCAN_OFFSET_MODULE:
groupdetby = "Group";
break;
case VULCAN_OFFSET_STACK:
groupdetby = "All";
break;
default:
throw runtime_error("Grouping type is not supported. ");
break;
}
// Calling algorithm CreateGroupingWorkspace
IAlgorithm_sptr creategroupws =
createChildAlgorithm("CreateGroupingWorkspace", -1, -1, true);
creategroupws->initialize();
creategroupws->setProperty("InstrumentName", "VULCAN");
creategroupws->setProperty("GroupDetectorsBy", groupdetby);
creategroupws->execute();
if (!creategroupws->isExecuted())
throw runtime_error("Unable to create grouping workspace.");
m_groupWS = creategroupws->getProperty("OutputWorkspace");
// Set title
m_groupWS->setTitle(groupdetby);
// Output
string WorkspaceName = getPropertyValue("WorkspaceName");
declareProperty(new WorkspaceProperty<GroupingWorkspace>(
"OutputGroupingWorkspace", WorkspaceName + "_group",
Direction::Output),
"Set the output GroupingWorkspace. ");
m_groupWS->mutableRun().addProperty("Filename", m_offsetFilename);
setProperty("OutputGroupingWorkspace", m_groupWS);
return;
}
void LoadNexus::runLoadNexusProcessed() {
IAlgorithm_sptr loadNexusPro =
createChildAlgorithm("LoadNexusProcessed", 0., 1.);
// Pass through the same input filename
loadNexusPro->setPropertyValue("Filename", m_filename);
// Set the workspace property
loadNexusPro->setPropertyValue("OutputWorkspace", m_workspace);
loadNexusPro->setPropertyValue("SpectrumMin",
getPropertyValue("SpectrumMin"));
loadNexusPro->setPropertyValue("SpectrumMax",
getPropertyValue("SpectrumMax"));
loadNexusPro->setPropertyValue("SpectrumList",
getPropertyValue("SpectrumList"));
/* !!! The spectrum min/max/list properties are currently missing from
LoadNexus
so don't pass them through here, just print a warning !!! */
// Get the array passed in the spectrum_list, if an empty array was passed use
// the default
// std::vector<int> specList = getProperty("SpectrumList");
// if ( !specList.empty() )
//{
// g_log.warning("SpectrumList property ignored - it is not implemented in
// LoadNexusProcessed.");
// //loadNexusPro->setProperty("SpectrumList",specList);
//}
// int specMin = getProperty("SpectrumMin");
// int specMax = getProperty("SpectrumMax");
// if ( specMax != Mantid::EMPTY_INT() || specMin != 0 )
//{
// g_log.warning("SpectrumMin/Max properties ignored - they are not
// implemented in LoadNexusProcessed.");
// //loadNexusPro->setProperty("SpectrumMax",specMin);
// //loadNexusPro->setProperty("SpectrumMin",specMax);
//}
loadNexusPro->setPropertyValue("EntryNumber",
getPropertyValue("EntryNumber"));
// Now execute the Child Algorithm. Catch and log any error, but don't stop.
loadNexusPro->execute();
if (!loadNexusPro->isExecuted())
g_log.error(
"Unable to successfully run LoadNexusProcessed Child Algorithm");
setOutputWorkspace(loadNexusPro);
}
/// Run the LoadLog Child Algorithm
void LoadMuonNexus1::runLoadLog(DataObjects::Workspace2D_sptr localWorkspace) {
IAlgorithm_sptr loadLog = createChildAlgorithm("LoadMuonLog");
// Pass through the same input filename
loadLog->setPropertyValue("Filename", m_filename);
// Set the workspace property to be the same one filled above
loadLog->setProperty<MatrixWorkspace_sptr>("Workspace", localWorkspace);
// Now execute the Child Algorithm. Catch and log any error, but don't stop.
try {
loadLog->execute();
} catch (std::runtime_error &) {
g_log.error("Unable to successfully run LoadMuonLog Child Algorithm");
} catch (std::logic_error &) {
g_log.error("Unable to successfully run LoadMuonLog Child Algorithm");
}
if (!loadLog->isExecuted())
g_log.error("Unable to successfully run LoadMuonLog Child Algorithm");
NXRoot root(m_filename);
// Get main field direction
std::string mainFieldDirection = "Longitudinal"; // default
try {
NXChar orientation = root.openNXChar("run/instrument/detector/orientation");
// some files have no data there
orientation.load();
if (orientation[0] == 't') {
auto p =
Kernel::make_unique<Kernel::TimeSeriesProperty<double>>("fromNexus");
std::string start_time = root.getString("run/start_time");
p->addValue(start_time, -90.0);
localWorkspace->mutableRun().addLogData(std::move(p));
mainFieldDirection = "Transverse";
}
} catch (...) {
// no data - assume main field was longitudinal
}
// set output property and add to workspace logs
auto &run = localWorkspace->mutableRun();
setProperty("MainFieldDirection", mainFieldDirection);
run.addProperty("main_field_direction", mainFieldDirection);
ISISRunLogs runLogs(run);
runLogs.addStatusLog(run);
}
/**
Process a row
@param rowNo : The row in the model to process
@throws std::runtime_error if processing fails
*/
void ReflMainViewPresenter::processRow(size_t rowNo)
{
const std::string run = m_model->String(rowNo, COL_RUNS);
const std::string transStr = m_model->String(rowNo, COL_TRANSMISSION);
const std::string transWSName = makeTransWSName(transStr);
double theta = 0;
const bool thetaGiven = !m_model->String(rowNo, COL_ANGLE).empty();
if(thetaGiven)
Mantid::Kernel::Strings::convert<double>(m_model->String(rowNo, COL_ANGLE), theta);
Workspace_sptr runWS = fetchRun(run, m_view->getProcessInstrument());
//If the transmission workspace already exists, re-use it.
MatrixWorkspace_sptr transWS;
if(AnalysisDataService::Instance().doesExist(transWSName))
transWS = AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(transWSName);
else
transWS = makeTransWS(transStr);
IAlgorithm_sptr algReflOne = AlgorithmManager::Instance().create("ReflectometryReductionOneAuto");
algReflOne->initialize();
algReflOne->setChild(true);
algReflOne->setProperty("InputWorkspace", runWS);
algReflOne->setProperty("FirstTransmissionRun", transWS);
algReflOne->setProperty("OutputWorkspace", run + "_IvsQ");
algReflOne->setProperty("OutputWorkspaceWaveLength", run + "_IvsLam");
algReflOne->setProperty("ThetaIn", theta);
algReflOne->execute();
if(!algReflOne->isExecuted())
throw std::runtime_error("Failed to run ReflectometryReductionOneAuto.");
MatrixWorkspace_sptr runWSQ = algReflOne->getProperty("OutputWorkspace");
MatrixWorkspace_sptr runWSLam = algReflOne->getProperty("OutputWorkspaceWaveLength");
//Finally, place the resulting workspaces into the ADS.
AnalysisDataService::Instance().addOrReplace(run + "_TOF", runWS);
AnalysisDataService::Instance().addOrReplace(run + "_IvsQ", runWSQ);
AnalysisDataService::Instance().addOrReplace(run + "_IvsLam", runWSLam);
AnalysisDataService::Instance().addOrReplace(transWSName, transWS);
}
/// Run the LoadLog Child Algorithm
void LoadMuonNexus1::runLoadLog(DataObjects::Workspace2D_sptr localWorkspace) {
IAlgorithm_sptr loadLog = createChildAlgorithm("LoadMuonLog");
// Pass through the same input filename
loadLog->setPropertyValue("Filename", m_filename);
// Set the workspace property to be the same one filled above
loadLog->setProperty<MatrixWorkspace_sptr>("Workspace", localWorkspace);
// Now execute the Child Algorithm. Catch and log any error, but don't stop.
try {
loadLog->execute();
} catch (std::runtime_error &) {
g_log.error("Unable to successfully run LoadLog Child Algorithm");
} catch (std::logic_error &) {
g_log.error("Unable to successfully run LoadLog Child Algorithm");
}
if (!loadLog->isExecuted())
g_log.error("Unable to successfully run LoadLog Child Algorithm");
NXRoot root(m_filename);
try {
NXChar orientation = root.openNXChar("run/instrument/detector/orientation");
// some files have no data there
orientation.load();
if (orientation[0] == 't') {
Kernel::TimeSeriesProperty<double> *p =
new Kernel::TimeSeriesProperty<double>("fromNexus");
std::string start_time = root.getString("run/start_time");
p->addValue(start_time, -90.0);
localWorkspace->mutableRun().addLogData(p);
setProperty("MainFieldDirection", "Transverse");
} else {
setProperty("MainFieldDirection", "Longitudinal");
}
} catch (...) {
setProperty("MainFieldDirection", "Longitudinal");
}
auto &run = localWorkspace->mutableRun();
int n = static_cast<int>(m_numberOfPeriods);
ISISRunLogs runLogs(run, n);
runLogs.addStatusLog(run);
}
/// Run LoadInstrumentFromRaw as a Child Algorithm (only if loading from instrument definition file fails)
void LoadRaw::runLoadInstrumentFromRaw(DataObjects::Workspace2D_sptr localWorkspace)
{
IAlgorithm_sptr loadInst = createChildAlgorithm("LoadInstrumentFromRaw");
loadInst->setPropertyValue("Filename", m_filename);
// Set the workspace property to be the same one filled above
loadInst->setProperty<MatrixWorkspace_sptr>("Workspace",localWorkspace);
// Now execute the Child Algorithm. Catch and log any error, but don't stop.
try
{
loadInst->execute();
}
catch (std::runtime_error&)
{
g_log.error("Unable to successfully run LoadInstrumentFromRaw Child Algorithm");
}
if ( ! loadInst->isExecuted() ) g_log.error("No instrument definition loaded");
}
/// Run the LoadLog Child Algorithm
void LoadRaw::runLoadLog(DataObjects::Workspace2D_sptr localWorkspace)
{
IAlgorithm_sptr loadLog = createChildAlgorithm("LoadLog");
// Pass through the same input filename
loadLog->setPropertyValue("Filename",m_filename);
// Set the workspace property to be the same one filled above
loadLog->setProperty<MatrixWorkspace_sptr>("Workspace",localWorkspace);
// Now execute the Child Algorithm. Catch and log any error, but don't stop.
try
{
loadLog->execute();
}
catch (std::runtime_error&)
{
g_log.error("Unable to successfully run LoadLog Child Algorithm");
}
if ( ! loadLog->isExecuted() ) g_log.error("Unable to successfully run LoadLog Child Algorithm");
}
/**
* Add a matrix workspace to the accumulation workspace.
*
* @param algoName :: Name of algorithm which will be adding the workspaces.
* @param accumWS :: accumulation matrix workspace
* @param chunkWS :: processed live data chunk matrix workspace
*/
void LoadLiveData::addMatrixWSChunk(const std::string &algoName,
Workspace_sptr accumWS,
Workspace_sptr chunkWS) {
// Handle the addition of the internal monitor workspace, if present
auto accumMW = boost::dynamic_pointer_cast<MatrixWorkspace>(accumWS);
auto chunkMW = boost::dynamic_pointer_cast<MatrixWorkspace>(chunkWS);
if (accumMW && chunkMW) {
auto accumMon = accumMW->monitorWorkspace();
auto chunkMon = chunkMW->monitorWorkspace();
if (accumMon && chunkMon)
accumMon += chunkMon;
}
// Now do the main workspace
IAlgorithm_sptr alg = this->createChildAlgorithm(algoName);
alg->setProperty("LHSWorkspace", accumWS);
alg->setProperty("RHSWorkspace", chunkWS);
alg->setProperty("OutputWorkspace", accumWS);
alg->execute();
if (!alg->isExecuted()) {
throw std::runtime_error("Error when calling " + alg->name() +
" to add the chunk of live data. See log.");
} else {
// Get the output as the generic Workspace type
// This step is necessary for when we are operating on MD workspaces
// (PlusMD)
Property *prop = alg->getProperty("OutputWorkspace");
IWorkspaceProperty *wsProp = dynamic_cast<IWorkspaceProperty *>(prop);
if (!wsProp)
throw std::runtime_error(
"The " + alg->name() +
" Algorithm's OutputWorkspace property is not a WorkspaceProperty!");
Workspace_sptr temp = wsProp->getWorkspace();
accumWS = temp;
// And sort the events, if any
doSortEvents(accumWS);
}
}
/**
Create a transmission workspace
@param transString : the numbers of the transmission runs to use
*/
MatrixWorkspace_sptr ReflMainViewPresenter::makeTransWS(const std::string& transString)
{
const size_t maxTransWS = 2;
std::vector<std::string> transVec;
std::vector<Workspace_sptr> transWSVec;
//Take the first two run numbers
boost::split(transVec, transString, boost::is_any_of(","));
if(transVec.size() > maxTransWS)
transVec.resize(maxTransWS);
if(transVec.size() == 0)
throw std::runtime_error("Failed to parse the transmission run list.");
for(auto it = transVec.begin(); it != transVec.end(); ++it)
transWSVec.push_back(fetchRun(*it, m_view->getProcessInstrument()));
//We have the runs, so we can create a TransWS
IAlgorithm_sptr algCreateTrans = AlgorithmManager::Instance().create("CreateTransmissionWorkspaceAuto");
algCreateTrans->initialize();
algCreateTrans->setChild(true);
algCreateTrans->setProperty("FirstTransmissionRun", boost::dynamic_pointer_cast<MatrixWorkspace>(transWSVec[0]));
if(transWSVec.size() > 1)
algCreateTrans->setProperty("SecondTransmissionRun", boost::dynamic_pointer_cast<MatrixWorkspace>(transWSVec[1]));
algCreateTrans->setProperty("OutputWorkspace", makeTransWSName(transString));
if(!algCreateTrans->isInitialized())
throw std::runtime_error("Could not initialize CreateTransmissionWorkspaceAuto");
algCreateTrans->execute();
if(!algCreateTrans->isExecuted())
throw std::runtime_error("CreateTransmissionWorkspaceAuto failed to execute");
return algCreateTrans->getProperty("OutputWorkspace");
}
/** Accumulate the data by appending the spectra into the
* the output workspace.
* Calls AppendSpectra algorithm.
*
* @param accumWS :: accumulation matrix workspace
* @param chunkWS :: processed live data chunk matrix workspace
*/
Workspace_sptr LoadLiveData::appendMatrixWSChunk(Workspace_sptr accumWS,
Workspace_sptr chunkWS) {
IAlgorithm_sptr alg;
ReadLock _lock1(*accumWS);
ReadLock _lock2(*chunkWS);
alg = this->createChildAlgorithm("AppendSpectra");
alg->setProperty("InputWorkspace1", accumWS);
alg->setProperty("InputWorkspace2", chunkWS);
alg->setProperty("ValidateInputs", false);
alg->setProperty("MergeLogs", true);
alg->execute();
if (!alg->isExecuted()) {
throw std::runtime_error("Error when calling AppendSpectra to append the "
"spectra of the chunk of live data. See log.");
}
MatrixWorkspace_sptr temp = alg->getProperty("OutputWorkspace");
accumWS = temp;
// And sort the events, if any
doSortEvents(accumWS);
return accumWS;
}
/**
Fetches a run from disk or the AnalysisDataService
@param run : The name of the run
@param instrument : The instrument the run belongs to
@throws std::runtime_error if the run cannot be found
@returns a shared pointer to the workspace
*/
Workspace_sptr ReflMainViewPresenter::fetchRun(const std::string& run, const std::string& instrument = "")
{
const std::string wsName = run + "_TOF";
//First, let's see if the run given is the name of a workspace in the ADS
if(AnalysisDataService::Instance().doesExist(wsName))
return AnalysisDataService::Instance().retrieveWS<Workspace>(wsName);
const std::string filename = instrument + run;
//We'll just have to load it ourselves
IAlgorithm_sptr algLoadRun = AlgorithmManager::Instance().create("Load");
algLoadRun->initialize();
algLoadRun->setChild(true);
algLoadRun->setProperty("Filename", filename);
algLoadRun->setProperty("OutputWorkspace", wsName);
algLoadRun->execute();
if(!algLoadRun->isExecuted())
throw std::runtime_error("Could not open " + filename);
return algLoadRun->getProperty("OutputWorkspace");
}
int main( int argc, char** argv )
{
std::cout << "Start of ImageViewNxEventFile..." << std::endl;
if ( argc < 2 )
{
std::cout << "Please enter a NeXus event file name on the command line!"
<< std::endl;
return 0;
}
std::string file_name(argv[1]);
QApplication a( argc, argv );
Mantid::API::FrameworkManager::Instance();
IAlgorithm_sptr ld = AlgorithmManager::Instance().createUnmanaged("LoadEventNexus");
ld->initialize();
ld->setPropertyValue("Filename", file_name );
std::string outws_name = "EventWS";
ld->setPropertyValue("OutputWorkspace",outws_name);
ld->setPropertyValue("Precount", "0");
std::cout << "Loading file: " << file_name << std::endl;
ld->execute();
ld->isExecuted();
std::cout << "File Loaded, getting workspace. " << std::endl;
IEventWorkspace_sptr WS;
WS = AnalysisDataService::Instance().retrieveWS<IEventWorkspace>(outws_name);
std::cout << "Got EventWorkspace, making EventWSDataSource..." << std::endl;
MantidQt::ImageView::MatrixWSImageView image_view( WS );
return a.exec();
}
/**
* Determine the instrument from the various input parameters.
*
* @return The correct instrument.
*/
Instrument_const_sptr CreateChunkingFromInstrument::getInstrument() {
// try the input workspace
MatrixWorkspace_sptr inWS = getProperty(PARAM_IN_WKSP);
if (inWS) {
return inWS->getInstrument();
}
// temporary workspace to hang everything else off of
MatrixWorkspace_sptr tempWS(new Workspace2D());
// name of the instrument
string instName = getPropertyValue(PARAM_INST_NAME);
// see if there is an input file
string filename = getPropertyValue(PARAM_IN_FILE);
if (!filename.empty()) {
string top_entry_name("entry"); // TODO make more flexible
// get the instrument name from the filename
size_t n = filename.rfind('/');
if (n != std::string::npos) {
std::string temp = filename.substr(n + 1, filename.size() - n - 1);
n = temp.find('_');
if (n != std::string::npos && n > 0) {
instName = temp.substr(0, n);
}
}
// read information from the nexus file itself
try {
NeXus::File nxsfile(filename);
// get the run start time
string start_time;
nxsfile.openGroup(top_entry_name, "NXentry");
nxsfile.readData("start_time", start_time);
tempWS->mutableRun().addProperty(
"run_start", DateAndTime(start_time).toISO8601String(), true);
// get the instrument name
nxsfile.openGroup("instrument", "NXinstrument");
nxsfile.readData("name", instName);
nxsfile.closeGroup();
// Test if IDF exists in file, move on quickly if not
nxsfile.openPath("instrument/instrument_xml");
nxsfile.close();
IAlgorithm_sptr loadInst =
createChildAlgorithm("LoadIDFFromNexus", 0.0, 0.2);
// Now execute the Child Algorithm. Catch and log any error, but don't
// stop.
try {
loadInst->setPropertyValue("Filename", filename);
loadInst->setProperty<MatrixWorkspace_sptr>("Workspace", tempWS);
loadInst->setPropertyValue("InstrumentParentPath", top_entry_name);
loadInst->execute();
} catch (std::invalid_argument &) {
g_log.error("Invalid argument to LoadIDFFromNexus Child Algorithm ");
} catch (std::runtime_error &) {
g_log.debug("No instrument definition found in " + filename + " at " +
top_entry_name + "/instrument");
}
if (loadInst->isExecuted())
return tempWS->getInstrument();
else
g_log.information("No IDF loaded from Nexus file.");
} catch (::NeXus::Exception &) {
g_log.information("No instrument definition found in " + filename +
" at " + top_entry_name + "/instrument");
}
}
// run LoadInstrument if other methods have not run
string instFilename = getPropertyValue(PARAM_INST_FILE);
Algorithm_sptr childAlg = createChildAlgorithm("LoadInstrument", 0.0, 0.2);
childAlg->setProperty<MatrixWorkspace_sptr>("Workspace", tempWS);
childAlg->setPropertyValue("Filename", instFilename);
childAlg->setPropertyValue("InstrumentName", instName);
childAlg->executeAsChildAlg();
return tempWS->getInstrument();
}
/** Rebin and scale a workspace in Q.
*
* @param inputWS :: the workspace in Q
* @param theta :: the angle of this run
* @param params :: [output] rebin parameters
* @return :: the output workspace
*/
MatrixWorkspace_sptr
ReflectometryReductionOneAuto2::rebinAndScale(MatrixWorkspace_sptr inputWS,
const double theta,
std::vector<double> ¶ms) {
Property *qStepProp = getProperty("MomentumTransferStep");
double qstep;
if (!qStepProp->isDefault()) {
qstep = getProperty("MomentumTransferStep");
qstep = -qstep;
} else {
if (theta == 0.0) {
throw std::runtime_error(
"Theta determined from the detector positions is "
"0.0. Please provide a value for theta manually "
"or correct the detector position before running "
"this algorithm.");
}
IAlgorithm_sptr calcRes = createChildAlgorithm("NRCalculateSlitResolution");
calcRes->setProperty("Workspace", inputWS);
calcRes->setProperty("TwoTheta", 2 * theta);
calcRes->execute();
if (!calcRes->isExecuted()) {
g_log.error(
"NRCalculateSlitResolution failed. Workspace in Q will not be "
"rebinned. Please provide dQ/Q.");
return inputWS;
}
qstep = calcRes->getProperty("Resolution");
qstep = -qstep;
}
Property *qMin = getProperty("MomentumTransferMin");
Property *qMax = getProperty("MomentumTransferMax");
if (!qMin->isDefault() && !qMax->isDefault()) {
double qmin = getProperty("MomentumTransferMin");
double qmax = getProperty("MomentumTransferMax");
params.push_back(qmin);
params.push_back(qstep);
params.push_back(qmax);
} else {
params.push_back(qstep);
}
// Rebin
IAlgorithm_sptr algRebin = createChildAlgorithm("Rebin");
algRebin->initialize();
algRebin->setProperty("InputWorkspace", inputWS);
algRebin->setProperty("OutputWorkspace", inputWS);
algRebin->setProperty("Params", params);
algRebin->execute();
MatrixWorkspace_sptr IvsQ = algRebin->getProperty("OutputWorkspace");
// Scale (optional)
Property *scaleProp = getProperty("ScaleFactor");
if (!scaleProp->isDefault()) {
double scaleFactor = getProperty("ScaleFactor");
IAlgorithm_sptr algScale = createChildAlgorithm("Scale");
algScale->initialize();
algScale->setProperty("InputWorkspace", IvsQ);
algScale->setProperty("OutputWorkspace", IvsQ);
algScale->setProperty("Factor", 1.0 / scaleFactor);
algScale->execute();
IvsQ = algScale->getProperty("OutputWorkspace");
}
return IvsQ;
}
/**
Stitches the workspaces created by the given rows together.
@param rows : the list of rows
*/
void ReflMainViewPresenter::stitchRows(std::vector<size_t> rows)
{
//If we can get away with doing nothing, do.
if(rows.size() < 2)
return;
//Ensure the rows are in order.
std::sort(rows.begin(), rows.end());
//Properties for Stitch1DMany
std::vector<std::string> wsNames;
std::vector<std::string> runs;
std::vector<double> params;
std::vector<double> startOverlaps;
std::vector<double> endOverlaps;
//Go through each row and prepare the properties
for(auto rowIt = rows.begin(); rowIt != rows.end(); ++rowIt)
{
const std::string runStr = m_model->String(*rowIt, COL_RUNS);
const std::string qMinStr = m_model->String(*rowIt, COL_QMIN);
const std::string qMaxStr = m_model->String(*rowIt, COL_QMAX);
double qmin, qmax;
Mantid::Kernel::Strings::convert<double>(qMinStr, qmin);
Mantid::Kernel::Strings::convert<double>(qMaxStr, qmax);
runs.push_back(runStr);
wsNames.push_back(runStr + "_IvsQ");
startOverlaps.push_back(qmin);
endOverlaps.push_back(qmax);
}
double dqq;
std::string dqqStr = m_model->String(rows.front(), COL_DQQ);
Mantid::Kernel::Strings::convert<double>(dqqStr, dqq);
//params are qmin, -dqq, qmax for the final output
params.push_back(*std::min_element(startOverlaps.begin(), startOverlaps.end()));
params.push_back(-dqq);
params.push_back(*std::max_element(endOverlaps.begin(), endOverlaps.end()));
//startOverlaps and endOverlaps need to be slightly offset from each other
//See usage examples of Stitch1DMany to see why we discard first qmin and last qmax
startOverlaps.erase(startOverlaps.begin());
endOverlaps.pop_back();
std::string outputWSName = boost::algorithm::join(runs, "_") + "_IvsQ";
IAlgorithm_sptr algStitch = AlgorithmManager::Instance().create("Stitch1DMany");
algStitch->initialize();
algStitch->setChild(true);
algStitch->setProperty("InputWorkspaces", boost::algorithm::join(wsNames, ","));
algStitch->setProperty("OutputWorkspace", outputWSName);
algStitch->setProperty("Params", params);
algStitch->setProperty("StartOverlaps", startOverlaps);
algStitch->setProperty("EndOverlaps", endOverlaps);
algStitch->execute();
if(!algStitch->isExecuted())
throw std::runtime_error("Failed to run Stitch1DMany on IvsQ workspaces.");
Workspace_sptr stitchedWS = algStitch->getProperty("OutputWorkspace");
//Insert the final stitched row into the ADS
AnalysisDataService::Instance().addOrReplace(outputWSName, stitchedWS);
}
