RootCnvSvc-04-01-15/src/Dst/CgemKalTrackCnv.cxx

Go to the documentation of this file.

#ifndef CgemKalTrackCnv_CXX
#define CgemKalTrackCnv_CXX  1
 
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/ObjectVector.h"
 
#include "TClonesArray.h"
 
#include "EventModel/EventModel.h"
#include "DstEvent/DstEvent.h"   //TDS object
#include "DstEvent/DstCgemKalTrack.h"   //TDS object
#include "CgemRecEvent/RecCgemKalTrack.h"
#include "RootEventData/TCgemKalTrack.h" // standard root object
#include "RootEventData/TDstEvent.h"
 
#include "RootCnvSvc/Dst/DstCnv.h"
#include "RootCnvSvc/Dst/CgemKalTrackCnv.h"
#include "RootCnvSvc/RootAddress.h"
 
#include "CLHEP/Matrix/Vector.h"
#include "CLHEP/Matrix/SymMatrix.h"
#include "CLHEP/Vector/ThreeVector.h"
#include "CLHEP/Geometry/Point3D.h"
#include <vector>
#include "string.h"
#include <cmath>
 
using CLHEP::HepVector;
using CLHEP::HepSymMatrix;
 
 
CgemKalTrackCnv::CgemKalTrackCnv(ISvcLocator* svc)
: RootEventBaseCnv(classID(), svc)
{
    // Here we associate this converter with the /Event path on the TDS.
    MsgStream log(msgSvc(), "CgemKalTrackCnv");
    m_rootBranchname ="m_cgemKalTrackCol";
    m_adresses.push_back(&m_cgemKalTrackCol);
    m_cgemKalTrackCol=0;
}
 
StatusCode CgemKalTrackCnv::TObjectToDataObject(DataObject*& refpObject) {
  // creation of TDS object from root object
 
    MsgStream log(msgSvc(), "CgemKalTrackCnv");
    log << MSG::DEBUG << "CgemKalTrackCnv::TObjectToDataObject" << endreq;
    StatusCode sc=StatusCode::SUCCESS;
 
    // create the TDS location for the CgemKalTrack Collection
    DstCgemKalTrackCol* cgemKalTrackTdsCol = new DstCgemKalTrackCol;
    refpObject=cgemKalTrackTdsCol;
 
    // now convert
    if (!m_cgemKalTrackCol) return sc;
    TIter cgemKalTrackIter(m_cgemKalTrackCol);
    TCgemKalTrack *cgemKalTrackRoot = 0;
    while ((cgemKalTrackRoot = (TCgemKalTrack*)cgemKalTrackIter.Next())) {
     std::vector<HepVector> zhelixs;
     std::vector<HepSymMatrix> zerrors;
     std::vector<HepPoint3D> pocas;
     std::vector<HepVector> fhelixs;
     std::vector<HepSymMatrix> ferrors;
 
     HepVector zhelix(5); 
     HepSymMatrix zerror(5); 
     HepPoint3D poca(0,0,0);
 
     HepVector zhelix_e(5); 
     HepSymMatrix zerror_e(5); 
     HepPoint3D poca_e(0,0,0);
  
     HepVector zhelix_mu(5); 
     HepSymMatrix zerror_mu(5); 
     HepPoint3D poca_mu(0,0,0);
      
     HepVector zhelix_k(5); 
     HepSymMatrix zerror_k(5);  
     HepPoint3D poca_k(0,0,0);
       
     HepVector zhelix_p(5);  
     HepSymMatrix zerror_p(5);
     HepPoint3D poca_p(0,0,0);
  
     HepVector fhelix(5); 
     HepSymMatrix ferror(5); 
 
     HepVector fhelix_e(5); 
     HepSymMatrix ferror_e(5); 
  
     HepVector fhelix_mu(5); 
     HepSymMatrix ferror_mu(5); 
      
     HepVector fhelix_k(5); 
     HepSymMatrix ferror_k(5);  
       
     HepVector fhelix_p(5);  
     HepSymMatrix ferror_p(5);
  
     
     DstCgemKalTrack *cgemKalTrackTds = new DstCgemKalTrack();
     m_common.m_rootCgemKalTrackMap[cgemKalTrackRoot] = cgemKalTrackTds;
     
     /* 
     for(int ii=0; ii<3; ii++){
       poca_e[ii]  =  cgemKalTrackRoot->getPocaE(ii);
       poca_mu[ii] =  cgemKalTrackRoot->getPocaMu(ii);
       poca[ii]    =  cgemKalTrackRoot->getPoca(ii);
       poca_k[ii]  =  cgemKalTrackRoot->getPocaK(ii);
       poca_p[ii]  =  cgemKalTrackRoot->getPocaP(ii);
     }
     */
 
     log<<MSG::DEBUG<<"T to DST, poca: "<<poca<<endreq;
     
     for (int i=0; i<5; i++){
         zhelix[i]    = cgemKalTrackRoot->getZHelix(i);
         zhelix_e[i]  = cgemKalTrackRoot->getZHelixE(i);
         zhelix_mu[i] = cgemKalTrackRoot->getZHelixMu(i);
         zhelix_k[i]  = cgemKalTrackRoot->getZHelixK(i);
         zhelix_p[i]  = cgemKalTrackRoot->getZHelixP(i);
         
         fhelix[i]    = cgemKalTrackRoot->getFHelix(i);
         fhelix_e[i]  = cgemKalTrackRoot->getFHelixE(i);
         fhelix_mu[i] = cgemKalTrackRoot->getFHelixMu(i);
         fhelix_k[i]  = cgemKalTrackRoot->getFHelixK(i);
         fhelix_p[i]  = cgemKalTrackRoot->getFHelixP(i);
 
         for (int j=0; j<=i; j++){
          zerror[i][j]    = cgemKalTrackRoot->getZError(i,j);
          zerror_e[i][j]  = cgemKalTrackRoot->getZErrorE(i,j);
          zerror_mu[i][j] = cgemKalTrackRoot->getZErrorMu(i,j);
          zerror_k[i][j]  = cgemKalTrackRoot->getZErrorK(i,j);
          zerror_p[i][j]  = cgemKalTrackRoot->getZErrorP(i,j);
          
          zerror[j][i]    = zerror[i][j];    
          zerror_e[j][i]  = zerror_e[i][j];  
          zerror_mu[j][i] = zerror_mu[i][j]; 
          zerror_k[j][i]  = zerror_k[i][j];  
          zerror_p[j][i]  = zerror_p[i][j];  
 
          ferror[i][j]    = cgemKalTrackRoot->getFError(i,j);
          ferror_e[i][j]  = cgemKalTrackRoot->getFErrorE(i,j);
          ferror_mu[i][j] = cgemKalTrackRoot->getFErrorMu(i,j);
          ferror_k[i][j]  = cgemKalTrackRoot->getFErrorK(i,j);
          ferror_p[i][j]  = cgemKalTrackRoot->getFErrorP(i,j);
          
          ferror[j][i]    = ferror[i][j];    
          ferror_e[j][i]  = ferror_e[i][j];  
          ferror_mu[j][i] = ferror_mu[i][j]; 
          ferror_k[j][i]  = ferror_k[i][j];  
          ferror_p[j][i]  = ferror_p[i][j];  
        }
      }
    
     
     double dr    = zhelix[0];
     double phi0  = zhelix[1];
     double kappa = zhelix[2];
     double dz    = zhelix[3];
     double tanl  = zhelix[4];
     poca[0]=dr*cos(phi0);
     poca[1]=dr*sin(phi0);
     poca[2]=dz;
 
     dr    = zhelix_e[0];
     phi0  = zhelix_e[1];
     kappa = zhelix_e[2];
     dz    = zhelix_e[3];
     tanl  = zhelix_e[4];
     poca_e[0]=dr*cos(phi0);
     poca_e[1]=dr*sin(phi0);
     poca_e[2]=dz;
 
     dr    = zhelix_mu[0];
     phi0  = zhelix_mu[1];
     kappa = zhelix_mu[2];
     dz    = zhelix_mu[3];
     tanl  = zhelix_mu[4];
     poca_mu[0]=dr*cos(phi0);
     poca_mu[1]=dr*sin(phi0);
     poca_mu[2]=dz;
 
     dr    = zhelix_k[0];
     phi0  = zhelix_k[1];
     kappa = zhelix_k[2];
     dz    = zhelix_k[3];
     tanl  = zhelix_k[4];
     poca_k[0]=dr*cos(phi0);
     poca_k[1]=dr*sin(phi0);
     poca_k[2]=dz;
 
     dr    = zhelix_p[0];
     phi0  = zhelix_p[1];
     kappa = zhelix_p[2];
     dz    = zhelix_p[3];
     tanl  = zhelix_p[4];
     poca_p[0]=dr*cos(phi0);
     poca_p[1]=dr*sin(phi0);
     poca_p[2]=dz;
 
     
     log<<MSG::DEBUG<<"T to DST, zhelix: "<<zhelix<<endreq;
     log<<MSG::DEBUG<<"T to DST, zerror: "<<zerror<<endreq;
 
     zhelixs.push_back(zhelix_e);
     zhelixs.push_back(zhelix_mu);
     zhelixs.push_back(zhelix);
     zhelixs.push_back(zhelix_k);
     zhelixs.push_back(zhelix_p);                                                                                           
     zerrors.push_back(zerror_e);
     zerrors.push_back(zerror_mu);
     zerrors.push_back(zerror);
     zerrors.push_back(zerror_k);
     zerrors.push_back(zerror_p);
 
     fhelixs.push_back(fhelix_e);
     fhelixs.push_back(fhelix_mu);
     fhelixs.push_back(fhelix);
     fhelixs.push_back(fhelix_k);
     fhelixs.push_back(fhelix_p);                                                                                           
     ferrors.push_back(ferror_e);
     ferrors.push_back(ferror_mu);
     ferrors.push_back(ferror);
     ferrors.push_back(ferror_k);
     ferrors.push_back(ferror_p);
 
     pocas.push_back(poca_e);
     pocas.push_back(poca_mu);
     pocas.push_back(poca);
     pocas.push_back(poca_k);
     pocas.push_back(poca_p);
     
     for(int m=0; m<5; m++){
       int charge;
       double pxy(0.),px(0.),py(0.),pz(0.),ptot(0.),dr(0.),phi0(0.),kappa(0.),dz(0.),tanl(0.),x(0.),y(0.),z(0.),vx0(0.),vy0(0.),vz0(0.);
       dr    = zhelixs[m][0];
       phi0  = zhelixs[m][1];
       kappa = zhelixs[m][2];
       dz    = zhelixs[m][3];
       tanl  = zhelixs[m][4];
       
//       x = pocas[m][0];
//       y = pocas[m][1];
//       z = pocas[m][2];
       
       x = dr * cos(phi0);
       y = dr * sin(phi0);
       z = dz;
 
 //  std::cout<<"x: "<<x<<"y: "<<y<<"z: "<<z<<std::endl;
 
       if (kappa > 0.0000000001)
     charge = 1;
       else if (kappa < -0.0000000001)
     charge = -1;
       else
     charge = 0;
 
       if(kappa!=0) pxy = 1.0/fabs(kappa);
       else pxy = 0;
        
       px = pxy * (-sin(phi0));
       py = pxy * cos(phi0);
       pz = pxy * tanl;
       ptot = sqrt(px*px+py*py+pz*pz);
       
       cgemKalTrackTds->setCharge(charge,m);
       cgemKalTrackTds->setPxy(pxy,m);
       cgemKalTrackTds->setPx(px,m);
       cgemKalTrackTds->setPy(py,m);
       cgemKalTrackTds->setPz(pz,m);
       cgemKalTrackTds->setP(ptot,m);
       cgemKalTrackTds->setTheta(acos(pz/ptot),m);
       cgemKalTrackTds->setPhi(atan2(py,px),m);
       cgemKalTrackTds->setX(x,m);
       cgemKalTrackTds->setY(y,m);
       cgemKalTrackTds->setZ(z,m);
       cgemKalTrackTds->setR(sqrt(x*x+y*y),m);
  
       cgemKalTrackTds->setStat(cgemKalTrackRoot->getStat(m),0,m);
       cgemKalTrackTds->setStat(cgemKalTrackRoot->getStat2(m),1,m);
       cgemKalTrackTds->setChisq(cgemKalTrackRoot->getChisq(m),0,m);
       cgemKalTrackTds->setNdf(cgemKalTrackRoot->getNdf(m),0,m);
     }  
     
      cgemKalTrackTds->setTrackId(cgemKalTrackRoot->getTrackId());
 
      for(int jj=0; jj<5; jj++){
    cgemKalTrackTds->setZHelix(zhelixs[jj],jj);          
    cgemKalTrackTds->setZError(zerrors[jj],jj);          
    cgemKalTrackTds->setFHelix(fhelixs[jj],jj);          
    cgemKalTrackTds->setFError(ferrors[jj],jj);          
    cgemKalTrackTds->setPoca(pocas[jj],jj);
      }
    
      cgemKalTrackTdsCol->push_back(cgemKalTrackTds);
    }
    // m_cgemKalTrackCol->Delete();  // wensp add 2005/12/30
    delete m_cgemKalTrackCol;
    m_cgemKalTrackCol = 0;  
    return StatusCode::SUCCESS;
}
 
StatusCode CgemKalTrackCnv::DataObjectToTObject(DataObject* obj,RootAddress* rootaddr) {
 
  MsgStream log(msgSvc(), "CgemKalTrackCnv");
  log << MSG::DEBUG << "CgemKalTrackCnv::DataObjectToTObject" << endreq;
  StatusCode sc=StatusCode::SUCCESS;
 
  DstCgemKalTrackCol * cgemKalTrackColTds=dynamic_cast<DstCgemKalTrackCol *> (obj);
  //RecCgemKalTrackCol * cgemKalTrackColTds=dynamic_cast<RecCgemKalTrackCol *> (obj);
  if (!cgemKalTrackColTds) {
    log << MSG::ERROR << "Could not downcast to DstCgemKalTrackCol" << endreq;
    return StatusCode::FAILURE;
  }
      
  DataObject *evt;
  m_eds->findObject(EventModel::Dst::Event,evt);
  if (evt==NULL) {
    log << MSG::ERROR << "Could not get ReconEvent in TDS "  << endreq;
    return StatusCode::FAILURE;
  }
 
  DstEvent * devtTds=dynamic_cast<DstEvent *> (evt);
  if (!devtTds) {
    log << MSG::ERROR << "CgemKalTrackCnv:Could not downcast to TDS Dst Event" << endreq;
  }
  IOpaqueAddress *addr;
 
  m_cnvSvc->getDstCnv()->createRep(evt,addr); 
  TDstEvent *recEvt=m_cnvSvc->getDstCnv()->getWriteObject();
 
  const TObjArray *m_cgemKalTrackCol = recEvt->getCgemKalTrackCol();
  
  if (!m_cgemKalTrackCol) return sc;
  
  recEvt->clearCgemKalTrackCol(); //necessary in case there is I/O at the same time since array is static
  DstCgemKalTrackCol::const_iterator cgemKalTrackTds;
 
  for (cgemKalTrackTds = cgemKalTrackColTds->begin(); cgemKalTrackTds != cgemKalTrackColTds->end(); cgemKalTrackTds++) {
      
    // Get Data from DST
 
     //Double_t poca[3]; 
     Double_t zhelix[5];        
     Double_t zerror[5][5];     
 
     //Double_t poca_e[3];
     Double_t zhelix_e[5];      
     Double_t zerror_e[5][5];   
 
     //Double_t poca_mu[3];
     Double_t zhelix_mu[5];     
     Double_t zerror_mu[5][5];  
 
     //Double_t poca_k[3];
     Double_t zhelix_k[5];      
     Double_t zerror_k[5][5];   
 
     //Double_t poca_p[3];
     Double_t zhelix_p[5];      
     Double_t zerror_p[5][5];   
    
     Double_t fhelix[5];        
     Double_t ferror[5][5];     
     Double_t fhelix_e[5];      
     Double_t ferror_e[5][5];   
     Double_t fhelix_mu[5];     
     Double_t ferror_mu[5][5];  
     Double_t fhelix_k[5];      
     Double_t ferror_k[5][5];   
     Double_t fhelix_p[5];      
     Double_t ferror_p[5][5];   
    
     TCgemKalTrack *cgemKalTrackRoot = new TCgemKalTrack();             
     //m_common.m_cgemKalTrackMap[(*cgemKalTrackTds)] = cgemKalTrackRoot;
     RecCgemKalTrack* recCgemKalTrackTds=(RecCgemKalTrack*) (*cgemKalTrackTds);
   
     for(int k=0; k<5; k++){
      cgemKalTrackRoot->setStat((*cgemKalTrackTds)->getStat(k),k);
      cgemKalTrackRoot->setStat2(recCgemKalTrackTds->getStat(1,k),k);
      cgemKalTrackRoot->setChisq((*cgemKalTrackTds)->getChisq(k),k);
      cgemKalTrackRoot->setNdf((*cgemKalTrackTds)->getNdf(k),k);
      cgemKalTrackRoot->setFirstLayer((*cgemKalTrackTds)->getFirstLayer(k),k);
      cgemKalTrackRoot->setLastLayer((*cgemKalTrackTds)->getLastLayer(k),k);
     }
     
     //HepPoint3D h_poca        = (*cgemKalTrackTds)->getPoca(2);
     HepVector h_zhelix       = (*cgemKalTrackTds)->getZHelix(2);           
     HepSymMatrix h_zerror    = (*cgemKalTrackTds)->getZError(2);           
 
     //HepPoint3D h_poca_e      = (*cgemKalTrackTds)->getPoca(0); 
     HepVector h_zhelix_e     = (*cgemKalTrackTds)->getZHelix(0);          
     HepSymMatrix h_zerror_e  = (*cgemKalTrackTds)->getZError(0);          
 
     //HepPoint3D h_poca_mu     = (*cgemKalTrackTds)->getPoca(1);
     HepVector h_zhelix_mu    = (*cgemKalTrackTds)->getZHelix(1);         
     HepSymMatrix h_zerror_mu = (*cgemKalTrackTds)->getZError(1);         
 
     //HepPoint3D h_poca_k      = (*cgemKalTrackTds)->getPoca(3);
     HepVector h_zhelix_k     = (*cgemKalTrackTds)->getZHelix(3);          
     HepSymMatrix h_zerror_k  = (*cgemKalTrackTds)->getZError(3);          
 
     //HepPoint3D h_poca_p      = (*cgemKalTrackTds)->getPoca(4);
     HepVector h_zhelix_p     = (*cgemKalTrackTds)->getZHelix(4);          
     HepSymMatrix h_zerror_p  = (*cgemKalTrackTds)->getZError(4);          
                                
     HepVector h_fhelix       = (*cgemKalTrackTds)->getFHelix(2);           
     HepSymMatrix h_ferror    = (*cgemKalTrackTds)->getFError(2);           
     HepVector h_fhelix_e     = (*cgemKalTrackTds)->getFHelix(0);          
     HepSymMatrix h_ferror_e  = (*cgemKalTrackTds)->getFError(0);          
     HepVector h_fhelix_mu    = (*cgemKalTrackTds)->getFHelix(1);         
     HepSymMatrix h_ferror_mu = (*cgemKalTrackTds)->getFError(1);         
     HepVector h_fhelix_k     = (*cgemKalTrackTds)->getFHelix(3);          
     HepSymMatrix h_ferror_k  = (*cgemKalTrackTds)->getFError(3);          
     HepVector h_fhelix_p     = (*cgemKalTrackTds)->getFHelix(4);          
     HepSymMatrix h_ferror_p  = (*cgemKalTrackTds)->getFError(4);          
                                
     cgemKalTrackRoot->setTrackId((*cgemKalTrackTds)->getTrackId());
 
     /*
     for(int k=0; k<3; k++){
       poca[k] = h_poca[k];
       poca_e[k] = h_poca_e[k];
       poca_mu[k] = h_poca_mu[k];
       poca_k[k] = h_poca_k[k];
       poca_p[k] = h_poca_p[k];
     }
     */
     
     for (int i=0; i<5; i++){
       zhelix[i] = h_zhelix[i];
       zhelix_e[i] = h_zhelix_e[i];
       zhelix_mu[i] = h_zhelix_mu[i];
       zhelix_p[i] = h_zhelix_p[i];
       zhelix_k[i] = h_zhelix_k[i];
       fhelix[i] = h_fhelix[i];
       fhelix_e[i] = h_fhelix_e[i];
       fhelix_mu[i] = h_fhelix_mu[i];
       fhelix_p[i] = h_fhelix_p[i];
       fhelix_k[i] = h_fhelix_k[i];
       for (int j=0; j<=i; j++){
     zerror[i][j] = h_zerror[i][j];       
     zerror_e[i][j] = h_zerror_e[i][j];   
     zerror_mu[i][j] = h_zerror_mu[i][j]; 
     zerror_p[i][j] = h_zerror_p[i][j];   
     zerror_k[i][j] = h_zerror_k[i][j];   
     zerror[j][i] = h_zerror[i][j];        
     zerror_e[j][i] = h_zerror_e[i][j];  
     zerror_mu[j][i] = h_zerror_mu[i][j];
     zerror_p[j][i] = h_zerror_p[i][j];  
     zerror_k[j][i] = h_zerror_k[i][j];  
     ferror[i][j] = h_ferror[i][j];       
     ferror_e[i][j] = h_ferror_e[i][j];   
     ferror_mu[i][j] = h_ferror_mu[i][j]; 
     ferror_p[i][j] = h_ferror_p[i][j];   
     ferror_k[i][j] = h_ferror_k[i][j];   
     ferror[j][i] = h_ferror[i][j];        
     ferror_e[j][i] = h_ferror_e[i][j];  
     ferror_mu[j][i] = h_ferror_mu[i][j];
     ferror_p[j][i] = h_ferror_p[i][j];  
     ferror_k[j][i] = h_ferror_k[i][j];  
       }      
     }
 
     //cgemKalTrackRoot->setPoca(poca);
     cgemKalTrackRoot->setZHelix(zhelix);     
     cgemKalTrackRoot->setZError(zerror);     
 
     //cgemKalTrackRoot->setPocaE(poca_e);
     cgemKalTrackRoot->setZHelixE(zhelix_e);   
     cgemKalTrackRoot->setZErrorE(zerror_e);   
 
     //cgemKalTrackRoot->setPocaMu(poca_mu);
     cgemKalTrackRoot->setZHelixMu(zhelix_mu);  
     cgemKalTrackRoot->setZErrorMu(zerror_mu);  
 
     //cgemKalTrackRoot->setPocaK(poca_k);
     cgemKalTrackRoot->setZHelixK(zhelix_k);   
     cgemKalTrackRoot->setZErrorK(zerror_k);   
 
     //cgemKalTrackRoot->setPocaP(poca_p);
     cgemKalTrackRoot->setZHelixP(zhelix_p);   
     cgemKalTrackRoot->setZErrorP(zerror_p);
 
     cgemKalTrackRoot->setFHelix(fhelix);     
     cgemKalTrackRoot->setFError(ferror);     
 
     cgemKalTrackRoot->setFHelixE(fhelix_e);   
     cgemKalTrackRoot->setFErrorE(ferror_e);   
 
     cgemKalTrackRoot->setFHelixMu(fhelix_mu);  
     cgemKalTrackRoot->setFErrorMu(ferror_mu);  
 
     cgemKalTrackRoot->setFHelixK(fhelix_k);   
     cgemKalTrackRoot->setFErrorK(ferror_k);   
 
     cgemKalTrackRoot->setFHelixP(fhelix_p);   
     cgemKalTrackRoot->setFErrorP(ferror_p);
 
     recEvt->addCgemKalTrack(cgemKalTrackRoot);
  }
 
  return StatusCode::SUCCESS;
}
#endif