RecEmcShowerCnv.cxx

Go to the documentation of this file.

#ifndef RecEmcShowerCnv_CXX
#define RecEmcShowerCnv_CXX 1
 
#include "GaudiKernel/Bootstrap.h"
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/ObjectVector.h"
 
#include "TClonesArray.h"
 
#include "EventModel/EventModel.h"
 
#include "EmcRecEventModel/RecEmcEventModel.h"
#include "ReconEvent/ReconEvent.h"
 
#include "RootEventData/TRecEmcShower.h"
#include "RootEventData/TRecTrackEvent.h"
 
#include "RootCnvSvc/Rec/RecEmcShowerCnv.h"
#include "RootCnvSvc/Rec/RecTrackCnv.h"
#include "RootCnvSvc/RootAddress.h"
 
#include <vector>
 
using namespace std;
 
// Instantiation of a static factory class used by clients to create
// instances of this service
// static CnvFactory<RecEmcShowerCnv> s_factory;
// const ICnvFactory& RecEmcShowerCnvFactory = s_factory;
 
RecEmcShowerCnv::RecEmcShowerCnv( ISvcLocator* svc ) : RootEventBaseCnv( classID(), svc ) {
 
  RecEmcShower* aShower = new RecEmcShower();
  // cout<<"in RecEmcShowerCnv::constructor:: showid= "<<aShower->clID()<<endl;
  delete aShower;
 
  // Here we associate this converter with the /Event path on the TDS.
  MsgStream log( msgSvc(), "RecEmcShowerCnv" );
  // log << MSG::DEBUG << "Constructor called for " << objType() << endmsg;
  // m_rootTreename ="Rec";
  m_rootBranchname = "m_recEmcShowerCol";
  // declareObject(EventModel::Recon::RecEmcShowerCol, objType(), m_rootTreename,
  // m_rootBranchname);
  m_adresses.push_back( &m_recEmcShowerCol );
  m_recEmcShowerCol = 0;
}
 
StatusCode RecEmcShowerCnv::TObjectToDataObject( DataObject*& refpObject ) {
  // creation of TDS object from root object
 
  MsgStream log( msgSvc(), "RecEmcShowerCnv" );
  log << MSG::DEBUG << "RecEmcShowerCnv::TObjectToDataObject" << endmsg;
  // cout << "RecEmcShowerCnv::TObjectToDataObject" << endl;
  StatusCode sc = StatusCode::SUCCESS;
 
  IDataProviderSvc* eventSvc;
  Gaudi::svcLocator()->service( "EventDataSvc", eventSvc );
 
  SmartDataPtr<RecEmcHitCol> emcRecHitCol( eventSvc, EventModel::Recon::RecEmcHitCol );
  if ( !emcRecHitCol ) log << MSG::INFO << "can't retrieve RecEmcHitCol" << endmsg;
 
  SmartDataPtr<RecEmcClusterCol> emcRecClusterCol( eventSvc,
                                                   EventModel::Recon::RecEmcClusterCol );
  if ( !emcRecClusterCol ) log << MSG::INFO << "can't retrieve RecEmcClusterCol" << endmsg;
 
  // create the TDS location for the RecEmcShower Collection
  RecEmcShowerCol* emcShowerTdsCol = new RecEmcShowerCol;
  refpObject                       = emcShowerTdsCol;
 
  // now convert
  if ( !m_recEmcShowerCol ) return sc;
  TIter          emcShowerIter( m_recEmcShowerCol );
  TRecEmcShower* emcShowerRoot = 0;
  while ( ( emcShowerRoot = (TRecEmcShower*)emcShowerIter.Next() ) )
  {
    int    trackId      = emcShowerRoot->trackId();
    int    numHits      = emcShowerRoot->numHits();
    int    status       = emcShowerRoot->status();
    int    cellId       = emcShowerRoot->cellId();
    int    module       = emcShowerRoot->module();
    double x            = emcShowerRoot->x();
    double y            = emcShowerRoot->y();
    double z            = emcShowerRoot->z();
    double theta        = emcShowerRoot->theta();
    double dtheta       = emcShowerRoot->dtheta();
    double phi          = emcShowerRoot->phi();
    double dphi         = emcShowerRoot->dphi();
    double energy       = emcShowerRoot->energy();
    double dE           = emcShowerRoot->dE();
    double eSeed        = emcShowerRoot->eSeed();
    double e3x3         = emcShowerRoot->e3x3();
    double e5x5         = emcShowerRoot->e5x5();
    double eall         = emcShowerRoot->eAll();
    double elepton      = emcShowerRoot->eLepton();
    double time         = emcShowerRoot->time();
    double secondMoment = emcShowerRoot->secondMoment();
    double latMoment    = emcShowerRoot->latMoment();
    double a20Moment    = emcShowerRoot->a20Moment();
    double a42Moment    = emcShowerRoot->a42Moment();
 
    HepSymMatrix matrix( 3 );
    matrix[0][0] = emcShowerRoot->err( 0 );
    matrix[1][1] = emcShowerRoot->err( 1 );
    matrix[2][2] = emcShowerRoot->err( 2 );
    matrix[0][1] = emcShowerRoot->err( 3 );
    matrix[0][2] = emcShowerRoot->err( 4 );
    matrix[1][2] = emcShowerRoot->err( 5 );
 
    RecEmcID showerId( cellId );
    RecEmcID clusterId( emcShowerRoot->clusterId() );
 
    RecEmcIDVector          id3x3;
    vector<Int_t>           cellId3x3 = emcShowerRoot->cellId3x3();
    vector<Int_t>::iterator iCellId;
    // cout<<"id3x3"<<endl;
    for ( iCellId = cellId3x3.begin(); iCellId != cellId3x3.end(); iCellId++ )
    {
      RecEmcID id( *iCellId );
      // cout<<"id="<<id<<endl;
      id3x3.push_back( id );
    }
 
    RecEmcIDVector id5x5;
    vector<Int_t>  cellId5x5 = emcShowerRoot->cellId5x5();
    // cout<<"id5x5"<<endl;
    for ( iCellId = cellId5x5.begin(); iCellId != cellId5x5.end(); iCellId++ )
    {
      RecEmcID id( *iCellId );
      // cout<<"id="<<id<<endl;
      id5x5.push_back( id );
    }
 
    RecEmcShower* emcShowerTds                    = new RecEmcShower();
    m_common.m_rootRecEmcShowerMap[emcShowerRoot] = emcShowerTds;
 
    emcShowerTds->setTrackId( trackId );
    emcShowerTds->setNumHits( numHits );
    emcShowerTds->setStatus( status );
    emcShowerTds->setCellId( cellId );
    emcShowerTds->setModule( module );
 
    HepPoint3D pos( x, y, z );
    emcShowerTds->setPosition( pos );
    emcShowerTds->setEnergy( energy );
    emcShowerTds->setDE( dE );
    emcShowerTds->setDtheta( dtheta );
    emcShowerTds->setDphi( dphi );
    emcShowerTds->setESeed( eSeed );
    emcShowerTds->setE3x3( e3x3 );
    emcShowerTds->setE5x5( e5x5 );
    emcShowerTds->EAll( eall );
    emcShowerTds->ELepton( elepton );
    emcShowerTds->setTime( time );
    emcShowerTds->setSecondMoment( secondMoment );
    emcShowerTds->setLatMoment( latMoment );
    emcShowerTds->setA20Moment( a20Moment );
    emcShowerTds->setA42Moment( a42Moment );
    emcShowerTds->setErrorMatrix( matrix );
 
    emcShowerTds->ShowerId( showerId );
    emcShowerTds->ClusterId( clusterId );
    emcShowerTds->CellId3x3( id3x3 );
    emcShowerTds->CellId5x5( id5x5 );
 
    // put fraction map into shower
    if ( emcRecHitCol )
    {
      map<Int_t, Double_t>           cellIdMap = emcShowerRoot->cellIdMap();
      map<Int_t, Double_t>::iterator iCellIdMap;
      for ( iCellIdMap = cellIdMap.begin(); iCellIdMap != cellIdMap.end(); iCellIdMap++ )
      {
 
        RecEmcID id( iCellIdMap->first );
 
        RecEmcHitCol::iterator iHit;
        for ( iHit = emcRecHitCol->begin(); iHit != emcRecHitCol->end(); iHit++ )
        {
 
          RecEmcID idHit( ( *iHit )->getCellId() );
 
          if ( id == idHit )
          {
            RecEmcFraction frac( *( *iHit ) );
            frac.Fraction( iCellIdMap->second );
            emcShowerTds->Insert( frac );
            break;
          }
        } // RecEmcHitCol
      }   // CellIdMap
    }
 
    if ( emcRecClusterCol )
    {
      RecEmcClusterCol::iterator iCluster;
      for ( iCluster = emcRecClusterCol->begin(); iCluster != emcRecClusterCol->end();
            iCluster++ )
      {
        if ( clusterId == ( *iCluster )->getClusterId() )
        {
          emcShowerTds->Cluster( *iCluster );
          break;
          // emcRecClusterCol->InsertShower(*iCluster);
        }
      }
    }
 
    emcShowerTdsCol->push_back( emcShowerTds );
    //     delete emcShowerTds;
    // emcShowerTds = NULL;
  }
 
  // m_recEmcShowerCol->Delete();  // wensp add 2005/12/30
  delete m_recEmcShowerCol;
  m_recEmcShowerCol = 0;
 
  return StatusCode::SUCCESS;
}
 
StatusCode RecEmcShowerCnv::DataObjectToTObject( DataObject* obj, RootAddress* rootaddr ) {
  MsgStream log( msgSvc(), "RecEmcShowerCnv" );
  log << MSG::DEBUG << "RecEmcShowerCnv::DataObjectToTObject" << endmsg;
  // cout << "RecEmcShowerCnv::DataObjectToTObject" << endl;
  StatusCode sc = StatusCode::SUCCESS;
 
  RecEmcShowerCol* emcShowerColTds = dynamic_cast<RecEmcShowerCol*>( obj );
  if ( !emcShowerColTds )
  {
    log << MSG::ERROR << "Could not downcast to RecEmcShowerCol" << endmsg;
    return StatusCode::FAILURE;
  }
 
  DataObject* evt;
  m_eds->findObject( EventModel::Recon::Event, evt );
  if ( evt == NULL )
  {
    log << MSG::ERROR << "Could not get RecEvent in TDS " << endmsg;
    return StatusCode::FAILURE;
  }
  ReconEvent* devtTds = dynamic_cast<ReconEvent*>( evt );
  if ( !devtTds )
  { log << MSG::ERROR << "RecEmcShowerCnv:Could not downcast to TDS DstEvent" << endmsg; }
  IOpaqueAddress* addr;
 
  m_cnvSvc->getRecTrackCnv()->createRep( evt, addr );
  TRecTrackEvent* recEvt = m_cnvSvc->getRecTrackCnv()->getWriteObject();
 
  const TObjArray* m_emcShowerCol = recEvt->getEmcShowerCol();
  if ( !m_emcShowerCol ) return sc;
  recEvt->clearEmcShowerCol(); // necessary in case there is I/O at the same time since array
                               // is static
  RecEmcShowerCol::const_iterator emcShowerTds;
 
  for ( emcShowerTds = emcShowerColTds->begin(); emcShowerTds != emcShowerColTds->end();
        emcShowerTds++ )
  {
    Int_t    trackId      = ( *emcShowerTds )->trackId();
    Int_t    numHits      = ( *emcShowerTds )->numHits();
    Int_t    status       = ( *emcShowerTds )->status();
    Int_t    cellId       = ( *emcShowerTds )->getShowerId();
    Int_t    clusterId    = ( *emcShowerTds )->getClusterId();
    Int_t    module       = ( *emcShowerTds )->module();
    Double_t x            = ( *emcShowerTds )->x();
    Double_t y            = ( *emcShowerTds )->y();
    Double_t z            = ( *emcShowerTds )->z();
    Double_t theta        = ( *emcShowerTds )->theta();
    Double_t dtheta       = ( *emcShowerTds )->dtheta();
    Double_t phi          = ( *emcShowerTds )->phi();
    Double_t dphi         = ( *emcShowerTds )->dphi();
    Double_t energy       = ( *emcShowerTds )->energy();
    Double_t dE           = ( *emcShowerTds )->dE();
    Double_t eSeed        = ( *emcShowerTds )->eSeed();
    Double_t e3x3         = ( *emcShowerTds )->e3x3();
    Double_t e5x5         = ( *emcShowerTds )->e5x5();
    Double_t eall         = ( *emcShowerTds )->getEAll();
    Double_t elepton      = ( *emcShowerTds )->getELepton();
    Double_t time         = (Int_t)( *emcShowerTds )->time();
    Double_t secondMoment = ( *emcShowerTds )->secondMoment();
    Double_t latMoment    = ( *emcShowerTds )->latMoment();
    Double_t a20Moment    = ( *emcShowerTds )->a20Moment();
    Double_t a42Moment    = ( *emcShowerTds )->a42Moment();
 
    HepSymMatrix matrix = ( *emcShowerTds )->errorMatrix();
    // cout<<"matrix: \n"<<matrix<<endl;
    Double_t err[6];
    err[0] = matrix[0][0];
    err[1] = matrix[1][1];
    err[2] = matrix[2][2];
    err[3] = matrix[0][1];
    err[4] = matrix[0][2];
    err[5] = matrix[1][2];
 
    map<Int_t, Double_t>              cellIdMap;
    RecEmcFractionMap::const_iterator pFractionMap;
 
    for ( pFractionMap = ( *emcShowerTds )->Begin(); pFractionMap != ( *emcShowerTds )->End();
          pFractionMap++ )
    {
      Int_t    id   = pFractionMap->first;
      Double_t frac = pFractionMap->second.getFraction();
      cellIdMap[id] = frac;
    }
 
    vector<Int_t>     cellId3x3;
    RecEmcIDVector    id3x3 = ( *emcShowerTds )->getCellId3x3();
    ci_RecEmcIDVector ciCellId;
    for ( ciCellId = id3x3.begin(); ciCellId != id3x3.end(); ciCellId++ )
    {
      Int_t id = *ciCellId;
      cellId3x3.push_back( id );
    }
 
    vector<Int_t>  cellId5x5;
    RecEmcIDVector id5x5 = ( *emcShowerTds )->getCellId5x5();
    for ( ciCellId = id5x5.begin(); ciCellId != id5x5.end(); ciCellId++ )
    {
      Int_t id = *ciCellId;
      cellId5x5.push_back( id );
    }
 
    TRecEmcShower* emcShowerRoot = new TRecEmcShower();
    // m_common.m_recEmcShowerMap[(*emcShowerTds)] = emcShowerRoot;
 
    // emcShowerRoot->initialize(numHits ,status ,cellId ,module ,x ,dx,y ,dy,z ,dz,theta
    // ,dtheta ,phi,dphi ,energy ,dE,cosx ,cosy ,cosz);
    emcShowerRoot->setTrackId( trackId );
    emcShowerRoot->setNumHits( numHits );
    emcShowerRoot->setStatus( status );
    emcShowerRoot->setCellId( cellId );
    emcShowerRoot->setClusterId( clusterId );
    emcShowerRoot->setModule( module );
    emcShowerRoot->setX( x );
    emcShowerRoot->setY( y );
    emcShowerRoot->setZ( z );
    emcShowerRoot->setEnergy( energy );
    emcShowerRoot->setDE( dE );
    emcShowerRoot->setTheta( theta );
    emcShowerRoot->setDtheta( dtheta );
    emcShowerRoot->setPhi( phi );
    emcShowerRoot->setDphi( dphi );
    emcShowerRoot->setESeed( eSeed );
    emcShowerRoot->setE3x3( e3x3 );
    emcShowerRoot->setE5x5( e5x5 );
    emcShowerRoot->setEAll( eall );
    emcShowerRoot->setELepton( elepton );
    emcShowerRoot->setTime( time );
    emcShowerRoot->setSecondMoment( secondMoment );
    emcShowerRoot->setLatMoment( latMoment );
    emcShowerRoot->setA20Moment( a20Moment );
    emcShowerRoot->setA42Moment( a42Moment );
    emcShowerRoot->setErr( err );
    // emcShowerRoot->setVecHits(vecHits);
 
    emcShowerRoot->setCellIdMap( cellIdMap );
    emcShowerRoot->setCellId3x3( cellId3x3 );
    emcShowerRoot->setCellId5x5( cellId5x5 );
 
    recEvt->addEmcShower( emcShowerRoot );
  }
  return StatusCode::SUCCESS;
}
#endif