LCIOFileReader.cpp

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation 
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
// Author     : M.Frank
//
//==========================================================================
 
#ifndef DD4HEP_DDG4_LCIOFILEREADER_H
#define DD4HEP_DDG4_LCIOFILEREADER_H
 
// Framework include files
#include "LCIOEventReader.h"
 
#include <DDG4/EventParameters.h>
 
#include <lcio.h>
 
using namespace lcio ;
 
// Forward declarations
namespace IO { class LCReader; }
 
namespace dd4hep  {
 
  namespace sim  {
 
    template <class T=EVENT::LCParameters> void EventParameters::ingestParameters(T const& source) {
      EVENT::StringVec intKeys;
      EVENT::StringVec floatKeys;
      EVENT::StringVec stringKeys;
      source.getIntKeys(intKeys);
      source.getFloatKeys(floatKeys);
      source.getStringKeys(stringKeys);
      for(auto const& key: intKeys) {
        EVENT::IntVec intVec;
        source.getIntVals(key,intVec);
        m_intValues[key] = std::move(intVec);
      }
      for(auto const& key: floatKeys) {
        EVENT::FloatVec floatVec;
        source.getFloatVals(key,floatVec);
        m_fltValues[key] = std::move(floatVec);
      }
      for(auto const& key: stringKeys) {
        EVENT::StringVec stringVec;
        source.getStringVals(key,stringVec);
        m_strValues[key] = std::move(stringVec);
      }
    }
 
 
    class LCIOFileReader : public LCIOEventReader  {
    protected:
      IO::LCReader* m_reader;
      std::string m_collectionName;
    public:
      LCIOFileReader(const std::string& nam);
      virtual ~LCIOFileReader();
 
      virtual EventReaderStatus readParticleCollection(int event_number, CollectionOwner& particles);
      virtual EventReaderStatus moveToEvent(int event_number);
      virtual EventReaderStatus skipEvent() { return EVENT_READER_OK; }
      virtual EventReaderStatus setParameters(std::map< std::string, std::string >& parameters); 
    };
  }
}
#endif // DD4HEP_DDG4_LCIOFILEREADER_H
 
#include <DD4hep/Printout.h>
#include <DDG4/Factories.h>
#include <UTIL/ILDConf.h>
 
using namespace dd4hep::sim;
 
// Factory entry
DECLARE_GEANT4_EVENT_READER_NS(dd4hep::sim,LCIOFileReader)
 
dd4hep::sim::LCIOFileReader::LCIOFileReader(const std::string& nam)
: LCIOEventReader(nam)
, m_collectionName(LCIO::MCPARTICLE)
{
  m_reader = ::lcio::LCFactory::getInstance()->createLCReader(LCReader::directAccess);
  printout(INFO,"LCIOFileReader","Created file reader. Try to open input %s",nam.c_str());
  m_reader->open(nam);
  m_directAccess = false;
}
 
dd4hep::sim::LCIOFileReader::~LCIOFileReader()    {
  dd4hep::detail::deletePtr(m_reader);
}
 
 
Geant4EventReader::EventReaderStatus
dd4hep::sim::LCIOFileReader::moveToEvent(int event_number) {
  // ::lcio::LCEvent* evt = m_reader->readEvent(/*runNumber*/ 0, event_number);
  // fg: direct access does not work if run number is different from 0 and/or event numbers are not stored consecutively
  if( m_currEvent == 0 && event_number != 0 ) {
    m_reader->skipNEvents( event_number ) ;
    printout(INFO,"LCIOFileReader::moveToEvent","Skipping the first %d events ", event_number );
    printout(INFO,"LCIOFileReader::moveToEvent","Event number before skipping: %d", m_currEvent );
    m_currEvent = event_number;
    printout(INFO,"LCIOFileReader::moveToEvent","Event number after skipping: %d", m_currEvent );
  }
  return EVENT_READER_OK;
}
 
Geant4EventReader::EventReaderStatus
dd4hep::sim::LCIOFileReader::readParticleCollection(int /*event_number*/, LCIOEventReader::CollectionOwner& particles)  {
 
  ::lcio::LCEvent* evt = m_reader->readNextEvent(); // simply read the events sequentially
  ++m_currEvent ;
 
  if ( evt ) {
    particles = LCIOEventReader::CollectionOwner(evt->getCollection(m_collectionName), [](EVENT::LCCollection*){});
    if ( particles ) {
      printout(INFO,"LCIOFileReader","read collection %s from event %d in run %d ", 
               m_collectionName.c_str(), evt->getEventNumber(), evt->getRunNumber());
      
      // Create input event parameters context
      try {
        // get EventParameters or create new if not existent yet
        Geant4Context* ctx = context();
        auto* parameters = ctx->event().extension<EventParameters>(false);
        if (!parameters) {
          parameters = new EventParameters();
          ctx->event().addExtension<EventParameters>(parameters);
        }
        parameters->setRunNumber(evt->getRunNumber());
        parameters->setEventNumber(evt->getEventNumber());
        parameters->ingestParameters(evt->parameters());
      }
      catch(std::exception &) 
      {
      }
      return EVENT_READER_OK;
    }
  }
  return EVENT_READER_EOF;
}
 
Geant4EventReader::EventReaderStatus
dd4hep::sim::LCIOFileReader::setParameters( std::map< std::string, std::string > & parameters ) {
  _getParameterValue( parameters, "MCParticleCollectionName", m_collectionName, std::string(LCIO::MCPARTICLE));
  return EVENT_READER_OK;
}