bool seekBlockFor(int64_t offset, std::string &error) {
bool matchingBlock =
(position >= 0
&& offset >= (int64_t)iter.block.uncompressed_file_offset
&& offset < (int64_t)(iter.block.uncompressed_file_offset + iter.block.uncompressed_size));
if (matchingBlock && position <= offset) {
/* we already are in the needed block, and still before the requested data; just continue from here */
LOG_VERBOSE("continue reading for offset %i (current position: %i)\n", (int) offset, (int) position);
} else {
if (matchingBlock) {
/* already passed the index we wanted, but same block */
LOG_VERBOSE("restarting block: %i (current position: %i)\n", (int) offset, (int) position);
} else {
LOG_VERBOSE("searching for offset: %i (current position: %i)\n", (int) offset, (int) position);
position = -1;
if (lzma_index_iter_locate(&iter, offset)) {
error.assign("couldn't find offset in index");
return false;
}
// LOG_VERBOSE("seeking to new block\n");
}
discard_output();
/* restart decoder */
if (!loadBlock(error)) return false;
}
return true;
}
inline void PBFParser::ParseData() {
while (true) {
_ThreadData *threadData;
threadDataQueue->wait_and_pop(threadData);
if( NULL==threadData ) {
SimpleLogger().Write() << "Parse Data Thread Finished";
threadDataQueue->push(NULL); // Signal end of data for other threads
break;
}
loadBlock(threadData);
for(int i = 0, groupSize = threadData->PBFprimitiveBlock.primitivegroup_size(); i < groupSize; ++i) {
threadData->currentGroupID = i;
loadGroup(threadData);
if(threadData->entityTypeIndicator == TypeNode) {
parseNode(threadData);
}
if(threadData->entityTypeIndicator == TypeWay) {
parseWay(threadData);
}
if(threadData->entityTypeIndicator == TypeRelation) {
parseRelation(threadData);
}
if(threadData->entityTypeIndicator == TypeDenseNode) {
parseDenseNode(threadData);
}
}
delete threadData;
threadData = NULL;
}
}
bool decodeFillBuffer(std::string &error) {
for (;0 != strm.avail_out;) {
LOG_VERBOSE("decodeFillBuffer: %i bytes to go\n", (int) strm.avail_out);
if (!fill_input_buffer(error)) return false;
if (0 == strm.avail_in) {
error.assign("Unexpected end of file");
return false;
}
lzma_ret ret = lzma_code(&strm, LZMA_RUN);
if (LZMA_OK != ret && LZMA_STREAM_END != ret) {
errnoLzmaToStr("failed decoding data", ret, error);
return false;
}
if (0 == strm.avail_out) return true; // done filling buffer
if (LZMA_STREAM_END == ret) {
if (lzma_index_iter_next(&iter, LZMA_INDEX_ITER_ANY)) {
error.assign("Unexepected end of file");
return false;
}
/* restart decoder */
if (!loadBlock(error)) return false;
}
}
return true;
}
bool decode(std::string &error) {
assert(0 != strm.avail_out);
const unsigned char *pos = strm.next_out;
for (;;) {
if (!fill_input_buffer(error)) return false;
if (0 == strm.avail_in) {
error.assign("Unexpected end of file");
return false;
}
lzma_ret ret = lzma_code(&strm, LZMA_RUN);
if (LZMA_OK != ret && LZMA_STREAM_END != ret) {
errnoLzmaToStr("failed decoding data", ret, error);
return false;
}
if (LZMA_STREAM_END == ret && pos == strm.next_out) {
/* end of stream AND we didn't get new data this round */
if (lzma_index_iter_next(&iter, LZMA_INDEX_ITER_ANY)) {
error.assign("Unexepected end of file");
return false;
}
/* restart decoder */
if (!loadBlock(error)) return false;
} else {
return true;
}
}
}
/* En base a un blockNumber, me lo carga en memoria y me deuvelve el putnerp*/
static char *
getBlock( int blockNumber ){
BLOCK block = kmalloc(7*512);
if (block == NULL ) {
printf("Fallo el malloc de getBlock\n");
return 0;
}
loadBlock(block, blockNumber);
return block;
}
void ThreadedDyscoColumn<DataType>::putValues(casacore::uInt rowNr, const casacore::Array<DataType>* dataPtr)
{
if(!areOffsetsInitialized())
{
// If the manager did not initialize its offsets yet, then it is determined
// from the first "time block" (a block with the same time, field and spw) that
// is written into the measurement set.
//
// This only happens when a new measurement
// set was created; if an existing measurement set is opened with at least one block,
// then the offsets will be read from the headers.
//
// A consequence of this is that the first blocks in a new measurement set are required to
// be written consecutively.
double time = (*_timeCol)(rowNr);
int fieldId = (*_fieldCol)(rowNr);
int dataDescId = (*_dataDescIdCol)(rowNr);
if(_timeBlockBuffer->Empty())
{
// This is the first row written
_currentBlock = 0;
_lastWrittenTime = time;
_lastWrittenField = fieldId;
_lastWrittenDataDescId = dataDescId;
}
else if(time != _lastWrittenTime || fieldId != _lastWrittenField || dataDescId != _lastWrittenDataDescId)
{
initializeRowsPerBlock(rowNr, _timeBlockBuffer->MaxAntennaIndex() + 1);
}
}
const int ant1 = (*_ant1Col)(rowNr), ant2 = (*_ant2Col)(rowNr);
if(areOffsetsInitialized())
{
const size_t
blockIndex = getBlockIndex(rowNr),
blockRow = getRowWithinBlock(rowNr);
// Is this the first row of a new block?
if(blockIndex != _currentBlock)
{
if(_isCurrentBlockChanged)
storeBlock();
// Load new block
loadBlock(blockIndex);
}
_timeBlockBuffer->SetData(blockRow, ant1, ant2, dataPtr->data());
}
else {
_timeBlockBuffer->SetData(rowNr, ant1, ant2, dataPtr->data());
}
_isCurrentBlockChanged = true;
}
Message *HistoryFileIterator::operator --()
{
if (m_msg){
delete m_msg;
m_msg = NULL;
}
if (msgs.empty())
loadBlock(false);
if (!msgs.empty()){
m_msg = msgs.back();
msgs.pop_back();
return m_msg;
}
return NULL;
}
Message *HistoryFileIterator::operator ++()
{
if (m_msg){
delete m_msg;
m_msg = NULL;
}
if (msgs.empty())
loadBlock(true);
if (!msgs.empty()){
m_msg = msgs.front();
msgs.pop_front();
return m_msg;
}
return NULL;
}
Byte * CachedBlockStore::getBlock(BlockId_t blockId)
{
BlockMapIterator iter = blockMap.find(blockId);
if (iter == blockMap.end()) {
return loadBlock(blockId);
}
else {
BlockInfo * blockInfo = iter->second;
// Put the block at the head of the list
blockList.remove(blockInfo);
blockList.push_front(blockInfo);
return blockInfo->blockPtr;
}
}
MutableBlockReference StorageManager::getBlockInternal(
const block_id block,
const CatalogRelationSchema &relation,
const int numa_node) {
MutableBlockReference ret;
{
SpinSharedMutexSharedLock<false> eviction_lock(*lock_manager_.get(block));
SpinSharedMutexSharedLock<false> read_lock(blocks_shared_mutex_);
std::unordered_map<block_id, BlockHandle>::iterator it = blocks_.find(block);
if (it != blocks_.end()) {
DEBUG_ASSERT(!it->second.block->isBlob());
ret = MutableBlockReference(static_cast<StorageBlock*>(it->second.block), eviction_policy_.get());
}
}
// To be safe, release the block's shard after 'eviction_lock' destructs.
lock_manager_.release(block);
if (ret.valid()) {
return ret;
}
// Note that there is no way for the block to be evicted between the call to
// loadBlock and the call to EvictionPolicy::blockReferenced from
// MutableBlockReference's constructor; this is because EvictionPolicy
// doesn't know about the block until blockReferenced is called, so
// chooseBlockToEvict shouldn't return the block.
do {
SpinSharedMutexExclusiveLock<false> io_lock(*lock_manager_.get(block));
{
// Check one more time if the block got loaded in memory by someone else.
SpinSharedMutexSharedLock<false> read_lock(blocks_shared_mutex_);
std::unordered_map<block_id, BlockHandle>::iterator it = blocks_.find(block);
if (it != blocks_.end()) {
DEBUG_ASSERT(!it->second.block->isBlob());
ret = MutableBlockReference(static_cast<StorageBlock*>(it->second.block), eviction_policy_.get());
break;
}
}
// No other thread loaded the block before us.
ret = MutableBlockReference(loadBlock(block, relation, numa_node), eviction_policy_.get());
} while (false);
// To be safe, release the block's shard after 'io_lock' destructs.
lock_manager_.release(block);
return ret;
}
inline void PBFParser::ParseData()
{
tbb::task_scheduler_init init(num_parser_threads);
while (true)
{
ParserThreadData *thread_data;
thread_data_queue->wait_and_pop(thread_data);
if (nullptr == thread_data)
{
thread_data_queue->push(nullptr); // Signal end of data for other threads
break;
}
loadBlock(thread_data);
int group_size = thread_data->PBFprimitiveBlock.primitivegroup_size();
for (int i = 0; i < group_size; ++i)
{
thread_data->currentGroupID = i;
loadGroup(thread_data);
if (thread_data->entityTypeIndicator == TypeNode)
{
parseNode(thread_data);
}
if (thread_data->entityTypeIndicator == TypeWay)
{
parseWay(thread_data);
}
if (thread_data->entityTypeIndicator == TypeRelation)
{
parseRelation(thread_data);
}
if (thread_data->entityTypeIndicator == TypeDenseNode)
{
parseDenseNode(thread_data);
}
}
delete thread_data;
thread_data = nullptr;
}
}
bool PagedWorkUnitDataSource::getRowData(__int64 row, size32_t & length, const void * & data, unsigned __int64 & offset)
{
if ((row < 0) || ((unsigned __int64)row > totalRows))
return false;
RowLocation location;
loop
{
if (cache.getCacheRow(row, location))
{
length = location.matchLength;
data = location.matchRow;
return true;
}
if (!loadBlock(location.bestRow, location.bestOffset))
return false;
}
}
void ThreadedDyscoColumn<DataType>::getValues(casacore::uInt rowNr, casacore::Array<DataType>* dataPtr)
{
if(!areOffsetsInitialized())
{
// Trying to read before first block was written -- return zero
// TODO if a few rows were written of the first block, those are
// incorrectly returned. This is a rare case but can be fixed.
for(typename casacore::Array<DataType>::contiter i=dataPtr->cbegin(); i!=dataPtr->cend(); ++i)
*i = DataType();
}
else {
size_t blockIndex = getBlockIndex(rowNr);
if(blockIndex >= nBlocksInFile())
{
// Trying to read a row that was not stored yet -- return zero
for(typename casacore::Array<DataType>::contiter i=dataPtr->cbegin(); i!=dataPtr->cend(); ++i)
*i = DataType();
}
else {
mutex::scoped_lock lock(_mutex);
// Wait until the block to be read is not in the write cache
typename cache_t::const_iterator cacheItemPtr = _cache.find(blockIndex);
while(cacheItemPtr != _cache.end())
{
_cacheChangedCondition.wait(lock);
cacheItemPtr = _cache.find(blockIndex);
}
lock.unlock();
if(_currentBlock != blockIndex)
{
if(_isCurrentBlockChanged)
storeBlock();
loadBlock(blockIndex);
}
// The time block encoder is now initialized and contains the unpacked block.
_timeBlockBuffer->GetData(getRowWithinBlock(rowNr), dataPtr->data());
}
}
}
void loadBitmap(void)
{
int bytesFileSize = getBitmapreg()->bytesFileSize;
// bitmap com n blocos de tamanho
bitmap = (uint8_t*) malloc(bytesFileSize);
char * buffer = (char*) malloc(BLOCK_SIZE);
buffer = loadBlock(getBitmapreg()->dataPtr[0]);
// buffer = loadBlock(2);
// Copia os 128 (bytesFileSize) primeiros bytes do bloco
memcpy(bitmap,buffer,bytesFileSize);
// 1111 1111 0000 0111
// Blocos
// 7 6 5 4 3 2 1 0 | 15 14 13 12 11 10 9 8
free(buffer);
}
// Not yet used.. Need to be completed, will replace code that is used in TinyXml
void xmldata::loadSet(IrrlichtDevice * device)
{
// File to seek is: dynamic_objects.xml
// Will provide the path and "sets" to load
// --> Loader code
// read configuration from xml file
device = device;
const u32 starttime = device->getTimer()->getRealTime();
io::IXMLReaderUTF8* xml = device->getFileSystem()->createXMLReaderUTF8("Media/dynamic_objects.xml");
core::stringc MessageText = "";
core::stringc set = "";
core::stringc id = "";
core::stringc str = "";
core::stringw result = L"";
bool inside = false;
// Language counter (using the XML hierachy)
u32 count = 0;
u32 linecount = 0;
while(xml && xml->read())
{
switch(xml->getNodeType())
{
case io::EXN_TEXT:
break;
case io::EXN_ELEMENT:
{
// Look for a specified node
if (core::stringw("dynamic_object") == xml->getNodeName())
{
if (!inside)
{
printf ("Inside the requested block!\n");
inside=true;
}
/*
set = xml->getAttributeValue("set");
list->addItem(winconvert((core::stringc)"Current set: " + set).c_str());
list->setItemOverrideColor(list->getItemCount()-1,video::SColor(255,0,0,255));
linecount++;
stats->addItem(winconvert((core::stringc)"Set #" + (core::stringc)linecount + ", model list: ").c_str());
stats->setItemOverrideColor(stats->getItemCount()-1,video::SColor(255,0,0,255)); */
// Load the block of data
loadBlock (device, set);
}
}
break;
case io::EXN_ELEMENT_END:
if (inside)
count++;
inside = false;
printf("The element has ended\n\n");
break;
default:
break;
}
}
/*core::stringw countstr = ((core::stringw)L"Object set count: ")+(core::stringw)(linecount);
stats->addItem(countstr.c_str());
const u32 endtime = device->getTimer()->getRealTime();
u32 time = endtime-starttime;
stats->addItem(((core::stringw)L"Parse time used: "+(core::stringw)time+L" ms.").c_str());*/
if (xml)
xml->drop(); // don't forget to delete the xml reader
// <-- Loader code
}
/**
* Load a given period into the workspace
* @param period :: The period number to load (starting from 1)
* @param entry :: The opened root entry node for accessing the monitor and data
* nodes
* @param local_workspace :: The workspace to place the data in
* @param update_spectra2det_mapping :: reset spectra-detector map to the one
* calculated earlier. (Warning! -- this map has to be calculated correctly!)
*/
void
LoadISISNexus2::loadPeriodData(int64_t period, NXEntry &entry,
DataObjects::Workspace2D_sptr &local_workspace,
bool update_spectra2det_mapping) {
int64_t hist_index = 0;
int64_t period_index(period - 1);
// int64_t first_monitor_spectrum = 0;
for (auto block = m_spectraBlocks.begin(); block != m_spectraBlocks.end();
++block) {
if (block->isMonitor) {
NXData monitor = entry.openNXData(block->monName);
NXInt mondata = monitor.openIntData();
m_progress->report("Loading monitor");
mondata.load(1, static_cast<int>(period - 1)); // TODO this is just wrong
MantidVec &Y = local_workspace->dataY(hist_index);
Y.assign(mondata(), mondata() + m_monBlockInfo.numberOfChannels);
MantidVec &E = local_workspace->dataE(hist_index);
std::transform(Y.begin(), Y.end(), E.begin(), dblSqrt);
if (update_spectra2det_mapping) {
// local_workspace->getAxis(1)->setValue(hist_index,
// static_cast<specid_t>(it->first));
auto spec = local_workspace->getSpectrum(hist_index);
specid_t specID = m_specInd2specNum_map.at(hist_index);
spec->setDetectorIDs(
m_spec2det_map.getDetectorIDsForSpectrumNo(specID));
spec->setSpectrumNo(specID);
}
NXFloat timeBins = monitor.openNXFloat("time_of_flight");
timeBins.load();
local_workspace->dataX(hist_index)
.assign(timeBins(), timeBins() + timeBins.dim0());
hist_index++;
} else if (m_have_detector) {
NXData nxdata = entry.openNXData("detector_1");
NXDataSetTyped<int> data = nxdata.openIntData();
data.open();
// Start with the list members that are lower than the required spectrum
const int *const spec_begin = m_spec.get();
// When reading in blocks we need to be careful that the range is exactly
// divisible by the block-size
// and if not have an extra read of the left overs
const int64_t blocksize = 8;
const int64_t rangesize = block->last - block->first + 1;
const int64_t fullblocks = rangesize / blocksize;
int64_t spectra_no = block->first;
// For this to work correctly, we assume that the spectrum list increases
// monotonically
int64_t filestart =
std::lower_bound(spec_begin, m_spec_end, spectra_no) - spec_begin;
if (fullblocks > 0) {
for (int64_t i = 0; i < fullblocks; ++i) {
loadBlock(data, blocksize, period_index, filestart, hist_index,
spectra_no, local_workspace);
filestart += blocksize;
}
}
int64_t finalblock = rangesize - (fullblocks * blocksize);
if (finalblock > 0) {
loadBlock(data, finalblock, period_index, filestart, hist_index,
spectra_no, local_workspace);
}
}
}
try {
const std::string title = entry.getString("title");
local_workspace->setTitle(title);
// write the title into the log file (run object)
local_workspace->mutableRun().addProperty("run_title", title, true);
} catch (std::runtime_error &) {
g_log.debug() << "No title was found in the input file, "
<< getPropertyValue("Filename") << std::endl;
}
}
/**
* 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);
}
int XMIResource::processElement(xmlTextReaderPtr reader)
{
const xmlChar *name = xmlTextReaderConstLocalName(reader);
parent = NB_XCOS_NAMES;
// lookup for known node names
// thanks to the string intern-ing, the pointer comparison could be used
auto found = std::find(constXcosNames.begin(), constXcosNames.end(), name);
enum xcosNames current = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), found));
switch (current)
{
case e_Diagram:
{
// the root diagram should be decoded
model::BaseObject o(root, DIAGRAM);
processed.push_back(o);
return loadDiagram(reader, o);
}
case e_child:
{
// this is a child of a diagram, resolve the type and call the loaders
// iterate on attributes to lookup for EMF type
// iterate on attributes
for (int rc = xmlTextReaderMoveToFirstAttribute(reader); rc > 0; rc = xmlTextReaderMoveToNextAttribute(reader))
{
const xmlChar* nsURI = xmlTextReaderConstNamespaceUri(reader);
if (nsURI != xsiNamespaceUri)
{
continue;
}
auto foundName = std::find(constXcosNames.begin(), constXcosNames.end(), xmlTextReaderConstLocalName(reader));
enum xcosNames currentName = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), foundName));
if (currentName != e_type)
{
continue;
}
const xmlChar* value = xmlTextReaderConstValue(reader);
const xmlChar* valueWithoutPrefix = BAD_CAST(std::strchr((const char*) value, ':'));
if (valueWithoutPrefix == nullptr)
{
valueWithoutPrefix = value;
}
else
{
// remove the leading ':'
valueWithoutPrefix = valueWithoutPrefix + 1;
}
const xmlChar* interned = xmlTextReaderConstString(reader, valueWithoutPrefix);
auto found = std::find(constXcosNames.begin(), constXcosNames.end(), interned);
enum xcosNames current = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), found));
switch (current)
{
case e_Block:
{
ScicosID o = controller.createObject(BLOCK);
// assign the child
model::BaseObject parent = processed.back();
std::vector<ScicosID> children;
controller.getObjectProperty(parent.id(), parent.kind(), CHILDREN, children);
children.push_back(o);
controller.setObjectProperty(parent.id(), parent.kind(), CHILDREN, children);
model::BaseObject child(o, BLOCK);
processed.push_back(child);
return loadBlock(reader, child);
}
case e_Link:
{
ScicosID o = controller.createObject(LINK);
// assign the child
model::BaseObject parent = processed.back();
std::vector<ScicosID> children;
controller.getObjectProperty(parent.id(), parent.kind(), CHILDREN, children);
children.push_back(o);
controller.setObjectProperty(parent.id(), parent.kind(), CHILDREN, children);
model::BaseObject child(o, LINK);
processed.push_back(child);
return loadLink(reader, child);
}
case e_Annotation:
{
ScicosID o = controller.createObject(ANNOTATION);
// assign the child
model::BaseObject parent = processed.back();
std::vector<ScicosID> children;
controller.getObjectProperty(parent.id(), parent.kind(), CHILDREN, children);
children.push_back(o);
controller.setObjectProperty(parent.id(), parent.kind(), CHILDREN, children);
model::BaseObject child(o, ANNOTATION);
return loadAnnotation(reader, child);
}
default:
sciprint("Not handled child type=%s at line %d\n", *found,
xmlTextReaderGetParserLineNumber(reader) - 1);
return -1;
}
}
break;
}
case e_in: // no break on purpose
case e_out: // no break on purpose
case e_ein: // no break on purpose
case e_eout:
{
ScicosID o = controller.createObject(PORT);
enum object_properties_t p;
switch (current)
{
case e_in:
p = INPUTS;
break;
case e_out:
p = OUTPUTS;
break;
case e_ein:
p = EVENT_INPUTS;
break;
case e_eout:
p = EVENT_OUTPUTS;
break;
default:
return -1;
}
model::BaseObject parent = processed.back();
// add the port them to the parent
std::vector<ScicosID> ports;
controller.getObjectProperty(parent.id(), parent.kind(), p, ports);
ports.push_back(o);
controller.setObjectProperty(parent.id(), parent.kind(), p, ports);
// decode content
model::BaseObject child(o, PORT);
return loadPort(reader, child);
}
case e_geometry:
// geometry is used for rectangle coordinates of its parent
return loadGeometry(reader, processed.back());
case e_nzcross:
// nzcross is a Block property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
case e_nmode:
// nmode is a Block property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
case e_rpar:
// rpar is a Block property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
case e_ipar:
// ipar is a Block property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
case e_opar:
// ipar is a Block property
return loadBase64(reader, OPAR, processed.back());
case e_state:
// state is a Block property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
case e_dstate:
// dstate is a Block property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
case e_odstate:
// odstate is a Block property
return loadBase64(reader, ODSTATE, processed.back());
case e_equations:
// equation is a Block property
return loadBase64(reader, EQUATIONS, processed.back());
case e_expression:
// expression is a Block property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
case e_exprs:
// exprs is a Block property
return loadBase64(reader, EXPRS, processed.back());
case e_controlPoint:
// controlPoint is a link property
return loadPoint(reader, processed.back());
case e_context:
// context is a Layer property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
case e_properties:
// properties is a Diagram property
return loadSimulationConfig(reader, processed.back());
case e_datatype:
// datatype is a Port property
if (!xmlTextReaderIsEmptyElement(reader))
{
parent = current;
}
return 1;
default:
sciprint("Unknown \"%s\" element name at line %d\n", name, xmlTextReaderGetParserLineNumber(reader) - 1);
return -1;
}
return 1;
}
