RawDataCnvSvc.cxx

Go to the documentation of this file.

#include "GaudiKernel/GenericAddress.h"
#include "GaudiKernel/IOpaqueAddress.h"
#include "GaudiKernel/IRegistry.h"
#include "GaudiKernel/SmartDataPtr.h"
 
#include "EventModel/EventModel.h"
#include "RawDataCnv/ClassID_temp.h"
#include <iostream>
 
#include "Converters/RawDataBaseCnv.h"
#include "Converters/RawDataCnv.hpp"
#include "Converters/RawDataDigiCnv.hpp"
#include "Converters/RawDataEmcDigiCnv.hpp"
#include "Converters/RawDataEmcMcHitCnv.hpp"
#include "Converters/RawDataEvtHeaderCnv.hpp"
#include "Converters/RawDataHltCnv.hpp"
#include "Converters/RawDataHltRawCnv.hpp"
#include "Converters/RawDataLumiDigiCnv.hpp"
#include "Converters/RawDataMcCnv.hpp"
#include "Converters/RawDataMcParticleCnv.hpp"
#include "Converters/RawDataMdcDigiCnv.hpp"
#include "Converters/RawDataMdcMcHitCnv.hpp"
#include "Converters/RawDataMucDigiCnv.hpp"
#include "Converters/RawDataMucMcHitCnv.hpp"
#include "Converters/RawDataTofDigiCnv.hpp"
#include "Converters/RawDataTofMcHitCnv.hpp"
#include "Converters/RawDataTrigCnv.hpp"
#include "Converters/RawDataTrigGTDCnv.hpp"
#include "Converters/RawDataZddEventCnv.hpp"
#include "RawDataCnvSvc.h"
 
DECLARE_COMPONENT( RawDataCnvSvc );
// DECLARE_COMPONENT_WITH_ID( RawDataCnvSvc, "PackedRawDataCnvSvc" );
 
RawDataCnvSvc::RawDataCnvSvc( const std::string& name, ISvcLocator* svc )
    : base_class( name, svc, PACKEDRAWEVENT_StorageType ) {
  declareProperty( "RawDataOutputSvc", m_ioSvcName );
  declareProperty( "Status", m_status = 0xFFFFFFFF ); // fucd
}
 
StatusCode RawDataCnvSvc::initialize() {
  StatusCode iret;
  StatusCode sc = ConversionSvc::initialize();
 
  if ( sc.isFailure() )
  {
    error() << "Unable to initialize ConversionSvc" << endmsg;
    return sc;
  }
 
  IDataProviderSvc* pIDP = 0;
  // Set event data service
  sc = service( "EventDataSvc", pIDP, true );
  if ( !sc.isSuccess() )
  {
    error() << "Unable to get EventDataSvc" << endmsg;
    return sc;
  }
 
  sc = setDataProvider( pIDP );
  if ( !sc.isSuccess() )
  {
    error() << "Unable to set DataProvider" << endmsg;
    return sc;
  }
 
  // Add converters to the service
  sc = addConverters();
  if ( !sc.isSuccess() )
  {
    error() << "Unable to add converters to the service" << endmsg;
    return sc;
  }
 
  // Now we have to configure the map of leaves
  // Which should contain the association of converters with
  // paths on the TDS
  for ( LeafMap::iterator k = m_leaves.begin(); k != m_leaves.end(); k++ )
  {
    std::string path = ( *k ).first;
    for ( LeafMap::iterator j = m_leaves.begin(); j != m_leaves.end(); j++ )
    {
      std::string pp = ( *j ).first.substr( 0, ( *j ).first.rfind( "/" ) );
      if ( path == pp && path != ( *j ).first ) { ( *k ).second->push_back( ( *j ).second ); }
    }
  }
 
  sc = service( m_ioSvcName, m_ioSvc );
  if ( sc != StatusCode::SUCCESS )
  {
    warning() << "Cant get RawDataOutputSvc " << endmsg;
    // return sc;
  }
 
  return StatusCode::SUCCESS;
}
 
/// Add converters to the service
StatusCode RawDataCnvSvc::addConverters() {
  MsgStream log( msgSvc(), name() );
  // log << MSG::INFO << name() << " PackedRawDataCnvSvc::addConverters" << endmsg;
  declareObject(
      IRawDataCnvSvc::Leaf( EventModel::EventH, RawDataCnv::classID(), "PASS", 0 ) );
  // log << MSG::INFO << "EventModel::EventH " << RawDataCnv::classID() << endmsg;
  declareObject( IRawDataCnvSvc::Leaf( EventModel::EventHeader, RawDataEvtHeaderCnv::classID(),
                                       "PASS", 0 ) );
  // log << MSG::INFO << "EventModel::EventHeader " << RawDataEvtHeaderCnv::classID() <<
  // endmsg;
  declareObject(
      IRawDataCnvSvc::Leaf( EventModel::MC::Event, RawDataMcCnv::classID(), "PASS", 0 ) );
  declareObject( IRawDataCnvSvc::Leaf( EventModel::MC::McParticleCol,
                                       RawDataMcParticleCnv::classID(), "PASS", 0 ) );
  declareObject( IRawDataCnvSvc::Leaf( EventModel::MC::MdcMcHitCol,
                                       RawDataMdcMcHitCnv::classID(), "PASS", 0 ) );
  declareObject( IRawDataCnvSvc::Leaf( EventModel::MC::TofMcHitCol,
                                       RawDataTofMcHitCnv::classID(), "PASS", 0 ) );
  declareObject( IRawDataCnvSvc::Leaf( EventModel::MC::EmcMcHitCol,
                                       RawDataEmcMcHitCnv::classID(), "PASS", 0 ) );
  declareObject( IRawDataCnvSvc::Leaf( EventModel::MC::MucMcHitCol,
                                       RawDataMucMcHitCnv::classID(), "PASS", 0 ) );
  declareObject(
      IRawDataCnvSvc::Leaf( EventModel::Digi::Event, RawDataDigiCnv::classID(), "PASS", 0 ) );
  declareObject( IRawDataCnvSvc::Leaf( EventModel::Digi::MdcDigiCol,
                                       RawDataMdcDigiCnv::classID(), "PASS", 0 ) );
  declareObject( IRawDataCnvSvc::Leaf( EventModel::Digi::TofDigiCol,
                                       RawDataTofDigiCnv::classID(), "PASS", 0 ) );
  declareObject( IRawDataCnvSvc::Leaf( EventModel::Digi::LumiDigiCol,
                                       RawDataLumiDigiCnv::classID(), "PASS", 0 ) );
  declareObject( IRawDataCnvSvc::Leaf( EventModel::Digi::EmcDigiCol,
                                       RawDataEmcDigiCnv::classID(), "PASS", 0 ) );
  declareObject( IRawDataCnvSvc::Leaf( EventModel::Digi::MucDigiCol,
                                       RawDataMucDigiCnv::classID(), "PASS", 0 ) );
  declareObject(
      IRawDataCnvSvc::Leaf( EventModel::Trig::Event, RawDataTrigCnv::classID(), "PASS", 0 ) );
  declareObject( IRawDataCnvSvc::Leaf( EventModel::Trig::TrigGTDCol,
                                       RawDataTrigGTDCnv::classID(), "PASS", 0 ) );
  declareObject(
      IRawDataCnvSvc::Leaf( EventModel::Hlt::Event, RawDataHltCnv::classID(), "PASS", 0 ) );
  declareObject( IRawDataCnvSvc::Leaf( EventModel::Hlt::HltRawCol, RawDataHltRawCnv::classID(),
                                       "PASS", 0 ) );
  declareObject( IRawDataCnvSvc::Leaf( EventModel::Zdd::ZddEvent,
                                       RawDataZddEventCnv::classID(), "PASS", 0 ) );
 
  return StatusCode::SUCCESS;
}
 
StatusCode RawDataCnvSvc::connectOutput( const std::string& /* t */ ) {
 
  MsgStream log( msgSvc(), name() );
 
  log << MSG::DEBUG << " In connectOutput " << endmsg;
 
  // Get DataObj from TDS
  SmartDataPtr<Event::EventHeader> evt( dataProvider(), EventModel::EventHeader );
  if ( !evt )
  {
    log << MSG::ERROR << "Did not retrieve event" << endmsg;
    return StatusCode::FAILURE;
  }
  unsigned int eventNo = evt->eventNumber();
  unsigned int runNo   = evt->runNumber();
 
  m_rawEvent = new WriteRawEvent( 0x790000, // source_id
                                  eventNo,  // global_id
                                  runNo,    // run_no
                                  eventNo,  // lel1_id
                                  0,        // lel1_type
                                  0,        // lel2_info
                                  ef_info   // ef_info
  );
  // const unsigned int status = 0;  // place holder for status
  if ( m_status != 0xFFFFFFFF ) m_rawEvent->status( 1, &m_status );
  else m_rawEvent->status( 0, NULL ); // fucd
 
  return StatusCode::SUCCESS;
}
 
StatusCode RawDataCnvSvc::commitOutput( const std::string& /* t*/, bool /*b*/ ) {
  MsgStream log( msgSvc(), name() );
 
  log << MSG::DEBUG << "In flushOutput" << endmsg;
 
  if ( !m_ioSvc )
  {
    log << MSG::ERROR << "RawDataCnvSvc not configure for output" << endmsg;
    return StatusCode::FAILURE;
  }
 
  log << MSG::DEBUG << "commitOutput: Size of Event (words) =" << m_rawEvent->size_word()
      << endmsg;
 
  if ( !m_ioSvc->putEvent( m_rawEvent ) )
  {
    log << MSG::ERROR << "commitOutput failed to send output" << endmsg;
    return StatusCode::FAILURE;
  }
 
  // delete ...
  const eformat::write::SubDetectorFragment* sd = m_rawEvent->first_child();
  while ( sd != 0 )
  {
    const eformat::write::ROSFragment* ros = sd->first_child();
    while ( ros != 0 )
    {
      const eformat::write::ROBFragment* rob = ros->first_child();
      while ( rob != 0 )
      {
        const eformat::write::ROBFragment* rob_tmp = rob;
        rob                                        = rob->next();
        delete rob_tmp;
      }
      const eformat::write::ROSFragment* ros_tmp = ros;
      ros                                        = ros->next();
      delete ros_tmp;
    }
    const eformat::write::SubDetectorFragment* sd_tmp = sd;
    sd                                                = sd->next();
    delete sd_tmp;
  }
  delete m_rawEvent;
 
  return StatusCode::SUCCESS;
}
 
IConverter* RawDataCnvSvc::createConverter( long typ, const CLID& wanted,
                                            const ICnvFactory* fac ) {
  if ( wanted == RawDataCnv::classID() ) return new RawDataCnv( Gaudi::svcLocator() );
  if ( wanted == RawDataDigiCnv::classID() ) return new RawDataDigiCnv( Gaudi::svcLocator() );
  if ( wanted == RawDataEmcDigiCnv::classID() )
    return new RawDataEmcDigiCnv( Gaudi::svcLocator() );
  if ( wanted == RawDataEmcMcHitCnv::classID() )
    return new RawDataEmcMcHitCnv( Gaudi::svcLocator() );
  if ( wanted == RawDataEvtHeaderCnv::classID() )
    return new RawDataEvtHeaderCnv( Gaudi::svcLocator() );
  if ( wanted == RawDataHltCnv::classID() ) return new RawDataHltCnv( Gaudi::svcLocator() );
  if ( wanted == RawDataHltRawCnv::classID() )
    return new RawDataHltRawCnv( Gaudi::svcLocator() );
  if ( wanted == RawDataLumiDigiCnv::classID() )
    return new RawDataLumiDigiCnv( Gaudi::svcLocator() );
  if ( wanted == RawDataMcCnv::classID() ) return new RawDataMcCnv( Gaudi::svcLocator() );
  if ( wanted == RawDataMcParticleCnv::classID() )
    return new RawDataMcParticleCnv( Gaudi::svcLocator() );
  if ( wanted == RawDataMdcDigiCnv::classID() )
    return new RawDataMdcDigiCnv( Gaudi::svcLocator() );
  if ( wanted == RawDataMdcMcHitCnv::classID() )
    return new RawDataMdcMcHitCnv( Gaudi::svcLocator() );
  if ( wanted == RawDataMucDigiCnv::classID() )
    return new RawDataMucDigiCnv( Gaudi::svcLocator() );
  if ( wanted == RawDataMucMcHitCnv::classID() )
    return new RawDataMucMcHitCnv( Gaudi::svcLocator() );
  if ( wanted == RawDataTofDigiCnv::classID() )
    return new RawDataTofDigiCnv( Gaudi::svcLocator() );
  if ( wanted == RawDataTofMcHitCnv::classID() )
    return new RawDataTofMcHitCnv( Gaudi::svcLocator() );
  if ( wanted == RawDataTrigCnv::classID() ) return new RawDataTrigCnv( Gaudi::svcLocator() );
  if ( wanted == RawDataTrigGTDCnv::classID() )
    return new RawDataTrigGTDCnv( Gaudi::svcLocator() );
  if ( wanted == RawDataZddEventCnv::classID() )
    return new RawDataZddEventCnv( Gaudi::svcLocator() );
  return ConversionSvc::createConverter( typ, wanted, fac );
}
 
StatusCode RawDataCnvSvc::finalize() {
  StatusCode status = ConversionSvc::finalize();
  for ( LeafMap::iterator k = m_leaves.begin(); k != m_leaves.end(); k++ )
  { delete ( *k ).second; }
  m_leaves.erase( m_leaves.begin(), m_leaves.end() );
  return status;
}
 
StatusCode RawDataCnvSvc::declareObject( const IRawDataCnvSvc::Leaf& leaf ) {
  // Purpose and Method:  Callback from each of the individual converters that allows
  //  association of TDS path and converter.
  Leaf*                              ll = new Leaf( leaf );
  std::pair<LeafMap::iterator, bool> p =
      m_leaves.insert( LeafMap::value_type( leaf.path, ll ) );
  if ( p.second ) { return StatusCode::SUCCESS; }
  delete ll;
  return StatusCode::FAILURE;
}
 
StatusCode RawDataCnvSvc::updateServiceState( IOpaqueAddress* pAddress ) {
 
  // not sure about the use of recid or bank...
  MsgStream  log( msgSvc(), name() );
  StatusCode status = Status::INVALID_ADDRESS;
  IRegistry* ent    = pAddress->registry();
 
  if ( 0 != ent )
  {
    SmartIF<IDataManagerSvc> iaddrReg( dataProvider() );
    //       if ( 0 != iaddrReg )   {
    status           = StatusCode::SUCCESS;
    std::string path = ent->identifier();
 
    LeafMap::iterator itm = m_leaves.find( path );
    if ( itm != m_leaves.end() )
    {
      IRawDataCnvSvc::Leaf* leaf = ( *itm ).second;
      if ( 0 != leaf )
      {
        // ipar[0] = leaf->userParameter;
        for ( Leaf::iterator il = leaf->begin(); il != leaf->end(); il++ )
        {
          IOpaqueAddress*   newAddr  = 0;
          unsigned long     ipars[2] = { 0, 0 };   //{(*il)->userParameter, new_rid};
          const std::string spars[2] = { "", "" }; //{par[0], (*il)->bank};
 
          StatusCode ir = createAddress( repSvcType(), ( *il )->clid, spars, ipars, newAddr );
          if ( ir.isSuccess() )
          {
            ir = iaddrReg->registerAddress( ( *il )->path, newAddr );
            if ( !ir.isSuccess() )
            {
              newAddr->release();
              status = ir;
            }
          }
        }
      }
    }
  }
  else { status = IInterface::Status::NO_INTERFACE; }
 
  return status;
}
 
StatusCode RawDataCnvSvc::createAddress( long storageType, const CLID& clid,
                                         const std::string*, const unsigned long*,
                                         IOpaqueAddress*& refpAddress ) {
  MsgStream log( msgSvc(), name() );
 
  if ( storageType != repSvcType() )
  {
    log << MSG::ERROR << "bad storage type" << storageType << endmsg;
    return StatusCode::FAILURE;
  }
 
  refpAddress = new GenericAddress( storageType, clid, "", "", 0 );
 
  return StatusCode::SUCCESS;
}
 
StatusCode RawDataCnvSvc::createAddress( long storageType, const CLID&        clid,
                                         const std::string&, IOpaqueAddress*& refpAddress ) {
  return createAddress( storageType, clid, nullptr, nullptr, refpAddress );
}