RecMdcKalHelixSegCnv.cxx

Go to the documentation of this file.

#ifndef RecMdcKalHelixSegCnv_CXX
#define RecMdcKalHelixSegCnv_CXX 1
 
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/ObjectVector.h"
 
#include "TClonesArray.h"
 
#include "EventModel/EventModel.h"
 
#include "Identifier/Identifier.h"
#include "MdcRecEvent/RecMdcKalHelixSeg.h"
#include "ReconEvent/ReconEvent.h"
 
#include "RootEventData/TRecMdcKalHelixSeg.h" // standard root object
#include "RootEventData/TRecTrackEvent.h"
 
#include "RootCnvSvc/Rec/RecMdcKalHelixSegCnv.h"
#include "RootCnvSvc/Rec/RecTrackCnv.h"
#include "RootCnvSvc/RootAddress.h"
 
#include <vector>
 
using namespace std;
 
RecMdcKalHelixSegCnv::RecMdcKalHelixSegCnv( ISvcLocator* svc )
    : RootEventBaseCnv( classID(), svc ) {
 
  // Here we associate this converter with the /Event path on the TDS.
  MsgStream log( msgSvc(), "RecMdcKalHelixSegCnv" );
  // log << MSG::DEBUG << "Constructor called for " << objType() << endmsg;
  // m_rootTreename ="Rec";
  m_rootBranchname = "m_recMdcKalHelixSegCol";
  // declareObject(EventModel::Recon::RecMdcKalHelixSegCol, objType(), m_rootTreename,
  // m_rootBranchname);
  m_adresses.push_back( &m_recMdcKalHelixSegCol );
  m_recMdcKalHelixSegCol = 0;
}
 
StatusCode RecMdcKalHelixSegCnv::TObjectToDataObject( DataObject*& refpObject ) {
  // creation of TDS object from root object
  MsgStream log( msgSvc(), "RecMdcKalHelixSegCnv" );
  log << MSG::DEBUG << "RecMdcKalHelixSegCnv::TObjectToDataObject" << endmsg;
 
  // create the TDS location for the RecMdcKalHelixSeg Collection
  RecMdcKalHelixSegCol* recMdcKalHelixSegCol = new RecMdcKalHelixSegCol;
  refpObject                                 = recMdcKalHelixSegCol;
 
  // now convert
  if ( !m_recMdcKalHelixSegCol ) return StatusCode::SUCCESS;
  TIter               mdcHitIter( m_recMdcKalHelixSegCol );
  TRecMdcKalHelixSeg* recMdcKalHelixSegRoot = 0;
  int                 nSeg                  = 0;
  while ( ( recMdcKalHelixSegRoot = (TRecMdcKalHelixSeg*)mdcHitIter.Next() ) )
  {
    int        trackId = recMdcKalHelixSegRoot->getTrackId();
    int        flagLR  = recMdcKalHelixSegRoot->getFlagLR();
    Identifier mdcId( recMdcKalHelixSegRoot->getMdcId() );
    double     tdc       = recMdcKalHelixSegRoot->getTdc();
    double     adc       = recMdcKalHelixSegRoot->getAdc();
    double     zhit      = recMdcKalHelixSegRoot->getZhit();
    double     tof       = recMdcKalHelixSegRoot->getTof();
    double     docaIncl  = recMdcKalHelixSegRoot->getDocaIncl();
    double     docaExcl  = recMdcKalHelixSegRoot->getDocaExcl();
    double     driftDist = recMdcKalHelixSegRoot->getDD();
    double     entra     = recMdcKalHelixSegRoot->getEntra();
    double     driftT    = recMdcKalHelixSegRoot->getDT();
    //  int      layerId = recMdcKalHelixSegRoot->getLayerId();
    //  double   drIncl = recMdcKalHelixSegRoot->getDrIncl();
    //  double   phi0Incl = recMdcKalHelixSegRoot->getFi0Incl();
    //  double   kappaIncl = recMdcKalHelixSegRoot->getCpaIncl();
    //  double   dzIncl = recMdcKalHelixSegRoot->getDzIncl();
    //  double   tanlIncl = recMdcKalHelixSegRoot->getTanlIncl();
    //  double   drExcl = recMdcKalHelixSegRoot->getDrExcl();
    //  double   phi0Excl = recMdcKalHelixSegRoot->getFi0Excl();
    //  double   kappaExcl = recMdcKalHelixSegRoot->getCpaExcl();
    //  double   dzExcl = recMdcKalHelixSegRoot->getDzExcl();
    //  double   tanlExcl = recMdcKalHelixSegRoot->getTanlExcl();
    double helixIncl[5]; // errIncl[15];
    double helixExcl[5]; // errExcl[15];
    for ( int i = 0, k = 0; i < 5; i++ )
    {
      helixIncl[i] = recMdcKalHelixSegRoot->getHelixIncl( i );
      helixExcl[i] = recMdcKalHelixSegRoot->getHelixExcl( i );
      // for(int j=0; j<=i; j++){
      //         errIncl[k] = recMdcKalHelixSegRoot->getErrorIncl(i,j);
      //         errExcl[k] = recMdcKalHelixSegRoot->getErrorExcl(i,j);
      // }
    }
 
    RecMdcKalHelixSeg* recMdcKalHelixSeg                       = new RecMdcKalHelixSeg();
    m_common.m_rootRecMdcKalHelixSegMap[recMdcKalHelixSegRoot] = recMdcKalHelixSeg;
 
    recMdcKalHelixSeg->setTrackId( trackId );
    recMdcKalHelixSeg->setFlagLR( flagLR );
    recMdcKalHelixSeg->setMdcId( Identifier( mdcId ) );
    recMdcKalHelixSeg->setTdc( tdc );
    recMdcKalHelixSeg->setAdc( adc );
    recMdcKalHelixSeg->setZhit( zhit );
    recMdcKalHelixSeg->setTof( tof );
    recMdcKalHelixSeg->setDocaIncl( docaIncl );
    recMdcKalHelixSeg->setDocaExcl( docaExcl );
    recMdcKalHelixSeg->setDD( driftDist );
    recMdcKalHelixSeg->setEntra( entra );
    recMdcKalHelixSeg->setDT( driftT );
    //    recMdcKalHelixSeg->setLayerId( layerId );
    //    recMdcKalHelixSeg->setDrIncl( drIncl );
    //    recMdcKalHelixSeg->setFi0Incl( phi0Incl );
    //    recMdcKalHelixSeg->setCpaIncl( kappaIncl );
    //    recMdcKalHelixSeg->setDzIncl( dzIncl );
    //    recMdcKalHelixSeg->setTanlIncl( tanlIncl );
    //    recMdcKalHelixSeg->setDrExcl( drIncl );
    //    recMdcKalHelixSeg->setFi0Excl( phi0Excl );
    //    recMdcKalHelixSeg->setCpaExcl( kappaExcl );
    //    recMdcKalHelixSeg->setDzExcl( dzExcl );
    //    recMdcKalHelixSeg->setTanlExcl( tanlExcl );
    recMdcKalHelixSeg->setHelixIncl( helixIncl );
    recMdcKalHelixSeg->setHelixExcl( helixExcl );
    //    recMdcKalHelixSeg->setErrorIncl( errIncl );
    //    recMdcKalHelixSeg->setErrorExcl( errExcl );
 
    recMdcKalHelixSegCol->push_back( recMdcKalHelixSeg );
    nSeg++;
  }
  // cout<<"rec -> Tds, nSeg = "<<nSeg<<",
  // recMdcKalHelixSegCol.size="<<recMdcKalHelixSegCol->size()<<endl;
  return StatusCode::SUCCESS;
}
 
StatusCode RecMdcKalHelixSegCnv::DataObjectToTObject( DataObject*  obj,
                                                      RootAddress* rootaddr ) {
 
  MsgStream log( msgSvc(), "RecMdcKalHelixSegCnv" );
  log << MSG::DEBUG << "RecMdcKalHelixSegCnv::DataObjectToTObject" << endmsg;
 
  RecMdcKalHelixSegCol* mdcHitColTds = dynamic_cast<RecMdcKalHelixSegCol*>( obj );
  if ( !mdcHitColTds )
  {
    log << MSG::ERROR << "Could not downcast to RecMdcKalHelixSegCol" << endmsg;
    return StatusCode::FAILURE;
  }
 
  DataObject* evt;
  m_eds->findObject( EventModel::Recon::Event, evt );
  if ( evt == NULL )
  {
    log << MSG::ERROR << "Could not get ReconEvent in TDS " << endmsg;
    return StatusCode::FAILURE;
  }
 
  ReconEvent* devtTds = dynamic_cast<ReconEvent*>( evt );
  if ( !devtTds )
  {
    log << MSG::ERROR << "RecMdcKalHelixSegCnv:Could not downcast to TDS ReconEvent" << endmsg;
  }
 
  IOpaqueAddress* addr;
 
  m_cnvSvc->getRecTrackCnv()->createRep( evt, addr );
  TRecTrackEvent* recEvt = m_cnvSvc->getRecTrackCnv()->getWriteObject();
 
  const TObjArray* m_recMdcKalHelixSegCol = recEvt->getRecMdcKalHelixSegCol();
  if ( !m_recMdcKalHelixSegCol ) return StatusCode::SUCCESS;
  recEvt->clearRecMdcKalHelixSegCol(); // necessary in case there is I/O at the same time since
                                       // array is static
 
  RecMdcKalHelixSegCol::const_iterator recMdcKalHelixSeg;
  int                                  nSeg = 0;
  for ( recMdcKalHelixSeg = mdcHitColTds->begin(); recMdcKalHelixSeg != mdcHitColTds->end();
        recMdcKalHelixSeg++ )
  {
    Int_t    trackId   = ( *recMdcKalHelixSeg )->getTrackId();
    Int_t    flagLR    = ( *recMdcKalHelixSeg )->getFlagLR();
    UInt_t   mdcId     = ( *recMdcKalHelixSeg )->getMdcId().get_value();
    Double_t tdc       = ( *recMdcKalHelixSeg )->getTdc();
    Double_t adc       = ( *recMdcKalHelixSeg )->getAdc();
    Double_t zhit      = ( *recMdcKalHelixSeg )->getZhit();
    Double_t tof       = ( *recMdcKalHelixSeg )->getTof();
    Double_t docaIncl  = ( *recMdcKalHelixSeg )->getDocaIncl();
    Double_t docaExcl  = ( *recMdcKalHelixSeg )->getDocaExcl();
    Double_t driftDist = ( *recMdcKalHelixSeg )->getDD();
    Double_t entra     = ( *recMdcKalHelixSeg )->getEntra();
    Double_t driftT    = ( *recMdcKalHelixSeg )->getDT();
    //     Int_t      layerId = (*recMdcKalHelixSeg)->getLayerId();
    //     Double_t   drIncl =  (*recMdcKalHelixSeg)->getDrIncl();
    //     Double_t   phi0Incl =(*recMdcKalHelixSeg)->getFi0Incl();
    //     Double_t   kappaIncl = (*recMdcKalHelixSeg)->getCpaIncl();
    //     Double_t   dzIncl =  (*recMdcKalHelixSeg)->getDzIncl();
    //     Double_t   tanlIncl = (*recMdcKalHelixSeg)->getTanlIncl();
    //     Double_t   drExcl =  (*recMdcKalHelixSeg)->getDrExcl();
    //     Double_t   phi0Excl = (*recMdcKalHelixSeg)->getFi0Excl();
    //     Double_t   kappaExcl = (*recMdcKalHelixSeg)->getCpaExcl();
    //     Double_t   dzExcl =   (*recMdcKalHelixSeg)->getDzExcl();
    //     Double_t   tanlExcl = (*recMdcKalHelixSeg)->getTanlExcl();
    HepVector helixIncl_vct = ( *recMdcKalHelixSeg )->getHelixIncl();
    HepVector helixExcl_vct = ( *recMdcKalHelixSeg )->getHelixExcl();
    //     HepSymMatrix  errIncl_mtx = (*recMdcKalHelixSeg)->getErrorIncl();
    //     HepSymMatrix  errExcl_mtx = (*recMdcKalHelixSeg)->getErrorExcl();
 
    Double_t helixIncl[5], helixExcl[5]; // errIncl[5][5], errExcl[5][5];
    for ( Int_t i = 0; i < 5; i++ )
    {
      helixIncl[i] = helixIncl_vct[i];
      helixExcl[i] = helixExcl_vct[i];
    }
    //     for (Int_t i=0; i<5; i++){
    //             for(Int_t j=0; j<5; j++){
    //               errIncl[i][j] = errIncl_mtx[i][j];
    //               errExcl[i][j] = errExcl_mtx[i][j];
    //             }
    //     }
 
    TRecMdcKalHelixSeg* recMdcKalHelixSegRoot = new TRecMdcKalHelixSeg();
    // m_common.m_recMdcKalHelixSegMap[(*recMdcKalHelixSeg)] = recMdcKalHelixSegRoot;
 
    recMdcKalHelixSegRoot->setTrackId( trackId );
    recMdcKalHelixSegRoot->setFlagLR( flagLR );
    recMdcKalHelixSegRoot->setMdcId( Identifier( mdcId ) );
    recMdcKalHelixSegRoot->setTdc( tdc );
    recMdcKalHelixSegRoot->setAdc( adc );
    recMdcKalHelixSegRoot->setZhit( zhit );
    recMdcKalHelixSegRoot->setTof( tof );
    recMdcKalHelixSegRoot->setDocaIncl( docaIncl );
    recMdcKalHelixSegRoot->setDocaExcl( docaExcl );
    recMdcKalHelixSegRoot->setDD( driftDist );
    recMdcKalHelixSegRoot->setEntra( entra );
    recMdcKalHelixSegRoot->setDT( driftT );
    //     recMdcKalHelixSegRoot->setLayerId( layerId );
    //     recMdcKalHelixSegRoot->setDrIncl( drIncl );
    //     recMdcKalHelixSegRoot->setFi0Incl( phi0Incl );
    //     recMdcKalHelixSegRoot->setCpaIncl( kappaIncl );
    //     recMdcKalHelixSegRoot->setDzIncl( dzIncl );
    //     recMdcKalHelixSegRoot->setTanlIncl( tanlIncl );
    //     recMdcKalHelixSegRoot->setDrExcl( drIncl );
    //     recMdcKalHelixSegRoot->setFi0Excl( phi0Excl );
    //     recMdcKalHelixSegRoot->setCpaExcl( kappaExcl );
    //     recMdcKalHelixSegRoot->setDzExcl( dzExcl );
    //     recMdcKalHelixSegRoot->setTanlExcl( tanlExcl );
    recMdcKalHelixSegRoot->setHelixIncl( helixIncl );
    recMdcKalHelixSegRoot->setHelixExcl( helixExcl );
    //     recMdcKalHelixSegRoot->setErrorIncl( errIncl );
    //     recMdcKalHelixSegRoot->setErrorExcl( errExcl );
 
    log << MSG::INFO << " recMdcKalHelixSegRoot.dd: " << recMdcKalHelixSegRoot->getDD()
        << " recMdcKalHelixSegRoot.entra: " << recMdcKalHelixSegRoot->getEntra() << endmsg;
 
    recEvt->addRecMdcKalHelixSeg( recMdcKalHelixSegRoot );
    nSeg++;
  }
  // cout<<"writing nSeg = "<<nSeg<<endl;
  return StatusCode::SUCCESS;
}
#endif