/**
* Loads the information contained in non-Spectra (ie, Text or Numeric) axis in the Nexus
* file into the workspace.
* @param local_workspace :: pointer to workspace object
* @param data :: reference to the NeXuS data for the axis
*/
void LoadNexusProcessed::loadNonSpectraAxis(API::MatrixWorkspace_sptr local_workspace, NXData & data)
{
Mantid::API::Axis* axis = local_workspace->getAxis(1);
if ( axis->isNumeric() )
{
NXDouble axisData = data.openNXDouble("axis2");
axisData.load();
for ( int i = 0; i < static_cast<int>(axis->length()); i++ )
{
axis->setValue(i, axisData[i]);
}
}
else if ( axis->isText() )
{
// We must cast the axis object to TextAxis so we may use ->setLabel
Mantid::API::TextAxis* textAxis = dynamic_cast<Mantid::API::TextAxis*>(axis);
NXChar axisData = data.openNXChar("axis2");
axisData.load();
std::string axisLabels = axisData();
// Use boost::tokenizer to split up the input
boost::char_separator<char> sep("\n");
boost::tokenizer<boost::char_separator<char> > tokenizer(axisLabels, sep);
boost::tokenizer<boost::char_separator<char> >::iterator tokIter;
int i = 0;
for ( tokIter = tokenizer.begin(); tokIter != tokenizer.end(); ++tokIter )
{
textAxis->setLabel(i, *tokIter);
++i;
}
}
}
/// 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);
}
/// 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);
}
/**
* Load a table
*/
API::Workspace_sptr LoadNexusProcessed::loadTableEntry(NXEntry & entry)
{
API::ITableWorkspace_sptr workspace;
workspace = Mantid::API::WorkspaceFactory::Instance().createTable("TableWorkspace");
NXData nx_tw = entry.openNXData("table_workspace");
std::vector<double> values;
bool hasNumberOfRowBeenSet = false;
//int numberOfRows = 0;
int columnNumber = 1;
do
{
std::string str = "column_" + boost::lexical_cast<std::string>(columnNumber);
NXInfo info = nx_tw.getDataSetInfo(str.c_str());
if (info.stat == NX_ERROR)
{
break;
}
if ( info.type == NX_FLOAT64 )
{
NXDouble nxDouble = nx_tw.openNXDouble(str.c_str());
std::string columnTitle = nxDouble.attributes("name");
if (!columnTitle.empty())
{
workspace->addColumn("double", columnTitle);
nxDouble.load();
int length = nxDouble.dim0();
if ( !hasNumberOfRowBeenSet )
{
workspace->setRowCount(length);
hasNumberOfRowBeenSet = true;
}
for (int i = 0; i < length; i++)
workspace->cell<double>(i,columnNumber-1) = *(nxDouble() + i);
}
}
else if ( info.type == NX_CHAR )
{
NXChar data = nx_tw.openNXChar(str.c_str());
std::string columnTitle = data.attributes("name");
if (!columnTitle.empty())
{
workspace->addColumn("str", columnTitle);
int nRows = info.dims[0];
if ( !hasNumberOfRowBeenSet )
{
workspace->setRowCount(nRows);
hasNumberOfRowBeenSet = true;
}
int maxStr = info.dims[1];
std::string fromCrap(maxStr,' ');
data.load();
for (int iR = 0; iR < nRows; iR++)
{
for (int i = 0; i < maxStr; i++)
fromCrap[i] = *(data()+i+maxStr*iR);
workspace->cell<std::string>(iR,columnNumber-1) = fromCrap;
}
}
}
columnNumber++;
} while ( 1 );
return boost::static_pointer_cast<API::Workspace>(workspace);
}