/** * Load a single entry into a workspace * @param root :: The opened root node * @param entry_name :: The entry name * @param progressStart :: The percentage value to start the progress reporting for this entry * @param progressRange :: The percentage range that the progress reporting should cover * @returns A 2D workspace containing the loaded data */ API::Workspace_sptr LoadNexusProcessed::loadEntry(NXRoot & root, const std::string & entry_name, const double& progressStart, const double& progressRange) { progress(progressStart,"Opening entry " + entry_name + "..."); NXEntry mtd_entry = root.openEntry(entry_name); if (mtd_entry.containsGroup("table_workspace")) { return loadTableEntry(mtd_entry); } bool isEvent = false; std::string group_name = "workspace"; if (mtd_entry.containsGroup("event_workspace")) { isEvent = true; group_name = "event_workspace"; } // Get workspace characteristics NXData wksp_cls = mtd_entry.openNXData(group_name); // Axis information // "X" axis NXDouble xbins = wksp_cls.openNXDouble("axis1"); xbins.load(); std::string unit1 = xbins.attributes("units"); // Non-uniform x bins get saved as a 2D 'axis1' dataset int xlength(-1); if( xbins.rank() == 2 ) { xlength = xbins.dim1(); m_shared_bins = false; } else if( xbins.rank() == 1 ) { xlength = xbins.dim0(); m_shared_bins = true; xbins.load(); m_xbins.access().assign(xbins(), xbins() + xlength); } else { throw std::runtime_error("Unknown axis1 dimension encountered."); } // MatrixWorkspace axis 1 NXDouble axis2 = wksp_cls.openNXDouble("axis2"); std::string unit2 = axis2.attributes("units"); // The workspace being worked on API::MatrixWorkspace_sptr local_workspace; size_t nspectra; int64_t nchannels; // -------- Process as event ? -------------------- if (isEvent) { local_workspace = loadEventEntry(wksp_cls, xbins, progressStart, progressRange); nspectra = local_workspace->getNumberHistograms(); nchannels = local_workspace->blocksize(); } else { NXDataSetTyped<double> data = wksp_cls.openDoubleData(); nspectra = data.dim0(); nchannels = data.dim1(); //// validate the optional spectrum parameters, if set checkOptionalProperties(nspectra); // Actual number of spectra in output workspace (if only a range was going to be loaded) int total_specs=calculateWorkspacesize(nspectra); //// Create the 2D workspace for the output local_workspace = boost::dynamic_pointer_cast<API::MatrixWorkspace> (WorkspaceFactory::Instance().create("Workspace2D", total_specs, xlength, nchannels)); try { local_workspace->setTitle(mtd_entry.getString("title")); } catch (std::runtime_error&) { g_log.debug() << "No title was found in the input file, " << getPropertyValue("Filename") << std::endl; } // Set the YUnit label local_workspace->setYUnit(data.attributes("units")); std::string unitLabel = data.attributes("unit_label"); if (unitLabel.empty()) unitLabel = data.attributes("units"); local_workspace->setYUnitLabel(unitLabel); readBinMasking(wksp_cls, local_workspace); NXDataSetTyped<double> errors = wksp_cls.openNXDouble("errors"); int64_t blocksize(8); //const int fullblocks = nspectra / blocksize; //size of the workspace int64_t fullblocks = total_specs / blocksize; int64_t read_stop = (fullblocks * blocksize); const double progressBegin = progressStart+0.25*progressRange; const double progressScaler = 0.75*progressRange; int64_t hist_index = 0; int64_t wsIndex=0; if( m_shared_bins ) { //if spectrum min,max,list properties are set if(m_interval||m_list) { //if spectrum max,min properties are set read the data as a block(multiple of 8) and //then read the remaining data as finalblock if(m_interval) { //specs at the min-max interval int interval_specs=static_cast<int>(m_spec_max-m_spec_min); fullblocks=(interval_specs)/blocksize; read_stop = (fullblocks * blocksize)+m_spec_min-1; if(interval_specs<blocksize) { blocksize=total_specs; read_stop=m_spec_max-1; } hist_index=m_spec_min-1; for( ; hist_index < read_stop; ) { progress(progressBegin+progressScaler*static_cast<double>(hist_index)/static_cast<double>(read_stop),"Reading workspace data..."); loadBlock(data, errors, blocksize, nchannels, hist_index,wsIndex, local_workspace); } int64_t finalblock = m_spec_max-1 - read_stop; if( finalblock > 0 ) { loadBlock(data, errors, finalblock, nchannels, hist_index,wsIndex,local_workspace); } } // if spectrum list property is set read each spectrum separately by setting blocksize=1 if(m_list) { std::vector<int64_t>::iterator itr=m_spec_list.begin(); for(;itr!=m_spec_list.end();++itr) { int64_t specIndex=(*itr)-1; progress(progressBegin+progressScaler*static_cast<double>(specIndex)/static_cast<double>(m_spec_list.size()),"Reading workspace data..."); loadBlock(data, errors, static_cast<int64_t>(1), nchannels, specIndex,wsIndex, local_workspace); } } } else { for( ; hist_index < read_stop; ) { progress(progressBegin+progressScaler*static_cast<double>(hist_index)/static_cast<double>(read_stop),"Reading workspace data..."); loadBlock(data, errors, blocksize, nchannels, hist_index,wsIndex, local_workspace); } int64_t finalblock = total_specs - read_stop; if( finalblock > 0 ) { loadBlock(data, errors, finalblock, nchannels, hist_index,wsIndex,local_workspace); } } } else { if(m_interval||m_list) { if(m_interval) { int64_t interval_specs=m_spec_max-m_spec_min; fullblocks=(interval_specs)/blocksize; read_stop = (fullblocks * blocksize)+m_spec_min-1; if(interval_specs<blocksize) { blocksize=interval_specs; read_stop=m_spec_max-1; } hist_index=m_spec_min-1; for( ; hist_index < read_stop; ) { progress(progressBegin+progressScaler*static_cast<double>(hist_index)/static_cast<double>(read_stop),"Reading workspace data..."); loadBlock(data, errors, xbins, blocksize, nchannels, hist_index,wsIndex,local_workspace); } int64_t finalblock = m_spec_max-1 - read_stop; if( finalblock > 0 ) { loadBlock(data, errors, xbins, finalblock, nchannels, hist_index,wsIndex, local_workspace); } } // if(m_list) { std::vector<int64_t>::iterator itr=m_spec_list.begin(); for(;itr!=m_spec_list.end();++itr) { int64_t specIndex=(*itr)-1; progress(progressBegin+progressScaler*static_cast<double>(specIndex)/static_cast<double>(read_stop),"Reading workspace data..."); loadBlock(data, errors, xbins, 1, nchannels, specIndex,wsIndex,local_workspace); } } } else { for( ; hist_index < read_stop; ) { progress(progressBegin+progressScaler*static_cast<double>(hist_index)/static_cast<double>(read_stop),"Reading workspace data..."); loadBlock(data, errors, xbins, blocksize, nchannels, hist_index,wsIndex,local_workspace); } int64_t finalblock = total_specs - read_stop; if( finalblock > 0 ) { loadBlock(data, errors, xbins, finalblock, nchannels, hist_index,wsIndex, local_workspace); } } } } //end of NOT an event ------------------------------- //Units try { local_workspace->getAxis(0)->unit() = UnitFactory::Instance().create(unit1); //If this doesn't throw then it is a numeric access so grab the data so we can set it later axis2.load(); m_axis1vals = MantidVec(axis2(), axis2() + axis2.dim0()); } catch( std::runtime_error & ) { g_log.information() << "Axis 0 set to unitless quantity \"" << unit1 << "\"\n"; } // Setting a unit onto a SpectraAxis makes no sense. if ( unit2 == "TextAxis" ) { Mantid::API::TextAxis* newAxis = new Mantid::API::TextAxis(nspectra); local_workspace->replaceAxis(1, newAxis); } else if ( unit2 != "spectraNumber" ) { try { Mantid::API::NumericAxis* newAxis = new Mantid::API::NumericAxis(nspectra); local_workspace->replaceAxis(1, newAxis); newAxis->unit() = UnitFactory::Instance().create(unit2); } catch( std::runtime_error & ) { g_log.information() << "Axis 1 set to unitless quantity \"" << unit2 << "\"\n"; } } //Are we a distribution std::string dist = xbins.attributes("distribution"); if( dist == "1" ) { local_workspace->isDistribution(true); } else { local_workspace->isDistribution(false); } //Get information from all but data group std::string parameterStr; progress(progressStart+0.05*progressRange,"Reading the sample details..."); // Hop to the right point cppFile->openPath(mtd_entry.path()); try { // This loads logs, sample, and instrument. local_workspace->loadExperimentInfoNexus(cppFile, parameterStr); } catch (std::exception & e) { g_log.information("Error loading Instrument section of nxs file"); g_log.information(e.what()); } // Now assign the spectra-detector map readInstrumentGroup(mtd_entry, local_workspace); // Parameter map parsing progress(progressStart+0.11*progressRange,"Reading the parameter maps..."); local_workspace->readParameterMap(parameterStr); if ( ! local_workspace->getAxis(1)->isSpectra() ) { // If not a spectra axis, load the axis data into the workspace. (MW 25/11/10) loadNonSpectraAxis(local_workspace, wksp_cls); } progress(progressStart+0.15*progressRange,"Reading the workspace history..."); try { readAlgorithmHistory(mtd_entry, local_workspace); } catch (std::out_of_range&) { g_log.warning() << "Error in the workspaces algorithm list, its processing history is incomplete\n"; } progress(progressStart+0.2*progressRange,"Reading the workspace history..."); return boost::static_pointer_cast<API::Workspace>(local_workspace); }
/** 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 LoadRaw::exec() { // Retrieve the filename from the properties m_filename = getPropertyValue("Filename"); LoadRawHelper *helper = new LoadRawHelper; FILE* file = helper->openRawFile(m_filename); ISISRAW iraw; iraw.ioRAW(file, true); std::string title(iraw.r_title, 80); g_log.information("**** Run title: "+title+ "***"); // Read in the number of spectra in the RAW file m_numberOfSpectra = iraw.t_nsp1; // Read the number of periods in this file m_numberOfPeriods = iraw.t_nper; // Need to extract the user-defined output workspace name Property *ws = getProperty("OutputWorkspace"); std::string localWSName = ws->value(); // Call private method to validate the optional parameters, if set checkOptionalProperties(); // Read the number of time channels (i.e. bins) from the RAW file const int channelsPerSpectrum = iraw.t_ntc1; // Read in the time bin boundaries const int lengthIn = channelsPerSpectrum + 1; float* timeChannels = new float[lengthIn]; iraw.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)); // Create an array to hold the read-in data int* spectrum = new int[lengthIn]; // Calculate the size of a workspace, given its number of periods & spectra to read specid_t total_specs; if( m_interval || m_list) { total_specs = static_cast<specid_t>(m_spec_list.size()); if (m_interval) { total_specs += (m_spec_max-m_spec_min+1); m_spec_max += 1; } } 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; } double histTotal = static_cast<double>(total_specs * m_numberOfPeriods); int32_t histCurrent = -1; // 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->getAxis(0)->unit() = UnitFactory::Instance().create("TOF"); localWorkspace->setTitle(title); // Run parameters helper->loadRunParameters(localWorkspace, &iraw); 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)); specid_t counter = 0; for (specid_t i = m_spec_min; i < m_spec_max; ++i) { // Shift the histogram to read if we're not in the first period int32_t histToRead = i + period*total_specs; loadData(timeChannelsVec,counter,histToRead,iraw,lengthIn,spectrum,localWorkspace ); counter++; if (++histCurrent % 100 == 0) progress(static_cast<double>(histCurrent)/histTotal); interruption_point(); } // Read in the spectra in the optional list parameter, if set if (m_list) { for(size_t i=0; i < m_spec_list.size(); ++i) { loadData(timeChannelsVec,counter,m_spec_list[i],iraw,lengthIn,spectrum, localWorkspace ); counter++; if (++histCurrent % 100 == 0) progress(static_cast<double>(histCurrent)/histTotal); interruption_point(); } } // 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 = 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(iraw.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"; } if (localWorkspace) localWorkspace->updateSpectraUsingMap(); // Assign the result to the output workspace property setProperty(outputWorkspace,localWorkspace); } // loop over periods // Clean up delete[] timeChannels; delete[] spectrum; }
/** 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 LoadRawBin0::exec() { // Retrieve the filename from the properties m_filename = getPropertyValue("Filename"); bool bLoadlogFiles = getProperty("LoadLogFiles"); //open the raw file FILE* file=openRawFile(m_filename); // Need to check that the file is not a text file as the ISISRAW routines don't deal with these very well, i.e // reading continues until a bad_alloc is encountered. if( isAscii(file) ) { g_log.error() << "File \"" << m_filename << "\" is not a valid RAW file.\n"; throw std::invalid_argument("Incorrect file type encountered."); } std::string title; readTitle(file,title); readworkspaceParameters(m_numberOfSpectra,m_numberOfPeriods,m_lengthIn,m_noTimeRegimes); /// setOptionalProperties(); // to validate the optional parameters, if set checkOptionalProperties(); // Calculate the size of a workspace, given its number of periods & spectra to read m_total_specs = calculateWorkspaceSize(); //no real X values for bin 0,so initialize this to zero boost::shared_ptr<MantidVec> channelsVec(new MantidVec(1,0)); m_timeChannelsVec.push_back(channelsVec); double histTotal = static_cast<double>(m_total_specs * m_numberOfPeriods); int64_t histCurrent = -1; // Create the 2D workspace for the output xlength and ylength is one DataObjects::Workspace2D_sptr localWorkspace = createWorkspace(m_total_specs, 1,1,title); Run& run = localWorkspace->mutableRun(); if (bLoadlogFiles) { runLoadLog(m_filename,localWorkspace, 0.0, 0.0); const int period_number = 1; createPeriodLogs(period_number, localWorkspace); } // Set the total proton charge for this run setProtonCharge(run); WorkspaceGroup_sptr ws_grp = createGroupWorkspace(); setWorkspaceProperty("OutputWorkspace", title, ws_grp, localWorkspace,m_numberOfPeriods, false); // 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=createWorkspace(localWorkspace); if (bLoadlogFiles) { //remove previous period data std::stringstream prevPeriod; prevPeriod << "PERIOD " << (period); Run& runObj = localWorkspace->mutableRun(); runObj.removeLogData(prevPeriod.str()); runObj.removeLogData("current_period"); //add current period data const int period_number = period + 1; createPeriodLogs(period_number, localWorkspace); } } skipData(file, period * (m_numberOfSpectra + 1)); int64_t wsIndex = 0; for (specid_t i = 1; i <= m_numberOfSpectra; ++i) { int64_t 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())) { progress(m_prog, "Reading raw file data..."); //readData(file, histToRead); //read spectrum if (!readData(file, histToRead)) { throw std::runtime_error("Error reading raw file"); } int64_t binStart=0; setWorkspaceData(localWorkspace, m_timeChannelsVec, wsIndex, i, m_noTimeRegimes,1,binStart); ++wsIndex; if (m_numberOfPeriods == 1) { if (++histCurrent % 100 == 0) { m_prog = double(histCurrent) / histTotal; } interruption_point(); } } else { skipData(file, histToRead); } } if(m_numberOfPeriods>1) { setWorkspaceProperty(localWorkspace, ws_grp, period, false); // progress for workspace groups m_prog = static_cast<double>(period) / static_cast<double>(m_numberOfPeriods - 1); } } // loop over periods // Clean up isisRaw.reset(); fclose(file); }
/** * Executes the algorithm. * Saves the workspace specified by the user to the VTK XML format */ void SaveVTK::exec() { std::string filename = getProperty("Filename"); g_log.debug() << "Parameters: Filename='" << filename << "'" << std::endl; //add extension filename += ".vtu"; MatrixWorkspace_sptr inputWorkspace = getProperty("InputWorkspace"); if( !inputWorkspace ) { g_log.error("Failed to retrieve inputWorkspace."); throw Exception::NullPointerException("SaveVTK::exec()", "inputWorkspace"); } checkOptionalProperties(); //Open file for writing std::ofstream outVTP(filename.c_str()); if( !outVTP ) { g_log.error("Failed to open file: " + filename); throw Exception::FileError("Failed to open file ", filename); } // First write document level XML header outVTP << "<?xml version=\"1.0\"?>\n" "<VTKFile type=\"UnstructuredGrid\" version=\"0.1\" byte_order=\"LittleEndian\">\n" "<UnstructuredGrid>\n"; const std::string workspaceID = inputWorkspace->id(); if( workspaceID.find("Workspace2D") != std::string::npos ) { const Workspace2D_sptr localWorkspace = boost::dynamic_pointer_cast<Workspace2D>(inputWorkspace); // const size_t numberOfHist = localWorkspace->getNumberHistograms(); //Write out whole range bool xMin(m_Xmin > 0.0), xMax(m_Xmax > 0.0); Progress prog(this,0.0,1.0,97); if( !xMin && !xMax ) { for( int hNum = 2; hNum < 100; ++hNum ) { writeVTKPiece(outVTP, localWorkspace->dataX(hNum), localWorkspace->dataY(hNum), localWorkspace->dataE(hNum), hNum); prog.report(); } } else { for( int hNum = 2; hNum < 100; ++hNum ) { std::vector<double> xValue, yValue, errors; std::vector<double>::size_type nVals(localWorkspace->dataY(hNum).size()); for( int i = 0; i < (int)nVals; ++i ) { if( xMin && localWorkspace->dataX(hNum)[i] < m_Xmin ) continue; if( xMax && localWorkspace->dataX(hNum)[i+1] > m_Xmax) { xValue.push_back(localWorkspace->dataX(hNum)[i]); break; } xValue.push_back(localWorkspace->dataX(hNum)[i]); if( i == (int)nVals - 1 ) { xValue.push_back(localWorkspace->dataX(hNum)[i+1]); } yValue.push_back(localWorkspace->dataY(hNum)[i]); errors.push_back(localWorkspace->dataE(hNum)[i]); } //sanity check assert( (int)xValue.size() == (int)yValue.size() + 1 ); writeVTKPiece(outVTP, xValue, yValue, errors, hNum); prog.report(); } } } else { outVTP.close(); Poco::File(filename).remove(); throw Exception::NotImplementedError("SaveVTK only implemented for Workspace2D\n"); } // Final XML end block tags outVTP << "</UnstructuredGrid>\n</VTKFile>\n"; outVTP.close(); }
/** 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); }