RecMucTrackCnv.cxx

Go to the documentation of this file.

#ifndef RecMucTrackCnv_CXX
#define RecMucTrackCnv_CXX 1
 
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/ObjectVector.h"
 
#include "TClonesArray.h"
 
#include "EventModel/EventModel.h"
 
#include "MucRecEvent/RecMucTrack.h"
#include "ReconEvent/ReconEvent.h"
 
// #include "RootEventData/TMucTrack.h" // standard root object
#include "RootEventData/TRecMucTrack.h" // standard root object
// #include "RootEventData/TDstEvent.h"
#include "RootEventData/TRecTrackEvent.h"
 
#include "RootCnvSvc/Rec/RecMucTrackCnv.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<RecMucTrackCnv> s_factory;
// const ICnvFactory& RecMucTrackCnvFactory = s_factory;
 
RecMucTrackCnv::RecMucTrackCnv( ISvcLocator* svc ) : RootEventBaseCnv( classID(), svc ) {
 
  // Here we associate this converter with the /Event path on the TDS.
  // MsgStream log( msgSvc(), "RecMucTrackCnv" );
  // log << MSG::DEBUG << "Constructor called for " << objType() << endmsg;
  // m_rootTreename ="Rec";
  // RecMucTrack *atrack = new RecMucTrack();
  // RecMucTrackCol *atrackCol = new RecMucTrackCol;
  // cout<<"in RecMucTrackCnv "<<atrack->clID()<<"  "<<atrackCol->clID()<<"
  // "<<CLID_ObjectVector<<endl;
  m_rootBranchname = "m_recMucTrackCol";
  // declareObject(EventModel::Recon::RecMucTrackCol, objType(), m_rootTreename,
  // m_rootBranchname);
  m_adresses.push_back( &m_recMucTrackCol );
  m_recMucTrackCol = 0;
}
 
StatusCode RecMucTrackCnv::TObjectToDataObject( DataObject*& refpObject ) {
  // creation of TDS object from root object
 
  MsgStream log( msgSvc(), "RecMucTrackCnv" );
  log << MSG::DEBUG << "RecMucTrackCnv::TObjectToDataObject" << endmsg;
  StatusCode sc = StatusCode::SUCCESS;
 
  // create the TDS location for the MucTrack Collection
  RecMucTrackCol* mucTrackTdsCol = new RecMucTrackCol;
  refpObject                     = mucTrackTdsCol;
 
  // now convert
  if ( !m_recMucTrackCol ) return sc;
  TIter         mucTrackIter( m_recMucTrackCol );
  TRecMucTrack* mucTrackRoot = 0;
  while ( ( mucTrackRoot = (TRecMucTrack*)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();
    // cout<<"in RecMucTrackCnv  distance = "<<distance<<" xpos= "<<xPos<<endl;
 
    vector<int>   vecHits  = mucTrackRoot->vecHits();
    vector<int>   expHits  = mucTrackRoot->expHits();
    vector<float> distHits = mucTrackRoot->distHits();
 
    // added by LI Chunhua
    double krechi2 = mucTrackRoot->kalRechi2();
    int    kdof    = mucTrackRoot->kaldof();
    double kdepth  = mucTrackRoot->kaldepth();
    int    kbrlay  = mucTrackRoot->kalbrLastLayer();
    int    keclay  = mucTrackRoot->kalecLastLayer();
    //*********************
    // cout<<"in RecMucTrackCnv  size = "<<vecHits.size()<<"    "<<expHits.size()<<"
    // "<<distHits.size()<<endl;
 
    RecMucTrack* mucTrackTds                    = new RecMucTrack();
    m_common.m_rootRecMucTrackMap[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 ); // need fix
    mucTrackTds->setExpHits( expHits );
    mucTrackTds->setDistHits( distHits );
 
    // added by LI Chunhua 2013/02/01
    mucTrackTds->setkalRechi2( krechi2 );
    mucTrackTds->setkalDof( kdof );
    mucTrackTds->setkalDepth( kdepth );
    mucTrackTds->setkalbrLastLayer( kbrlay );
    mucTrackTds->setkalecLastLayer( keclay );
    //******************
 
    // cout<<"in RecMucTrackCnv::T->D  set mucpos"<<endl;
 
    mucTrackTdsCol->push_back( mucTrackTds );
    // delete mucTrackTds; // wensp add 2005/12/31
    // mucTrackTds = NULL;
  }
 
  // m_mucTrackCol->Delete();  // wensp add 2005/12/30
  delete m_recMucTrackCol;
  m_recMucTrackCol = 0;
  return StatusCode::SUCCESS;
}
 
StatusCode RecMucTrackCnv::DataObjectToTObject( DataObject* obj, RootAddress* rootaddr ) {
 
  MsgStream log( msgSvc(), "RecMucTrackCnv" );
  log << MSG::DEBUG << "RecMucTrackCnv::DataObjectToTObject" << endmsg;
  StatusCode sc = StatusCode::SUCCESS;
 
  RecMucTrackCol* mucTrackColTds = dynamic_cast<RecMucTrackCol*>( obj );
  if ( !mucTrackColTds )
  {
    log << MSG::ERROR << "Could not downcast to RecMucTrackCol" << 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 << "RecMucTrackCnv:Could not downcast to TDS DigiEvent" << endmsg; }
  IOpaqueAddress* addr;
 
  m_cnvSvc->getRecTrackCnv()->createRep( evt, addr );
  TRecTrackEvent* recEvt = m_cnvSvc->getRecTrackCnv()->getWriteObject();
 
  const TObjArray* m_recMucTrackCol = recEvt->getMucTrackCol();
  if ( !m_recMucTrackCol ) return sc;
  recEvt->clearMucTrackCol(); // necessary in case there is I/O at the same time since array is
                              // static
  RecMucTrackCol::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 distance = ( *mucTrackTds )->distance();
    Double_t deltaphi = ( *mucTrackTds )->deltaPhi();
 
    Double_t px = ( *mucTrackTds )->px();
    Double_t py = ( *mucTrackTds )->py();
    Double_t pz = ( *mucTrackTds )->pz();
 
    vector<Int_t>   vecHits  = ( *mucTrackTds )->getVecHits();
    vector<Int_t>   expHits  = ( *mucTrackTds )->getExpHits();
    vector<Float_t> distHits = ( *mucTrackTds )->getDistHits();
    // 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();
    //*********************
 
    /*
    cout<<"in RecMucTrackCnv  "<<vecHits.size()<<endl;
    for(int i = 0; i < vecHits.size(); i++){
      cout<<"  vec i = "<<i<<"   "<<vecHits[i]<<endl;
    }
 
    for(int i = 0; i < expHits.size(); i++){
      cout<<"  exp i = "<<i<<"   "<<expHits[i]<<endl;
    }
 
    for(int i = 0; i < distHits.size(); i++){
      cout<<"  dist i = "<<i<<"   "<<distHits[i]<<endl;
    }
    */
 
    TRecMucTrack* mucTrackRoot = new TRecMucTrack(); // liangyt
    // m_common.m_RecMucTrackMap[(*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->setDistance( distance );
    mucTrackRoot->setDeltaPhi( deltaphi );
 
    // cout<<"in RecMucTrackCnv  xyz = "<<xPos<<"  "<<yPos<<"  "<<zPos<<" depth= "<<depth<<"
    // "<<maxHitsInLayer<<"
    // "<<deltaphi<<endl;
 
    mucTrackRoot->setPx( px );
    mucTrackRoot->setPy( py );
    mucTrackRoot->setPz( pz );
 
    mucTrackRoot->setVecHits( vecHits );
    mucTrackRoot->setExpHits( expHits );
    mucTrackRoot->setDistHits( distHits );
 
    // added by LI Chunhua 2013/02/01
    mucTrackRoot->setkalRechi2( krechi2 );
    mucTrackRoot->setkalDof( kdof );
    mucTrackRoot->setkalDepth( kdepth );
    mucTrackRoot->setkalbrLastLayer( kbrlay );
    mucTrackRoot->setkalecLastLayer( keclay );
    //******************
    recEvt->addMucTrack( mucTrackRoot );
  }
 
  return StatusCode::SUCCESS;
}
#endif