void
SaveNXTomo::writeIntensityValue(const DataObjects::Workspace2D_sptr workspace,
::NeXus::File &nxFile, int thisFileInd) {
// Add Intensity to control if present, use 1 if not
try {
nxFile.openPath("/entry1/tomo_entry/control");
} catch (...) {
throw std::runtime_error("Unable to create a valid NXTomo file");
}
std::vector<double> intensityValue;
intensityValue.push_back(1);
if (workspace->run().hasProperty("Intensity")) {
std::string tmpVal = workspace->run().getLogData("Intensity")->value();
try {
intensityValue[0] = boost::lexical_cast<double>(tmpVal);
} catch (...) {
}
// Invalid Cast is handled below
}
nxFile.openData("data");
nxFile.putSlab(intensityValue, thisFileInd, 1);
nxFile.closeData();
}
void
SaveNXTomo::writeImageKeyValue(const DataObjects::Workspace2D_sptr workspace,
::NeXus::File &nxFile, int thisFileInd) {
// Add ImageKey to instrument/image_key if present, use 0 if not
try {
nxFile.openPath("/entry1/tomo_entry/instrument/detector");
} catch (...) {
throw std::runtime_error("Unable to create a valid NXTomo file");
}
// Set the default key value for this WS
std::vector<double> keyValue;
keyValue.push_back(0);
if (workspace->run().hasProperty("ImageKey")) {
std::string tmpVal = workspace->run().getLogData("ImageKey")->value();
try {
keyValue[0] = boost::lexical_cast<double>(tmpVal);
} catch (...) {
}
// Invalid Cast is handled below
}
nxFile.openData("image_key");
nxFile.putSlab(keyValue, thisFileInd, 1);
nxFile.closeData();
nxFile.closeGroup();
}
/** Load logs from Nexus file. Logs are expected to be in
* /raw_data_1/runlog group of the file. Call to this method must be done
* within /raw_data_1 group.
* @param ws :: The workspace to load the logs to.
* @param period :: The period of this workspace
*/
void LoadISISNexus2::loadLogs(DataObjects::Workspace2D_sptr ws, int period)
{
IAlgorithm_sptr alg = createSubAlgorithm("LoadNexusLogs", 0.0, 0.5);
alg->setPropertyValue("Filename", this->getProperty("Filename"));
alg->setProperty<MatrixWorkspace_sptr>("Workspace", ws);
try
{
alg->executeAsSubAlg();
}
catch(std::runtime_error&)
{
g_log.warning() << "Unable to load run logs. There will be no log "
<< "data associated with this workspace\n";
return;
}
ws->populateInstrumentParameters();
// If we loaded an icp_event log then create the necessary period logs
if( ws->run().hasProperty("icp_event") )
{
Kernel::Property *log = ws->run().getProperty("icp_event");
LogParser parser(log);
ws->mutableRun().addProperty(parser.createPeriodLog(period));
ws->mutableRun().addProperty(parser.createAllPeriodsLog());
}
}
void SaveNXTomo::writeLogValues(const DataObjects::Workspace2D_sptr workspace,
::NeXus::File &nxFile, int thisFileInd) {
// Add Log information (minus special values - Rotation, ImageKey, Intensity)
// Unable to add multidimensional string data, storing strings as
// multidimensional data set of uint8 values
try {
nxFile.openPath("/entry1/log_info");
} catch (...) {
throw std::runtime_error("Unable to create a valid NXTomo file");
}
// Loop through all log values, create it if it doesn't exist. Then append
// value
std::vector<Property *> logVals = workspace->run().getLogData();
for (auto it = logVals.begin(); it != logVals.end(); ++it) {
auto prop = *it;
if (prop->name() != "ImageKey" && prop->name() != "Rotation" &&
prop->name() != "Intensity" && prop->name() != "Axis1" &&
prop->name() != "Axis2") {
try {
nxFile.openData(prop->name());
} catch (::NeXus::Exception &) {
// Create the data entry if it doesn't exist yet, and open.
std::vector<int64_t> infDim;
infDim.push_back(NX_UNLIMITED);
infDim.push_back(NX_UNLIMITED);
nxFile.makeData(prop->name(), ::NeXus::UINT8, infDim, true);
}
size_t strSize = prop->value().length();
char *val = new char[80]();
// If log value is from FITS file as it should be,
// it won't be greater than this. Otherwise Shorten it
if (strSize > 80)
strSize = 80;
strncpy(val, prop->value().c_str(), strSize);
std::vector<int64_t> start, size;
start.push_back(thisFileInd);
start.push_back(0);
size.push_back(1);
size.push_back(strSize);
// single item
nxFile.putSlab(val, start, size);
nxFile.closeData();
}
}
}
/** Load logs from Nexus file. Logs are expected to be in
* /raw_data_1/runlog group of the file. Call to this method must be done
* within /raw_data_1 group.
* @param ws :: The workspace to load the logs to.
* @param entry :: Nexus entry
*/
void LoadISISNexus2::loadLogs(DataObjects::Workspace2D_sptr ws, NXEntry & entry)
{
IAlgorithm_sptr alg = createChildAlgorithm("LoadNexusLogs", 0.0, 0.5);
alg->setPropertyValue("Filename", this->getProperty("Filename"));
alg->setProperty<MatrixWorkspace_sptr>("Workspace", ws);
try
{
alg->executeAsChildAlg();
}
catch(std::runtime_error&)
{
g_log.warning() << "Unable to load run logs. There will be no log "
<< "data associated with this workspace\n";
return;
}
// For ISIS Nexus only, fabricate an addtional log containing an array of proton charge information from the periods group.
try
{
NXClass protonChargeClass = entry.openNXGroup("periods");
NXFloat periodsCharge = protonChargeClass.openNXFloat("proton_charge");
periodsCharge.load();
size_t nperiods = periodsCharge.dim0();
std::vector<double> chargesVector(nperiods);
std::copy(periodsCharge(), periodsCharge() + nperiods, chargesVector.begin());
ArrayProperty<double>* protonLogData = new ArrayProperty<double>("proton_charge_by_period", chargesVector);
ws->mutableRun().addProperty(protonLogData);
}
catch(std::runtime_error&)
{
this->g_log.debug("Cannot read periods information from the nexus file. This group may be absent.");
}
// Populate the instrument parameters.
ws->populateInstrumentParameters();
// Make log creator object and add the run status log
m_logCreator.reset(new ISISRunLogs(ws->run(), m_numberOfPeriods));
m_logCreator->addStatusLog(ws->mutableRun());
}
/** Executes the algorithm. Reading in the file and creating and populating
* the output workspace
*
* @throw Exception::NotFoundError Error when saving the PoldiDeadWires Results data to Workspace
* @throw std::runtime_error Error when saving the PoldiDeadWires Results data to Workspace
*/
void PoldiAutoCorrelation5::exec()
{
g_log.information() << "_Poldi start conf -------------- " << std::endl;
/* From localWorkspace three things are used:
* - Count data from POLDI experiment
* - POLDI instrument definition
* - Some data from the "Log" (for example chopper-speed)
*/
DataObjects::Workspace2D_sptr localWorkspace = this->getProperty("InputWorkspace");
g_log.information() << "_Poldi ws loaded -------------- " << std::endl;
double wlen_min = this->getProperty("wlenmin");
double wlen_max = this->getProperty("wlenmax");
double chopperSpeed = 0.0;
try {
chopperSpeed = localWorkspace->run().getPropertyValueAsType<std::vector<double> >("chopperspeed").front();
} catch(std::invalid_argument&) {
throw(std::runtime_error("Chopper speed could not be extracted from Workspace '" + localWorkspace->name() + "'. Aborting."));
}
// Instrument definition
Instrument_const_sptr poldiInstrument = localWorkspace->getInstrument();
// Chopper configuration
PoldiChopperFactory chopperFactory;
boost::shared_ptr<PoldiAbstractChopper> chopper(chopperFactory.createChopper(std::string("default-chopper")));
chopper->loadConfiguration(poldiInstrument);
chopper->setRotationSpeed(chopperSpeed);
g_log.information() << "____________________________________________________ " << std::endl;
g_log.information() << "_Poldi chopper conf ------------------------------ " << std::endl;
g_log.information() << "_Poldi - Chopper speed: " << chopper->rotationSpeed() << " rpm" << std::endl;
g_log.information() << "_Poldi - Number of slits: " << chopper->slitPositions().size() << std::endl;
g_log.information() << "_Poldi - Cycle time: " << chopper->cycleTime() << " µs" << std::endl;
g_log.information() << "_Poldi - Zero offset: " << chopper->zeroOffset() << " µs" << std::endl;
g_log.information() << "_Poldi - Distance: " << chopper->distanceFromSample() << " mm" << std::endl;
if(g_log.is(Poco::Message::PRIO_DEBUG)) {
for(size_t i = 0; i < chopper->slitPositions().size(); ++i) {
g_log.information() << "_Poldi - Slits: " << i
<< ": Position = " << chopper->slitPositions()[i]
<< "\t Time = " << chopper->slitTimes()[i] << " µs" << std::endl;
}
}
// Detector configuration
PoldiDetectorFactory detectorFactory;
boost::shared_ptr<PoldiAbstractDetector> detector(detectorFactory.createDetector(std::string("helium3-detector")));
detector->loadConfiguration(poldiInstrument);
g_log.information() << "_Poldi detector conf ------------------------------ " << std::endl;
g_log.information() << "_Poldi - Element count: " << detector->elementCount() << std::endl;
g_log.information() << "_Poldi - Central element: " << detector->centralElement() << std::endl;
g_log.information() << "_Poldi - 2Theta(central): " << detector->twoTheta(199) / M_PI * 180.0 << "°" << std::endl;
g_log.information() << "_Poldi - Distance(central): " << detector->distanceFromSample(199) << " mm" << std::endl;
boost::shared_ptr<PoldiDeadWireDecorator> cleanDetector(new PoldiDeadWireDecorator(poldiInstrument, detector));
std::set<int> deadWires = cleanDetector->deadWires();
g_log.information() << "_Poldi - Number of dead wires: " << deadWires.size() << std::endl;
g_log.information() << "_Poldi - Wire indices: ";
for(std::set<int>::const_iterator dw = deadWires.begin(); dw != deadWires.end(); ++dw) {
g_log.information() << *dw << " ";
}
g_log.information() << std::endl;
// putting together POLDI instrument for calculations
m_core->setInstrument(cleanDetector, chopper);
m_core->setWavelengthRange(wlen_min, wlen_max);
try
{
Mantid::DataObjects::Workspace2D_sptr outputws = m_core->calculate(localWorkspace);
setProperty("OutputWorkspace",boost::dynamic_pointer_cast<Workspace>(outputws));
}
catch(Mantid::Kernel::Exception::NotFoundError& )
{
throw std::runtime_error("Error when saving the PoldiIPP Results data to Workspace : NotFoundError");
}
catch(std::runtime_error &)
{
throw std::runtime_error("Error when saving the PoldiIPP Results data to Workspace : runtime_error");
}
}