/** 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()); } }
/** 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::FileError If the RAW file cannot be found/opened * @throw std::invalid_argument If the optional properties are set to invalid values */ void LoadRaw2::exec() { // Retrieve the filename from the properties m_filename = getPropertyValue("Filename"); LoadRawHelper *helper = new LoadRawHelper; FILE* file = helper->openRawFile(m_filename); isisRaw->ioRAW(file, true); std::string title(isisRaw->r_title, 80); g_log.information("**** Run title: "+ title + "***"); // Read in the number of spectra in the RAW file m_numberOfSpectra = isisRaw->t_nsp1; // Read the number of periods in this file m_numberOfPeriods = isisRaw->t_nper; // Read the number of time channels (i.e. bins) from the RAW file const int channelsPerSpectrum = isisRaw->t_ntc1; // Read in the time bin boundaries const int lengthIn = channelsPerSpectrum + 1; // Call private method to validate the optional parameters, if set checkOptionalProperties(); // Calculate the size of a workspace, given its number of periods & spectra to read specid_t total_specs; if( m_interval || m_list) { if (m_interval) { total_specs = (m_spec_max-m_spec_min+1); m_spec_max += 1; } else total_specs = 0; if (m_list) { if (m_interval) { for(std::vector<specid_t>::iterator it=m_spec_list.begin();it!=m_spec_list.end();) if (*it >= m_spec_min && *it <m_spec_max) { it = m_spec_list.erase(it); } else ++it; } if (m_spec_list.size() == 0) m_list = false; total_specs += static_cast<specid_t>(m_spec_list.size()); } } else { total_specs = m_numberOfSpectra; // In this case want all the spectra, but zeroth spectrum is garbage so go from 1 to NSP1 m_spec_min = 1; m_spec_max = m_numberOfSpectra + 1; } // If there is not enough memory use ManagedRawFileWorkspace2D. if ( ConfigService::Instance().getString("ManagedRawFileWorkspace.DoNotUse") != "1" && m_numberOfPeriods == 1 && MemoryManager::Instance().goForManagedWorkspace(total_specs,lengthIn,channelsPerSpectrum) && total_specs == m_numberOfSpectra) { const std::string cache_option = getPropertyValue("Cache"); size_t option = find(m_cache_options.begin(),m_cache_options.end(),cache_option) - m_cache_options.begin(); DataObjects::Workspace2D_sptr localWorkspace = DataObjects::Workspace2D_sptr( new ManagedRawFileWorkspace2D(m_filename, static_cast<int>(option))); progress(0.,"Reading raw file..."); helper->loadRunParameters(localWorkspace, isisRaw.get()); runLoadInstrument(localWorkspace ); runLoadMappingTable(localWorkspace ); runLoadLog(localWorkspace ); const int period_number = 1; Property* log=createPeriodLog(period_number); if(log) { localWorkspace->mutableRun().addLogData(log); localWorkspace->mutableRun().addLogData(createCurrentPeriodLog(period_number)); } localWorkspace->mutableRun().setProtonCharge(isisRaw->rpb.r_gd_prtn_chrg); for (int i = 0; i < m_numberOfSpectra; ++i) localWorkspace->getAxis(1)->setValue(i, i+1); localWorkspace->populateInstrumentParameters(); setProperty("OutputWorkspace",localWorkspace); return; } float* timeChannels = new float[lengthIn]; isisRaw->getTimeChannels(timeChannels, lengthIn); // Put the read in array into a vector (inside a shared pointer) boost::shared_ptr<MantidVec> timeChannelsVec (new MantidVec(timeChannels, timeChannels + lengthIn)); // Need to extract the user-defined output workspace name Property *ws = getProperty("OutputWorkspace"); std::string localWSName = ws->value(); Progress pr(this,0.,1.,total_specs * m_numberOfPeriods); // Create the 2D workspace for the output DataObjects::Workspace2D_sptr localWorkspace = boost::dynamic_pointer_cast<DataObjects::Workspace2D> (WorkspaceFactory::Instance().create("Workspace2D",total_specs,lengthIn,lengthIn-1)); localWorkspace->setTitle(title); localWorkspace->getAxis(0)->unit() = UnitFactory::Instance().create("TOF"); // Run parameters helper->loadRunParameters(localWorkspace, isisRaw.get()); delete helper; helper = NULL; // Loop over the number of periods in the raw file, putting each period in a separate workspace for (int period = 0; period < m_numberOfPeriods; ++period) { if ( period > 0 ) { localWorkspace = boost::dynamic_pointer_cast<DataObjects::Workspace2D> (WorkspaceFactory::Instance().create(localWorkspace)); } isisRaw->skipData(file,period*(m_numberOfSpectra+1)); int counter = 0; for (int i = 1; i <= m_numberOfSpectra; ++i) { int histToRead = i + period*(m_numberOfSpectra+1); if ((i >= m_spec_min && i < m_spec_max) || (m_list && find(m_spec_list.begin(),m_spec_list.end(),i) != m_spec_list.end())) { isisRaw->readData(file,histToRead); // Copy the data into the workspace vector, discarding the 1st entry, which is rubbish // But note that the last (overflow) bin is kept MantidVec& Y = localWorkspace->dataY(counter); Y.assign(isisRaw->dat1 + 1, isisRaw->dat1 + lengthIn); // Fill the vector for the errors, containing sqrt(count) MantidVec& E = localWorkspace->dataE(counter); std::transform(Y.begin(), Y.end(), E.begin(), dblSqrt); // Set the X vector pointer and spectrum number localWorkspace->setX(counter, timeChannelsVec); localWorkspace->getAxis(1)->setValue(counter, i); // NOTE: Raw numbers go straight into the workspace // - no account taken of bin widths/units etc. ++counter; pr.report(); } else { isisRaw->skipData(file,histToRead); } } // Just a sanity check assert(counter == total_specs); std::string outputWorkspace = "OutputWorkspace"; if (period == 0) { // Only run the Child Algorithms once runLoadInstrument(localWorkspace ); runLoadMappingTable(localWorkspace ); runLoadLog(localWorkspace ); const int period_number = period + 1; Property* log=createPeriodLog(period_number); if(log) { localWorkspace->mutableRun().addLogData(log); localWorkspace->mutableRun().addLogData(createCurrentPeriodLog(period_number)); } // Set the total proton charge for this run // (not sure how this works for multi_period files) localWorkspace->mutableRun().setProtonCharge(isisRaw->rpb.r_gd_prtn_chrg); } else // We are working on a higher period of a multiperiod raw file { // Create a WorkspaceProperty for the new workspace of a higher period // The workspace name given in the OutputWorkspace property has _periodNumber appended to it // (for all but the first period, which has no suffix) std::stringstream suffix; suffix << (period+1); outputWorkspace += suffix.str(); std::string WSName = localWSName + "_" + suffix.str(); declareProperty(new WorkspaceProperty<DataObjects::Workspace2D>(outputWorkspace,WSName,Direction::Output)); g_log.information() << "Workspace " << WSName << " created. \n"; //remove previous period data std::stringstream index; index << (period); std::string prevPeriod="PERIOD "+index.str(); localWorkspace->mutableRun().removeLogData(prevPeriod); localWorkspace->mutableRun().removeLogData("current_period"); //add current period data const int period_number = period + 1; Property* log=createPeriodLog(period_number); if(log) { localWorkspace->mutableRun().addLogData(log); localWorkspace->mutableRun().addLogData(createCurrentPeriodLog(period_number)); } } // check if values stored in logfiles should be used to define parameters of the instrument localWorkspace->populateInstrumentParameters(); // Assign the result to the output workspace property setProperty(outputWorkspace,localWorkspace); } // loop over periods // Clean up delete[] timeChannels; //delete[] spectrum; fclose(file); }