BOSS 8.0.0
BESIII Offline Software System
Loading...
Searching...
No Matches
RecMdcKalTrackCnv.cxx
Go to the documentation of this file.
1#ifndef RecMdcKalTrackCnv_CXX
2#define RecMdcKalTrackCnv_CXX 1
3
4#include "GaudiKernel/DataObject.h"
5#include "GaudiKernel/MsgStream.h"
6#include "GaudiKernel/ObjectVector.h"
7#include "Identifier/Identifier.h"
8#include "Identifier/MdcID.h"
9#include "TClonesArray.h"
10
11#include "EventModel/EventModel.h"
12#include "MdcRecEvent/RecMdcKalHelixSeg.h"
13#include "MdcRecEvent/RecMdcKalTrack.h"
14#include "ReconEvent/ReconEvent.h"
15// #include "RootEventData/TDstEvent.h"
16#include "RootEventData/TRecMdcKalTrack.h"
17#include "RootEventData/TRecTrackEvent.h"
18
19#include "RootCnvSvc/Rec/RecMdcKalTrackCnv.h"
20#include "RootCnvSvc/Rec/RecTrackCnv.h"
21#include "RootCnvSvc/RootAddress.h"
22
23#include <vector>
24
25using namespace std;
26
27// Instantiation of a static factory class used by clients to create
28// instances of this service
29// static CnvFactory<RecMdcKalTrackCnv> s_factory;
30// const ICnvFactory& RecMdcKalTrackCnvFactory = s_factory;
31
32RecMdcKalTrackCnv::RecMdcKalTrackCnv( ISvcLocator* svc ) : RootEventBaseCnv( classID(), svc ) {
33
34 // Here we associate this converter with the /Event path on the TDS.
35 MsgStream log( msgSvc(), "RecMdcKalTrackCnv" );
36 // log << MSG::DEBUG << "Constructor called for " << objType() << endmsg;
37 // m_rootTreename ="Rec";
38 m_rootBranchname = "m_recMdcKalTrackCol";
39 // declareObject(EventModel::Recon::MdcKalTrackCol, objType(), m_rootTreename,
40 // m_rootBranchname);
41 m_adresses.push_back( &m_recMdcKalTrackCol );
42 m_recMdcKalTrackCol = 0;
43}
44
45StatusCode RecMdcKalTrackCnv::TObjectToDataObject( DataObject*& refpObject ) {
46 // creation of TDS object from root object
47 MsgStream log( msgSvc(), "RecMdcKalTrackCnv" );
48 log << MSG::DEBUG << "RecMdcKalTrackCnv::TObjectToDataObject" << endmsg;
49 StatusCode sc = StatusCode::SUCCESS;
50
51 // create the TDS location for the MdcKalTrack Collection
52 RecMdcKalTrackCol* recMdcKalTrackCol = new RecMdcKalTrackCol;
53 refpObject = recMdcKalTrackCol;
54
55 // now convert
56 if ( !m_recMdcKalTrackCol ) return sc;
57 TIter recMdcKalTrackIter( m_recMdcKalTrackCol );
58
59 IDataProviderSvc* dataSvc = 0;
60 sc = serviceLocator()->getService( "EventDataSvc", IDataProviderSvc::interfaceID(),
61 (IInterface*&)dataSvc );
62 if ( !sc.isSuccess() )
63 {
64 log << MSG::FATAL << "Could not get EventDataSvc in RecMdcTrackCnv" << endmsg;
65 return ( StatusCode::FAILURE );
66 }
67 SmartDataPtr<RecMdcKalHelixSegCol> recMdcKalHelixSegCol(
68 dataSvc, "/Event/Recon/RecMdcKalHelixSegCol" );
69 if ( !recMdcKalHelixSegCol )
70 {
71 log << MSG::FATAL << "Could not find RecMdcKalHelixSegCol" << endmsg;
72 return ( StatusCode::FAILURE );
73 }
74
75 TRecMdcKalTrack* recMdcKalTrackRoot = 0;
76 while ( ( recMdcKalTrackRoot = (TRecMdcKalTrack*)recMdcKalTrackIter.Next() ) )
77 {
78
79 std::vector<HepVector> zhelixs;
80 std::vector<HepSymMatrix> zerrors;
81 std::vector<HepVector> fhelixs;
82 std::vector<HepSymMatrix> ferrors;
83 std::vector<HepVector> lhelixs;
84 std::vector<HepSymMatrix> lerrors;
85 std::vector<HepPoint3D> pocas;
86 std::vector<HepPoint3D> lpivots;
87 std::vector<HepPoint3D> lpoints;
88
89 HepVector zhelix( 5 );
90 HepSymMatrix zerror( 5 );
91 HepVector fhelix( 5 );
92 HepSymMatrix ferror( 5 );
93 HepVector lhelix( 5 );
94 HepSymMatrix lerror( 5 );
95 HepVector thelix( 5 );
96 HepSymMatrix terror( 5 );
97 HepPoint3D poca( 0, 0, 0 );
98 HepPoint3D lpivot( 0, 0, 0 );
99 HepPoint3D lpoint( 0, 0, 0 );
100
101 HepVector zhelix_e( 5 );
102 HepSymMatrix zerror_e( 5 );
103 HepVector fhelix_e( 5 );
104 HepSymMatrix ferror_e( 5 );
105 HepVector lhelix_e( 5 );
106 HepSymMatrix lerror_e( 5 );
107 HepPoint3D poca_e( 0, 0, 0 );
108 HepPoint3D lpivot_e( 0, 0, 0 );
109 HepPoint3D lpoint_e( 0, 0, 0 );
110
111 HepVector zhelix_mu( 5 );
112 HepSymMatrix zerror_mu( 5 );
113 HepVector fhelix_mu( 5 );
114 HepSymMatrix ferror_mu( 5 );
115 HepVector lhelix_mu( 5 );
116 HepSymMatrix lerror_mu( 5 );
117 HepPoint3D poca_mu( 0, 0, 0 );
118 HepPoint3D lpivot_mu( 0, 0, 0 );
119 HepPoint3D lpoint_mu( 0, 0, 0 );
120
121 HepVector zhelix_k( 5 );
122 HepSymMatrix zerror_k( 5 );
123 HepVector fhelix_k( 5 );
124 HepSymMatrix ferror_k( 5 );
125 HepVector lhelix_k( 5 );
126 HepSymMatrix lerror_k( 5 );
127 HepPoint3D poca_k( 0, 0, 0 );
128 HepPoint3D lpivot_k( 0, 0, 0 );
129 HepPoint3D lpoint_k( 0, 0, 0 );
130
131 HepVector zhelix_p( 5 );
132 HepSymMatrix zerror_p( 5 );
133 HepVector fhelix_p( 5 );
134 HepSymMatrix ferror_p( 5 );
135 HepVector lhelix_p( 5 );
136 HepSymMatrix lerror_p( 5 );
137 HepPoint3D poca_p( 0, 0, 0 );
138 HepPoint3D lpivot_p( 0, 0, 0 );
139 HepPoint3D lpoint_p( 0, 0, 0 );
140
141 int stat[2][5];
142 double chisq[2][5];
143 int ndf[2][5];
144
145 double mass[5];
146 double length[5];
147 double tof[5];
148 int nhits[5];
149 int nlayer[5];
150 int trackId;
151 double pathSM[5];
152 double fiTerm[5];
153 // std::cout<<" step 0: "<<std::endl;
154
155 RecMdcKalTrack* recMdcKalTrackTds = new RecMdcKalTrack();
156
157 // std::cout<<" step 1: "<<std::endl;
158
159 trackId = recMdcKalTrackRoot->getTrackId();
160 // std::cout<<"track id: "<<trackId<<std::endl;
161 recMdcKalTrackTds->setTrackId( trackId );
162
163 for ( int u = 0; u < 5; u++ )
164 {
165 mass[u] = recMdcKalTrackRoot->getMass( u );
166 length[u] = recMdcKalTrackRoot->getLength( u );
167 tof[u] = recMdcKalTrackRoot->getTof( u );
168 nhits[u] = recMdcKalTrackRoot->getNhits( u );
169 fiTerm[u] = recMdcKalTrackRoot->getfiTerm( u );
170 pathSM[u] = recMdcKalTrackRoot->getPathSM( u );
171 nlayer[u] = recMdcKalTrackRoot->getNlayer( u );
172
173 recMdcKalTrackTds->setMass( mass[u], u );
174 recMdcKalTrackTds->setLength( length[u], u );
175 recMdcKalTrackTds->setTof( tof[u], u );
176 recMdcKalTrackTds->setNhits( nhits[u], u );
177 recMdcKalTrackTds->setFiTerm( fiTerm[u], u );
178 recMdcKalTrackTds->setPathSM( pathSM[u], u );
179 recMdcKalTrackTds->setNlayer( nlayer[u], u );
180 }
181
182 for ( int v = 0; v < 3; v++ )
183 {
184 poca_e[v] = recMdcKalTrackRoot->getPocaE( v );
185 poca_mu[v] = recMdcKalTrackRoot->getPocaMu( v );
186 poca[v] = recMdcKalTrackRoot->getPoca( v );
187 poca_k[v] = recMdcKalTrackRoot->getPocaK( v );
188 poca_p[v] = recMdcKalTrackRoot->getPocaP( v );
189 lpivot_e[v] = recMdcKalTrackRoot->getLPivotE( v );
190 lpivot_mu[v] = recMdcKalTrackRoot->getLPivotMu( v );
191 lpivot[v] = recMdcKalTrackRoot->getLPivot( v );
192 lpivot_k[v] = recMdcKalTrackRoot->getLPivotK( v );
193 lpivot_p[v] = recMdcKalTrackRoot->getLPivotP( v );
194 lpoint_e[v] = recMdcKalTrackRoot->getLPointE( v );
195 lpoint_mu[v] = recMdcKalTrackRoot->getLPointMu( v );
196 lpoint[v] = recMdcKalTrackRoot->getLPoint( v );
197 lpoint_k[v] = recMdcKalTrackRoot->getLPointK( v );
198 lpoint_p[v] = recMdcKalTrackRoot->getLPointP( v );
199 // std::cout<<"poca_e[v]: "<<setprecision(6)<<poca_e[v]<<std::endl;
200 // std::cout<<"lpoint_e[v]: "<<setprecision(6)<<lpoint_e[v]<<std::endl;
201 // std::cout<<"lpivot_e[v]: "<<setprecision(6)<<lpivot_e[v]<<std::endl;
202 }
203
204 for ( int i = 0, k = 0; i < 5; i++ )
205 {
206 zhelix[i] = recMdcKalTrackRoot->getZHelix( i );
207 zhelix_e[i] = recMdcKalTrackRoot->getZHelixE( i );
208 zhelix_mu[i] = recMdcKalTrackRoot->getZHelixMu( i );
209 zhelix_k[i] = recMdcKalTrackRoot->getZHelixK( i );
210 zhelix_p[i] = recMdcKalTrackRoot->getZHelixP( i );
211
212 fhelix[i] = recMdcKalTrackRoot->getFHelix( i );
213 fhelix_e[i] = recMdcKalTrackRoot->getFHelixE( i );
214 fhelix_mu[i] = recMdcKalTrackRoot->getFHelixMu( i );
215 fhelix_k[i] = recMdcKalTrackRoot->getFHelixK( i );
216 fhelix_p[i] = recMdcKalTrackRoot->getFHelixP( i );
217
218 lhelix[i] = recMdcKalTrackRoot->getLHelix( i );
219 lhelix_e[i] = recMdcKalTrackRoot->getLHelixE( i );
220 lhelix_mu[i] = recMdcKalTrackRoot->getLHelixMu( i );
221 lhelix_k[i] = recMdcKalTrackRoot->getLHelixK( i );
222 lhelix_p[i] = recMdcKalTrackRoot->getLHelixP( i );
223
224 thelix[i] = recMdcKalTrackRoot->getTHelix( i );
225
226 for ( int j = 0; j <= i; j++ )
227 {
228
229 zerror[i][j] = recMdcKalTrackRoot->getZError( i, j );
230 zerror_e[i][j] = recMdcKalTrackRoot->getZErrorE( i, j );
231 zerror_mu[i][j] = recMdcKalTrackRoot->getZErrorMu( i, j );
232 zerror_k[i][j] = recMdcKalTrackRoot->getZErrorK( i, j );
233 zerror_p[i][j] = recMdcKalTrackRoot->getZErrorP( i, j );
234 zerror[j][i] = zerror[i][j];
235 zerror_e[j][i] = zerror_e[i][j];
236 zerror_mu[j][i] = zerror_mu[i][j];
237 zerror_k[j][i] = zerror_k[i][j];
238 zerror_p[j][i] = zerror_p[i][j];
239
240 ferror[i][j] = recMdcKalTrackRoot->getFError( i, j );
241 ferror_e[i][j] = recMdcKalTrackRoot->getFErrorE( i, j );
242 ferror_mu[i][j] = recMdcKalTrackRoot->getFErrorMu( i, j );
243 ferror_k[i][j] = recMdcKalTrackRoot->getFErrorK( i, j );
244 ferror_p[i][j] = recMdcKalTrackRoot->getFErrorP( i, j );
245 ferror[j][i] = ferror[i][j];
246 ferror_e[j][i] = ferror_e[i][j];
247 ferror_mu[j][i] = ferror_mu[i][j];
248 ferror_k[j][i] = ferror_k[i][j];
249 ferror_p[j][i] = ferror_p[i][j];
250
251 lerror[i][j] = recMdcKalTrackRoot->getLError( i, j );
252 lerror_e[i][j] = recMdcKalTrackRoot->getLErrorE( i, j );
253 lerror_mu[i][j] = recMdcKalTrackRoot->getLErrorMu( i, j );
254 lerror_k[i][j] = recMdcKalTrackRoot->getLErrorK( i, j );
255 lerror_p[i][j] = recMdcKalTrackRoot->getLErrorP( i, j );
256 lerror[j][i] = lerror[i][j];
257 lerror_e[j][i] = lerror_e[i][j];
258 lerror_mu[j][i] = lerror_mu[i][j];
259 lerror_k[j][i] = lerror_k[i][j];
260 lerror_p[j][i] = lerror_p[i][j];
261
262 terror[i][j] = recMdcKalTrackRoot->getTError( k++ );
263 terror[j][i] = terror[i][j];
264 }
265 }
266
267 // std::cout<<" step 2: "<<std::endl;
268
269 // std::cout<<"T to rec tds: "<<endl;
270 // std::cout<<"lpoint_e: "<<lpoint_e<<std::endl;
271 // std::cout<<"lpivot_e: "<<lpivot_e<<std::endl;
272 /// for zero point
273 zhelixs.push_back( zhelix_e );
274 zhelixs.push_back( zhelix_mu );
275 zhelixs.push_back( zhelix );
276 zhelixs.push_back( zhelix_k );
277 zhelixs.push_back( zhelix_p );
278 zerrors.push_back( zerror_e );
279 zerrors.push_back( zerror_mu );
280 zerrors.push_back( zerror );
281 zerrors.push_back( zerror_k );
282 zerrors.push_back( zerror_p );
283 /// first hit point
284 fhelixs.push_back( fhelix_e );
285 fhelixs.push_back( fhelix_mu );
286 fhelixs.push_back( fhelix );
287 fhelixs.push_back( fhelix_k );
288 fhelixs.push_back( fhelix_p );
289 ferrors.push_back( ferror_e );
290 ferrors.push_back( ferror_mu );
291 ferrors.push_back( ferror );
292 ferrors.push_back( ferror_k );
293 ferrors.push_back( ferror_p );
294 /// last hit point
295 lhelixs.push_back( lhelix_e );
296 lhelixs.push_back( lhelix_mu );
297 lhelixs.push_back( lhelix );
298 lhelixs.push_back( lhelix_k );
299 lhelixs.push_back( lhelix_p );
300 lerrors.push_back( lerror_e );
301 lerrors.push_back( lerror_mu );
302 lerrors.push_back( lerror );
303 lerrors.push_back( lerror_k );
304 lerrors.push_back( lerror_p );
305 /// track finding helix for dE/dx usage
306
307 pocas.push_back( poca_e );
308 pocas.push_back( poca_mu );
309 pocas.push_back( poca );
310 pocas.push_back( poca_k );
311 pocas.push_back( poca_p );
312 lpivots.push_back( lpivot_e );
313 lpivots.push_back( lpivot_mu );
314 lpivots.push_back( lpivot );
315 lpivots.push_back( lpivot_k );
316 lpivots.push_back( lpivot_p );
317 lpoints.push_back( lpoint_e );
318 lpoints.push_back( lpoint_mu );
319 lpoints.push_back( lpoint );
320 lpoints.push_back( lpoint_k );
321 lpoints.push_back( lpoint_p );
322
323 for ( int m = 0; m < 5; m++ )
324 {
325 int charge;
326 double pxy( 0. ), px( 0. ), py( 0. ), pz( 0. ), ptot( 0. ), dr( 0. ), phi0( 0. ),
327 kappa( 0. ), dz( 0. ), tanl( 0. ), x( 0. ), y( 0. ), z( 0. ), vx0( 0. ), vy0( 0. ),
328 vz0( 0. );
329 dr = zhelixs[m][0];
330 phi0 = zhelixs[m][1];
331 kappa = zhelixs[m][2];
332 dz = zhelixs[m][3];
333 tanl = zhelixs[m][4];
334
335 // x = pocas[m][0];
336 // y = pocas[m][1];
337 // z = pocas[m][2];
338 x = dr * cos( phi0 );
339 y = dr * sin( phi0 );
340 z = dz;
341 // std::cout<<"x: "<<x<<"y: "<<y<<"z: "<<z<<std::endl;
342
343 if ( kappa > 0.0000000001 ) charge = 1;
344 else if ( kappa < -0.0000000001 ) charge = -1;
345 else charge = 0;
346
347 if ( kappa != 0 ) pxy = 1.0 / fabs( kappa );
348 else pxy = 0;
349
350 px = pxy * ( -sin( phi0 ) );
351 py = pxy * cos( phi0 );
352 pz = pxy * tanl;
353 ptot = sqrt( px * px + py * py + pz * pz );
354 // cout<<"x, y, z, charge, px, py, pz, ptot: "<<x<<" , "<<y<<" , "<<z<<" , "<<charge<<" ,
355 // "<<px<<" , "<<py<<" ,
356 // "<<pz<<" , "<<ptot<<endl;
357 recMdcKalTrackTds->setCharge( charge, m );
358 recMdcKalTrackTds->setPxy( pxy, m );
359 recMdcKalTrackTds->setPx( px, m );
360 recMdcKalTrackTds->setPy( py, m );
361 recMdcKalTrackTds->setPz( pz, m );
362 recMdcKalTrackTds->setP( ptot, m );
363 recMdcKalTrackTds->setTheta( acos( pz / ptot ), m );
364 recMdcKalTrackTds->setPhi( atan2( py, px ), m );
365 recMdcKalTrackTds->setX( x, m );
366 recMdcKalTrackTds->setY( y, m );
367 recMdcKalTrackTds->setZ( z, m );
368 recMdcKalTrackTds->setR( sqrt( x * x + y * y ), m );
369 /// the next three function need more consideration, temporarily
370
371 for ( int n = 0; n < 2; n++ )
372 {
373 int stat = recMdcKalTrackRoot->getStat( n, m );
374 int chisq = recMdcKalTrackRoot->getChisq( n, m );
375 int ndf = recMdcKalTrackRoot->getNdf( n, m );
376 recMdcKalTrackTds->setStat( stat, n, m );
377 recMdcKalTrackTds->setChisq( chisq, n, m );
378 recMdcKalTrackTds->setNdf( ndf, n, m );
379 }
380 }
381
382 // std::cout<<" step 3: "<<std::endl;
383
384 for ( int jj = 0; jj < 5; jj++ )
385 {
386 // std::cout<<" step 3.0: "<<std::endl;
387 // std::cout<<"zhelixs[jj]: "<<zhelixs[jj]<<std::endl;
388
389 recMdcKalTrackTds->setZHelix( zhelixs[jj], jj );
390 // std::cout<<" step 3.1: "<<std::endl;
391
392 recMdcKalTrackTds->setZError( zerrors[jj], jj );
393 recMdcKalTrackTds->setFHelix( fhelixs[jj], jj );
394 recMdcKalTrackTds->setFError( ferrors[jj], jj );
395 // std::cout<<" step 3.5: "<<std::endl;
396
397 recMdcKalTrackTds->setLHelix( lhelixs[jj], jj );
398 recMdcKalTrackTds->setLError( lerrors[jj], jj );
399 recMdcKalTrackTds->setPoca( pocas[jj], jj );
400
401 recMdcKalTrackTds->setLPoint( lpoints[jj], jj );
402 recMdcKalTrackTds->setLPivot( lpivots[jj], jj );
403 }
404 recMdcKalTrackTds->setTHelix( thelix );
405 recMdcKalTrackTds->setTError( terror );
406
407 // std::cout<<" step 4: "<<std::endl;
408
409 log << MSG::DEBUG << "T to REC TDS, zhelix: " << zhelix << endmsg;
410 log << MSG::DEBUG << "T to REC TDS, zerror: " << zerror << endmsg;
411
412 m_common.m_rootRecMdcKalTrackMap[recMdcKalTrackRoot] = recMdcKalTrackTds;
413
414 int nSegTot = 0;
415 for ( int i = 0; i < 5; i++ )
416 {
417 HelixSegRefVec theKalHelixSegRefVec;
418
419 int nSeg = recMdcKalTrackRoot->getNseg( i );
420 int iSeg = 0;
421 RecMdcKalHelixSegCol::iterator iter = recMdcKalHelixSegCol->begin();
422 for ( ; iter != recMdcKalHelixSegCol->end(); iter++ )
423 {
424
425 // cout<<" (*iter)->getTrkId(): "<<(*iter)->getTrkId()<<endl;
426 if ( ( *iter )->getTrackId() == trackId )
427 {
428 if ( iSeg >= nSegTot && iSeg < nSeg + nSegTot )
429 {
430 SmartRef<RecMdcKalHelixSeg> refhit( *iter );
431 theKalHelixSegRefVec.push_back( refhit );
432 }
433 iSeg++;
434 }
435 }
436 nSegTot += nSeg;
437
438 recMdcKalTrackTds->setVecHelixSegs( theKalHelixSegRefVec, i );
439 }
440
441 int nhelixsegs = recMdcKalTrackTds->getVecHelixSegs().size();
442
443 // std::cout<<" mdc hits: "<<nhelixsegs<< std::endl;
444
445 for ( int ii = 0; ii < nhelixsegs; ii++ )
446 {
447
448 // cout<<"ddl: "<<(recMdcTrack->getVecKalHelixSegs()[ii])->getDriftDistLeft()<<endl;
449 // cout<<"erddl: "<<(recMdcTrack->getVecKalHelixSegs()[ii])->getErrDriftDistLeft()<<endl;
450 Identifier id( recMdcKalTrackTds->getVecHelixSegs()[ii]->getMdcId() );
451 int layer = MdcID::layer( id );
452 int wire = MdcID::wire( id );
453 // cout<<"layer: "<<layer<<" wire: "<<wire<<endl;
454 }
455
456 recMdcKalTrackCol->push_back( recMdcKalTrackTds );
457 }
458
459 delete m_recMdcKalTrackCol;
460
461 m_recMdcKalTrackCol = 0;
462
463 return StatusCode::SUCCESS;
464}
465
466StatusCode RecMdcKalTrackCnv::DataObjectToTObject( DataObject* obj, RootAddress* rootaddr ) {
467
468 MsgStream log( msgSvc(), "RecMdcKalTrackCnv" );
469 log << MSG::DEBUG << "RecMdcKalTrackCnv::DataObjectToTObject" << endmsg;
470 StatusCode sc = StatusCode::SUCCESS;
471
472 RecMdcKalTrackCol* mdcKalTrackColTds = dynamic_cast<RecMdcKalTrackCol*>( obj );
473 if ( !mdcKalTrackColTds )
474 {
475 log << MSG::ERROR << "Could not downcast to RecMdcKalTrackCol" << endmsg;
476 return StatusCode::FAILURE;
477 }
478
479 DataObject* evt;
480 m_eds->findObject( EventModel::Recon::Event, evt );
481 if ( evt == NULL )
482 {
483 log << MSG::ERROR << "Could not get ReconEvent in TDS " << endmsg;
484 return StatusCode::FAILURE;
485 }
486
487 ReconEvent* devtTds = dynamic_cast<ReconEvent*>( evt );
488 if ( !devtTds )
489 { log << MSG::ERROR << "MdcKalTrackCnv:Could not downcast to TDS Recon Event" << endmsg; }
490 IOpaqueAddress* addr;
491
492 m_cnvSvc->getRecTrackCnv()->createRep( evt, addr );
493 TRecTrackEvent* recEvt = m_cnvSvc->getRecTrackCnv()->getWriteObject();
494
495 const TObjArray* m_recMdcKalTrackCol = recEvt->getRecMdcKalTrackCol();
496
497 if ( !m_recMdcKalTrackCol ) return sc;
498
499 recEvt->clearRecMdcKalTrackCol(); // necessary in case there is I/O at the same time since
500 // array is static
501 RecMdcKalTrackCol::const_iterator mdcKalTrackTds;
502
503 for ( mdcKalTrackTds = mdcKalTrackColTds->begin();
504 mdcKalTrackTds != mdcKalTrackColTds->end(); mdcKalTrackTds++ )
505 {
506
507 // Get Data from TDS
508 // root data
509 Int_t trackId;
510 Double_t mass[5];
511 Double_t length[5];
512 Double_t tof[5];
513 Int_t nhits[5];
514 Int_t nlayer[5];
515 Int_t stat[2][5];
516 Double_t chisq[2][5];
517 Int_t ndf[2][5];
518 Int_t nSeg[5];
519 Double_t fiTerm[5];
520 Double_t pathSM[5];
521
522 Double_t poca_e[3];
523 Double_t poca_mu[3];
524 Double_t poca[3];
525 Double_t poca_k[3];
526 Double_t poca_p[3];
527
528 Double_t zhelix[5];
529 Double_t zerror[5][5];
530 Double_t zhelix_e[5];
531 Double_t zerror_e[5][5];
532 Double_t zhelix_mu[5];
533 Double_t zerror_mu[5][5];
534 Double_t zhelix_k[5];
535 Double_t zerror_k[5][5];
536 Double_t zhelix_p[5];
537 Double_t zerror_p[5][5];
538
539 Double_t fhelix[5];
540 Double_t ferror[5][5];
541 Double_t fhelix_e[5];
542 Double_t ferror_e[5][5];
543 Double_t fhelix_mu[5];
544 Double_t ferror_mu[5][5];
545 Double_t fhelix_k[5];
546 Double_t ferror_k[5][5];
547 Double_t fhelix_p[5];
548 Double_t ferror_p[5][5];
549
550 Double_t lhelix[5];
551 Double_t lerror[5][5];
552 Double_t lhelix_e[5];
553 Double_t lerror_e[5][5];
554 Double_t lhelix_mu[5];
555 Double_t lerror_mu[5][5];
556 Double_t lhelix_k[5];
557 Double_t lerror_k[5][5];
558 Double_t lhelix_p[5];
559 Double_t lerror_p[5][5];
560
561 Double_t thelix[5];
562 Double_t terror[15];
563
564 Double_t lpoint_e[3];
565 Double_t lpoint_mu[3];
566 Double_t lpoint[3];
567 Double_t lpoint_k[3];
568 Double_t lpoint_p[3];
569
570 Double_t lpivot_e[3];
571 Double_t lpivot_mu[3];
572 Double_t lpivot[3];
573 Double_t lpivot_k[3];
574 Double_t lpivot_p[3];
575
576 TRecMdcKalTrack* mdcKalTrackRoot = new TRecMdcKalTrack();
577
578 trackId = ( *mdcKalTrackTds )->getTrackId();
579 for ( Int_t i = 0; i < 5; i++ )
580 {
581 mass[i] = ( *mdcKalTrackTds )->getMass( i );
582 length[i] = ( *mdcKalTrackTds )->getLength( i );
583 tof[i] = ( *mdcKalTrackTds )->getTof( i );
584 nhits[i] = ( *mdcKalTrackTds )->getNhits( i );
585 nlayer[i] = ( *mdcKalTrackTds )->getNlayer( i );
586 fiTerm[i] = ( *mdcKalTrackTds )->getFiTerm( i );
587 pathSM[i] = ( *mdcKalTrackTds )->getPathSM( i );
588 // stat[i] = (*mdcKalTrackTds)->getStat(i);
589 nSeg[i] = ( ( *mdcKalTrackTds )->getVecHelixSegs( i ) ).size();
590 mdcKalTrackRoot->setNseg( nSeg[i], i );
591 mdcKalTrackRoot->setNlayer( nlayer[i], i );
592 for ( Int_t j = 0; j < 2; j++ )
593 {
594 stat[j][i] = ( *mdcKalTrackTds )->getStat( j, i );
595 chisq[j][i] = ( *mdcKalTrackTds )->getChisq( j, i );
596 ndf[j][i] = ( *mdcKalTrackTds )->getNdf( j, i );
597 mdcKalTrackRoot->setStat( stat[j][i], j, i );
598 mdcKalTrackRoot->setChisq( chisq[j][i], j, i );
599 mdcKalTrackRoot->setNdf( ndf[j][i], j, i );
600 }
601 }
602 for ( Int_t i = 0; i < 5; i++ )
603 {
604 log << MSG::INFO << " recMdcKalTrack.helix(" << i
605 << "): " << ( *mdcKalTrackTds )->getTHelix( i ) << endmsg;
606 thelix[i] = ( *mdcKalTrackTds )->getTHelix( i );
607 }
608 for ( Int_t i = 0; i < 15; i++ ) { terror[i] = ( *mdcKalTrackTds )->getTError( i ); }
609 HepPoint3D h_poca_e = ( *mdcKalTrackTds )->getPocaE();
610 HepPoint3D h_poca_mu = ( *mdcKalTrackTds )->getPocaMu();
611 HepPoint3D h_poca = ( *mdcKalTrackTds )->getPoca();
612 HepPoint3D h_poca_k = ( *mdcKalTrackTds )->getPocaK();
613 HepPoint3D h_poca_p = ( *mdcKalTrackTds )->getPocaP();
614 HepPoint3D h_lpoint_e = ( *mdcKalTrackTds )->getLPointE();
615 HepPoint3D h_lpoint_mu = ( *mdcKalTrackTds )->getLPointMu();
616 HepPoint3D h_lpoint = ( *mdcKalTrackTds )->getLPoint();
617 HepPoint3D h_lpoint_k = ( *mdcKalTrackTds )->getLPointK();
618 HepPoint3D h_lpoint_p = ( *mdcKalTrackTds )->getLPointP();
619 HepPoint3D h_lpivot_e = ( *mdcKalTrackTds )->getLPivotE();
620 HepPoint3D h_lpivot_mu = ( *mdcKalTrackTds )->getLPivotMu();
621 HepPoint3D h_lpivot = ( *mdcKalTrackTds )->getLPivot();
622 HepPoint3D h_lpivot_k = ( *mdcKalTrackTds )->getLPivotK();
623 HepPoint3D h_lpivot_p = ( *mdcKalTrackTds )->getLPivotP();
624
625 // std::cout<<" h_poca_mu: "<<h_poca_mu<<std::endl;
626 // std::cout<<" h_poca: "<<h_poca<<std::endl;
627 // std::cout<<" h_poca_k: "<<h_poca_k<<std::endl;
628 // std::cout<<" h_poca_p: "<<h_poca_p<<std::endl;
629
630 HepVector h_zhelix = ( *mdcKalTrackTds )->getZHelix();
631 HepSymMatrix h_zerror = ( *mdcKalTrackTds )->getZError();
632 HepVector h_zhelix_e = ( *mdcKalTrackTds )->getZHelixE();
633 HepSymMatrix h_zerror_e = ( *mdcKalTrackTds )->getZErrorE();
634 HepVector h_zhelix_mu = ( *mdcKalTrackTds )->getZHelixMu();
635 HepSymMatrix h_zerror_mu = ( *mdcKalTrackTds )->getZErrorMu();
636 HepVector h_zhelix_k = ( *mdcKalTrackTds )->getZHelixK();
637 HepSymMatrix h_zerror_k = ( *mdcKalTrackTds )->getZErrorK();
638 HepVector h_zhelix_p = ( *mdcKalTrackTds )->getZHelixP();
639 HepSymMatrix h_zerror_p = ( *mdcKalTrackTds )->getZErrorP();
640
641 HepVector h_fhelix = ( *mdcKalTrackTds )->getFHelix();
642 HepSymMatrix h_ferror = ( *mdcKalTrackTds )->getFError();
643 HepVector h_fhelix_e = ( *mdcKalTrackTds )->getFHelixE();
644 HepSymMatrix h_ferror_e = ( *mdcKalTrackTds )->getFErrorE();
645 HepVector h_fhelix_mu = ( *mdcKalTrackTds )->getFHelixMu();
646 HepSymMatrix h_ferror_mu = ( *mdcKalTrackTds )->getFErrorMu();
647 HepVector h_fhelix_k = ( *mdcKalTrackTds )->getFHelixK();
648 HepSymMatrix h_ferror_k = ( *mdcKalTrackTds )->getFErrorK();
649 HepVector h_fhelix_p = ( *mdcKalTrackTds )->getFHelixP();
650 HepSymMatrix h_ferror_p = ( *mdcKalTrackTds )->getFErrorP();
651
652 HepVector h_lhelix = ( *mdcKalTrackTds )->getLHelix();
653 HepSymMatrix h_lerror = ( *mdcKalTrackTds )->getLError();
654 HepVector h_lhelix_e = ( *mdcKalTrackTds )->getLHelixE();
655 HepSymMatrix h_lerror_e = ( *mdcKalTrackTds )->getLErrorE();
656 HepVector h_lhelix_mu = ( *mdcKalTrackTds )->getLHelixMu();
657 HepSymMatrix h_lerror_mu = ( *mdcKalTrackTds )->getLErrorMu();
658 HepVector h_lhelix_k = ( *mdcKalTrackTds )->getLHelixK();
659 HepSymMatrix h_lerror_k = ( *mdcKalTrackTds )->getLErrorK();
660 HepVector h_lhelix_p = ( *mdcKalTrackTds )->getLHelixP();
661 HepSymMatrix h_lerror_p = ( *mdcKalTrackTds )->getLErrorP();
662
663 mdcKalTrackRoot->setTrackId( trackId );
664 mdcKalTrackRoot->setMass( mass );
665 mdcKalTrackRoot->setLength( length );
666 mdcKalTrackRoot->setTof( tof );
667 mdcKalTrackRoot->setNhits( nhits );
668 mdcKalTrackRoot->setFiTerm( fiTerm );
669 mdcKalTrackRoot->setPathSM( pathSM );
670 // mdcKalTrackRoot->setStat(stat);
671
672 for ( int s = 0; s < 3; s++ )
673 {
674 poca_e[s] = h_poca_e[s];
675 poca_mu[s] = h_poca_mu[s];
676 poca[s] = h_poca[s];
677 poca_k[s] = h_poca_k[s];
678 poca_p[s] = h_poca_p[s];
679 lpoint_e[s] = h_lpoint_e[s];
680 lpoint_mu[s] = h_lpoint_mu[s];
681 lpoint[s] = h_lpoint[s];
682 lpoint_k[s] = h_lpoint_k[s];
683 lpoint_p[s] = h_lpoint_p[s];
684 lpivot_e[s] = h_lpivot_e[s];
685 lpivot_mu[s] = h_lpivot_mu[s];
686 lpivot[s] = h_lpivot[s];
687 lpivot_k[s] = h_lpivot_k[s];
688 lpivot_p[s] = h_lpivot_p[s];
689 }
690
691 for ( int i = 0; i < 5; i++ )
692 {
693 zhelix[i] = h_zhelix[i];
694 zhelix_e[i] = h_zhelix_e[i];
695 zhelix_mu[i] = h_zhelix_mu[i];
696 zhelix_p[i] = h_zhelix_p[i];
697 zhelix_k[i] = h_zhelix_k[i];
698
699 fhelix[i] = h_fhelix[i];
700 fhelix_e[i] = h_fhelix_e[i];
701 fhelix_mu[i] = h_fhelix_mu[i];
702 fhelix_p[i] = h_fhelix_p[i];
703 fhelix_k[i] = h_fhelix_k[i];
704
705 lhelix[i] = h_lhelix[i];
706 lhelix_e[i] = h_lhelix_e[i];
707 lhelix_mu[i] = h_lhelix_mu[i];
708 lhelix_p[i] = h_lhelix_p[i];
709 lhelix_k[i] = h_lhelix_k[i];
710
711 for ( int j = 0; j <= i; j++ )
712 {
713 zerror[i][j] = h_zerror[i][j];
714 zerror_e[i][j] = h_zerror_e[i][j];
715 zerror_mu[i][j] = h_zerror_mu[i][j];
716 zerror_p[i][j] = h_zerror_p[i][j];
717 zerror_k[i][j] = h_zerror_k[i][j];
718
719 ferror[i][j] = h_ferror[i][j];
720 ferror_e[i][j] = h_ferror_e[i][j];
721 ferror_mu[i][j] = h_ferror_mu[i][j];
722 ferror_p[i][j] = h_ferror_p[i][j];
723 ferror_k[i][j] = h_ferror_k[i][j];
724
725 lerror[i][j] = h_lerror[i][j];
726 lerror_e[i][j] = h_lerror_e[i][j];
727 lerror_mu[i][j] = h_lerror_mu[i][j];
728 lerror_p[i][j] = h_lerror_p[i][j];
729 lerror_k[i][j] = h_lerror_k[i][j];
730
731 zerror[j][i] = h_zerror[i][j];
732 zerror_e[j][i] = h_zerror_e[i][j];
733 zerror_mu[j][i] = h_zerror_mu[i][j];
734 zerror_p[j][i] = h_zerror_p[i][j];
735 zerror_k[j][i] = h_zerror_k[i][j];
736
737 ferror[j][i] = h_ferror[i][j];
738 ferror_e[j][i] = h_ferror_e[i][j];
739 ferror_mu[j][i] = h_ferror_mu[i][j];
740 ferror_p[j][i] = h_ferror_p[i][j];
741 ferror_k[j][i] = h_ferror_k[i][j];
742
743 lerror[j][i] = h_lerror[i][j];
744 lerror_e[j][i] = h_lerror_e[i][j];
745 lerror_mu[j][i] = h_lerror_mu[i][j];
746 lerror_p[j][i] = h_lerror_p[i][j];
747 lerror_k[j][i] = h_lerror_k[i][j];
748 }
749 }
750
751 mdcKalTrackRoot->setZHelix( zhelix );
752 mdcKalTrackRoot->setZError( zerror );
753 for ( int k = 0; k < 5; k++ )
754 {
755 log << MSG::INFO << " RecMdcKalTrackRoot.ZHelix "
756 << "[" << k << "]" << mdcKalTrackRoot->getZHelix( k ) << endmsg;
757 }
758 mdcKalTrackRoot->setZHelixE( zhelix_e );
759 mdcKalTrackRoot->setZErrorE( zerror_e );
760 mdcKalTrackRoot->setZHelixMu( zhelix_mu );
761 mdcKalTrackRoot->setZErrorMu( zerror_mu );
762 mdcKalTrackRoot->setZHelixK( zhelix_k );
763 mdcKalTrackRoot->setZErrorK( zerror_k );
764 mdcKalTrackRoot->setZHelixP( zhelix_p );
765 mdcKalTrackRoot->setZErrorP( zerror_p );
766 mdcKalTrackRoot->setFHelix( fhelix );
767 mdcKalTrackRoot->setFError( ferror );
768 mdcKalTrackRoot->setFHelixE( fhelix_e );
769 mdcKalTrackRoot->setFErrorE( ferror_e );
770 mdcKalTrackRoot->setFHelixMu( fhelix_mu );
771 mdcKalTrackRoot->setFErrorMu( ferror_mu );
772 mdcKalTrackRoot->setFHelixK( fhelix_k );
773 mdcKalTrackRoot->setFErrorK( ferror_k );
774 mdcKalTrackRoot->setFHelixP( fhelix_p );
775 mdcKalTrackRoot->setFErrorP( ferror_p );
776
777 mdcKalTrackRoot->setLHelix( lhelix );
778 mdcKalTrackRoot->setLError( lerror );
779 mdcKalTrackRoot->setLHelixE( lhelix_e );
780 mdcKalTrackRoot->setLErrorE( lerror_e );
781 mdcKalTrackRoot->setLHelixMu( lhelix_mu );
782 mdcKalTrackRoot->setLErrorMu( lerror_mu );
783 mdcKalTrackRoot->setLHelixK( lhelix_k );
784 mdcKalTrackRoot->setLErrorK( lerror_k );
785 mdcKalTrackRoot->setLHelixP( lhelix_p );
786 mdcKalTrackRoot->setLErrorP( lerror_p );
787
788 mdcKalTrackRoot->setTHelix( thelix );
789 mdcKalTrackRoot->setTError( terror );
790
791 mdcKalTrackRoot->setPocaE( poca_e );
792 mdcKalTrackRoot->setPocaMu( poca_mu );
793 mdcKalTrackRoot->setPoca( poca );
794 mdcKalTrackRoot->setPocaK( poca_k );
795 mdcKalTrackRoot->setPocaP( poca_p );
796
797 mdcKalTrackRoot->setLPointE( lpoint_e );
798 mdcKalTrackRoot->setLPointMu( lpoint_mu );
799 mdcKalTrackRoot->setLPoint( lpoint );
800 mdcKalTrackRoot->setLPointK( lpoint_k );
801 mdcKalTrackRoot->setLPointP( lpoint_p );
802
803 mdcKalTrackRoot->setLPivotE( lpivot_e );
804 mdcKalTrackRoot->setLPivotMu( lpivot_mu );
805 mdcKalTrackRoot->setLPivot( lpivot );
806 mdcKalTrackRoot->setLPivotK( lpivot_k );
807 mdcKalTrackRoot->setLPivotP( lpivot_p );
808 // std::cout<<" mdcKalTrackRoot->getPivotE(1):
809 // "<<mdcKalTrackRoot->getLPivotE(1)<<std::endl;
810
811 recEvt->addRecMdcKalTrack( mdcKalTrackRoot );
812 }
813
814 return StatusCode::SUCCESS;
815}
816#endif
mass
double mass
Definition CosmicGenerator.cxx:128
n
const Int_t n
Definition DataBase/tau_mode.c:57
x
Double_t x[10]
Definition DataBase/tau_mode.c:49
iter
EvtStreamInputIterator< typename Generator::result_type > iter(Generator gen, int N=0)
Definition EvtStreamInputIterator.hh:83
s
XmlRpcServer s
Definition HelloServer.cpp:11
sin
double sin(const BesAngle a)
Definition InstallArea/x86_64-el9-gcc13-dbg/include/MdcGeom/BesAngle.h:185
cos
double cos(const BesAngle a)
Definition InstallArea/x86_64-el9-gcc13-dbg/include/MdcGeom/BesAngle.h:187
HelixSegRefVec
SmartRefVector< RecMdcKalHelixSeg > HelixSegRefVec
Definition InstallArea/x86_64-el9-gcc13-dbg/include/MdcRecEvent/RecMdcKalTrack.h:26
RecMdcKalTrackCol
ObjectVector< RecMdcKalTrack > RecMdcKalTrackCol
Definition InstallArea/x86_64-el9-gcc13-dbg/include/MdcRecEvent/RecMdcKalTrack.h:321
v
**********Class see also m_nmax DOUBLE PRECISION m_amel DOUBLE PRECISION m_x2 DOUBLE PRECISION m_alfinv DOUBLE PRECISION m_Xenph INTEGER m_KeyWtm INTEGER m_idyfs DOUBLE PRECISION m_zini DOUBLE PRECISION m_q2 DOUBLE PRECISION m_Wt_KF DOUBLE PRECISION m_WtCut INTEGER m_KFfin *COMMON c_KarLud $ !Input CMS energy[GeV] $ !CMS energy after beam spread beam strahlung[GeV] $ !Beam energy spread[GeV] $ !z boost due to beam spread $ !electron beam mass *ff pair spectrum $ !minimum v
Definition KarLud.h:35
msgSvc
IMessageSvc * msgSvc()
Definition ServiceAccessor.h:12
DstMdcKalTrack::setFHelix
void setFHelix(const HepVector &fhelix, const int pid)
Definition Event/DstEvent/include/DstEvent/DstMdcKalTrack.h:145
DstMdcKalTrack::setPhi
void setPhi(const double phi, const int pid)
Definition Event/DstEvent/include/DstEvent/DstMdcKalTrack.h:104
DstMdcKalTrack::setY
void setY(const double y, const int pid)
Definition Event/DstEvent/include/DstEvent/DstMdcKalTrack.h:106
DstMdcKalTrack::setPz
void setPz(const double pz, const int pid)
Definition Event/DstEvent/include/DstEvent/DstMdcKalTrack.h:101
DstMdcKalTrack::setChisq
void setChisq(double chisq, int i, int pid)
Definition Event/DstEvent/include/DstEvent/DstMdcKalTrack.h:112
DstMdcKalTrack::setZError
void setZError(const HepSymMatrix &error, const int pid)
Definition Event/DstEvent/include/DstEvent/DstMdcKalTrack.h:126
DstMdcKalTrack::setX
void setX(const double x, const int pid)
Definition Event/DstEvent/include/DstEvent/DstMdcKalTrack.h:105
DstMdcKalTrack::setP
void setP(const double p, const int pid)
Definition Event/DstEvent/include/DstEvent/DstMdcKalTrack.h:102
DstMdcKalTrack::setPoca
void setPoca(const HepPoint3D &poca, const int pid)
Definition Event/DstEvent/include/DstEvent/DstMdcKalTrack.h:118
DstMdcKalTrack::setPx
void setPx(const double px, const int pid)
Definition Event/DstEvent/include/DstEvent/DstMdcKalTrack.h:99
DstMdcKalTrack::setZ
void setZ(const double z, const int pid)
Definition Event/DstEvent/include/DstEvent/DstMdcKalTrack.h:107
DstMdcKalTrack::setTheta
void setTheta(const double theta, const int pid)
Definition Event/DstEvent/include/DstEvent/DstMdcKalTrack.h:103
DstMdcKalTrack::setR
void setR(const double r, const int pid)
Definition Event/DstEvent/include/DstEvent/DstMdcKalTrack.h:108
DstMdcKalTrack::setPxy
void setPxy(const double pxy, const int pid)
Definition Event/DstEvent/include/DstEvent/DstMdcKalTrack.h:98
DstMdcKalTrack::setPy
void setPy(const double py, const int pid)
Definition Event/DstEvent/include/DstEvent/DstMdcKalTrack.h:100
DstMdcKalTrack::setFError
void setFError(const HepSymMatrix &ferror, const int pid)
Definition Event/DstEvent/include/DstEvent/DstMdcKalTrack.h:147
DstMdcKalTrack::setZHelix
void setZHelix(const HepVector &helix, const int pid)
Definition Event/DstEvent/include/DstEvent/DstMdcKalTrack.h:124
DstMdcKalTrack::setCharge
void setCharge(const int charge, const int pid)
Definition Event/DstEvent/include/DstEvent/DstMdcKalTrack.h:97
MdcID::layer
static int layer(const Identifier &id)
Values of different levels (failure returns 0).
Definition MdcID.cxx:47
MdcID::wire
static int wire(const Identifier &id)
Definition MdcID.cxx:52
RecMdcKalTrackCnv::DataObjectToTObject
virtual StatusCode DataObjectToTObject(DataObject *obj, RootAddress *addr)
transformation to root
Definition RecMdcKalTrackCnv.cxx:466
RecMdcKalTrackCnv::RecMdcKalTrackCnv
RecMdcKalTrackCnv(ISvcLocator *svc)
Definition RecMdcKalTrackCnv.cxx:32
RecMdcKalTrackCnv::TObjectToDataObject
virtual StatusCode TObjectToDataObject(DataObject *&obj)
transformation from root
Definition RecMdcKalTrackCnv.cxx:45
RecMdcKalTrack::getVecHelixSegs
HelixSegRefVec getVecHelixSegs(int pid=-1) const
Definition RecMdcKalTrack.cxx:157
RecMdcKalTrack::setVecHelixSegs
void setVecHelixSegs(const HelixSegRefVec &vechelixsegs, int pid=-1)
Definition RecMdcKalTrack.cxx:163
RecMdcKalTrack::setLError
void setLError(const HepSymMatrix &error, const int pid)
Definition InstallArea/x86_64-el9-gcc13-dbg/include/MdcRecEvent/RecMdcKalTrack.h:211
RootAddress
Definition of a Root address, derived from IOpaqueAddress.
Definition Event/RootCnvSvc/include/RootCnvSvc/RootAddress.h:21
RootEventBaseCnv::m_eds
IDataProviderSvc * m_eds
pointer to eventdataservice
Definition Event/RootCnvSvc/include/RootCnvSvc/RootEventBaseCnv.h:48
RootEventBaseCnv::m_adresses
std::vector< void * > m_adresses
each converter knows the corresponding adresses
Definition Event/RootCnvSvc/include/RootCnvSvc/RootEventBaseCnv.h:75
RootEventBaseCnv::m_rootBranchname
std::string m_rootBranchname
root branchname (may be concatenated of severals)
Definition Event/RootCnvSvc/include/RootCnvSvc/RootEventBaseCnv.h:69
RootEventBaseCnv::RootEventBaseCnv
RootEventBaseCnv(const CLID &clid, ISvcLocator *svc)
Definition RootEventBaseCnv.cxx:30
TRecMdcKalTrack::setChisq
void setChisq(const Double_t chisq, Int_t i, Int_t pid)
Definition Event/RootEventData/include/RootEventData/TRecMdcKalTrack.h:109
TRecMdcKalTrack::setNdf
void setNdf(const Int_t ndf, Int_t i, Int_t pid)
Definition Event/RootEventData/include/RootEventData/TRecMdcKalTrack.h:110
TRecMdcKalTrack::setStat
void setStat(const Int_t stat, Int_t i, Int_t pid)
Definition Event/RootEventData/include/RootEventData/TRecMdcKalTrack.h:108
TRecTrackEvent::addRecMdcKalTrack
void addRecMdcKalTrack(TRecMdcKalTrack *Track)
Definition TRecTrackEvent.cxx:239