MucTrackCnv.cxx

Go to the documentation of this file.

#ifndef MucTrackCnv_CXX
#define MucTrackCnv_CXX 1
 
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/ObjectVector.h"
 
#include "TClonesArray.h"
 
#include "EventModel/EventModel.h"
 
#include "DstEvent/DstEvent.h"    //TDS object
#include "DstEvent/DstMucTrack.h" //TDS object
#include "RootEventData/TDstEvent.h"
#include "RootEventData/TMucTrack.h" // standard root object
 
#include "RootCnvSvc/Dst/DstCnv.h"
#include "RootCnvSvc/Dst/MucTrackCnv.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<MucTrackCnv> s_factory;
// const ICnvFactory& MucTrackCnvFactory = s_factory;
 
MucTrackCnv::MucTrackCnv( ISvcLocator* svc ) : RootEventBaseCnv( classID(), svc ) {
  // Here we associate this converter with the /Event path on the TDS.
  MsgStream log( msgSvc(), "MucTrackCnv" );
  // log << MSG::DEBUG << "Constructor called for " << objType() << endmsg;
  m_rootBranchname = "m_mucTrackCol";
  // declareObject(EventModel::Dst::DstMucTrackCol, objType(), m_rootTreename,
  // m_rootBranchname);
  m_adresses.push_back( &m_mucTrackCol );
  m_mucTrackCol = 0;
}
 
StatusCode MucTrackCnv::TObjectToDataObject( DataObject*& refpObject ) {
  // creation of TDS object from root object
 
  MsgStream log( msgSvc(), "MucTrackCnv" );
  log << MSG::DEBUG << "MucTrackCnv::TObjectToDataObject" << endmsg;
  StatusCode sc = StatusCode::SUCCESS;
 
  // create the TDS location for the MucTrack Collection
  DstMucTrackCol* mucTrackTdsCol = new DstMucTrackCol;
  refpObject                     = mucTrackTdsCol;
 
  // now convert
  if ( !m_mucTrackCol ) return sc;
  TIter      mucTrackIter( m_mucTrackCol );
  TMucTrack* mucTrackRoot = 0;
  while ( ( mucTrackRoot = (TMucTrack*)mucTrackIter.Next() ) )
  {
 
    int trackId = mucTrackRoot->trackId();
    int id      = mucTrackRoot->id();
    int st      = mucTrackRoot->status();
    int type    = mucTrackRoot->type();
 
    int startPart      = mucTrackRoot->startPart();
    int endPart        = mucTrackRoot->endPart();
    int brLastLayer    = mucTrackRoot->brLastLayer();
    int ecLastLayer    = mucTrackRoot->ecLastLayer();
    int numHits        = mucTrackRoot->numHits();
    int numLayers      = mucTrackRoot->numLayers();
    int maxHitsInLayer = mucTrackRoot->maxHitsInLayer();
 
    double depth = mucTrackRoot->depth();
    double chi2  = mucTrackRoot->chi2();
    int    dof   = mucTrackRoot->dof();
    double rms   = mucTrackRoot->rms();
 
    double xPos = mucTrackRoot->xPos();
    double yPos = mucTrackRoot->yPos();
    double zPos = mucTrackRoot->zPos();
 
    double xPosSigma = mucTrackRoot->xPosSigma();
    double yPosSigma = mucTrackRoot->yPosSigma();
    double zPosSigma = mucTrackRoot->zPosSigma();
 
    double px = mucTrackRoot->px();
    double py = mucTrackRoot->py();
    double pz = mucTrackRoot->pz();
 
    double distance = mucTrackRoot->distance();
    double deltaphi = mucTrackRoot->deltaPhi();
    // vector<int> vecHits = mucTrackRoot->vecHits();
    // added by LI Chunhua
    double krechi2 = mucTrackRoot->kalRechi2();
    int    kdof    = mucTrackRoot->kaldof();
    double kdepth  = mucTrackRoot->kaldepth();
    int    kbrlay  = mucTrackRoot->kalbrLastLayer();
    int    keclay  = mucTrackRoot->kalecLastLayer();
    //*********************
 
    DstMucTrack* mucTrackTds                 = new DstMucTrack();
    m_common.m_rootMucTrackMap[mucTrackRoot] = mucTrackTds;
 
    mucTrackTds->setTrackId( trackId );
    mucTrackTds->setId( id );
    mucTrackTds->setStatus( st );
    mucTrackTds->setType( type );
 
    mucTrackTds->setStartPart( startPart );
    mucTrackTds->setEndPart( endPart );
    mucTrackTds->setBrLastLayer( brLastLayer );
    mucTrackTds->setEcLastLayer( ecLastLayer );
    mucTrackTds->setNumHits( numHits );
    mucTrackTds->setNumLayers( numLayers );
    mucTrackTds->setMaxHitsInLayer( maxHitsInLayer );
 
    mucTrackTds->setDepth( depth );
    mucTrackTds->setChi2( chi2 );
    mucTrackTds->setDof( dof );
    mucTrackTds->setRms( rms );
 
    mucTrackTds->setXPos( xPos );
    mucTrackTds->setYPos( yPos );
    mucTrackTds->setZPos( zPos );
 
    mucTrackTds->setXPosSigma( xPosSigma );
    mucTrackTds->setYPosSigma( yPosSigma );
    mucTrackTds->setZPosSigma( zPosSigma );
 
    mucTrackTds->setPx( px );
    mucTrackTds->setPy( py );
    mucTrackTds->setPz( pz );
 
    mucTrackTds->setDistance( distance );
    mucTrackTds->setDeltaPhi( deltaphi );
 
    // mucTrackTds->setVecHits(vecHits);
    // added by LI Chunhua 2013/02/01
    mucTrackTds->setkalRechi2( krechi2 );
    mucTrackTds->setkalDof( kdof );
    mucTrackTds->setkalDepth( kdepth );
    mucTrackTds->setkalbrLastLayer( kbrlay );
    mucTrackTds->setkalecLastLayer( keclay );
    //******************
    mucTrackTdsCol->push_back( mucTrackTds );
    // delete mucTrackTds; // wensp add 2005/12/31
    // mucTrackTds = NULL;
  }
 
  // m_mucTrackCol->Delete();  // wensp add 2005/12/30
  delete m_mucTrackCol;
  m_mucTrackCol = 0;
  return StatusCode::SUCCESS;
}
 
StatusCode MucTrackCnv::DataObjectToTObject( DataObject* obj, RootAddress* rootaddr ) {
 
  MsgStream log( msgSvc(), "MucTrackCnv" );
  log << MSG::DEBUG << "MucTrackCnv::DataObjectToTObject" << endmsg;
  StatusCode sc = StatusCode::SUCCESS;
 
  DstMucTrackCol* mucTrackColTds = dynamic_cast<DstMucTrackCol*>( obj );
  if ( !mucTrackColTds )
  {
    log << MSG::ERROR << "Could not downcast to MucTrackCol" << endmsg;
    return StatusCode::FAILURE;
  }
 
  DataObject* evt;
  m_eds->findObject( EventModel::Dst::Event, evt );
  if ( evt == NULL )
  {
    log << MSG::ERROR << "Could not get DstEvent in TDS " << endmsg;
    return StatusCode::FAILURE;
  }
  DstEvent* devtTds = dynamic_cast<DstEvent*>( evt );
  if ( !devtTds )
  { log << MSG::ERROR << "MucTrackCnv:Could not downcast to TDS DigiEvent" << endmsg; }
  IOpaqueAddress* addr;
 
  m_cnvSvc->getDstCnv()->createRep( evt, addr );
  TDstEvent* recEvt = m_cnvSvc->getDstCnv()->getWriteObject();
 
  const TObjArray* m_mucTrackCol = recEvt->getMucTrackCol();
  if ( !m_mucTrackCol ) return sc;
  recEvt->clearMucTrackCol(); // necessary in case there is I/O at the same time since array is
                              // static
  DstMucTrackCol::const_iterator mucTrackTds;
 
  for ( mucTrackTds = mucTrackColTds->begin(); mucTrackTds != mucTrackColTds->end();
        mucTrackTds++ )
  {
    Int_t trackId = ( *mucTrackTds )->trackId();
    Int_t id      = ( *mucTrackTds )->id();
    Int_t st      = ( *mucTrackTds )->status();
    Int_t type    = ( *mucTrackTds )->type();
 
    Int_t startPart      = ( *mucTrackTds )->startPart();
    Int_t endPart        = ( *mucTrackTds )->endPart();
    Int_t brLastLayer    = ( *mucTrackTds )->brLastLayer();
    Int_t ecLastLayer    = ( *mucTrackTds )->ecLastLayer();
    Int_t numHits        = ( *mucTrackTds )->numHits();
    Int_t numLayers      = ( *mucTrackTds )->numLayers();
    Int_t maxHitsInLayer = ( *mucTrackTds )->maxHitsInLayer();
 
    Double_t depth = ( *mucTrackTds )->depth();
    Double_t chi2  = ( *mucTrackTds )->chi2();
    Int_t    dof   = ( *mucTrackTds )->dof();
    Double_t rms   = ( *mucTrackTds )->rms();
 
    Double_t xPos = ( *mucTrackTds )->xPos();
    Double_t yPos = ( *mucTrackTds )->yPos();
    Double_t zPos = ( *mucTrackTds )->zPos();
 
    Double_t xPosSigma = ( *mucTrackTds )->xPosSigma();
    Double_t yPosSigma = ( *mucTrackTds )->yPosSigma();
    Double_t zPosSigma = ( *mucTrackTds )->zPosSigma();
 
    Double_t px = ( *mucTrackTds )->px();
    Double_t py = ( *mucTrackTds )->py();
    Double_t pz = ( *mucTrackTds )->pz();
 
    Double_t distance = ( *mucTrackTds )->distance();
    Double_t deltaphi = ( *mucTrackTds )->deltaPhi();
    // added by LI Chunhua
    Double_t krechi2 = ( *mucTrackTds )->kalRechi2();
    Int_t    kdof    = ( *mucTrackTds )->kaldof();
    Double_t kdepth  = ( *mucTrackTds )->kaldepth();
    Int_t    kbrlay  = ( *mucTrackTds )->kalbrLastLayer();
    Int_t    keclay  = ( *mucTrackTds )->kalecLastLayer();
    //*********************
 
    // vector<Int_t> vecHits = (*mucTrackTds)->vecHits();
 
    TMucTrack* mucTrackRoot = new TMucTrack();
    // m_common.m_mucTrackMap[(*mucTrackTds)] = mucTrackRoot;
 
    mucTrackRoot->setTrackId( trackId );
    mucTrackRoot->setId( id );
    mucTrackRoot->setStatus( st );
    mucTrackRoot->setType( type );
 
    mucTrackRoot->setStartPart( startPart );
    mucTrackRoot->setEndPart( endPart );
    mucTrackRoot->setBrLastLayer( brLastLayer );
    mucTrackRoot->setEcLastLayer( ecLastLayer );
    mucTrackRoot->setNumHits( numHits );
    mucTrackRoot->setNumLayers( numLayers );
    mucTrackRoot->setMaxHitsInLayer( maxHitsInLayer );
 
    mucTrackRoot->setDepth( depth );
    mucTrackRoot->setChi2( chi2 );
    mucTrackRoot->setDof( dof );
    mucTrackRoot->setRms( rms );
 
    mucTrackRoot->setXPos( xPos );
    mucTrackRoot->setYPos( yPos );
    mucTrackRoot->setZPos( zPos );
 
    mucTrackRoot->setXPosSigma( xPosSigma );
    mucTrackRoot->setYPosSigma( yPosSigma );
    mucTrackRoot->setZPosSigma( zPosSigma );
 
    mucTrackRoot->setPx( px );
    mucTrackRoot->setPy( py );
    mucTrackRoot->setPz( pz );
 
    mucTrackRoot->setDistance( distance );
    mucTrackRoot->setDeltaPhi( deltaphi );
    // added by LI Chunhua 2013/02/01
    mucTrackRoot->setkalRechi2( krechi2 );
    mucTrackRoot->setkalDof( kdof );
    mucTrackRoot->setkalDepth( kdepth );
    mucTrackRoot->setkalbrLastLayer( kbrlay );
    mucTrackRoot->setkalecLastLayer( keclay );
    //******************
    // mucTrackRoot->setVecHits(vecHits);
 
    recEvt->addMucTrack( mucTrackRoot );
  }
 
  return StatusCode::SUCCESS;
}
#endif