00001 #ifndef RecMdcKalTrackCnv_CXX
00002 #define RecMdcKalTrackCnv_CXX 1
00003
00004 #include "GaudiKernel/MsgStream.h"
00005 #include "GaudiKernel/DataObject.h"
00006 #include "GaudiKernel/ObjectVector.h"
00007 #include "TClonesArray.h"
00008 #include "TClonesArray.h"
00009 #include "Identifier/MdcID.h"
00010 #include "Identifier/Identifier.h"
00011
00012 #include "EventModel/EventModel.h"
00013 #include "MdcRecEvent/RecMdcKalTrack.h"
00014 #include "MdcRecEvent/RecMdcKalHelixSeg.h"
00015 #include "ReconEvent/ReconEvent.h"
00016
00017 #include "RootEventData/TRecTrackEvent.h"
00018 #include "RootEventData/TRecMdcKalTrack.h"
00019
00020 #include "RootCnvSvc/Rec/RecTrackCnv.h"
00021 #include "RootCnvSvc/Rec/RecMdcKalTrackCnv.h"
00022 #include "RootCnvSvc/RootAddress.h"
00023
00024 #include <vector>
00025
00026 using namespace std;
00027
00028
00029
00030
00031
00032
00033 RecMdcKalTrackCnv::RecMdcKalTrackCnv(ISvcLocator* svc)
00034 : RootEventBaseCnv(classID(), svc)
00035 {
00036
00037
00038 MsgStream log(msgSvc(), "RecMdcKalTrackCnv");
00039
00040
00041 m_rootBranchname ="m_recMdcKalTrackCol";
00042
00043 m_adresses.push_back(&m_recMdcKalTrackCol);
00044 m_recMdcKalTrackCol = 0;
00045 }
00046
00047 StatusCode RecMdcKalTrackCnv::TObjectToDataObject(DataObject*& refpObject) {
00048
00049 MsgStream log(msgSvc(), "RecMdcKalTrackCnv");
00050 log << MSG::DEBUG << "RecMdcKalTrackCnv::TObjectToDataObject" << endreq;
00051 StatusCode sc = StatusCode::SUCCESS;
00052
00053
00054 RecMdcKalTrackCol* recMdcKalTrackCol = new RecMdcKalTrackCol;
00055 refpObject = recMdcKalTrackCol;
00056
00057
00058 if (!m_recMdcKalTrackCol) return sc;
00059 TIter recMdcKalTrackIter(m_recMdcKalTrackCol);
00060
00061 IDataProviderSvc* dataSvc = 0;
00062 sc = serviceLocator()->getService ("EventDataSvc",
00063 IDataProviderSvc::interfaceID(), (IInterface*&)dataSvc);
00064 if (!sc.isSuccess()) {
00065 log << MSG::FATAL << "Could not get EventDataSvc in RecMdcTrackCnv" << endreq;
00066 return( StatusCode::FAILURE);
00067 }
00068 SmartDataPtr<RecMdcKalHelixSegCol> recMdcKalHelixSegCol(dataSvc,"/Event/Recon/RecMdcKalHelixSegCol");
00069 if (!recMdcKalHelixSegCol) {
00070 log << MSG::FATAL << "Could not find RecMdcKalHelixSegCol" << endreq;
00071 return( StatusCode::FAILURE);
00072 }
00073
00074 TRecMdcKalTrack *recMdcKalTrackRoot = 0;
00075 while ((recMdcKalTrackRoot = (TRecMdcKalTrack*)recMdcKalTrackIter.Next())) {
00076
00077 std::vector<HepVector> zhelixs;
00078 std::vector<HepSymMatrix> zerrors;
00079 std::vector<HepVector> fhelixs;
00080 std::vector<HepSymMatrix> ferrors;
00081 std::vector<HepVector> lhelixs;
00082 std::vector<HepSymMatrix> lerrors;
00083 std::vector<HepPoint3D> pocas;
00084 std::vector<HepPoint3D> lpivots;
00085 std::vector<HepPoint3D> lpoints;
00086
00087
00088 HepVector zhelix(5);
00089 HepSymMatrix zerror(5);
00090 HepVector fhelix(5);
00091 HepSymMatrix ferror(5);
00092 HepVector lhelix(5);
00093 HepSymMatrix lerror(5);
00094 HepVector thelix(5);
00095 HepSymMatrix terror(5);
00096 HepPoint3D poca(0,0,0);
00097 HepPoint3D lpivot(0,0,0);
00098 HepPoint3D lpoint(0,0,0);
00099
00100
00101 HepVector zhelix_e(5);
00102 HepSymMatrix zerror_e(5);
00103 HepVector fhelix_e(5);
00104 HepSymMatrix ferror_e(5);
00105 HepVector lhelix_e(5);
00106 HepSymMatrix lerror_e(5);
00107 HepPoint3D poca_e(0,0,0);
00108 HepPoint3D lpivot_e(0,0,0);
00109 HepPoint3D lpoint_e(0,0,0);
00110
00111
00112 HepVector zhelix_mu(5);
00113 HepSymMatrix zerror_mu(5);
00114 HepVector fhelix_mu(5);
00115 HepSymMatrix ferror_mu(5);
00116 HepVector lhelix_mu(5);
00117 HepSymMatrix lerror_mu(5);
00118 HepPoint3D poca_mu(0,0,0);
00119 HepPoint3D lpivot_mu(0,0,0);
00120 HepPoint3D lpoint_mu(0,0,0);
00121
00122
00123 HepVector zhelix_k(5);
00124 HepSymMatrix zerror_k(5);
00125 HepVector fhelix_k(5);
00126 HepSymMatrix ferror_k(5);
00127 HepVector lhelix_k(5);
00128 HepSymMatrix lerror_k(5);
00129 HepPoint3D poca_k(0,0,0);
00130 HepPoint3D lpivot_k(0,0,0);
00131 HepPoint3D lpoint_k(0,0,0);
00132
00133
00134 HepVector zhelix_p(5);
00135 HepSymMatrix zerror_p(5);
00136 HepVector fhelix_p(5);
00137 HepSymMatrix ferror_p(5);
00138 HepVector lhelix_p(5);
00139 HepSymMatrix lerror_p(5);
00140 HepPoint3D poca_p(0,0,0);
00141 HepPoint3D lpivot_p(0,0,0);
00142 HepPoint3D lpoint_p(0,0,0);
00143
00144
00145 int stat[2][5];
00146 double chisq[2][5];
00147 int ndf[2][5];
00148
00149 double mass[5];
00150 double length[5];
00151 double tof[5];
00152 int nhits[5];
00153 int nlayer[5];
00154 int trackId;
00155 double pathSM[5];
00156 double fiTerm[5];
00157
00158
00159
00160 RecMdcKalTrack *recMdcKalTrackTds = new RecMdcKalTrack();
00161
00162
00163
00164 trackId = recMdcKalTrackRoot->getTrackId();
00165
00166 recMdcKalTrackTds->setTrackId(trackId);
00167
00168 for (int u=0; u<5; u++){
00169 mass[u] = recMdcKalTrackRoot->getMass(u);
00170 length[u] = recMdcKalTrackRoot->getLength(u);
00171 tof[u] = recMdcKalTrackRoot->getTof(u);
00172 nhits[u] = recMdcKalTrackRoot->getNhits(u);
00173 fiTerm[u]=recMdcKalTrackRoot->getfiTerm(u);
00174 pathSM[u]=recMdcKalTrackRoot->getPathSM(u);
00175 nlayer[u]=recMdcKalTrackRoot->getNlayer(u);
00176
00177 recMdcKalTrackTds->setMass(mass[u],u);
00178 recMdcKalTrackTds->setLength(length[u],u);
00179 recMdcKalTrackTds->setTof(tof[u],u);
00180 recMdcKalTrackTds->setNhits(nhits[u],u);
00181 recMdcKalTrackTds->setFiTerm(fiTerm[u],u);
00182 recMdcKalTrackTds->setPathSM(pathSM[u],u);
00183 recMdcKalTrackTds->setNlayer(nlayer[u],u);
00184 }
00185
00186
00187 for(int v=0; v<3; v++){
00188 poca_e[v] = recMdcKalTrackRoot->getPocaE(v);
00189 poca_mu[v] = recMdcKalTrackRoot->getPocaMu(v);
00190 poca[v] = recMdcKalTrackRoot->getPoca(v);
00191 poca_k[v] = recMdcKalTrackRoot->getPocaK(v);
00192 poca_p[v] = recMdcKalTrackRoot->getPocaP(v);
00193 lpivot_e[v] = recMdcKalTrackRoot->getLPivotE(v);
00194 lpivot_mu[v] = recMdcKalTrackRoot->getLPivotMu(v);
00195 lpivot[v] = recMdcKalTrackRoot->getLPivot(v);
00196 lpivot_k[v] = recMdcKalTrackRoot->getLPivotK(v);
00197 lpivot_p[v] = recMdcKalTrackRoot->getLPivotP(v);
00198 lpoint_e[v] = recMdcKalTrackRoot->getLPointE(v);
00199 lpoint_mu[v] = recMdcKalTrackRoot->getLPointMu(v);
00200 lpoint[v] = recMdcKalTrackRoot->getLPoint(v);
00201 lpoint_k[v] = recMdcKalTrackRoot->getLPointK(v);
00202 lpoint_p[v] = recMdcKalTrackRoot->getLPointP(v);
00203
00204
00205
00206
00207 }
00208
00209 for (int i=0, k=0; i<5; i++){
00210 zhelix[i] = recMdcKalTrackRoot->getZHelix(i);
00211 zhelix_e[i] = recMdcKalTrackRoot->getZHelixE(i);
00212 zhelix_mu[i] = recMdcKalTrackRoot->getZHelixMu(i);
00213 zhelix_k[i] = recMdcKalTrackRoot->getZHelixK(i);
00214 zhelix_p[i] = recMdcKalTrackRoot->getZHelixP(i);
00215
00216
00217 fhelix[i] = recMdcKalTrackRoot->getFHelix(i);
00218 fhelix_e[i] = recMdcKalTrackRoot->getFHelixE(i);
00219 fhelix_mu[i] = recMdcKalTrackRoot->getFHelixMu(i);
00220 fhelix_k[i] = recMdcKalTrackRoot->getFHelixK(i);
00221 fhelix_p[i] = recMdcKalTrackRoot->getFHelixP(i);
00222
00223 lhelix[i] = recMdcKalTrackRoot->getLHelix(i);
00224 lhelix_e[i] = recMdcKalTrackRoot->getLHelixE(i);
00225 lhelix_mu[i] = recMdcKalTrackRoot->getLHelixMu(i);
00226 lhelix_k[i] = recMdcKalTrackRoot->getLHelixK(i);
00227 lhelix_p[i] = recMdcKalTrackRoot->getLHelixP(i);
00228
00229 thelix[i] = recMdcKalTrackRoot->getTHelix(i);
00230
00231 for (int j=0; j<=i; j++){
00232
00233 zerror[i][j] = recMdcKalTrackRoot->getZError(i,j);
00234 zerror_e[i][j] = recMdcKalTrackRoot->getZErrorE(i,j);
00235 zerror_mu[i][j] = recMdcKalTrackRoot->getZErrorMu(i,j);
00236 zerror_k[i][j] = recMdcKalTrackRoot->getZErrorK(i,j);
00237 zerror_p[i][j] = recMdcKalTrackRoot->getZErrorP(i,j);
00238 zerror[j][i] = zerror[i][j];
00239 zerror_e[j][i] = zerror_e[i][j];
00240 zerror_mu[j][i] = zerror_mu[i][j];
00241 zerror_k[j][i] = zerror_k[i][j];
00242 zerror_p[j][i] = zerror_p[i][j];
00243
00244 ferror[i][j] = recMdcKalTrackRoot->getFError(i,j);
00245 ferror_e[i][j] = recMdcKalTrackRoot->getFErrorE(i,j);
00246 ferror_mu[i][j] = recMdcKalTrackRoot->getFErrorMu(i,j);
00247 ferror_k[i][j] = recMdcKalTrackRoot->getFErrorK(i,j);
00248 ferror_p[i][j] = recMdcKalTrackRoot->getFErrorP(i,j);
00249 ferror[j][i] = ferror[i][j];
00250 ferror_e[j][i] = ferror_e[i][j];
00251 ferror_mu[j][i] = ferror_mu[i][j];
00252 ferror_k[j][i] = ferror_k[i][j];
00253 ferror_p[j][i] = ferror_p[i][j];
00254
00255 lerror[i][j] = recMdcKalTrackRoot->getLError(i,j);
00256 lerror_e[i][j] = recMdcKalTrackRoot->getLErrorE(i,j);
00257 lerror_mu[i][j] = recMdcKalTrackRoot->getLErrorMu(i,j);
00258 lerror_k[i][j] = recMdcKalTrackRoot->getLErrorK(i,j);
00259 lerror_p[i][j] = recMdcKalTrackRoot->getLErrorP(i,j);
00260 lerror[j][i] = lerror[i][j];
00261 lerror_e[j][i] = lerror_e[i][j];
00262 lerror_mu[j][i] = lerror_mu[i][j];
00263 lerror_k[j][i] = lerror_k[i][j];
00264 lerror_p[j][i] = lerror_p[i][j];
00265
00266 terror[i][j] = recMdcKalTrackRoot->getTError(k++);
00267 terror[j][i] = terror[i][j];
00268
00269 }
00270 }
00271
00272
00273
00274
00275
00276
00278 zhelixs.push_back(zhelix_e);
00279 zhelixs.push_back(zhelix_mu);
00280 zhelixs.push_back(zhelix);
00281 zhelixs.push_back(zhelix_k);
00282 zhelixs.push_back(zhelix_p);
00283 zerrors.push_back(zerror_e);
00284 zerrors.push_back(zerror_mu);
00285 zerrors.push_back(zerror);
00286 zerrors.push_back(zerror_k);
00287 zerrors.push_back(zerror_p);
00289 fhelixs.push_back(fhelix_e);
00290 fhelixs.push_back(fhelix_mu);
00291 fhelixs.push_back(fhelix);
00292 fhelixs.push_back(fhelix_k);
00293 fhelixs.push_back(fhelix_p);
00294 ferrors.push_back(ferror_e);
00295 ferrors.push_back(ferror_mu);
00296 ferrors.push_back(ferror);
00297 ferrors.push_back(ferror_k);
00298 ferrors.push_back(ferror_p);
00300 lhelixs.push_back(lhelix_e);
00301 lhelixs.push_back(lhelix_mu);
00302 lhelixs.push_back(lhelix);
00303 lhelixs.push_back(lhelix_k);
00304 lhelixs.push_back(lhelix_p);
00305 lerrors.push_back(lerror_e);
00306 lerrors.push_back(lerror_mu);
00307 lerrors.push_back(lerror);
00308 lerrors.push_back(lerror_k);
00309 lerrors.push_back(lerror_p);
00311
00312 pocas.push_back(poca_e);
00313 pocas.push_back(poca_mu);
00314 pocas.push_back(poca);
00315 pocas.push_back(poca_k);
00316 pocas.push_back(poca_p);
00317 lpivots.push_back(lpivot_e);
00318 lpivots.push_back(lpivot_mu);
00319 lpivots.push_back(lpivot);
00320 lpivots.push_back(lpivot_k);
00321 lpivots.push_back(lpivot_p);
00322 lpoints.push_back(lpoint_e);
00323 lpoints.push_back(lpoint_mu);
00324 lpoints.push_back(lpoint);
00325 lpoints.push_back(lpoint_k);
00326 lpoints.push_back(lpoint_p);
00327
00328 for(int m=0; m<5; m++){
00329 int charge;
00330 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.);
00331 dr = zhelixs[m][0];
00332 phi0 = zhelixs[m][1];
00333 kappa = zhelixs[m][2];
00334 dz = zhelixs[m][3];
00335 tanl = zhelixs[m][4];
00336
00337
00338
00339
00340 x = dr * cos(phi0);
00341 y = dr * sin(phi0);
00342 z = dz;
00343
00344
00345 if (kappa > 0.0000000001)
00346 charge = 1;
00347 else if (kappa < -0.0000000001)
00348 charge = -1;
00349 else
00350 charge = 0;
00351
00352 if(kappa!=0) pxy = 1.0/fabs(kappa);
00353 else pxy = 0;
00354
00355 px = pxy * (-sin(phi0));
00356 py = pxy * cos(phi0);
00357 pz = pxy * tanl;
00358 ptot = sqrt(px*px+py*py+pz*pz);
00359
00360 recMdcKalTrackTds->setCharge(charge,m);
00361 recMdcKalTrackTds->setPxy(pxy,m);
00362 recMdcKalTrackTds->setPx(px,m);
00363 recMdcKalTrackTds->setPy(py,m);
00364 recMdcKalTrackTds->setPz(pz,m);
00365 recMdcKalTrackTds->setP(ptot,m);
00366 recMdcKalTrackTds->setTheta(acos(pz/ptot),m);
00367 recMdcKalTrackTds->setPhi(atan2(py,px),m);
00368 recMdcKalTrackTds->setX(x,m);
00369 recMdcKalTrackTds->setY(y,m);
00370 recMdcKalTrackTds->setZ(z,m);
00371 recMdcKalTrackTds->setR(sqrt(x*x+y*y),m);
00373
00374 for(int n=0; n<2; n++){
00375 int stat = recMdcKalTrackRoot->getStat(n,m);
00376 int chisq = recMdcKalTrackRoot->getChisq(n,m);
00377 int ndf = recMdcKalTrackRoot->getNdf(n,m);
00378 recMdcKalTrackTds->setStat(stat,n,m);
00379 recMdcKalTrackTds->setChisq(chisq,n,m);
00380 recMdcKalTrackTds->setNdf(ndf,n,m);
00381 }
00382 }
00383
00384
00385
00386
00387
00388 for(int jj=0; jj<5; jj++){
00389
00390
00391
00392 recMdcKalTrackTds->setZHelix(zhelixs[jj],jj);
00393
00394
00395 recMdcKalTrackTds->setZError(zerrors[jj],jj);
00396 recMdcKalTrackTds->setFHelix(fhelixs[jj],jj);
00397 recMdcKalTrackTds->setFError(ferrors[jj],jj);
00398
00399
00400 recMdcKalTrackTds->setLHelix(lhelixs[jj],jj);
00401 recMdcKalTrackTds->setLError(lerrors[jj],jj);
00402 recMdcKalTrackTds->setPoca(pocas[jj],jj);
00403
00404
00405 recMdcKalTrackTds->setLPoint(lpoints[jj],jj);
00406 recMdcKalTrackTds->setLPivot(lpivots[jj],jj);
00407 }
00408 recMdcKalTrackTds->setTHelix(thelix);
00409 recMdcKalTrackTds->setTError(terror);
00410
00411
00412
00413
00414 log<<MSG::DEBUG<<"T to REC TDS, zhelix: "<<zhelix<<endreq;
00415 log<<MSG::DEBUG<<"T to REC TDS, zerror: "<<zerror<<endreq;
00416
00417 m_common.m_rootRecMdcKalTrackMap[recMdcKalTrackRoot] = recMdcKalTrackTds;
00418
00419 int nSegTot=0;
00420 for(int i=0; i<5; i++) {
00421 HelixSegRefVec theKalHelixSegRefVec;
00422
00423 int nSeg=recMdcKalTrackRoot->getNseg(i);
00424 int iSeg=0;
00425 RecMdcKalHelixSegCol::iterator iter = recMdcKalHelixSegCol->begin();
00426 for (;iter != recMdcKalHelixSegCol->end(); iter++){
00427
00428
00429 if((*iter)->getTrackId() == trackId){
00430 if(iSeg>=nSegTot&&iSeg<nSeg+nSegTot) {
00431 SmartRef<RecMdcKalHelixSeg> refhit(*iter);
00432 theKalHelixSegRefVec.push_back(refhit);
00433 }
00434 iSeg++;
00435 }
00436 }
00437 nSegTot+=nSeg;
00438
00439 recMdcKalTrackTds->setVecHelixSegs(theKalHelixSegRefVec,i);
00440 }
00441
00442 int nhelixsegs = recMdcKalTrackTds->getVecHelixSegs().size();
00443
00444
00445
00446 for(int ii=0; ii <nhelixsegs ; ii++){
00447
00448
00449
00450 Identifier id(recMdcKalTrackTds->getVecHelixSegs()[ii]->getMdcId());
00451 int layer = MdcID::layer(id);
00452 int wire = MdcID::wire(id);
00453
00454 }
00455
00456 recMdcKalTrackCol->push_back(recMdcKalTrackTds);
00457
00458 }
00459
00460 delete m_recMdcKalTrackCol;
00461
00462 m_recMdcKalTrackCol = 0;
00463
00464 return StatusCode::SUCCESS;
00465 }
00466
00467
00468 StatusCode RecMdcKalTrackCnv::DataObjectToTObject(DataObject* obj,RootAddress* rootaddr) {
00469
00470
00471 MsgStream log(msgSvc(), "RecMdcKalTrackCnv");
00472 log << MSG::DEBUG << "RecMdcKalTrackCnv::DataObjectToTObject" << endreq;
00473 StatusCode sc=StatusCode::SUCCESS;
00474
00475 RecMdcKalTrackCol * mdcKalTrackColTds=dynamic_cast<RecMdcKalTrackCol *> (obj);
00476 if (!mdcKalTrackColTds) {
00477 log << MSG::ERROR << "Could not downcast to RecMdcKalTrackCol" << endreq;
00478 return StatusCode::FAILURE;
00479 }
00480
00481 DataObject *evt;
00482 m_eds->findObject(EventModel::Recon::Event,evt);
00483 if (evt==NULL) {
00484 log << MSG::ERROR << "Could not get ReconEvent in TDS " << endreq;
00485 return StatusCode::FAILURE;
00486 }
00487
00488 ReconEvent * devtTds=dynamic_cast<ReconEvent *> (evt);
00489 if (!devtTds) {
00490 log << MSG::ERROR << "MdcKalTrackCnv:Could not downcast to TDS Recon Event" << endreq;
00491 }
00492 IOpaqueAddress *addr;
00493
00494 m_cnvSvc->getRecTrackCnv()->createRep(evt,addr);
00495 TRecTrackEvent *recEvt=m_cnvSvc->getRecTrackCnv()->getWriteObject();
00496
00497 const TObjArray *m_recMdcKalTrackCol = recEvt->getRecMdcKalTrackCol();
00498
00499 if (!m_recMdcKalTrackCol) return sc;
00500
00501 recEvt->clearRecMdcKalTrackCol();
00502 RecMdcKalTrackCol::const_iterator mdcKalTrackTds;
00503
00504 for (mdcKalTrackTds = mdcKalTrackColTds->begin(); mdcKalTrackTds != mdcKalTrackColTds->end(); mdcKalTrackTds++) {
00505
00506
00507
00508 Int_t trackId;
00509 Double_t mass[5];
00510 Double_t length[5];
00511 Double_t tof[5];
00512 Int_t nhits[5];
00513 Int_t nlayer[5];
00514 Int_t stat[2][5];
00515 Double_t chisq[2][5];
00516 Int_t ndf[2][5];
00517 Int_t nSeg[5];
00518 Double_t fiTerm[5];
00519 Double_t pathSM[5];
00520
00521 Double_t poca_e[3];
00522 Double_t poca_mu[3];
00523 Double_t poca[3];
00524 Double_t poca_k[3];
00525 Double_t poca_p[3];
00526
00527 Double_t zhelix[5];
00528 Double_t zerror[5][5];
00529 Double_t zhelix_e[5];
00530 Double_t zerror_e[5][5];
00531 Double_t zhelix_mu[5];
00532 Double_t zerror_mu[5][5];
00533 Double_t zhelix_k[5];
00534 Double_t zerror_k[5][5];
00535 Double_t zhelix_p[5];
00536 Double_t zerror_p[5][5];
00537
00538 Double_t fhelix[5];
00539 Double_t ferror[5][5];
00540 Double_t fhelix_e[5];
00541 Double_t ferror_e[5][5];
00542 Double_t fhelix_mu[5];
00543 Double_t ferror_mu[5][5];
00544 Double_t fhelix_k[5];
00545 Double_t ferror_k[5][5];
00546 Double_t fhelix_p[5];
00547 Double_t ferror_p[5][5];
00548
00549 Double_t lhelix[5];
00550 Double_t lerror[5][5];
00551 Double_t lhelix_e[5];
00552 Double_t lerror_e[5][5];
00553 Double_t lhelix_mu[5];
00554 Double_t lerror_mu[5][5];
00555 Double_t lhelix_k[5];
00556 Double_t lerror_k[5][5];
00557 Double_t lhelix_p[5];
00558 Double_t lerror_p[5][5];
00559
00560 Double_t thelix[5];
00561 Double_t terror[15];
00562
00563 Double_t lpoint_e[3];
00564 Double_t lpoint_mu[3];
00565 Double_t lpoint[3];
00566 Double_t lpoint_k[3];
00567 Double_t lpoint_p[3];
00568
00569 Double_t lpivot_e[3];
00570 Double_t lpivot_mu[3];
00571 Double_t lpivot[3];
00572 Double_t lpivot_k[3];
00573 Double_t lpivot_p[3];
00574
00575 TRecMdcKalTrack *mdcKalTrackRoot = new TRecMdcKalTrack();
00576
00577 trackId = (*mdcKalTrackTds)->getTrackId();
00578 for (Int_t i = 0 ; i < 5 ; i++){
00579 mass[i] = (*mdcKalTrackTds)->getMass(i);
00580 length[i] = (*mdcKalTrackTds)->getLength(i);
00581 tof[i] = (*mdcKalTrackTds)->getTof(i);
00582 nhits[i] = (*mdcKalTrackTds)->getNhits(i);
00583 nlayer[i] = (*mdcKalTrackTds)->getNlayer(i);
00584 fiTerm[i]=(*mdcKalTrackTds)->getFiTerm(i);
00585 pathSM[i]=(*mdcKalTrackTds)->getPathSM(i);
00586
00587 nSeg[i]=((*mdcKalTrackTds)->getVecHelixSegs(i)).size();
00588 mdcKalTrackRoot->setNseg(nSeg[i],i);
00589 mdcKalTrackRoot->setNlayer(nlayer[i],i);
00590 for (Int_t j = 0 ; j< 2 ; j++){
00591 stat[j][i] = (*mdcKalTrackTds)->getStat(j,i);
00592 chisq[j][i] = (*mdcKalTrackTds)->getChisq(j,i);
00593 ndf[j][i] = (*mdcKalTrackTds)->getNdf(j,i);
00594 mdcKalTrackRoot->setStat(stat[j][i],j,i);
00595 mdcKalTrackRoot->setChisq(chisq[j][i],j,i);
00596 mdcKalTrackRoot->setNdf(ndf[j][i],j,i);
00597 }
00598 }
00599 for(Int_t i=0;i<5;i++){
00600 log<<MSG::INFO<<" recMdcKalTrack.helix("<<i<<"): "<<(*mdcKalTrackTds)->getTHelix(i)<<endreq;
00601 thelix[i] = (*mdcKalTrackTds)->getTHelix(i);
00602 }
00603 for(Int_t i=0; i<15; i++){
00604 terror[i] = (*mdcKalTrackTds)->getTError(i);
00605 }
00606 HepPoint3D h_poca_e = (*mdcKalTrackTds)->getPocaE();
00607 HepPoint3D h_poca_mu = (*mdcKalTrackTds)->getPocaMu();
00608 HepPoint3D h_poca = (*mdcKalTrackTds)->getPoca();
00609 HepPoint3D h_poca_k = (*mdcKalTrackTds)->getPocaK();
00610 HepPoint3D h_poca_p = (*mdcKalTrackTds)->getPocaP();
00611 HepPoint3D h_lpoint_e = (*mdcKalTrackTds)->getLPointE();
00612 HepPoint3D h_lpoint_mu = (*mdcKalTrackTds)->getLPointMu();
00613 HepPoint3D h_lpoint = (*mdcKalTrackTds)->getLPoint();
00614 HepPoint3D h_lpoint_k = (*mdcKalTrackTds)->getLPointK();
00615 HepPoint3D h_lpoint_p = (*mdcKalTrackTds)->getLPointP();
00616 HepPoint3D h_lpivot_e = (*mdcKalTrackTds)->getLPivotE();
00617 HepPoint3D h_lpivot_mu = (*mdcKalTrackTds)->getLPivotMu();
00618 HepPoint3D h_lpivot = (*mdcKalTrackTds)->getLPivot();
00619 HepPoint3D h_lpivot_k = (*mdcKalTrackTds)->getLPivotK();
00620 HepPoint3D h_lpivot_p = (*mdcKalTrackTds)->getLPivotP();
00621
00622
00623
00624
00625
00626
00627
00628 HepVector h_zhelix = (*mdcKalTrackTds)->getZHelix();
00629 HepSymMatrix h_zerror = (*mdcKalTrackTds)->getZError();
00630 HepVector h_zhelix_e = (*mdcKalTrackTds)->getZHelixE();
00631 HepSymMatrix h_zerror_e = (*mdcKalTrackTds)->getZErrorE();
00632 HepVector h_zhelix_mu = (*mdcKalTrackTds)->getZHelixMu();
00633 HepSymMatrix h_zerror_mu= (*mdcKalTrackTds)->getZErrorMu();
00634 HepVector h_zhelix_k = (*mdcKalTrackTds)->getZHelixK();
00635 HepSymMatrix h_zerror_k = (*mdcKalTrackTds)->getZErrorK();
00636 HepVector h_zhelix_p = (*mdcKalTrackTds)->getZHelixP();
00637 HepSymMatrix h_zerror_p = (*mdcKalTrackTds)->getZErrorP();
00638
00639 HepVector h_fhelix = (*mdcKalTrackTds)->getFHelix();
00640 HepSymMatrix h_ferror = (*mdcKalTrackTds)->getFError();
00641 HepVector h_fhelix_e = (*mdcKalTrackTds)->getFHelixE();
00642 HepSymMatrix h_ferror_e = (*mdcKalTrackTds)->getFErrorE();
00643 HepVector h_fhelix_mu = (*mdcKalTrackTds)->getFHelixMu();
00644 HepSymMatrix h_ferror_mu= (*mdcKalTrackTds)->getFErrorMu();
00645 HepVector h_fhelix_k = (*mdcKalTrackTds)->getFHelixK();
00646 HepSymMatrix h_ferror_k = (*mdcKalTrackTds)->getFErrorK();
00647 HepVector h_fhelix_p = (*mdcKalTrackTds)->getFHelixP();
00648 HepSymMatrix h_ferror_p = (*mdcKalTrackTds)->getFErrorP();
00649
00650 HepVector h_lhelix = (*mdcKalTrackTds)->getLHelix();
00651 HepSymMatrix h_lerror = (*mdcKalTrackTds)->getLError();
00652 HepVector h_lhelix_e = (*mdcKalTrackTds)->getLHelixE();
00653 HepSymMatrix h_lerror_e = (*mdcKalTrackTds)->getLErrorE();
00654 HepVector h_lhelix_mu = (*mdcKalTrackTds)->getLHelixMu();
00655 HepSymMatrix h_lerror_mu= (*mdcKalTrackTds)->getLErrorMu();
00656 HepVector h_lhelix_k = (*mdcKalTrackTds)->getLHelixK();
00657 HepSymMatrix h_lerror_k = (*mdcKalTrackTds)->getLErrorK();
00658 HepVector h_lhelix_p = (*mdcKalTrackTds)->getLHelixP();
00659 HepSymMatrix h_lerror_p = (*mdcKalTrackTds)->getLErrorP();
00660
00661 mdcKalTrackRoot->setTrackId(trackId);
00662 mdcKalTrackRoot->setMass(mass);
00663 mdcKalTrackRoot->setLength(length);
00664 mdcKalTrackRoot->setTof(tof);
00665 mdcKalTrackRoot->setNhits(nhits);
00666 mdcKalTrackRoot->setFiTerm(fiTerm);
00667 mdcKalTrackRoot->setPathSM(pathSM);
00668
00669
00670 for(int s=0; s<3; s++){
00671 poca_e[s] = h_poca_e[s];
00672 poca_mu[s] = h_poca_mu[s];
00673 poca[s] = h_poca[s];
00674 poca_k[s] = h_poca_k[s];
00675 poca_p[s] = h_poca_p[s];
00676 lpoint_e[s] = h_lpoint_e[s];
00677 lpoint_mu[s] = h_lpoint_mu[s];
00678 lpoint[s] = h_lpoint[s];
00679 lpoint_k[s] = h_lpoint_k[s];
00680 lpoint_p[s] = h_lpoint_p[s];
00681 lpivot_e[s] = h_lpivot_e[s];
00682 lpivot_mu[s] = h_lpivot_mu[s];
00683 lpivot[s] = h_lpivot[s];
00684 lpivot_k[s] = h_lpivot_k[s];
00685 lpivot_p[s] = h_lpivot_p[s];
00686 }
00687
00688 for (int i=0; i<5; i++){
00689 zhelix[i] = h_zhelix[i];
00690 zhelix_e[i] = h_zhelix_e[i];
00691 zhelix_mu[i] = h_zhelix_mu[i];
00692 zhelix_p[i] = h_zhelix_p[i];
00693 zhelix_k[i] = h_zhelix_k[i];
00694
00695 fhelix[i] = h_fhelix[i];
00696 fhelix_e[i] = h_fhelix_e[i];
00697 fhelix_mu[i] = h_fhelix_mu[i];
00698 fhelix_p[i] = h_fhelix_p[i];
00699 fhelix_k[i] = h_fhelix_k[i];
00700
00701 lhelix[i] = h_lhelix[i];
00702 lhelix_e[i] = h_lhelix_e[i];
00703 lhelix_mu[i] = h_lhelix_mu[i];
00704 lhelix_p[i] = h_lhelix_p[i];
00705 lhelix_k[i] = h_lhelix_k[i];
00706
00707 for (int j=0; j<=i; j++){
00708 zerror[i][j] = h_zerror[i][j];
00709 zerror_e[i][j] = h_zerror_e[i][j];
00710 zerror_mu[i][j] = h_zerror_mu[i][j];
00711 zerror_p[i][j] = h_zerror_p[i][j];
00712 zerror_k[i][j] = h_zerror_k[i][j];
00713
00714
00715 ferror[i][j] = h_ferror[i][j];
00716 ferror_e[i][j] = h_ferror_e[i][j];
00717 ferror_mu[i][j] = h_ferror_mu[i][j];
00718 ferror_p[i][j] = h_ferror_p[i][j];
00719 ferror_k[i][j] = h_ferror_k[i][j];
00720
00721
00722 lerror[i][j] = h_lerror[i][j];
00723 lerror_e[i][j] = h_lerror_e[i][j];
00724 lerror_mu[i][j] = h_lerror_mu[i][j];
00725 lerror_p[i][j] = h_lerror_p[i][j];
00726 lerror_k[i][j] = h_lerror_k[i][j];
00727
00728 zerror[j][i] = h_zerror[i][j];
00729 zerror_e[j][i] = h_zerror_e[i][j];
00730 zerror_mu[j][i] = h_zerror_mu[i][j];
00731 zerror_p[j][i] = h_zerror_p[i][j];
00732 zerror_k[j][i] = h_zerror_k[i][j];
00733
00734
00735 ferror[j][i] = h_ferror[i][j];
00736 ferror_e[j][i] = h_ferror_e[i][j];
00737 ferror_mu[j][i] = h_ferror_mu[i][j];
00738 ferror_p[j][i] = h_ferror_p[i][j];
00739 ferror_k[j][i] = h_ferror_k[i][j];
00740
00741
00742 lerror[j][i] = h_lerror[i][j];
00743 lerror_e[j][i] = h_lerror_e[i][j];
00744 lerror_mu[j][i] = h_lerror_mu[i][j];
00745 lerror_p[j][i] = h_lerror_p[i][j];
00746 lerror_k[j][i] = h_lerror_k[i][j];
00747
00748 }
00749 }
00750
00751 mdcKalTrackRoot->setZHelix(zhelix);
00752 mdcKalTrackRoot->setZError(zerror);
00753 for(int k=0; k<5; k++){
00754 log<<MSG::INFO<<" RecMdcKalTrackRoot.ZHelix "<<"["<<k<<"]"
00755 <<mdcKalTrackRoot->getZHelix(k)<<endreq;
00756 }
00757 mdcKalTrackRoot->setZHelixE(zhelix_e);
00758 mdcKalTrackRoot->setZErrorE(zerror_e);
00759 mdcKalTrackRoot->setZHelixMu(zhelix_mu);
00760 mdcKalTrackRoot->setZErrorMu(zerror_mu);
00761 mdcKalTrackRoot->setZHelixK(zhelix_k);
00762 mdcKalTrackRoot->setZErrorK(zerror_k);
00763 mdcKalTrackRoot->setZHelixP(zhelix_p);
00764 mdcKalTrackRoot->setZErrorP(zerror_p);
00765 mdcKalTrackRoot->setFHelix(fhelix);
00766 mdcKalTrackRoot->setFError(ferror);
00767 mdcKalTrackRoot->setFHelixE(fhelix_e);
00768 mdcKalTrackRoot->setFErrorE(ferror_e);
00769 mdcKalTrackRoot->setFHelixMu(fhelix_mu);
00770 mdcKalTrackRoot->setFErrorMu(ferror_mu);
00771 mdcKalTrackRoot->setFHelixK(fhelix_k);
00772 mdcKalTrackRoot->setFErrorK(ferror_k);
00773 mdcKalTrackRoot->setFHelixP(fhelix_p);
00774 mdcKalTrackRoot->setFErrorP(ferror_p);
00775
00776 mdcKalTrackRoot->setLHelix(lhelix);
00777 mdcKalTrackRoot->setLError(lerror);
00778 mdcKalTrackRoot->setLHelixE(lhelix_e);
00779 mdcKalTrackRoot->setLErrorE(lerror_e);
00780 mdcKalTrackRoot->setLHelixMu(lhelix_mu);
00781 mdcKalTrackRoot->setLErrorMu(lerror_mu);
00782 mdcKalTrackRoot->setLHelixK(lhelix_k);
00783 mdcKalTrackRoot->setLErrorK(lerror_k);
00784 mdcKalTrackRoot->setLHelixP(lhelix_p);
00785 mdcKalTrackRoot->setLErrorP(lerror_p);
00786
00787 mdcKalTrackRoot->setTHelix(thelix);
00788 mdcKalTrackRoot->setTError(terror);
00789
00790 mdcKalTrackRoot->setPocaE(poca_e);
00791 mdcKalTrackRoot->setPocaMu(poca_mu);
00792 mdcKalTrackRoot->setPoca(poca);
00793 mdcKalTrackRoot->setPocaK(poca_k);
00794 mdcKalTrackRoot->setPocaP(poca_p);
00795
00796 mdcKalTrackRoot->setLPointE(lpoint_e);
00797 mdcKalTrackRoot->setLPointMu(lpoint_mu);
00798 mdcKalTrackRoot->setLPoint(lpoint);
00799 mdcKalTrackRoot->setLPointK(lpoint_k);
00800 mdcKalTrackRoot->setLPointP(lpoint_p);
00801
00802 mdcKalTrackRoot->setLPivotE(lpivot_e);
00803 mdcKalTrackRoot->setLPivotMu(lpivot_mu);
00804 mdcKalTrackRoot->setLPivot(lpivot);
00805 mdcKalTrackRoot->setLPivotK(lpivot_k);
00806 mdcKalTrackRoot->setLPivotP(lpivot_p);
00807
00808
00809 recEvt->addRecMdcKalTrack(mdcKalTrackRoot);
00810 }
00811
00812
00813 return StatusCode::SUCCESS;
00814 }
00815 #endif
