FairRoot/PandaRoot
Public Member Functions | Private Member Functions | Private Attributes | List of all members
PndLmdTrkQTask Class Reference

#include <PndLmdTrkQTask.h>

Inheritance diagram for PndLmdTrkQTask:

Public Member Functions

 PndLmdTrkQTask (const PndLmdTrkQTask &)=delete
 
 PndLmdTrkQTask (Double_t pBeam=0, TString geaneBranch="GeaneTrackFinal", TString trackBranch="LMDPndTrackFilt")
 Set up beam momuntum value. More...
 
 ~PndLmdTrkQTask ()
 
virtual InitStatus Init ()
 
virtual void Exec (Option_t *opt)
 
virtual void Finish ()
 
void SetWriteMC (bool wr)
 

Private Member Functions

 ClassDef (PndLmdTrkQTask, 2)
 

Private Attributes

TString fGeaneName
 
TString fTrackBranchName
 
TClonesArray * fMCHits
 
TClonesArray * fMCTracks
 
TClonesArray * fRecHits
 
TClonesArray * fRecCandTracks
 
TClonesArray * fRecTracks
 
TClonesArray * fRecBPTracks
 
TClonesArray * fTrackQ
 
int fEventNr
 
Double_t fPbeam
 
bool fWriteAllMC
 

Detailed Description

Definition at line 31 of file PndLmdTrkQTask.h.

Constructor & Destructor Documentation

PndLmdTrkQTask::PndLmdTrkQTask ( const PndLmdTrkQTask &  )
delete

Default constructor

PndLmdTrkQTask::PndLmdTrkQTask ( Double_t  pBeam = 0,
TString  geaneBranch = "GeaneTrackFinal",
TString  trackBranch = "LMDPndTrackFilt" 
)

Set up beam momuntum value.

Definition at line 47 of file PndLmdTrkQTask.cxx.

References fGeaneName, fPbeam, fTrackBranchName, and fWriteAllMC.

48  :
49  FairTask("Track Quality Task for PANDA Lmd"), fEventNr(0) {
50  fWriteAllMC = false;
51  fPbeam = pBeam;
52  fGeaneName = geaneBranch;
53  fTrackBranchName = trackBranch;
54  //cout<<"Beam Momentum for particle with PDGid#"<<fPDGid<<" this run is "<<fPbeam<<endl;
55  // vtx = IP;
56  // cout<<"Interaction Point:"<<endl;
57  // vtx.Print();
58 }
PndLmdTrkQTask::fTrackBranchName
TString fTrackBranchName
Definition: PndLmdTrkQTask.h:62
PndLmdTrkQTask::fGeaneName
TString fGeaneName
Definition: PndLmdTrkQTask.h:61
PndLmdTrkQTask::~PndLmdTrkQTask ( )

Destructor

Definition at line 61 of file PndLmdTrkQTask.cxx.

61  {
62 }

Member Function Documentation

PndLmdTrkQTask::ClassDef ( PndLmdTrkQTask  ,
2   
)
private
void PndLmdTrkQTask::Exec ( Option_t *  opt)
virtual

Virtual method Exec

Set signal/bkg flag -—————————————————

Chech how many MC hits has MC trk -—————————

Chech how many REC hits has MC trk -—————————

Compare trk-cand vs. trk-fit –—————————

Obtain first approximation

Set MC ID for each track ----------------————————————

Matching between MC & Rec on hits level--———————————

Counting number of diff MC ids -------------—————————

Set track quality: good or ghost? and assign MC id to rec trk ———

(II) missed tracks are defined on hits information GHOST -------------------------------------------------------------------------------------------------------------------------------------------------------————— check repeated assignment to one MC trk (maybe one MC trk rec. trk was assigned to several REC trk) ------------------—————

END check repeated assignment to one MC trk ------------------------------------------------------------------------------------------------------————

END GHOST-----------------------------------------------------------------------------------------------------------------------------------------------------------———

MISSED ------------------------------------------------------------------------------------------------------------------------------------------------------------------——

if MC trk was missed, justify why

Definition at line 149 of file PndLmdTrkQTask.cxx.

References Double_t, fabs(), fEventNr, fMCHits, fMCTracks, fPbeam, fRecBPTracks, fRecCandTracks, fRecHits, fRecTracks, fTrackQ, fVerbose, fWriteAllMC, PndTrack::GetChi2(), PndTrackCandHit::GetHitId(), PndLmdGeometryHelper::getInstance(), PndMCTrack::GetMomentum(), PndMCTrack::GetMotherID(), PndTrackCand::GetNHits(), PndTrack::GetParamFirst(), PndMCTrack::GetPdgCode(), PndSdsMCPoint::GetPosition(), PndSdsHit::GetPosition(), PndTrack::GetRefIndex(), PndSdsMergedHit::GetSecondMCHit(), PndSdsHit::GetSensorID(), PndTrackCand::GetSortedHit(), PndMCTrack::GetStartVertex(), m, MCPoint, n, nk, Pi, PndLmdTrackQ::SetEvMCMulti(), PndLmdTrackQ::SetEvRECMulti(), PndLmdTrackQ::SetEvTime(), PndLmdTrackQ::SetHalf(), PndLmdTrackQ::SetIPerrmom(), PndLmdTrackQ::SetIPerrpoint(), PndLmdTrackQ::SetIPmom(), PndLmdTrackQ::SetIPpoint(), PndLmdTrackQ::SetLMDchi2(), PndLmdTrackQ::SetLMDdir(), PndLmdTrackQ::SetLMDpoint(), PndLmdTrackQ::SetMCmom(), PndLmdTrackQ::SetMCmomLMD(), PndLmdTrackQ::SetMCpoint(), PndLmdTrackQ::SetMCpointLMD(), PndLmdTrackQ::SetModule(), PndLmdTrackQ::SetNumDoubleMChits(), PndLmdTrackQ::SetNumMChits(), PndLmdTrackQ::SetPDGcode(), PndLmdTrackQ::SetSecondary(), PndLmdTrackQ::SetSumEvPDG(), PndLmdTrackQ::SetTrkRecStatus(), PndLmdTrackQ::SetTrkTime(), and x.

149  {
150 
151  fTrackQ->Delete();
152  // fDetName->Delete();
153 
154  Double_t glXrecLMD, glYrecLMD, glZrecLMD, glThetarecLMD, glPhirecLMD;
155  Double_t glXrec, glYrec, glZrec, glThetarec, glPhirec, glMomrec;
156  Double_t glXmc, glYmc, glZmc, glThetamc, glPhimc, glMommc;
157  Double_t glXmcLMD, glYmcLMD, glZmcLMD, glThetamcLMD, glPhimcLMD, glMommcLMD;
158  Int_t trkRECStatus;
159  Int_t trkMCStatus;
160  Double_t glchi2;
161  int glPDG;
162  int glNumMChits;
163  int glNumDoubleMChits;
164 
165  int glModule, glHalf;
166  FairRootManager* ioman = FairRootManager::Instance();
167  // double glEvTime = FairRootManager::Instance()->GetEventTime();
168  double glEvTime = ioman->GetEventTime();
169  // FairMCEventHeader* iomchead = (FairMCEventHeader*) ioman->GetObject("MCEventHeader");
170  // FairMCEventHeader* mcevhead = (FairMCEventHeader*) fMCHeader->At(0);
171  // int glEvID = mcevhead->GetEventID();
172  // cout<<"this is event # "<<glEvID<<endl;
173  double glTrkTime;
174 
175  const int nGeaneTrks = fRecBPTracks->GetEntriesFast();
176  const int nParticles = fMCTracks->GetEntriesFast();
177  const int numTrk = fRecTracks->GetEntriesFast();
178  const int nRecHits = fRecHits->GetEntriesFast();
179  const int nMCHits = fMCHits->GetEntriesFast();
180 
181  const int nTrkCandidates = fRecCandTracks->GetEntriesFast();
182  //const int nRecTrks = fRecTracks->GetEntriesFast(); //[R.K. 01/2017] unused variable
183 
184  if (fVerbose > 0)
185  cout << "%%%%%! Event #" << fEventNr << " has " << nParticles
186  << " true particles, " << " out of it " << nRecHits << " hits, "
187  << nTrkCandidates << " trk-cands, " << numTrk << " tracks and "
188  << nGeaneTrks << " geane Trks!" << endl;
189 
191  int sumID = 0;
192  //int TotCharge=0; //[R.K. 01/2017] unused variable
193  for (Int_t iN = 0; iN < nParticles; iN++) {
194  PndMCTrack *mctrk = (PndMCTrack*) fMCTracks->At(iN);
195  glPDG = mctrk->GetPdgCode();
196  Int_t mcID = mctrk->GetPdgCode();
197  int motherid = mctrk->GetMotherID();
198  if (motherid < 0 && fabs(mcID) < 1e5) {
199  sumID += fabs(mcID);
200  }
201  // TParticlePDG *fParticle = fdbPDG->GetParticle(mcID);
202  // Double_t fCharge = fParticle->Charge();
203  // TotCharge += fCharge;
204  }
206 
208  int MCtksSIMhits[nParticles];
209  int MCDoubleHits[nParticles];
210  for (int imctrk = 0; imctrk < nParticles; imctrk++) {
211  MCtksSIMhits[imctrk] = 0;
212  MCDoubleHits[imctrk] = 0;
213  }
214  for (int imc = 0; imc < nMCHits; imc++) {
215  PndSdsMCPoint* MCPoint = (PndSdsMCPoint*) (fMCHits->At(imc));
216  int MCtrk = MCPoint->GetTrackID();
217  MCtksSIMhits[MCtrk]++;
218  }
220 
222 
223  int MCtksREChits[nParticles];
224  // const int nSize = 2e4;
225  // int MCtksREChits[nSize];//add arbitrary number of fake trks due to noise hits
226  for (int imctrk = 0; imctrk < nParticles; imctrk++) {
227  MCtksREChits[imctrk] = 0;
228  }
229  if (fVerbose > 7)
230  cout << " ** ALL REChits are made from MChits: " << endl; //start MC hit content
231  //bool fMCnegative = false; //[R.K. 01/2017] unused variable
232  for (int irec = 0; irec < nRecHits; irec++) {
233  PndSdsMergedHit* myHit = (PndSdsMergedHit*) (fRecHits->At(irec));
234  int mcrefbot = myHit->GetSecondMCHit();
235  int MCtrkidbot, MCtrkidtop;
236  if (mcrefbot > 0) {
237  PndSdsMCPoint* MCPointBot = (PndSdsMCPoint*) (fMCHits->At(mcrefbot));
238  int MCtrkid = MCPointBot->GetTrackID();
239 
240  MCtksREChits[MCtrkid]++;
241  MCtrkidbot = MCtrkid;
242  if (fVerbose > 7)
243  cout << " " << MCtrkid << "(MChitID=" << mcrefbot << ",z="
244  << MCPointBot->GetZ() << ")";
245  }
246  int mcreftop = myHit->GetRefIndex();
247  if (mcreftop > 0) {
248  PndSdsMCPoint* MCPointTop = (PndSdsMCPoint*) (fMCHits->At(mcreftop));
249  int MCtrkid = MCPointTop->GetTrackID();
250 
251  MCtksREChits[MCtrkid]++;
252  MCtrkidtop = MCtrkid;
253  if (fVerbose > 7)
254  cout << " " << MCtrkid << "(MChitID=" << mcreftop << ",z="
255  << MCPointTop->GetZ() << ")";
256  }
257  if (mcreftop > 0 && mcrefbot > 0) {
258  if (MCtrkidtop == MCtrkidbot) {
259  MCDoubleHits[MCtrkidbot]++;
260  } else {
261  if (fVerbose > 7)
262  cout << " REChit No." << irec << "contain MCid: " << MCtrkidtop
263  << ", " << MCtrkidbot << " !" << endl;
264  }
265  }
266  // if(fVerbose>7)
267  // cout<<" "<<endl;//next hit content
268  }
269  // if(fMCnegative){
270  // if(fVerbose>7) cout<<"bad event, skip it!"<<endl;
271  // }
272  // if(fMCnegative) continue;
274 
276  // TNtuple *ntupTrkFit = new TNtuple("ntupTrkFit","Info about reconstructed trks: trk-cand vs. trk after fit","xtc:ytc:ztc:thtc:phitc:xtf:ytf:ztf:thtf:phitf:chi2");
277  for (Int_t iN = 0; iN < nGeaneTrks; iN++) { // loop over all reconstructed trks
278  //dummy values
279  glXrecLMD = -9999;
280  glYrecLMD = -9999;
281  glZrecLMD = -9999;
282  glThetarecLMD = -9999;
283  glPhirecLMD = -9999;
284  glXrec = -9999;
285  glYrec = -9999;
286  glZrec = -9999;
287  glThetarec = -9999;
288  glPhirec = -9999;
289  glMomrec = -9999;
290  glXmc = -9999;
291  glYmc = -9999;
292  glZmc = -9999;
293  glThetamc = -9999;
294  glPhimc = -9999;
295  glMommc = -9999;
296  glXmcLMD = -9999;
297  glYmcLMD = -9999;
298  glZmcLMD = -9999;
299  glThetamcLMD = -9999;
300  glPhimcLMD = -9999;
301  glMommcLMD = -9999;
302  trkRECStatus = -9999;
303  trkMCStatus = -9999;
304  glchi2 = -9999;
305  glPDG = -9999;
306  glNumMChits = -9999;
307  glNumDoubleMChits = -9999;
308 
309  PndTrack *trkpnd = (PndTrack*) fRecTracks->At(iN);
310  //double chi2 = trkpnd->GetChi2(); //[R.K. 01/2017] unused variable
311  FairTrackParP fFittedTrkP = trkpnd->GetParamFirst();
312  TVector3 PosRecLMD(fFittedTrkP.GetX(), fFittedTrkP.GetY(),
313  fFittedTrkP.GetZ());
314  TVector3 MomRecLMD(fFittedTrkP.GetPx(), fFittedTrkP.GetPy(),
315  fFittedTrkP.GetPz());
316  MomRecLMD *= fPbeam / MomRecLMD.Mag();
317 
318  int candID = trkpnd->GetRefIndex();
319  // cout<<"candID = "<<candID<<endl;
320  PndTrackCand *trkcand = (PndTrackCand*) fRecCandTracks->At(candID);
322  const int numPts = trkcand->GetNHits(); //read how many points in this track
323  PndTrackCandHit theHit1 = trkcand->GetSortedHit(0); //get 1st hit
324  Int_t index1 = theHit1.GetHitId();
325  PndSdsHit* Hit1sds = (PndSdsHit*) fRecHits->At(index1);
326  TVector3 posSeed = Hit1sds->GetPosition();
327  PndTrackCandHit theHit2 = trkcand->GetSortedHit(numPts - 1); //get last hit
328  Int_t index2 = theHit2.GetHitId();
329  PndSdsHit* Hit2sds = (PndSdsHit*) fRecHits->At(index2);
330  TVector3 pos2 = Hit2sds->GetPosition();
331  TVector3 MomRecCandLMD = pos2 - posSeed;
332  MomRecCandLMD *= fPbeam / MomRecCandLMD.Mag();
333  // TVector3 PosRecCandLMD = trkcand->getPosSeed();
334  // TVector3 MomRecCandLMD = trkcand->getDirSeed();
335  // MomRecCandLMD *=fPbeam/MomRecCandLMD.Mag();
336  }
338 
340  //Int_t nRecGEANEtrk = 0; //[R.K. 01/2017] unused variable
341  int MCtrk[nParticles]; //Number of participation this MCid in rec.tracks
342  int RECtrkMCid[nGeaneTrks]; //Assignment MC id to REC trk;
343  for (int nk = 0; nk < nParticles; nk++)
344  MCtrk[nk] = 0;
345  bool goodTrk[nGeaneTrks];
346  bool ghostTrk[nGeaneTrks];
347  for (Int_t iN = 0; iN < nGeaneTrks; iN++) {
348  goodTrk[iN] = false;
349  ghostTrk[iN] = false;
350  RECtrkMCid[iN] = -1;
351  }
352 
353  //int goodRectrk=0;//for missed trk-search //[R.K. 01/2017] unused variable
354  for (Int_t iN = 0; iN < nGeaneTrks; iN++) { // loop over all reconstructed trks
355  FairTrackParH *fRes = (FairTrackParH*) fRecBPTracks->At(iN);
356  TVector3 PosRec = fRes->GetPosition();
357  Double_t lyambda = fRes->GetLambda();
358  if (lyambda == 0) {
359  cout << "GEANE didn't propagate trk No." << iN << "!" << endl;
360  }
361 
362  PndTrack *trkpnd = (PndTrack*) fRecTracks->At(iN);
363  //double chi2 = trkpnd->GetChi2(); //[R.K. 01/2017] unused variable
364  int candID = trkpnd->GetRefIndex();
365  //if(fVerbose>5) cout<<"candID = "<<candID<<endl;
366  PndTrackCand *trkcand = (PndTrackCand*) fRecCandTracks->At(candID);
367  const int Ntrkcandhits = trkcand->GetNHits();
368  // PndSdsMCPoint* MCPointHit;
369  int MCtrkID[Ntrkcandhits]; //arrray of hits MCid
370  for (Int_t iHit = 0; iHit < Ntrkcandhits; iHit++) {
371  MCtrkID[iHit] = 9999;
372  }
373  Int_t diffIDs = 1;
374 
376  //bool emergExit=false; //[R.K. 01/2017] unused variable
377  if (fVerbose > 7)
378  cout << " *** REChits in trk (with " << Ntrkcandhits
379  << " hits) are made from MChits: " << endl; //start MC hit content
380  for (Int_t iHit = 0; iHit < Ntrkcandhits; iHit++) { // loop over rec.hits
381  if (fVerbose > 7)
382  cout << "No." << iHit << ": ";
383  PndTrackCandHit candhit = (PndTrackCandHit) (trkcand->GetSortedHit(iHit));
384  Int_t hitID = candhit.GetHitId();
385  PndSdsMergedHit* myHit = (PndSdsMergedHit*) (fRecHits->At(hitID));
386  int mcrefbot = myHit->GetSecondMCHit();
387  //bool badpxbot=false; //[R.K. 01/2017] unused variable
388  //bool badpxtop=false; //[R.K. 01/2017] unused variable
389  if (mcrefbot >= 0) {
390  PndSdsMCPoint* MCPointBot = (PndSdsMCPoint*) (fMCHits->At(mcrefbot));
391  int MCtrkid = MCPointBot->GetTrackID();
392  if (MCtrkid < 0) {
393  //emergExit=true; //[R.K. 01/2017] unused variable
394  if (fVerbose > 7)
395  cout << " " << MCtrkid << "!!!";
396  break; //TODO: how it is possible???
397  }
398  // if(MCtrkid>-1)
399  MCtrkID[iHit] = MCtrkid;
400  if (fVerbose > 7)
401  cout << " " << MCtrkid;
402  } else {
403  //badpxbot=true; //[R.K. 01/2017] unused variable
404  if (fVerbose > 7)
405  cout << " Ooops, mcrefbot = " << mcrefbot;
406  }
407  int mcreftop = myHit->GetRefIndex();
408 
409  if (mcreftop >= 0) {
410  // if(fVerbose>5)
411  // cout<<", "<<mcreftop<<")";
412  PndSdsMCPoint* MCPointTop = (PndSdsMCPoint*) (fMCHits->At(mcreftop));
413  int MCtrkid = MCPointTop->GetTrackID();
414  if (MCtrkid < 0) {
415  //emergExit=true; //[R.K. 01/2017] unused variable
416  if (fVerbose > 7)
417  cout << " " << MCtrkid << "!!!";
418  break; //TODO: how it is possible???
419  }
420  // if(MCtrkid>-1)
421  MCtrkID[iHit] = MCtrkid;
422  if (fVerbose > 7)
423  cout << " " << MCtrkid;
424  } else {
425  //badpxtop=true; //[R.K. 01/2017] unused variable
426  if (fVerbose > 7)
427  cout << " Ooops, mcreftop = " << mcreftop;
428  }
429 
430  if (fVerbose > 7)
431  cout << " " << endl; //next hit content
432  }
433  // if(emergExit) continue;
434 
435  // Sorting MC IDs ----------------------------------------
436  //TODO: sort it by c++ function
437  Int_t k, x;
438  //bool ch=false; //Was element changed? //[R.K. 01/2017] unused variable
439  Int_t nch = 0; //How many times?
440  for (Int_t n = 0; n < Ntrkcandhits; n++) { // n - current position
441  k = n;
442  x = MCtrkID[n];
443  for (Int_t m = n + 1; m < Ntrkcandhits; m++) // find the least element
444  if (MCtrkID[m] < x) {
445  k = m;
446  x = MCtrkID[m]; // k - index for the least element
447  //ch=true; //[R.K. 01/2017] unused variable
448  nch++;
449  }
450  MCtrkID[k] = MCtrkID[n];
451  MCtrkID[n] = x; // change position between the least and current elements
452  }
454 
456  Int_t prevID = MCtrkID[0];
457  for (int nk = 0; nk < nParticles; nk++) {
458  if (MCtrkID[0] == nk)
459  MCtrk[nk] = MCtrk[nk] + 1;
460  }
461  diffIDs = 1;
462  for (Int_t n = 1; n < Ntrkcandhits; n++) {
463  if (MCtrkID[n] > 9998)
464  break;
465  if (prevID < MCtrkID[n]) {
466  diffIDs++;
467  prevID = MCtrkID[n];
468  for (int nk = 0; nk < nParticles; nk++) {
469  if (MCtrkID[n] == nk)
470  MCtrk[nk] = MCtrk[nk] + 1;
471  }
472  }
473  }
474 
476 
478  if (diffIDs < 2) {
479  RECtrkMCid[iN] = MCtrkID[0];
480  // cout<<"MCtrkID[0] = "<<MCtrkID[0]<<endl;
481  if (MCtrkID[0] < 9999)
482  goodTrk[iN] = true;
483  else {
484  goodTrk[iN] = false;
485  ghostTrk[iN] = true;
486  }
487  } else {
488  vector<int> countMC_IDs(diffIDs);
489  for (int kn = 0; kn < diffIDs; kn++) {
490  countMC_IDs[kn] = 0;
491  }
492 
493  prevID = MCtrkID[0];
494  int diffCount = 0;
495  for (Int_t n = 0; n < Ntrkcandhits; n++) {
496  // cout<<"MCtrkID[n] = "<<MCtrkID[n]<<endl;
497  if (MCtrkID[n] > 9998) { //Trk from noise hits
498  goodTrk[iN] = false;
499  ghostTrk[iN] = true;
500  // break;
501  }
502 
503  if (prevID < MCtrkID[n]) {
504  diffCount++;
505  prevID = MCtrkID[n];
506  }
507  countMC_IDs[diffCount]++;
508  }
509  // if(fVerbose>1) cout<<""<<endl;
510  int maxID = countMC_IDs[0];
511  int posIDmax = 0;
512  for (int kn = 0; kn < diffIDs; kn++) {
513  if (fVerbose > 3)
514  cout << "countMC_IDs[" << kn << "]=" << countMC_IDs[kn]
515  << " 0.65*Ntrkcandhits = " << 0.65 * Ntrkcandhits << endl;
516  if (countMC_IDs[kn] > 0.65 * Ntrkcandhits) { //more then 65% of hits come from the same MC id
517  goodTrk[iN] = true;
518  ghostTrk[iN] = false;
519  } else {
520  if (!goodTrk[iN]) {
521  ghostTrk[iN] = true;
522  // cout<<" aaaaa!"<<iN<< " is ghost trk !aaaa"<<endl;
523  }
524  }
525 
526  if (countMC_IDs[kn] > maxID) {
527  maxID = countMC_IDs[kn];
528  posIDmax = kn;
529  }
530  }
531  prevID = MCtrkID[0];
532  diffCount = 0;
533  for (Int_t n = 0; n < Ntrkcandhits; n++) {
534  if (diffCount == posIDmax)
535  RECtrkMCid[iN] = prevID;
536  if (prevID < MCtrkID[n]) {
537  diffCount++;
538  prevID = MCtrkID[n];
539  }
540  }
541  }
543 
544  // /// Comporision MC, trk-candidates and REConstructed tracks --------------------------------------------
545 
546  // if(diffIDs>-1){ // All tracks
547 
548  // /// Read MC track parameters ----------------------------------------------------------
549  // int MCidforREC = RECtrkMCid[iN];
550  // PndMCTrack *mctrk =(PndMCTrack*) fMCTracks->At(MCidforREC);
551  // Int_t mcID = mctrk->GetPdgCode();
552  // // glPDG = mctrk->GetPdgCode();
553  // TVector3 MomMC = mctrk->GetMomentum();
554  // Double_t thetaMC = MomMC.Theta();
555  // Double_t phiMC = MomMC.Phi();
556  // ///------------------------------------------------------------------------------------
557 
558  // /// Read track-parameters after back-propagation ---------------------------------------
559  // //TODO: problem with covarance matrix in FairTrackParH???
560  // Double_t CovGEANELAB[6][6];
561  // fRes->GetMARSCov(CovGEANELAB);
562  // Double_t errX = fRes->GetDX();
563  // Double_t errY = fRes->GetDY();
564  // Double_t errZ = fRes->GetDZ();
565 
566  // Double_t errPx = fRes->GetDPx();
567  // Double_t errPy = fRes->GetDPy();
568  // Double_t errPz = fRes->GetDPz();
569  // TVector3 errMomBP(errPx,errPy,errPz);
570 
571  // Double_t thetaBP = TMath::Pi()/2. - lyambda;
572  // Double_t err_lyambda = fRes->GetDLambda();
573  // if(err_lyambda==0) err_lyambda = errMomBP.Theta();
574  // // Double_t err_lyambda = errMom.Theta();
575  // Double_t phiBP = fRes->GetPhi();
576  // Double_t err_phi = fRes->GetDPhi();
577  // if(err_phi==0) err_phi=errMomBP.Phi();
578  // Double_t errMomRecBP = fRes->GetDQp();
579  // TVector3 MomRecBP = fRes->GetMomentum();
580 
581  // ///==================================
582  // }
583  // ///-------------------------------------------------------------------------------------
584  }
585 
589  //NB: it's only quantity and _ NOT_ quality check. 1st REC trk will be called GOOD and 2nd and others GHOST
590  int RECassigMC[nGeaneTrks]; //how many time MCid from this RECtrk met in other RECtrks
591  for (Int_t iN = 0; iN < nGeaneTrks; iN++)
592  RECassigMC[iN] = 1;
593 
594  for (Int_t iN = 0; iN < nGeaneTrks; iN++) {
595  int mc_i = RECtrkMCid[iN];
596  for (Int_t jN = (iN + 1); jN < nGeaneTrks; jN++) {
597  int mc_j = RECtrkMCid[jN];
598  if (mc_i == mc_j) {
599  RECassigMC[iN]++;
600  if (fVerbose > 3)
601  cout << "GHOST?!: rec.trks #" << iN << " and #" << jN
602  << "were assigned to one MC trk =|" << endl;
603  }
604  }
605  }
607 
608  int goodRecII = 0, ghostRecI = 0, ghostRecII = 0;
609  for (Int_t iN = 0; iN < nGeaneTrks; iN++) { //ghost/good trk determination
610 
611  int trkType = -1;
612  if (RECassigMC[iN] > 1) { //one RECtrk was already called GOOD for this MCid -> all next are GHOSTs
613  goodTrk[iN] = false;
614  ghostTrk[iN] = true;
615  trkType = +2;
616  ghostRecI++;
617  }
618 
619  if (goodTrk[iN]) {
620  if (fVerbose > 7)
621  cout << "... RECtrk#" << iN << " was defined as GOOD ..." << endl;
622  goodRecII++;
623  trkType = 0;
624  }
625  if (ghostTrk[iN]) {
626  if (fVerbose > 7)
627  cout << "... RECtrk#" << iN << " was defined as GHOST ..." << endl;
628  if (trkType < 0) {
629  trkType = +1;
630  ghostRecII++;
631  }
632  }
633  if (trkType < 0) {
634  cout << "Ooops, RECtrk isn't GOOD and isn't GHOST!!!" << endl;
635  trkType = -10;
636  }
637  // if(trkType<0) continue; //GEANE didn't propagate this track
638  FairTrackParH *fRes = (FairTrackParH*) fRecBPTracks->At(iN);
639  Double_t lyambda = fRes->GetLambda();
640  if (lyambda == 0)
641  trkType = -100; //Trk was not back-propagated!
642  // cout<<"GEANE didn't propagate "<<iN<<" trk!"<<endl;
643  Double_t thetaBP = TMath::Pi() / 2. - lyambda;
644  Double_t phiBP = fRes->GetPhi();
645  TVector3 MomRecBP = fRes->GetMomentum();
646  TVector3 PosBP = fRes->GetPosition();
647 
648  //Fill tree with rec vs. mc trk info ------------------------------------------------
649  glXrec = PosBP.X();
650  glYrec = PosBP.Y();
651  glZrec = PosBP.Z();
652  glThetarec = thetaBP;
653  glPhirec = phiBP;
654  glMomrec = MomRecBP.Mag();
655  Double_t errX = fRes->GetDX();
656  Double_t errY = fRes->GetDY();
657  Double_t errZ = fRes->GetDZ();
658 
659  Double_t errPx = fRes->GetDPx();
660  Double_t errPy = fRes->GetDPy();
661  Double_t errPz = fRes->GetDPz();
662  TVector3 errMomBP(errPx, errPy, errPz);
663 
664  Double_t err_lyambda = fRes->GetDLambda();
665  // if(err_lyambda==0) err_lyambda = errMomBP.Theta();
666  Double_t err_phi = fRes->GetDPhi();
667 
668  PndTrack *trkpnd = (PndTrack*) fRecTracks->At(iN);
669  glchi2 = trkpnd->GetChi2();
670  FairTrackParP fFittedTrkP = trkpnd->GetParamFirst();
671  TVector3 PosRecLMD(fFittedTrkP.GetX(), fFittedTrkP.GetY(),
672  fFittedTrkP.GetZ());
673  TVector3 MomRecLMD(fFittedTrkP.GetPx(), fFittedTrkP.GetPy(),
674  fFittedTrkP.GetPz());
675  MomRecLMD *= fPbeam / MomRecLMD.Mag();
676  glXrecLMD = PosRecLMD.X();
677  glYrecLMD = PosRecLMD.Y();
678  glZrecLMD = PosRecLMD.Z();
679  glThetarecLMD = MomRecLMD.Theta();
680  glPhirecLMD = MomRecLMD.Phi();
681  trkRECStatus = trkType;
682  int candID = trkpnd->GetRefIndex();
683  PndTrackCand *trkcand = (PndTrackCand*) fRecCandTracks->At(candID);
684  PndTrackCandHit candhit = (PndTrackCandHit) (trkcand->GetSortedHit(0)); //1st hit info
685  Int_t hitID = candhit.GetHitId();
686  PndSdsMergedHit* myHit = (PndSdsMergedHit*) (fRecHits->At(hitID));
687  int sensorID = myHit->GetSensorID();
688 
689  auto& lmd_geo_helper(PndLmdGeometryHelper::getInstance());
690  auto const& digi_info(lmd_geo_helper.getHitLocationInfo(sensorID));
691  glModule = digi_info.module;
692  glHalf = digi_info.detector_half;
693  glTrkTime = myHit->GetTimeStamp();
694  //TODO: include info from GetTimeStampError()
695 
696  // if(trkType>0){ //TODO: ghost-doubled trks has MC trk!!!
697  // // int MCidforREC = RECtrkMCid[iN];
698 
699  // // glXmc= -9999; glYmc =-9999; glZmc = -9999; glThetamc =-9999; glPhimc = -9999; glMommc = -9999;
700  // // glXmcLMD = -9999; glYmcLMD =-9999; glZmcLMD = -9999; glThetamcLMD =-9999; glPhimcLMD = -9999; glMommcLMD = -9999;
701  // // glNumMChits = -9999; glNumDoubleMChits = -9999; // glEvTime = -9999;
702  // // trkMCStatus = -9999;
703  // // glPDG = -9999;
704  // }
705  // else{
706 
707  // }
708  int MCidforREC = RECtrkMCid[iN];
709  // if(!goodTrk[iN]) continue;
710  //cout<<" MCidforREC = "<<MCidforREC<<endl;
711  if (MCidforREC > 9998) {
712  glXmc = -9999;
713  glYmc = -9999;
714  glZmc = -9999;
715  glThetamc = -9999;
716  glPhimc = -9999;
717  glMommc = -9999;
718  glXmcLMD = -9999;
719  glYmcLMD = -9999;
720  glZmcLMD = -9999;
721  glThetamcLMD = -9999;
722  glPhimcLMD = -9999;
723  glMommcLMD = -9999;
724  glNumMChits = -9999;
725  glNumDoubleMChits = -9999; // glEvTime = -9999;
726  trkMCStatus = -9999;
727  glPDG = -9999;
728  } else {
729  PndMCTrack *mctrk = (PndMCTrack*) fMCTracks->At(MCidforREC);
730  glPDG = mctrk->GetPdgCode();
731  // glEvTime = mctrk->GetStartTime(); //this gives start time of trk, doesn't matter since all el. pbar start in IP
732  TVector3 MomMC = mctrk->GetMomentum();
733  glThetamc = MomMC.Theta();
734  glPhimc = MomMC.Phi();
735  glMommc = MomMC.Mag();
736  TVector3 StartMC = mctrk->GetStartVertex();
737  glXmc = StartMC.X();
738  glYmc = StartMC.Y();
739  glZmc = StartMC.Z();
740  int movID = mctrk->GetMotherID();
741  trkMCStatus = movID;
742  // if(movID<0) trkMCStatus=1;
743  // else
744  // trkMCStatus=0;
745  glNumMChits = MCtksSIMhits[MCidforREC];
746  glNumDoubleMChits = MCDoubleHits[MCidforREC];
747 
748  // //Get MC info in LMD
749 
750  int mcrefbot = myHit->GetSecondMCHit();
751  int mcreftop = myHit->GetRefIndex();
752  if (fVerbose > 0) {
753  cout << "mcrefbot = " << mcrefbot << " mcreftop = " << mcreftop << endl;
754  }
755  PndSdsMCPoint* MCPointHit;
756  if (mcreftop >= 0) {
757  MCPointHit = (PndSdsMCPoint*) (fMCHits->At(mcreftop));
758  } else {
759  if (mcrefbot >= 0)
760  MCPointHit = (PndSdsMCPoint*) (fMCHits->At(mcrefbot));
761  else
762  MCPointHit = NULL;
763  }
764  if (MCPointHit != NULL) {
765  TVector3 PosMClmd = MCPointHit->GetPosition();
766 
767  double pxTrue = MCPointHit->GetPx();
768  double pyTrue = MCPointHit->GetPy();
769  double pzTrue = MCPointHit->GetPz();
770  TVector3 MomMClmd(pxTrue, pyTrue, pzTrue);
771  glXmcLMD = PosMClmd.X();
772  glYmcLMD = PosMClmd.Y();
773  glZmcLMD = PosMClmd.Z();
774  glThetamcLMD = MomMClmd.Theta();
775  glPhimcLMD = MomMClmd.Phi();
776  glMommcLMD = MomMClmd.Mag();
777  } else { // Noise MC hit
778  // glXmcLMD = -9999; glYmcLMD = -9999; glZmcLMD = -9999;
779  // glThetamcLMD = -9999; glPhimcLMD = -9999; glMommcLMD = -9999;
780  glXmc = -9999;
781  glYmc = -9999;
782  glZmc = -9999;
783  glThetamc = -9999;
784  glPhimc = -9999;
785  glMommc = -9999;
786  glXmcLMD = -9999;
787  glYmcLMD = -9999;
788  glZmcLMD = -9999;
789  glThetamcLMD = -9999;
790  glPhimcLMD = -9999;
791  glMommcLMD = -9999;
792  glNumMChits = -9999;
793  glNumDoubleMChits = -9999; // glEvTime = -9999;
794  trkMCStatus = -99; //1st rec hit = Noise MC hit TODO: check if all hits of this rec.trk are noise ones
795  glPDG = -99; //1st rec hit = Noise MC hit
796  }
797  }
798  // tRECMCtrks->Fill();
799  PndLmdTrackQ *trkqlmd =
800  new ((*fTrackQ)[fTrackQ->GetEntriesFast()]) PndLmdTrackQ(glMommc);
801 
802  trkqlmd->SetTrkRecStatus(trkRECStatus);
803  trkqlmd->SetSecondary(trkMCStatus);
804  trkqlmd->SetPDGcode(glPDG);
805  trkqlmd->SetLMDpoint(glXrecLMD, glYrecLMD, glZrecLMD);
806  trkqlmd->SetLMDdir(glThetarecLMD, glPhirecLMD);
807  trkqlmd->SetLMDchi2(glchi2);
808  trkqlmd->SetIPpoint(glXrec, glYrec, glZrec);
809  trkqlmd->SetIPmom(glThetarec, glPhirec, glMomrec);
810  trkqlmd->SetIPerrpoint(errX, errY, errZ);
811  trkqlmd->SetIPerrmom(err_lyambda, err_phi, errMomBP.Mag());
812 
813  trkqlmd->SetMCpoint(glXmc, glYmc, glZmc);
814  trkqlmd->SetMCmom(glThetamc, glPhimc, glMommc);
815  // trkqlmd->SetSecondary(trkMCStatus);
816  trkqlmd->SetNumMChits(glNumMChits);
817  trkqlmd->SetNumDoubleMChits(glNumDoubleMChits);
818  trkqlmd->SetMCpointLMD(glXmcLMD, glYmcLMD, glZmcLMD);
819  trkqlmd->SetMCmomLMD(glThetamcLMD, glPhimcLMD, glMommcLMD);
820  // trkqlmd->SetTotEvCharge(TotCharge);
821  trkqlmd->SetSumEvPDG(sumID);
822  trkqlmd->SetEvMCMulti(nParticles);
823  trkqlmd->SetEvRECMulti(nGeaneTrks);
824  trkqlmd->SetEvTime(glEvTime);
825  trkqlmd->SetTrkTime(glTrkTime);
826  trkqlmd->SetModule(glModule);
827  trkqlmd->SetHalf(glHalf);
828  //(end) Fill tree with rec vs. mc trk info ---------------------------------------
829 
830  }
832 
834  if ((nParticles - goodRecII) > 0) { //missed trks
835 
836  int nMCmissedTrkSearch = 0;
837  int nMCmissedLossHits = 0;
838  for (int imc = 0; imc < nParticles; imc++) { //MC trks
839  bool missTrk = true;
840  for (int irec = 0; irec < nGeaneTrks; irec++) { //RECids assigment
841  int mc_comp = RECtrkMCid[irec];
842  if (mc_comp == imc && goodTrk[irec])
843  missTrk = false;
844  }
845  PndMCTrack *mctrk = (PndMCTrack*) fMCTracks->At(imc);
846  int movID = mctrk->GetMotherID();
847  TVector3 MomMC = mctrk->GetMomentum();
848  TVector3 PosMC = mctrk->GetStartVertex();
849  glXmc = PosMC.X();
850  glYmc = PosMC.Y();
851  glZmc = PosMC.Z();
852  glThetamc = MomMC.Theta();
853  glPhimc = MomMC.Phi();
854  glMommc = MomMC.Mag();
855 
856  int trkQ = 0;
858  int minHits = MCDoubleHits[imc] + 2;
859  if (MCDoubleHits[imc] == 4)
860  minHits -= 1;
861 
862  if (missTrk) {
863  if (MCtksREChits[imc] > minHits) { //missed during trk-search
864  if (fVerbose > 7) {
865  cout << " --- MCtrk#" << imc
866  << " was defined as MISSED during trk-search (#MChits="
867  << MCtksREChits[imc] << " with limit>" << minHits << ")"
868  << endl;
869  if (MCDoubleHits[imc] > 0)
870  cout << " NB:this MCtrk contains " << MCDoubleHits[imc]
871  << " double hits!" << endl;
872  }
873  trkQ = -1;
874  nMCmissedTrkSearch++;
875  } else { //missed due to small amount of hits
876  if (MCtksREChits[imc] > 0) { // if MCtksREChits[imc]==0 trk is out of measurment range
877  // if(MCtksREChits[imc]>0){// if MCtksREChits[imc]==0 trk is out of measurment range
878  nMCmissedLossHits++;
879  trkQ = -2;
880  if (fVerbose > 7)
881  cout << " --- MCtrk#" << imc
882  << " was defined as MISSED due to little amount of hits (#MChits="
883  << MCtksREChits[imc] << " with limit>" << minHits << ")"
884  << endl;
885  int hitArr = -1;
886  // cout<<"nMCHits = "<<nMCHits<<endl;
887  for (int imhc = 0; imhc < nMCHits; imhc++) {//find corresponding MC hit for this MC trk
888  PndSdsMCPoint* MCPoint = (PndSdsMCPoint*) (fMCHits->At(imhc));
889  int MCtrkID = MCPoint->GetTrackID();
890  // cout<<"MCtrkID = "<<MCtrkID<<" imc = "<<imc<<endl;
891  if (MCtrkID == imc) {
892  hitArr = imhc;
893  break;
894  }
895  }
896  if (hitArr > 0) {
897  PndSdsMCPoint* MCPointHit = (PndSdsMCPoint*) (fMCHits->At(hitArr));
898  TVector3 PosMClmd = MCPointHit->GetPosition();
899  double pxTrue = MCPointHit->GetPx();
900  double pyTrue = MCPointHit->GetPy();
901  double pzTrue = MCPointHit->GetPz();
902  TVector3 MomMClmd(pxTrue, pyTrue, pzTrue);
903  glXmcLMD = PosMClmd.X();
904  glYmcLMD = PosMClmd.Y();
905  glZmcLMD = PosMClmd.Z();
906  glThetamcLMD = MomMClmd.Theta();
907  glPhimcLMD = MomMClmd.Phi();
908  glMommcLMD = MomMClmd.Mag();
909  } else {
910  trkQ = -3;
911  glXmcLMD = -9999;
912  glYmcLMD = -9999;
913  glZmcLMD = -9999;
914  glThetamcLMD = -9999;
915  glPhimcLMD = -9999;
916  glMommcLMD = -9999;
917  }
918  } else {
919  trkQ = -3;
920  glXmcLMD = -9999;
921  glYmcLMD = -9999;
922  glZmcLMD = -9999;
923  glThetamcLMD = -9999;
924  glPhimcLMD = -9999;
925  glMommcLMD = -9999;
926  }
927  }
928  // cout<<"trk was marked ad missed, reason trkQ="<<trkQ<<endl;
929 
930  //Fill tree with rec vs. mc trk info for missed trks ------------------------------------------------
931  glXrec = -9999;
932  glYrec = -9999;
933  glZrec = -9999;
934  glThetarec = -9999;
935  glPhirec = -9999;
936  glXrecLMD = -9999;
937  glYrecLMD = -9999;
938  glZrecLMD = -9999;
939  glThetarecLMD = -9999;
940  glPhirecLMD = -9999;
941  glMomrec = -9999;
942  glchi2 = -9999;
943  glTrkTime = -9999;
944  trkRECStatus = trkQ;
945 
946  trkMCStatus = movID;
947  glPDG = mctrk->GetPdgCode();
948  // glEvTime = mctrk->GetStartTime();
949  // if(movID<0) trkMCStatus=0;
950  // if(movID>=0) trkMCStatus=+1;
951  // tRECMCtrks->Fill();
952  if (!fWriteAllMC && trkRECStatus == -3) {
953  } else {
954  TClonesArray& clref = *fTrackQ;
955  Int_t size = clref.GetEntriesFast();
956  PndLmdTrackQ *trkqlmd = new (clref[size]) PndLmdTrackQ(glMommc);
957  trkqlmd->SetTrkRecStatus(trkRECStatus);
958  trkqlmd->SetSecondary(trkMCStatus);
959  trkqlmd->SetPDGcode(glPDG);
960  trkqlmd->SetLMDpoint(glXrecLMD, glYrecLMD, glZrecLMD);
961  trkqlmd->SetLMDdir(glThetarecLMD, glPhirecLMD);
962  trkqlmd->SetLMDchi2(glchi2);
963  trkqlmd->SetIPpoint(glXrec, glYrec, glZrec);
964  trkqlmd->SetIPmom(glThetarec, glPhirec, glMomrec);
965  trkqlmd->SetMCpoint(glXmc, glYmc, glZmc);
966  trkqlmd->SetMCmom(glThetamc, glPhimc, glMommc);
967  // trkqlmd->SetSecondary(trkMCStatus);
968  trkqlmd->SetIPerrpoint(-9999, -9999, -9999);
969  trkqlmd->SetIPerrmom(-9999, -9999, -9999);
970  trkqlmd->SetNumMChits(MCtksREChits[imc]);
971  trkqlmd->SetNumDoubleMChits(MCDoubleHits[imc]);
972  // cout<<"glXmcLMD = "<<glXmcLMD<<endl;
973  trkqlmd->SetMCpointLMD(glXmcLMD, glYmcLMD, glZmcLMD);
974  trkqlmd->SetMCmomLMD(glThetamcLMD, glPhimcLMD, glMommcLMD);
975  // cout<<"glPhimcLMD = "<<glPhimcLMD<<endl;
976  // trkqlmd->SetTotEvCharge(TotCharge);
977  trkqlmd->SetSumEvPDG(sumID);
978  trkqlmd->SetEvMCMulti(nParticles);
979  trkqlmd->SetEvRECMulti(nGeaneTrks);
980  trkqlmd->SetEvTime(glEvTime);
981  trkqlmd->SetTrkTime(glTrkTime);
982  trkqlmd->SetModule(glModule);
983  trkqlmd->SetHalf(glHalf);
984  }
985  //(end) Fill tree with rec vs. mc trk info for missed trks ---------------------------------------
986  }
987  }
988  }
989 
990  if (fVerbose > 2)
991  cout << "PndLmdTrkQTask::Exec END!" << endl;
992  fEventNr++;
993 }
PndLmdTrackQ::SetModule
void SetModule(int mod)
Definition: PndLmdTrackQ.h:197
PndLmdTrkQTask::fRecBPTracks
TClonesArray * fRecBPTracks
Definition: PndLmdTrkQTask.h:68
PndLmdTrkQTask::fMCTracks
TClonesArray * fMCTracks
Definition: PndLmdTrkQTask.h:64
PndLmdTrackQ::SetEvRECMulti
void SetEvRECMulti(int tot)
Definition: PndLmdTrackQ.h:185
fVerbose
int fVerbose
Definition: poormantracks.C:24
m
__m128 m
Definition: P4_F32vec4.h:28
PndSdsHit::GetPosition
TVector3 GetPosition() const
Definition: PndSdsHit.h:93
nk
int nk
Definition: toy_core.C:124
PndMCTrack::GetPdgCode
Int_t GetPdgCode() const
Definition: PndMCTrack.h:73
PndLmdTrackQ::SetMCmom
void SetMCmom(double theta, double phi, double mom)
Definition: PndLmdTrackQ.h:120
PndLmdTrackQ::SetMCpoint
void SetMCpoint(double x, double y, double z)
Definition: PndLmdTrackQ.h:114
PndTrackCand::GetSortedHit
PndTrackCandHit GetSortedHit(UInt_t i)
Definition: PndTrackCand.h:54
PndLmdTrackQ::SetTrkRecStatus
void SetTrkRecStatus(int st)
Definition: PndLmdTrackQ.h:47
n
int n
Definition: HypStatDecay.cxx:21
PndLmdGeometryHelper::getInstance
static PndLmdGeometryHelper & getInstance()
Definition: PndLmdGeometryHelper.h:75
PndLmdTrackQ::SetLMDdir
void SetLMDdir(double theta, double phi)
Definition: PndLmdTrackQ.h:69
MCPoint
TFile * MCPoint
Definition: anaLmdDigi.C:25
PndMCTrack::GetMomentum
TVector3 GetMomentum() const
Definition: PndMCTrack.h:78
PndLmdTrackQ::SetIPpoint
void SetIPpoint(double x, double y, double z)
Definition: PndLmdTrackQ.h:84
PndLmdTrackQ::SetMCpointLMD
void SetMCpointLMD(double x, double y, double z)
Definition: PndLmdTrackQ.h:135
PndLmdTrkQTask::fTrackQ
TClonesArray * fTrackQ
Definition: PndLmdTrkQTask.h:70
PndLmdTrackQ::SetIPerrpoint
void SetIPerrpoint(double errx, double erry, double errz)
Definition: PndLmdTrackQ.h:102
PndLmdTrackQ::SetMCmomLMD
void SetMCmomLMD(double theta, double phi, double mom)
Definition: PndLmdTrackQ.h:138
PndLmdTrackQ::SetPDGcode
void SetPDGcode(int pdg)
Definition: PndLmdTrackQ.h:56
Double_t
Double_t
Definition: SimCompleteLinkDef.h:6
PndLmdTrackQ::SetSecondary
void SetSecondary(int sec)
Definition: PndLmdTrackQ.h:151
PndLmdTrackQ::SetIPerrmom
void SetIPerrmom(double errtheta, double errphi, double errmom)
Definition: PndLmdTrackQ.h:108
PndLmdTrkQTask::fRecCandTracks
TClonesArray * fRecCandTracks
Definition: PndLmdTrkQTask.h:66
PndLmdTrkQTask::fMCHits
TClonesArray * fMCHits
Definition: PndLmdTrkQTask.h:63
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: P4_F32vec4.h:47
PndLmdTrackQ::SetEvTime
void SetEvTime(double evtm)
Definition: PndLmdTrackQ.h:191
PndLmdTrackQ::SetTrkTime
void SetTrkTime(double trktm)
Definition: PndLmdTrackQ.h:192
PndLmdTrkQTask::fRecTracks
TClonesArray * fRecTracks
Definition: PndLmdTrkQTask.h:67
PndLmdTrackQ::SetSumEvPDG
void SetSumEvPDG(int sumid)
Definition: PndLmdTrackQ.h:170
PndLmdTrackQ::SetLMDchi2
void SetLMDchi2(double chi2)
Definition: PndLmdTrackQ.h:78
PndSdsMCPoint::GetPosition
TVector3 GetPosition() const
Definition: PndSdsMCPoint.h:90
PndLmdTrackQ::SetLMDpoint
void SetLMDpoint(double x, double y, double z)
Definition: PndLmdTrackQ.h:63
PndSdsMergedHit::GetSecondMCHit
Int_t GetSecondMCHit() const
Definition: PndSdsMergedHit.h:78
x
Double_t x
Definition: createRootFscGeometryFile.C:159
PndLmdTrackQ::SetNumMChits
void SetNumMChits(int num)
Definition: PndLmdTrackQ.h:158
PndTrack::GetChi2
Double_t GetChi2() const
Definition: PndTrack.h:34
PndLmdTrackQ::SetNumDoubleMChits
void SetNumDoubleMChits(int num)
Definition: PndLmdTrackQ.h:164
PndTrackCand::GetNHits
UInt_t GetNHits() const
Definition: PndTrackCand.h:59
PndLmdTrackQ::SetEvMCMulti
void SetEvMCMulti(int tot)
Definition: PndLmdTrackQ.h:179
PndTrack::GetRefIndex
Int_t GetRefIndex() const
Definition: PndTrack.h:36
PndMCTrack::GetStartVertex
TVector3 GetStartVertex() const
Definition: PndMCTrack.h:76
PndSdsHit::GetSensorID
Int_t GetSensorID() const
Definition: PndSdsHit.h:90
PndMCTrack::GetMotherID
Int_t GetMotherID() const
Definition: PndMCTrack.h:74
PndTrackCandHit::GetHitId
Int_t GetHitId() const
Definition: PndTrackCandHit.h:55
Pi
Double_t Pi
Definition: PndGeoHypGeCrystal.cxx:10
PndLmdTrkQTask::fRecHits
TClonesArray * fRecHits
Definition: PndLmdTrkQTask.h:65
PndLmdTrackQ::SetIPmom
void SetIPmom(double theta, double phi, double mom)
Definition: PndLmdTrackQ.h:90
PndTrack::GetParamFirst
FairTrackParP GetParamFirst()
Definition: PndTrack.h:49
PndLmdTrackQ::SetHalf
void SetHalf(int hf)
Definition: PndLmdTrackQ.h:198
void PndLmdTrkQTask::Finish ( )
virtual

Definition at line 995 of file PndLmdTrkQTask.cxx.

995  {
996 }
InitStatus PndLmdTrkQTask::Init ( )
virtual

Virtual method Init

Definition at line 65 of file PndLmdTrkQTask.cxx.

References fGeaneName, fMCHits, fMCTracks, fRecBPTracks, fRecCandTracks, fRecHits, fRecTracks, fTrackBranchName, and fTrackQ.

65  {
66 
67  // Get RootManager
68  FairRootManager* ioman = FairRootManager::Instance();
69  if (!ioman) {
70  std::cout << "-E- PndLmdTrkQTask::Init: " << "RootManager not instantiated!"
71  << std::endl;
72  return kFATAL;
73  }
74 
75  // fMCHeader = (TClonesArray*) ioman->GetObject("MCEventHeader.");
76  // if ( !fMCHeader) {
77  // std::cout << "-W- PndLmdTrkQTask::Init: "<< "No MCEventHeader "<<" object!" << std::endl;
78  // return kERROR;
79  // }
80 
81  //Get MC points
82  fMCHits = (TClonesArray*) ioman->GetObject("LMDPoint");
83  if (!fMCHits) {
84  std::cout << "-W- PndLmdTrkQTask::Init: " << "No LMDPoint" << " array!"
85  << std::endl;
86  return kERROR;
87  }
88 
89  //Get MC tracks
90  fMCTracks = (TClonesArray*) ioman->GetObject("MCTrack");
91  if (!fMCTracks) {
92  std::cout << "-W- PndLmdTrkQTask::Init: " << "No MCTrack" << " array!"
93  << std::endl;
94  return kERROR;
95  }
96 
97  //Get rec. hits
98  fRecHits = (TClonesArray*) ioman->GetObject("LMDHitsMerged");
99  if (!fRecHits) {
100  std::cout << "-W- PndLmdTrkQTask::Init: " << "No LMDHitsMerged" << " array!"
101  << std::endl;
102  return kERROR;
103  }
104  //Get trk cand
105  fRecCandTracks = (TClonesArray*) ioman->GetObject("LMDTrackCand");
106  if (!fRecCandTracks) {
107  std::cout << "-W- PndLmdTrkQTask::Init: " << "No LMDTrackCand" << " array!"
108  << std::endl;
109  return kERROR;
110  }
111  //Get rec.tracks before back propagation
112  fRecTracks = (TClonesArray*) ioman->GetObject(fTrackBranchName);
113  if (!fRecTracks) {
114  std::cout << "-W- PndLmdTrkQTask::Init: " << "No LMDPndTrackFilt"
115  << " array!" << std::endl;
116  return kERROR;
117  }
118 
119  //Get rec.tracks after back propagation
120  // fRecBPTracks = (TClonesArray*) ioman->GetObject("GeaneTrackFinal");//use raw reconstructed data
121  // fRecBPTracks = (TClonesArray*) ioman->GetObject("LMDCleanTrack");//use cleaned data
122  fRecBPTracks = (TClonesArray*) ioman->GetObject(fGeaneName);
123  if (!fRecBPTracks) {
124  std::cout << "-W- PndLmdTrkQTask::Init: " << "No GeaneTrackFinal"
125  << " array!" << std::endl;
126  return kERROR;
127  }
128 
129  fTrackQ = new TClonesArray("PndLmdTrackQ");
130  ioman->Register("LMDTrackQ", "TrkQ", fTrackQ, kTRUE);
131 
132  // fDetName = new TClonesArray("TObjString");
133  // ioman->Register("DetName", "TrkQ", fDetName, kTRUE);
134 
135  // fGeoH = PndGeoHandling::Instance();
136  //FairRun* fRun = FairRun::Instance(); //[R.K. 01/2017] unused variable?
137  //FairRuntimeDb* rtdb = fRun->GetRuntimeDb(); //[R.K. 01/2017] unused variable
138  // TDatabasePDG *fdbPDG = TDatabasePDG::Instance();
139  // fdbPDG = TDatabasePDG::Instance();
140 
141  return kSUCCESS;
142 }
PndLmdTrkQTask::fRecBPTracks
TClonesArray * fRecBPTracks
Definition: PndLmdTrkQTask.h:68
PndLmdTrkQTask::fMCTracks
TClonesArray * fMCTracks
Definition: PndLmdTrkQTask.h:64
PndLmdTrkQTask::fTrackQ
TClonesArray * fTrackQ
Definition: PndLmdTrkQTask.h:70
PndLmdTrkQTask::fTrackBranchName
TString fTrackBranchName
Definition: PndLmdTrkQTask.h:62
PndLmdTrkQTask::fRecCandTracks
TClonesArray * fRecCandTracks
Definition: PndLmdTrkQTask.h:66
PndLmdTrkQTask::fMCHits
TClonesArray * fMCHits
Definition: PndLmdTrkQTask.h:63
PndLmdTrkQTask::fRecTracks
TClonesArray * fRecTracks
Definition: PndLmdTrkQTask.h:67
PndLmdTrkQTask::fRecHits
TClonesArray * fRecHits
Definition: PndLmdTrkQTask.h:65
PndLmdTrkQTask::fGeaneName
TString fGeaneName
Definition: PndLmdTrkQTask.h:61
void PndLmdTrkQTask::SetWriteMC ( bool  wr)
inline

Definition at line 57 of file PndLmdTrkQTask.h.

References fWriteAllMC.

Referenced by runLumiPixel7TrksQA().

57 {fWriteAllMC = wr;}

Member Data Documentation

int PndLmdTrkQTask::fEventNr
private

Definition at line 72 of file PndLmdTrkQTask.h.

Referenced by Exec().

TString PndLmdTrkQTask::fGeaneName
private

Definition at line 61 of file PndLmdTrkQTask.h.

Referenced by Init(), and PndLmdTrkQTask().

TClonesArray* PndLmdTrkQTask::fMCHits
private

Definition at line 63 of file PndLmdTrkQTask.h.

Referenced by Exec(), and Init().

TClonesArray* PndLmdTrkQTask::fMCTracks
private

Definition at line 64 of file PndLmdTrkQTask.h.

Referenced by Exec(), and Init().

Double_t PndLmdTrkQTask::fPbeam
private

Definition at line 74 of file PndLmdTrkQTask.h.

Referenced by Exec(), and PndLmdTrkQTask().

TClonesArray* PndLmdTrkQTask::fRecBPTracks
private

Definition at line 68 of file PndLmdTrkQTask.h.

Referenced by Exec(), and Init().

TClonesArray* PndLmdTrkQTask::fRecCandTracks
private

Definition at line 66 of file PndLmdTrkQTask.h.

Referenced by Exec(), and Init().

TClonesArray* PndLmdTrkQTask::fRecHits
private

Definition at line 65 of file PndLmdTrkQTask.h.

Referenced by Exec(), and Init().

TClonesArray* PndLmdTrkQTask::fRecTracks
private

Definition at line 67 of file PndLmdTrkQTask.h.

Referenced by Exec(), and Init().

TString PndLmdTrkQTask::fTrackBranchName
private

Definition at line 62 of file PndLmdTrkQTask.h.

Referenced by Init(), and PndLmdTrkQTask().

TClonesArray* PndLmdTrkQTask::fTrackQ
private

Definition at line 70 of file PndLmdTrkQTask.h.

Referenced by Exec(), and Init().

bool PndLmdTrkQTask::fWriteAllMC
private

Definition at line 77 of file PndLmdTrkQTask.h.

Referenced by Exec(), PndLmdTrkQTask(), and SetWriteMC().

The documentation for this class was generated from the following files:
Generated on Wed Apr 3 2019 10:03:34 for FairRoot/PandaRoot by   doxygen 1.8.5