RecCgemKalTrackCnv.cxx

Go to the documentation of this file.

#ifndef RecCgemKalTrackCnv_CXX
#define RecCgemKalTrackCnv_CXX  1
 
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/DataObject.h"
#include "GaudiKernel/ObjectVector.h"
#include "TClonesArray.h"
#include "TClonesArray.h"
#include "Identifier/CgemID.h"
#include "Identifier/Identifier.h"
 
#include "EventModel/EventModel.h"
#include "CgemRecEvent/RecCgemKalTrack.h"
#include "CgemRecEvent/RecCgemKalHelixSeg.h"
#include "ReconEvent/ReconEvent.h"
//#include "RootEventData/TDstEvent.h"
#include "RootEventData/TRecTrackEvent.h"
#include "RootEventData/TRecCgemKalTrack.h"
 
#include "RootCnvSvc/Rec/RecTrackCnv.h"
#include "RootCnvSvc/Rec/RecCgemKalTrackCnv.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<RecCgemKalTrackCnv> s_factory;
//const ICnvFactory& RecCgemKalTrackCnvFactory = s_factory;
 
RecCgemKalTrackCnv::RecCgemKalTrackCnv(ISvcLocator* svc)
: RootEventBaseCnv(classID(), svc)
{
 
    // Here we associate this converter with the /Event path on the TDS.
    MsgStream log(msgSvc(), "RecCgemKalTrackCnv");
    //log << MSG::DEBUG << "Constructor called for " << objType() << endreq;
    //m_rootTreename ="Rec";
    m_rootBranchname ="m_recCgemKalTrackCol";
    // declareObject(EventModel::Recon::CgemKalTrackCol, objType(), m_rootTreename, m_rootBranchname);
    m_adresses.push_back(&m_recCgemKalTrackCol);
    m_recCgemKalTrackCol = 0;
}
 
StatusCode RecCgemKalTrackCnv::TObjectToDataObject(DataObject*& refpObject) {
  // creation of TDS object from root object
    MsgStream log(msgSvc(), "RecCgemKalTrackCnv");
    log << MSG::DEBUG << "RecCgemKalTrackCnv::TObjectToDataObject" << endreq;
    StatusCode sc = StatusCode::SUCCESS;
 
    // create the TDS location for the CgemKalTrack Collection
    RecCgemKalTrackCol* recCgemKalTrackCol = new RecCgemKalTrackCol;
    refpObject = recCgemKalTrackCol;
 
    // now convert
    if (!m_recCgemKalTrackCol) return sc;
    TIter recCgemKalTrackIter(m_recCgemKalTrackCol);
    
    IDataProviderSvc* dataSvc = 0;
    sc = serviceLocator()->getService ("EventDataSvc",  
       IDataProviderSvc::interfaceID(), (IInterface*&)dataSvc);
    if (!sc.isSuccess()) {
        log << MSG::FATAL << "Could not get EventDataSvc in RecCgemTrackCnv" << endreq;
        return( StatusCode::FAILURE);
    }
    SmartDataPtr<RecCgemKalHelixSegCol> recCgemKalHelixSegCol(dataSvc,"/Event/Recon/RecCgemKalHelixSegCol");
    if (!recCgemKalHelixSegCol) {
        log << MSG::FATAL << "Could not find RecCgemKalHelixSegCol" << endreq;
        return( StatusCode::FAILURE);
    }
 
    TRecCgemKalTrack *recCgemKalTrackRoot = 0;
    while ((recCgemKalTrackRoot = (TRecCgemKalTrack*)recCgemKalTrackIter.Next())) {
 
      std::vector<HepVector> zhelixs;
      std::vector<HepSymMatrix> zerrors;
      std::vector<HepVector> fhelixs;
      std::vector<HepSymMatrix> ferrors;
      std::vector<HepVector> lhelixs;
      std::vector<HepSymMatrix> lerrors;
      std::vector<HepPoint3D> pocas;
      std::vector<HepPoint3D> lpivots;
      std::vector<HepPoint3D> lpoints;
 
      
      HepVector zhelix(5); 
      HepSymMatrix zerror(5); 
      HepVector fhelix(5);
      HepSymMatrix ferror(5);
      HepVector lhelix(5);
      HepSymMatrix lerror(5);
      HepVector thelix(5);
      HepSymMatrix terror(5);
      HepPoint3D poca(0,0,0);
      HepPoint3D lpivot(0,0,0); 
      HepPoint3D lpoint(0,0,0); 
      
    
      HepVector zhelix_e(5); 
      HepSymMatrix zerror_e(5); 
      HepVector fhelix_e(5);
      HepSymMatrix ferror_e(5); 
      HepVector lhelix_e(5);
      HepSymMatrix lerror_e(5);
      HepPoint3D poca_e(0,0,0);
      HepPoint3D lpivot_e(0,0,0); 
      HepPoint3D lpoint_e(0,0,0); 
      
    
      HepVector zhelix_mu(5); 
      HepSymMatrix zerror_mu(5); 
      HepVector fhelix_mu(5);
      HepSymMatrix ferror_mu(5);
      HepVector lhelix_mu(5);
      HepSymMatrix lerror_mu(5);
      HepPoint3D poca_mu(0,0,0);
      HepPoint3D lpivot_mu(0,0,0); 
      HepPoint3D lpoint_mu(0,0,0); 
      
    
      HepVector zhelix_k(5); 
      HepSymMatrix zerror_k(5);  
      HepVector fhelix_k(5);
      HepSymMatrix ferror_k(5);
      HepVector lhelix_k(5);
      HepSymMatrix lerror_k(5);
      HepPoint3D poca_k(0,0,0);
      HepPoint3D lpivot_k(0,0,0); 
      HepPoint3D lpoint_k(0,0,0); 
      
    
      HepVector zhelix_p(5);  
      HepSymMatrix zerror_p(5);
      HepVector fhelix_p(5);
      HepSymMatrix ferror_p(5);
      HepVector lhelix_p(5);
      HepSymMatrix lerror_p(5);
      HepPoint3D poca_p(0,0,0);
      HepPoint3D lpivot_p(0,0,0); 
      HepPoint3D lpoint_p(0,0,0); 
 
       
      int stat[2][5];
      double chisq[2][5];
      int ndf[2][5];
 
      double  mass[5];
      double  length[5];
      double  tof[5]; 
      int     nhits[5];
      int     trackId;
      double  pathSM[5];
      double  fiTerm[5]; 
      //std::cout<<" step 0: "<<std::endl;
      
      
     RecCgemKalTrack *recCgemKalTrackTds = new RecCgemKalTrack();
 
     //std::cout<<" step 1: "<<std::endl;
     
     trackId = recCgemKalTrackRoot->getTrackId();
     // std::cout<<"track id: "<<trackId<<std::endl;
     recCgemKalTrackTds->setTrackId(trackId);
     
     for (int u=0; u<5; u++){                     
       mass[u]   = recCgemKalTrackRoot->getMass(u);          
       length[u] = recCgemKalTrackRoot->getLength(u);      
       tof[u]    = recCgemKalTrackRoot->getTof(u);            
       nhits[u]  = recCgemKalTrackRoot->getNhits(u);          
       fiTerm[u]=recCgemKalTrackRoot->getfiTerm(u);
       pathSM[u]=recCgemKalTrackRoot->getPathSM(u); 
       
       recCgemKalTrackTds->setMass(mass[u],u);     
       recCgemKalTrackTds->setLength(length[u],u); 
       recCgemKalTrackTds->setTof(tof[u],u);       
       recCgemKalTrackTds->setNhits(nhits[u],u);     
       recCgemKalTrackTds->setFiTerm(fiTerm[u],u);     
       recCgemKalTrackTds->setPathSM(pathSM[u],u);     
     }    
 
 
     for(int v=0; v<3; v++){
       poca_e[v]  = recCgemKalTrackRoot->getPocaE(v);   
       poca_mu[v] = recCgemKalTrackRoot->getPocaMu(v);
       poca[v]    = recCgemKalTrackRoot->getPoca(v);
       poca_k[v]  = recCgemKalTrackRoot->getPocaK(v);
       poca_p[v]  = recCgemKalTrackRoot->getPocaP(v);
       lpivot_e[v]  = recCgemKalTrackRoot->getLPivotE(v);
       lpivot_mu[v] = recCgemKalTrackRoot->getLPivotMu(v);
       lpivot[v]    = recCgemKalTrackRoot->getLPivot(v);
       lpivot_k[v]  = recCgemKalTrackRoot->getLPivotK(v);
       lpivot_p[v]  = recCgemKalTrackRoot->getLPivotP(v);
       lpoint_e[v]  = recCgemKalTrackRoot->getLPointE(v);
       lpoint_mu[v] = recCgemKalTrackRoot->getLPointMu(v);
       lpoint[v]    = recCgemKalTrackRoot->getLPoint(v);
       lpoint_k[v]  = recCgemKalTrackRoot->getLPointK(v);
       lpoint_p[v]  = recCgemKalTrackRoot->getLPointP(v);
       //std::cout<<"poca_e[v]: "<<setprecision(6)<<poca_e[v]<<std::endl;
       //std::cout<<"lpoint_e[v]: "<<setprecision(6)<<lpoint_e[v]<<std::endl;
       //std::cout<<"lpivot_e[v]: "<<setprecision(6)<<lpivot_e[v]<<std::endl;
     
     }
     
     for (int i=0, k=0; i<5; i++){
       zhelix[i]    = recCgemKalTrackRoot->getZHelix(i);
       zhelix_e[i]  = recCgemKalTrackRoot->getZHelixE(i);
       zhelix_mu[i] = recCgemKalTrackRoot->getZHelixMu(i);
       zhelix_k[i]  = recCgemKalTrackRoot->getZHelixK(i);
       zhelix_p[i]  = recCgemKalTrackRoot->getZHelixP(i);
                             
 
       fhelix[i]    = recCgemKalTrackRoot->getFHelix(i);
       fhelix_e[i]  = recCgemKalTrackRoot->getFHelixE(i);
       fhelix_mu[i] = recCgemKalTrackRoot->getFHelixMu(i);
       fhelix_k[i]  = recCgemKalTrackRoot->getFHelixK(i);
       fhelix_p[i]  = recCgemKalTrackRoot->getFHelixP(i);
    
       lhelix[i]    = recCgemKalTrackRoot->getLHelix(i);
       lhelix_e[i]  = recCgemKalTrackRoot->getLHelixE(i);
       lhelix_mu[i] = recCgemKalTrackRoot->getLHelixMu(i);
       lhelix_k[i]  = recCgemKalTrackRoot->getLHelixK(i);
       lhelix_p[i]  = recCgemKalTrackRoot->getLHelixP(i);
 
       thelix[i]    = recCgemKalTrackRoot->getTHelix(i);
       
       for (int j=0; j<=i; j++){
 
     zerror[i][j]    = recCgemKalTrackRoot->getZError(i,j);
     zerror_e[i][j]  = recCgemKalTrackRoot->getZErrorE(i,j);
     zerror_mu[i][j] = recCgemKalTrackRoot->getZErrorMu(i,j);
     zerror_k[i][j]  = recCgemKalTrackRoot->getZErrorK(i,j);
     zerror_p[i][j]  = recCgemKalTrackRoot->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]    = recCgemKalTrackRoot->getFError(i,j);
     ferror_e[i][j]  = recCgemKalTrackRoot->getFErrorE(i,j);
     ferror_mu[i][j] = recCgemKalTrackRoot->getFErrorMu(i,j);
     ferror_k[i][j]  = recCgemKalTrackRoot->getFErrorK(i,j);
     ferror_p[i][j]  = recCgemKalTrackRoot->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];
 
     lerror[i][j]    = recCgemKalTrackRoot->getLError(i,j);
     lerror_e[i][j]  = recCgemKalTrackRoot->getLErrorE(i,j);
     lerror_mu[i][j] = recCgemKalTrackRoot->getLErrorMu(i,j);
     lerror_k[i][j]  = recCgemKalTrackRoot->getLErrorK(i,j);
     lerror_p[i][j]  = recCgemKalTrackRoot->getLErrorP(i,j);
     lerror[j][i]    = lerror[i][j];
     lerror_e[j][i]  = lerror_e[i][j];
     lerror_mu[j][i] = lerror_mu[i][j];
     lerror_k[j][i]  = lerror_k[i][j];
     lerror_p[j][i]  = lerror_p[i][j];
     
     terror[i][j] = recCgemKalTrackRoot->getTError(k++);
     terror[j][i] = terror[i][j];
 
       }    
     }
 
     //std::cout<<" step 2: "<<std::endl;
 
     //std::cout<<"T to rec tds: "<<endl;
     //std::cout<<"lpoint_e: "<<lpoint_e<<std::endl;
     //std::cout<<"lpivot_e: "<<lpivot_e<<std::endl;
     /// for zero point
     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);
     /// first hit point
     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);
     /// last hit point
     lhelixs.push_back(lhelix_e);
     lhelixs.push_back(lhelix_mu);
     lhelixs.push_back(lhelix);
     lhelixs.push_back(lhelix_k);
     lhelixs.push_back(lhelix_p); 
     lerrors.push_back(lerror_e);
     lerrors.push_back(lerror_mu);
     lerrors.push_back(lerror);
     lerrors.push_back(lerror_k);
     lerrors.push_back(lerror_p);
     /// track finding helix for dE/dx usage
     
     pocas.push_back(poca_e);
     pocas.push_back(poca_mu);
     pocas.push_back(poca);
     pocas.push_back(poca_k);
     pocas.push_back(poca_p);
     lpivots.push_back(lpivot_e);
     lpivots.push_back(lpivot_mu);
     lpivots.push_back(lpivot);
     lpivots.push_back(lpivot_k);
     lpivots.push_back(lpivot_p);
     lpoints.push_back(lpoint_e);
     lpoints.push_back(lpoint_mu);
     lpoints.push_back(lpoint);
     lpoints.push_back(lpoint_k);
     lpoints.push_back(lpoint_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);
  // cout<<"x, y, z, charge, px, py, pz, ptot: "<<x<<" , "<<y<<" , "<<z<<" , "<<charge<<" , "<<px<<" , "<<py<<" , "<<pz<<" , "<<ptot<<endl;
   recCgemKalTrackTds->setCharge(charge,m);
   recCgemKalTrackTds->setPxy(pxy,m);
   recCgemKalTrackTds->setPx(px,m);
   recCgemKalTrackTds->setPy(py,m);
   recCgemKalTrackTds->setPz(pz,m);
   recCgemKalTrackTds->setP(ptot,m);
   recCgemKalTrackTds->setTheta(acos(pz/ptot),m);
   recCgemKalTrackTds->setPhi(atan2(py,px),m);
   recCgemKalTrackTds->setX(x,m);
   recCgemKalTrackTds->setY(y,m);
   recCgemKalTrackTds->setZ(z,m);
   recCgemKalTrackTds->setR(sqrt(x*x+y*y),m);
   /// the next three function need more consideration, temporarily
 
   for(int n=0; n<2; n++){
   int stat  = recCgemKalTrackRoot->getStat(n,m);
   int chisq = recCgemKalTrackRoot->getChisq(n,m);
   int ndf   = recCgemKalTrackRoot->getNdf(n,m);
   recCgemKalTrackTds->setStat(stat,n,m);
   recCgemKalTrackTds->setChisq(chisq,n,m);
   recCgemKalTrackTds->setNdf(ndf,n,m);
   }
 }
 
   //std::cout<<" step 3: "<<std::endl;
 
 
   
 for(int jj=0; jj<5; jj++){
   //std::cout<<" step 3.0: "<<std::endl;
   //std::cout<<"zhelixs[jj]: "<<zhelixs[jj]<<std::endl;
   
   recCgemKalTrackTds->setZHelix(zhelixs[jj],jj);
   //std::cout<<" step 3.1: "<<std::endl;
    
   recCgemKalTrackTds->setZError(zerrors[jj],jj);
   recCgemKalTrackTds->setFHelix(fhelixs[jj],jj);
   recCgemKalTrackTds->setFError(ferrors[jj],jj);
   //std::cout<<" step 3.5: "<<std::endl;
   
   recCgemKalTrackTds->setLHelix(lhelixs[jj],jj);
   recCgemKalTrackTds->setLError(lerrors[jj],jj);
   recCgemKalTrackTds->setPoca(pocas[jj],jj);
 
 
   recCgemKalTrackTds->setLPoint(lpoints[jj],jj);
   recCgemKalTrackTds->setLPivot(lpivots[jj],jj);
 }
   recCgemKalTrackTds->setTHelix(thelix);
   recCgemKalTrackTds->setTError(terror);
 
 //std::cout<<" step 4: "<<std::endl;
 
 
 log<<MSG::DEBUG<<"T to REC TDS, zhelix: "<<zhelix<<endreq;
 log<<MSG::DEBUG<<"T to REC TDS, zerror: "<<zerror<<endreq;
 
 m_common.m_rootRecCgemKalTrackMap[recCgemKalTrackRoot] = recCgemKalTrackTds;
 
    RecCgemHelixSegRefVec theKalHelixSegRefVec;
 
    RecCgemKalHelixSegCol::iterator iter = recCgemKalHelixSegCol->begin();
    for (;iter != recCgemKalHelixSegCol->end(); iter++){
  
      //cout<<" (*iter)->getTrkId(): "<<(*iter)->getTrkId()<<endl;
      if((*iter)->getTrackId() == trackId){
    SmartRef<RecCgemKalHelixSeg> refhit(*iter);
    theKalHelixSegRefVec.push_back(refhit);
      }
    }
 
    recCgemKalTrackTds->setVecHelixSegs(theKalHelixSegRefVec);
    
    int nhelixsegs = recCgemKalTrackTds->getVecHelixSegs().size();
          
    //std::cout<<" cgem hits: "<<nhelixsegs<< std::endl;
    
    for(int ii=0; ii <nhelixsegs ; ii++)
    {
      //cout<<"ddl: "<<(recCgemTrack->getVecKalHelixSegs()[ii])->getDriftDistLeft()<<endl;
      //cout<<"erddl: "<<(recCgemTrack->getVecKalHelixSegs()[ii])->getErrDriftDistLeft()<<endl;
      Identifier id(recCgemKalTrackTds->getVecHelixSegs()[ii]->getCgemId());
      int layer = CgemID::layer(id);
      int sheet = CgemID::sheet(id);
      int strip = CgemID::strip(id);
      //cout<<"layer: "<<layer<<" wire: "<<wire<<endl;
    } 
 
    recCgemKalTrackCol->push_back(recCgemKalTrackTds);
    
    }
 
    delete m_recCgemKalTrackCol;
    
    m_recCgemKalTrackCol = 0;  
   
    return StatusCode::SUCCESS;
}
 
 
StatusCode RecCgemKalTrackCnv::DataObjectToTObject(DataObject* obj,RootAddress* rootaddr) {
 
 
 
  MsgStream log(msgSvc(), "RecCgemKalTrackCnv");
  log << MSG::DEBUG << "RecCgemKalTrackCnv::DataObjectToTObject" << endreq;
  StatusCode sc=StatusCode::SUCCESS;
 
  RecCgemKalTrackCol * cgemKalTrackColTds=dynamic_cast<RecCgemKalTrackCol *> (obj);
  if (!cgemKalTrackColTds) {
    log << MSG::ERROR << "Could not downcast to RecCgemKalTrackCol" << endreq;
    return StatusCode::FAILURE;
  }
      
  DataObject *evt;
  m_eds->findObject(EventModel::Recon::Event,evt);
  if (evt==NULL) {
    log << MSG::ERROR << "Could not get ReconEvent in TDS "  << endreq;
    return StatusCode::FAILURE;
  }
 
  ReconEvent * devtTds=dynamic_cast<ReconEvent *> (evt);
  if (!devtTds) {
    log << MSG::ERROR << "CgemKalTrackCnv:Could not downcast to TDS Recon Event" << endreq;
  }
  IOpaqueAddress *addr;
 
  m_cnvSvc->getRecTrackCnv()->createRep(evt,addr); 
  TRecTrackEvent *recEvt=m_cnvSvc->getRecTrackCnv()->getWriteObject();
 
  const TObjArray *m_recCgemKalTrackCol = recEvt->getRecCgemKalTrackCol();
  
  if (!m_recCgemKalTrackCol) return sc;
  
  recEvt->clearRecCgemKalTrackCol(); //necessary in case there is I/O at the same time since array is static
  RecCgemKalTrackCol::const_iterator cgemKalTrackTds;
 
  for (cgemKalTrackTds = cgemKalTrackColTds->begin(); cgemKalTrackTds != cgemKalTrackColTds->end(); cgemKalTrackTds++) {
 
    // Get Data from TDS
    // root data
       Int_t trackId;
       Double_t mass[5];          
       Double_t length[5];        
       Double_t tof[5];           
       Int_t nhits[5];           
       Int_t stat[2][5];            
       Double_t chisq[2][5];      
       Int_t ndf[2][5];        
       Double_t fiTerm[5];
       Double_t pathSM[5];
 
       Double_t poca_e[3];
       Double_t poca_mu[3];
       Double_t poca[3];
       Double_t poca_k[3];
       Double_t poca_p[3];
 
       Double_t zhelix[5];        
       Double_t zerror[5][5];     
       Double_t zhelix_e[5];      
       Double_t zerror_e[5][5];   
       Double_t zhelix_mu[5];     
       Double_t zerror_mu[5][5];  
       Double_t zhelix_k[5];      
       Double_t zerror_k[5][5];   
       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];      
                                    
       Double_t lhelix[5];           
       Double_t lerror[5][5];               
       Double_t lhelix_e[5];            
       Double_t lerror_e[5][5];          
       Double_t lhelix_mu[5];           
       Double_t lerror_mu[5][5];  
       Double_t lhelix_k[5];      
       Double_t lerror_k[5][5];   
       Double_t lhelix_p[5];      
       Double_t lerror_p[5][5];  
     
       Double_t thelix[5];        
       Double_t terror[15];        
 
       Double_t lpoint_e[3];
       Double_t lpoint_mu[3];
       Double_t lpoint[3];
       Double_t lpoint_k[3];
       Double_t lpoint_p[3];
 
       Double_t lpivot_e[3];
       Double_t lpivot_mu[3];
       Double_t lpivot[3];
       Double_t lpivot_k[3];
       Double_t lpivot_p[3];
 
       TRecCgemKalTrack *cgemKalTrackRoot = new TRecCgemKalTrack();             
     
       trackId = (*cgemKalTrackTds)->getTrackId();
       for (Int_t i = 0 ; i < 5 ; i++){                     
        mass[i] = (*cgemKalTrackTds)->getMass(i);          
        length[i] = (*cgemKalTrackTds)->getLength(i);      
        tof[i] = (*cgemKalTrackTds)->getTof(i);            
        nhits[i] = (*cgemKalTrackTds)->getNhits(i);         
        fiTerm[i]=(*cgemKalTrackTds)->getFiTerm(i); 
        pathSM[i]=(*cgemKalTrackTds)->getPathSM(i); 
    //stat[i] = (*cgemKalTrackTds)->getStat(i);                
        for (Int_t j = 0 ; j< 2 ; j++){                    
    stat[j][i] = (*cgemKalTrackTds)->getStat(j,i);
    chisq[j][i] = (*cgemKalTrackTds)->getChisq(j,i);
    ndf[j][i] = (*cgemKalTrackTds)->getNdf(j,i);
    cgemKalTrackRoot->setStat(stat[j][i],j,i);
    cgemKalTrackRoot->setChisq(chisq[j][i],j,i);     
    cgemKalTrackRoot->setNdf(ndf[j][i],j,i);         
        }                                                 
       }    
       for(Int_t i=0;i<5;i++){
           log<<MSG::INFO<<" recCgemKalTrack.helix("<<i<<"): "<<(*cgemKalTrackTds)->getTHelix(i)<<endreq;
           thelix[i] = (*cgemKalTrackTds)->getTHelix(i);
       }
       for(Int_t i=0; i<15; i++){
           terror[i] = (*cgemKalTrackTds)->getTError(i);
       }
       HepPoint3D h_poca_e     = (*cgemKalTrackTds)->getPocaE();
       HepPoint3D h_poca_mu    = (*cgemKalTrackTds)->getPocaMu();
       HepPoint3D h_poca       = (*cgemKalTrackTds)->getPoca();
       HepPoint3D h_poca_k     = (*cgemKalTrackTds)->getPocaK();
       HepPoint3D h_poca_p     = (*cgemKalTrackTds)->getPocaP();
       HepPoint3D h_lpoint_e   = (*cgemKalTrackTds)->getLPointE();
       HepPoint3D h_lpoint_mu  = (*cgemKalTrackTds)->getLPointMu();
       HepPoint3D h_lpoint     = (*cgemKalTrackTds)->getLPoint();
       HepPoint3D h_lpoint_k   = (*cgemKalTrackTds)->getLPointK();
       HepPoint3D h_lpoint_p   = (*cgemKalTrackTds)->getLPointP();
       HepPoint3D h_lpivot_e   = (*cgemKalTrackTds)->getLPivotE();
       HepPoint3D h_lpivot_mu  = (*cgemKalTrackTds)->getLPivotMu();
       HepPoint3D h_lpivot     = (*cgemKalTrackTds)->getLPivot();
       HepPoint3D h_lpivot_k   = (*cgemKalTrackTds)->getLPivotK();
       HepPoint3D h_lpivot_p   = (*cgemKalTrackTds)->getLPivotP();
 
       //std::cout<<" h_poca_mu: "<<h_poca_mu<<std::endl;
       //std::cout<<" h_poca: "<<h_poca<<std::endl;
       //std::cout<<" h_poca_k: "<<h_poca_k<<std::endl;
       //std::cout<<" h_poca_p: "<<h_poca_p<<std::endl;
       
       
       HepVector h_zhelix      = (*cgemKalTrackTds)->getZHelix();           
       HepSymMatrix h_zerror   = (*cgemKalTrackTds)->getZError();           
       HepVector h_zhelix_e    = (*cgemKalTrackTds)->getZHelixE();          
       HepSymMatrix h_zerror_e = (*cgemKalTrackTds)->getZErrorE();          
       HepVector h_zhelix_mu   = (*cgemKalTrackTds)->getZHelixMu();         
       HepSymMatrix h_zerror_mu= (*cgemKalTrackTds)->getZErrorMu();         
       HepVector h_zhelix_k    = (*cgemKalTrackTds)->getZHelixK();          
       HepSymMatrix h_zerror_k = (*cgemKalTrackTds)->getZErrorK();          
       HepVector h_zhelix_p    = (*cgemKalTrackTds)->getZHelixP();          
       HepSymMatrix h_zerror_p = (*cgemKalTrackTds)->getZErrorP();          
                                                                  
       HepVector h_fhelix      = (*cgemKalTrackTds)->getFHelix();    
       HepSymMatrix h_ferror   = (*cgemKalTrackTds)->getFError();    
       HepVector h_fhelix_e    = (*cgemKalTrackTds)->getFHelixE();   
       HepSymMatrix h_ferror_e = (*cgemKalTrackTds)->getFErrorE();   
       HepVector h_fhelix_mu   = (*cgemKalTrackTds)->getFHelixMu();  
       HepSymMatrix h_ferror_mu= (*cgemKalTrackTds)->getFErrorMu();  
       HepVector h_fhelix_k    = (*cgemKalTrackTds)->getFHelixK();   
       HepSymMatrix h_ferror_k = (*cgemKalTrackTds)->getFErrorK();   
       HepVector h_fhelix_p    = (*cgemKalTrackTds)->getFHelixP();   
       HepSymMatrix h_ferror_p = (*cgemKalTrackTds)->getFErrorP();   
                                                                  
       HepVector h_lhelix      = (*cgemKalTrackTds)->getLHelix();    
       HepSymMatrix h_lerror   = (*cgemKalTrackTds)->getLError();    
       HepVector h_lhelix_e    = (*cgemKalTrackTds)->getLHelixE();   
       HepSymMatrix h_lerror_e = (*cgemKalTrackTds)->getLErrorE();   
       HepVector h_lhelix_mu   = (*cgemKalTrackTds)->getLHelixMu();  
       HepSymMatrix h_lerror_mu= (*cgemKalTrackTds)->getLErrorMu();  
       HepVector h_lhelix_k    = (*cgemKalTrackTds)->getLHelixK();   
       HepSymMatrix h_lerror_k = (*cgemKalTrackTds)->getLErrorK();   
       HepVector h_lhelix_p    = (*cgemKalTrackTds)->getLHelixP();   
       HepSymMatrix h_lerror_p = (*cgemKalTrackTds)->getLErrorP();   
                                
       cgemKalTrackRoot->setTrackId(trackId);
       cgemKalTrackRoot->setMass(mass);     
       cgemKalTrackRoot->setLength(length); 
       cgemKalTrackRoot->setTof(tof);       
       cgemKalTrackRoot->setNhits(nhits);     
       cgemKalTrackRoot->setFiTerm(fiTerm);     
       cgemKalTrackRoot->setPathSM(pathSM);     
       // cgemKalTrackRoot->setStat(stat);     
    
       for(int s=0; s<3; s++){
     poca_e[s]  = h_poca_e[s];
     poca_mu[s] = h_poca_mu[s];
     poca[s]    = h_poca[s];
     poca_k[s]  = h_poca_k[s];
     poca_p[s]  = h_poca_p[s];
     lpoint_e[s]  = h_lpoint_e[s];
     lpoint_mu[s] = h_lpoint_mu[s];
     lpoint[s]    = h_lpoint[s];
     lpoint_k[s]  = h_lpoint_k[s];
     lpoint_p[s]  = h_lpoint_p[s];
     lpivot_e[s]  = h_lpivot_e[s];
     lpivot_mu[s] = h_lpivot_mu[s];
     lpivot[s]    = h_lpivot[s];
     lpivot_k[s]  = h_lpivot_k[s];
     lpivot_p[s]  = h_lpivot_p[s];
       }
       
       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]; 
      
        lhelix[i]    = h_lhelix[i];      
        lhelix_e[i]  = h_lhelix_e[i];  
        lhelix_mu[i] = h_lhelix_mu[i];
        lhelix_p[i]  = h_lhelix_p[i];  
        lhelix_k[i]  = h_lhelix_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];   
      
        
      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];   
      
    
      lerror[i][j]    = h_lerror[i][j];       
      lerror_e[i][j]  = h_lerror_e[i][j];   
      lerror_mu[i][j] = h_lerror_mu[i][j]; 
      lerror_p[i][j]  = h_lerror_p[i][j];   
      lerror_k[i][j]  = h_lerror_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[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];  
      
        
      lerror[j][i]    = h_lerror[i][j];      
      lerror_e[j][i]  = h_lerror_e[i][j];  
      lerror_mu[j][i] = h_lerror_mu[i][j];
      lerror_p[j][i]  = h_lerror_p[i][j];  
      lerror_k[j][i]  = h_lerror_k[i][j];  
 
    }      
       }
       
       cgemKalTrackRoot->setZHelix(zhelix);     
       cgemKalTrackRoot->setZError(zerror);   
       for(int k=0; k<5; k++){
     log<<MSG::INFO<<" RecCgemKalTrackRoot.ZHelix "<<"["<<k<<"]"
                   <<cgemKalTrackRoot->getZHelix(k)<<endreq;
       }
       cgemKalTrackRoot->setZHelixE(zhelix_e);   
       cgemKalTrackRoot->setZErrorE(zerror_e);   
       cgemKalTrackRoot->setZHelixMu(zhelix_mu);  
       cgemKalTrackRoot->setZErrorMu(zerror_mu);  
       cgemKalTrackRoot->setZHelixK(zhelix_k);          
       cgemKalTrackRoot->setZErrorK(zerror_k);   
       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);   
     
       cgemKalTrackRoot->setLHelix(lhelix);         
       cgemKalTrackRoot->setLError(lerror);        
       cgemKalTrackRoot->setLHelixE(lhelix_e);     
       cgemKalTrackRoot->setLErrorE(lerror_e);     
       cgemKalTrackRoot->setLHelixMu(lhelix_mu);   
       cgemKalTrackRoot->setLErrorMu(lerror_mu);   
       cgemKalTrackRoot->setLHelixK(lhelix_k);     
       cgemKalTrackRoot->setLErrorK(lerror_k);     
       cgemKalTrackRoot->setLHelixP(lhelix_p);     
       cgemKalTrackRoot->setLErrorP(lerror_p);    
        
       cgemKalTrackRoot->setTHelix(thelix);         
       cgemKalTrackRoot->setTError(terror);        
 
       cgemKalTrackRoot->setPocaE(poca_e);
       cgemKalTrackRoot->setPocaMu(poca_mu);
       cgemKalTrackRoot->setPoca(poca);
       cgemKalTrackRoot->setPocaK(poca_k);
       cgemKalTrackRoot->setPocaP(poca_p);
                   
       cgemKalTrackRoot->setLPointE(lpoint_e);
       cgemKalTrackRoot->setLPointMu(lpoint_mu);
       cgemKalTrackRoot->setLPoint(lpoint);
       cgemKalTrackRoot->setLPointK(lpoint_k);
       cgemKalTrackRoot->setLPointP(lpoint_p);
 
       cgemKalTrackRoot->setLPivotE(lpivot_e);
       cgemKalTrackRoot->setLPivotMu(lpivot_mu);
       cgemKalTrackRoot->setLPivot(lpivot);
       cgemKalTrackRoot->setLPivotK(lpivot_k);
       cgemKalTrackRoot->setLPivotP(lpivot_p);
       //std::cout<<" cgemKalTrackRoot->getPivotE(1): "<<cgemKalTrackRoot->getLPivotE(1)<<std::endl;
       
       recEvt->addRecCgemKalTrack(cgemKalTrackRoot);
  }
 
 
  return StatusCode::SUCCESS;
}
#endif