ATTPCROOT  0.3.0-alpha
A ROOT-based framework for analyzing data from active target detectors
AtEventDrawTaskProto.cxx
Go to the documentation of this file.
1 #include "AtEventDrawTaskProto.h"
2 // IWYU pragma: no_include <ext/alloc_traits.h>
3 #include "AtAuxPad.h" // for AtAuxPad
4 #include "AtBaseEvent.h" // for AtBaseEvent::AuxPadMap
5 #include "AtEvent.h" // for AtEvent, hitVector
6 #include "AtEventManagerProto.h" // for AtEventManagerProto
7 #include "AtHit.h" // for AtHit
8 #include "AtMap.h" // for AtMap
9 #include "AtPad.h" // for AtPad
10 #include "AtPatternEvent.h" // for AtPatternEvent
11 #include "AtProtoEvent.h" // for AtProtoEvent
12 #include "AtProtoEventAna.h" // for AtProtoEventAna
13 #include "AtProtoQuadrant.h" // for AtProtoQuadrant
14 #include "AtRawEvent.h" // for AtRawEvent, AuxPadMap
15 #include "AtTpcProtoMap.h" // for AtTpcProtoMap
16 #include "AtTrack.h" // for AtTrack
17 
18 #include <FairLogger.h> // for Logger, LOG
19 #include <FairRootManager.h> // for FairRootManager
20 #include <FairTask.h> // for InitStatus, kSUCCESS
21 
22 #include <Math/Point3D.h> // for PositionVector3D
23 #include <TAttMarker.h> // for kFullDotMedium
24 #include <TAxis.h> // for TAxis
25 #include <TCanvas.h> // for TCanvas
26 #include <TClonesArray.h> // for TClonesArray
27 #include <TColor.h> // for TColor
28 #include <TEveBoxSet.h> // for TEveBoxSet, TEveBoxSet::kBT_AABox
29 #include <TEveLine.h> // for TEveLine
30 #include <TEveManager.h> // for TEveManager, gEve
31 #include <TEvePointSet.h> // for TEvePointSet
32 #include <TEveTrans.h> // for TEveTrans
33 #include <TEveTreeTools.h> // for TEvePointSelectorConsumer, TEvePoin...
34 #include <TF1.h> // for TF1
35 #include <TGraph.h> // for TGraph
36 #include <TH1.h> // for TH1I, TH1D, TH1F
37 #include <TH2.h> // for TH2F
38 #include <TH2Poly.h> // for TH2Poly
39 #include <TList.h> // for TList
40 #include <TMath.h> // for Power, Sqrt
41 #include <TNamed.h> // for TNamed
42 #include <TObject.h> // for TObject
43 #include <TPad.h> // for TPad
44 #include <TPaletteAxis.h> // for TPaletteAxis
45 #include <TROOT.h> // for TROOT, gROOT
46 #include <TSeqCollection.h> // for TSeqCollection
47 #include <TStyle.h> // for TStyle, gStyle
48 #include <TVirtualPad.h> // for TVirtualPad, gPad
49 #include <TVirtualX.h> // for TVirtualX, gVirtualX
50 
51 #include <algorithm> // for max
52 #include <array> // for array
53 #include <cstdio> // for sprintf
54 #include <exception> // for exception
55 #include <iostream> // for operator<<, basic_ostream, endl
56 #include <map> // for operator!=, _Rb_tree_const_iterator
57 #include <memory> // for allocator, allocator_traits<>::valu...
58 #include <string> // for char_traits, operator<<
59 #include <utility> // for pair
60 #include <vector> // for vector
61 
62 constexpr auto cRED = "\033[1;31m";
63 constexpr auto cYELLOW = "\033[1;33m";
64 constexpr auto cNORMAL = "\033[0m";
65 constexpr auto cGREEN = "\033[1;32m";
66 
67 using namespace std;
68 
69 ClassImp(AtEventDrawTaskProto);
70 
71 AtEventDrawTaskProto::AtEventDrawTaskProto()
72  : fHitColor(kPink), fHitSize(1), fHitStyle(kFullDotMedium), fHitSet(nullptr), fSaveTextData(false),
73  fhitBoxSet(nullptr)
74 {
75  Char_t padhistname[256];
76 
77  for (Int_t i = 0; i < 2015; i++) {
78  sprintf(padhistname, "pad_%d", i);
79  fPadAll[i] = new TH1I(padhistname, padhistname, 512, 0, 511);
80  }
81 
82  Char_t phihistname[256];
83 
84  for (Int_t i = 0; i < 5; i++) {
85  sprintf(phihistname, "PhiDistr_%d", i);
86  fPhiDistr[i] = new TH1D(phihistname, phihistname, 180.0, -180.0, 180.0);
87  if (i == 0)
88  fPhiDistr[i]->SetLineColor(kRed);
89  else if (i == 1)
90  fPhiDistr[i]->SetLineColor(kBlue);
91  else if (i == 2)
92  fPhiDistr[i]->SetLineColor(kGreen);
93  else if (i == 3)
94  fPhiDistr[i]->SetLineColor(kCyan);
95  else if (i == 4)
96  fPhiDistr[i]->SetLineColor(kMagenta);
97  fPhiDistr[i]->SetLineWidth(2);
98  fPhiDistr[i]->GetYaxis()->SetRangeUser(0., 20.);
99  }
100 
101  fIsCircularHough = kFALSE;
102  fIsLinearHough = kTRUE;
103  fIsRawData = kFALSE;
104  kIsPRDrawn = kFALSE;
105  fHoughLinearFit =
106  new TF1("HoughLinearFit", " ( (-TMath::Cos([0])/TMath::Sin([0]))*x ) + [1]/TMath::Sin([0])", 0, 500);
107 
108  for (Int_t i = 0; i < 4; i++) {
109  fHoughFit[i] =
110  new TF1(Form("HoughFit%i", i), " ( (-TMath::Cos([0])/TMath::Sin([0]))*x ) + [1]/TMath::Sin([0])", 0, 120);
111  fHoughFit[i]->SetLineColor(kRed);
112  fFit[i] = new TF1(Form("HoughFit%i", i), "pol1", 0, 120);
113  fFit[i]->SetLineColor(kBlue);
114  }
115 
116  f3DHitStyle = 1;
117 }
118 
119 AtEventDrawTaskProto::~AtEventDrawTaskProto()
120 {
121 
122  delete fHoughLinearFit;
123 }
124 
125 InitStatus AtEventDrawTaskProto::Init()
126 {
127 
128  std::cout << " ===== AtEventDrawTaskProto::Init =====" << std::endl;
129 
130  gROOT->Reset();
131  FairRootManager *ioMan = FairRootManager::Instance();
132  fEventManager = AtEventManagerProto::Instance();
133  fDetmap = new AtTpcProtoMap();
134  dynamic_cast<AtTpcProtoMap *>(fDetmap)->SetProtoMap(fMap.Data());
135  dynamic_cast<AtTpcProtoMap *>(fDetmap)->SetGeoFile("proto20181201_geo_hires.root");
136  fDetmap->SetName("fMap");
137  gROOT->GetListOfSpecials()->Add(fDetmap);
138 
139  fHitArray = dynamic_cast<TClonesArray *>(
140  ioMan->GetObject("AtEventH")); // TODO: Why this confusing name? It should be fEventArray
141  if (fHitArray)
142  LOG(INFO) << cGREEN << "Hit Array Found." << cNORMAL;
143 
144  fRawEventArray = dynamic_cast<TClonesArray *>(ioMan->GetObject("AtRawEvent"));
145  if (fRawEventArray) {
146  LOG(INFO) << cGREEN << "Raw Event Array Found." << cNORMAL;
147  fIsRawData = kTRUE;
148  }
149 
150  fPatternEventArray = dynamic_cast<TClonesArray *>(ioMan->GetObject("AtPatternEvent"));
151  if (fPatternEventArray)
152  LOG(INFO) << cGREEN << "Pattern Event Array Found." << cNORMAL;
153 
154  // fHoughSpaceArray = (TClonesArray*) ioMan->GetObject("AtHough");
155  // if(fHoughSpaceArray) LOG(INFO)<<cGREEN<<"Hough Array Found."<<cNORMAL<<FairLogger::endl;
156 
157  // fProtoEventArray = (TClonesArray*) ioMan->GetObject("AtProtoEvent");
158  // if(fProtoEventArray) LOG(INFO)<<cGREEN<<"Prototype Event Array Found."<<cNORMAL<<FairLogger::endl;
159 
160  fProtoEventAnaArray = dynamic_cast<TClonesArray *>(ioMan->GetObject("AtProtoEventAna"));
161  if (fProtoEventAnaArray)
162  LOG(INFO) << cGREEN << "Prototype Event Analysis Array Found." << cNORMAL;
163 
164  // Drawing histograms
165 
166  gStyle->SetPalette(55);
167  fCvsPadWave = fEventManager->GetCvsPadWave();
168  fCvsPadWave->SetName("fCvsPadWave");
169  gROOT->GetListOfSpecials()->Add(fCvsPadWave);
170  DrawPadWave();
171  fCvsPadPlane = fEventManager->GetCvsPadPlane(); // There is a problem if the pad plane is drawn first
172  fCvsPadPlane->ToggleEventStatus();
173  fCvsPadPlane->AddExec("ex", "AtEventDrawTaskProto::SelectPad(\"fRawEvent\")");
174  DrawPadPlane();
175  fCvsPadAll = fEventManager->GetCvsPadAll();
176  DrawPadAll();
177  fCvsMesh = fEventManager->GetCvsMesh();
178  DrawMesh();
179 
180  /*fCvsQuadrant1 = fEventManager->GetCvsQuadrant1();
181  fCvsQuadrant2 = fEventManager->GetCvsQuadrant2();
182  fCvsQuadrant3 = fEventManager->GetCvsQuadrant3();
183  fCvsQuadrant4 = fEventManager->GetCvsQuadrant4();
184  DrawProtoSpace();
185  fCvsELQuadrant1 = fEventManager->GetCvsELQuadrant1();
186  fCvsELQuadrant2 = fEventManager->GetCvsELQuadrant2();
187  fCvsELQuadrant3 = fEventManager->GetCvsELQuadrant3();
188  fCvsELQuadrant4 = fEventManager->GetCvsELQuadrant4();
189  DrawProtoEL();
190  //if(fProtoEventAnaArray) DrawProtoELAna();
191  fCvsVertex = fEventManager->GetCvsVertex();
192  fCvsKineAA = fEventManager->GetCvsKineAA();
193  DrawProtoVertex();
194  DrawProtoKine();*/
195  fCvsAux = fEventManager->GetCvsAux();
196  DrawProtoAux();
197 
198  std::cout << " AtEventDrawTaskProto::Init - End of initialization " << std::endl;
199  return kSUCCESS;
200 }
201 
202 void AtEventDrawTaskProto::Exec(Option_t *option)
203 {
204  Reset();
205 
206  if (fHitArray)
207  DrawHitPoints();
208  // if(fProtoEventArray) DrawProtoPattern();
209  // if(fHoughSpaceArray) DrawProtoHough();
210  // if(fProtoEventAnaArray) DrawProtoPatternAna();
211 
212  gEve->Redraw3D(kFALSE);
213 
214  UpdateCvsPadWave();
215  UpdateCvsPadPlane();
216  UpdateCvsPadAll();
217  UpdateCvsMesh();
218  // UpdateCvsProtoQ();
219  // UpdateCvsProtoEL();
220  // UpdateCvsProtoVertex();
221  // UpdateCvsProtoKine();
222  UpdateCvsProtoAux();
223 }
224 
225 void AtEventDrawTaskProto::Reset()
226 {
227 
228  if (fHitSet) {
229  fHitSet->Reset();
230  gEve->RemoveElement(fHitSet, fEventManager);
231  }
232 
233  if (fhitBoxSet) {
234  fhitBoxSet->Reset();
235  gEve->RemoveElement(fhitBoxSet, fEventManager);
236  }
237 
238  if (fEventManager->GetDrawPatternRecognition()) {
239 
240  if (fPatternEventArray != nullptr & kIsPRDrawn == kTRUE) {
241 
242  if (fLineNum > 0) {
243  for (Int_t i = 0; i < fLineNum; i++) {
244  if (fHitSetPR[i] != nullptr) {
245  gEve->RemoveElement(fHitSetPR[i], fEventManager);
246  }
247  }
248  }
249  }
250 
251  kIsPRDrawn = kFALSE;
252  }
253 
254  if (fPadPlane != nullptr)
255  fPadPlane->Reset(nullptr);
256 }
257 
258 // Filling functions
259 
260 void AtEventDrawTaskProto::DrawHitPoints()
261 {
262 
263  // Float_t *MeshArray;
264  fMesh->Reset(nullptr);
265  for (auto &fAuxChannel : fAuxChannels)
266  fAuxChannel->Reset(nullptr);
267  // f3DHist->Reset(0);
268  // TRandom r(0);
269 
270  for (auto &i : fPadAll)
271  i->Reset(nullptr);
272 
273  std::ofstream dumpEvent;
274  dumpEvent.open("event.dat");
275 
276  std::vector<Double_t> fPosXMin;
277  std::vector<Double_t> fPosYMin;
278  std::vector<Double_t> fPosZMin;
279 
280  // fQEventHist_H->Reset(0);
281  auto *event = dynamic_cast<AtEvent *>(fHitArray->At(0)); // TODO: Why this confusing name? It should be fEventArray
282  Int_t nHits = 0;
283 
284  if (event != nullptr) {
285  auto MeshArray = event->GetMesh();
286  Int_t eventID = event->GetEventID();
287  nHits = event->GetNumHits();
288  TString TSevt = " Event ID : ";
289  TString TSpad = " Pad ID : ";
290  dumpEvent << TSevt << eventID << std::endl;
291 
292  /* if(fEventManager->GetEraseQEvent()){
293  fQEventHist->Reset();
294  fRhoVariance->Reset();
295  }
296 
297  fQEventHist->Fill(Qevent);
298  fQEventHist_H->Fill(Qevent);
299  fRhoVariance->Fill(RhoVariance);*/
300 
301  for (Int_t i = 0; i < 512; i++) {
302 
303  fMesh->SetBinContent(i, MeshArray[i]);
304  }
305  } // if(event=!NULL)
306 
307  fHitSet = new TEvePointSet("Hit", nHits, TEvePointSelectorConsumer::kTVT_XYZ);
308  fHitSet->SetOwnIds(kTRUE);
309  fHitSet->SetMarkerColor(fHitColor);
310  fHitSet->SetMarkerSize(fHitSize);
311  fHitSet->SetMarkerStyle(fHitStyle);
312  std::cout << cYELLOW << " Number of hits : " << nHits << cNORMAL << std::endl;
313 
315 
316  fhitBoxSet = new TEveBoxSet("hitBox");
317  fhitBoxSet->Reset(TEveBoxSet::kBT_AABox, kTRUE, 64);
318 
319  for (Int_t iHit = 0; iHit < nHits; iHit++) {
320 
321  AtHit hit = *event->GetHits().at(iHit);
322 
323  // if(hit.GetCharge()<fThreshold) continue;
324  // if(PadMultHit>fMultiHit) continue;
325  auto position = hit.GetPosition();
326 
327  fHitSet->SetMarkerColor(fHitColor);
328  fHitSet->SetNextPoint(position.X() / 10., position.Y() / 10., position.Z() / 10.); // Convert into cm
329  fHitSet->SetPointId(new TNamed(Form("Hit %d", iHit), ""));
330  fPadPlane->Fill(position.X(), position.Y(), hit.GetCharge());
331 
332  Bool_t fValidPad;
333 
334  // if(fSaveTextData)
335  // dumpEvent<<position.X()<<" "<<position.Y()<<" "<<position.Z()<<" "<<hit.GetTimeStamp()<<"
336  // "<<hit.GetCharge()<<std::endl;
337  }
339 
340  // fPadPlane -> Draw("zcol");
341  gPad->Update();
342  fPadPlanePal = dynamic_cast<TPaletteAxis *>(fPadPlane->GetListOfFunctions()->FindObject("palette"));
343 
344  for (Int_t iHit = 0; iHit < nHits; iHit++) {
345 
346  AtHit hit = *event->GetHits().at(iHit);
347  auto position = hit.GetPosition();
348 
349  if (f3DHitStyle == 0) {
350 
351  Float_t HitBoxYDim = hit.GetCharge() * 0.001;
352  Float_t HitBoxZDim = 0.05;
353  Float_t HitBoxXDim = 0.05;
354 
355  fhitBoxSet->AddBox(position.X() / 10. - HitBoxXDim / 2.0, position.Y() / 10.,
356  position.Z() / 10. - HitBoxZDim / 2.0, HitBoxXDim, HitBoxYDim,
357  HitBoxZDim); // This coordinates are x,y,z in our system
358 
359  } else if (f3DHitStyle == 1) {
360 
361  Float_t HitBoxYDim = hit.GetCharge() * 0.0002;
362  Float_t HitBoxZDim = hit.GetCharge() * 0.0002;
363  Float_t HitBoxXDim = hit.GetCharge() * 0.0002;
364 
365  fhitBoxSet->AddBox(position.X() / 10. - HitBoxXDim / 2.0, position.Y() / 10. - HitBoxYDim / 2.0,
366  position.Z() / 10. - HitBoxZDim / 2.0, HitBoxXDim, HitBoxYDim,
367  HitBoxZDim); // This coordinates are x,y,z in our system
368  }
369 
370  Float_t xrgb = 255, yrgb = 0, zrgb = 0;
371  if (fPadPlanePal) {
372 
373  Int_t cHit = fPadPlanePal->GetValueColor(hit.GetCharge());
374  TColor *hitBoxColor = gROOT->GetColor(cHit);
375  hitBoxColor->GetRGB(xrgb, yrgb, zrgb);
376  }
377 
378  fhitBoxSet->DigitColor(xrgb * 255, yrgb * 255, zrgb * 255, 0);
379 
380  dumpEvent << position.X() << " " << position.Y() << " " << position.Z() << " " << hit.GetTimeStamp() << " "
381  << hit.GetCharge() << std::endl;
382  }
383 
385 
386  fhitBoxSet->RefitPlex();
387  TEveTrans &tHitBoxPos = fhitBoxSet->RefMainTrans();
388  tHitBoxPos.SetPos(0.0, 0.0, 0.0);
389 
390  // for(Int_t i=0;i<hitSphereArray.size();i++) gEve->AddElement(hitSphereArray[i]);
391 
392  if (fIsRawData) {
393 
394  fRawevent = dynamic_cast<AtRawEvent *>(fRawEventArray->At(0));
395 
396  if (fRawevent) {
397  fRawevent->SetName("fRawEvent");
398  gROOT->GetListOfSpecials()->Add(fRawevent);
399 
400  Int_t numAux = 0;
401 
402  for (auto &padIt : fRawevent->GetAuxPads()) {
403  const AtAuxPad &pad = padIt.second;
404  if (numAux < 9) {
405  std::cout << cYELLOW << " Auxiliary Channel " << numAux << " - Name " << pad.GetAuxName() << cNORMAL
406  << std::endl;
407  auto rawAdc = pad.GetRawADC();
408  for (int i = 0; i < 512; ++i)
409  fAuxChannels[numAux]->SetBinContent(i, rawAdc[i]);
410  numAux++;
411  }
412  }
413  if (numAux + 1 == 9)
414  std::cout << cYELLOW << "Warning: More auxiliary channels than expected (max 9)" << cNORMAL << std::endl;
415 
416  } // if raw event
417  }
418 
419  if (fIsRawData) {
420 
421  if (fRawevent != nullptr) {
422 
423  Int_t nPads = fRawevent->GetNumPads();
424  std::cout << "Num of pads : " << nPads << std::endl;
425 
426  for (Int_t iPad = 0; iPad < nPads; iPad++) {
427 
428  AtPad *fPad = fRawevent->GetPad(iPad);
429  // std::cout<<"Pad num : "<<iPad<<" Is Valid? : "<<fPad->GetValidPad()<<" Pad num in pad object
430  // :"<<fPad->GetPadNum()<<std::endl;
431 
432  if (fPad != nullptr) {
433  auto rawadc = fPad->GetRawADC();
434  auto adc = fPad->GetADC();
435  Int_t PadNum_temp = fPad->GetPadNum();
436  // dumpEvent<<TSpad<<fPad->GetPadNum()<<std::endl;
437  if (fPad->GetValidPad() && PadNum_temp < 2015 && PadNum_temp > -1) {
438 
439  for (Int_t j = 0; j < 512; j++) {
440  fPadAll[PadNum_temp]->SetBinContent(j, adc[j]);
441  }
442  }
443  }
444 
445  } // Pads
446 
447  } // NULL
448 
449  } // Rawdata
450 
451  if (fEventManager->GetDrawPatternRecognition()) {
452 
453  for (auto &i : fLineArray)
454  i = new TEveLine();
455  int n = 100;
456  double t0 = 0;
457  double dt = 2000;
458  std::vector<AtTrack> TrackCand;
459 
460  if (fPatternEventArray) {
461 
462  auto *patternEvent = dynamic_cast<AtPatternEvent *>(fPatternEventArray->At(0));
463 
464  if (patternEvent != nullptr) {
465  TrackCand = patternEvent->GetTrackCand();
466  for (auto &i : fHitSetPR)
467  i = nullptr;
468 
469  fLineNum = TrackCand.size();
470  std::cout << cRED << " Found " << TrackCand.size() << " track candidates " << cNORMAL << std::endl;
471 
472  if (TrackCand.size() < 20) {
473  for (Int_t i = 0; i < TrackCand.size(); i++) {
474 
475  AtTrack track = TrackCand.at(i);
476  std::vector<AtHit> trackHits = track.GetHitArrayObject();
477  int nHitsMin = trackHits.size();
478 
479  fHitSetPR[i] = new TEvePointSet(Form("HitPR_%d", i), nHitsMin, TEvePointSelectorConsumer::kTVT_XYZ);
480  fHitSetPR[i]->SetMarkerColor(GetTrackColor(i) + 1);
481  fHitSetPR[i]->SetMarkerSize(fHitSize);
482  fHitSetPR[i]->SetMarkerStyle(fHitStyle);
483 
484  for (auto &trackHit : trackHits) {
485  auto position = trackHit.GetPosition();
486  fHitSetPR[i]->SetNextPoint(position.X() / 10., position.Y() / 10., position.Z() / 10.);
487  }
488 
489  if (fEventManager->GetDrawPatternRecognition())
490  gEve->AddElement(fHitSetPR[i]);
491  kIsPRDrawn = kTRUE;
492  }
493  }
494  }
495  }
496  }
497 
498  if (!fEventManager->GetDrawPatternRecognition()) {
499 
500  gEve->AddElement(fHitSet);
501  gEve->AddElement(fhitBoxSet);
502 
503  } else if (fEventManager->GetDrawPatternRecognition()) {
504 
505  // if(fPatternEventArray)
506  // if(fLineNum>0) for(Int_t i=0;i<fLineNum;i++) gEve -> AddElement(fHitSetPR[i]);
507  }
508 
509  dumpEvent.close();
510 }
511 
512 void AtEventDrawTaskProto::DrawProtoPattern()
513 {
514 
515  for (Int_t i = 0; i < 4; i++) {
516  fQHitPattern[i]->Set(0);
517  fQELossPattern[i]->Set(0);
518  }
519  auto *protoevent = dynamic_cast<AtProtoEvent *>(fProtoEventArray->At(0));
520  Int_t nQuads = protoevent->GetNumQuadrants();
521  std::vector<AtProtoQuadrant> quadrantArray;
522 
523  // fHoughSpaceLine = dynamic_cast<AtHoughSpaceLine*> (fHoughSpaceArray->At(0));
524  // std::vector<std::pair<Double_t,Double_t>> HoughPar = fHoughSpaceLine->GetHoughPar();
525 
526  if (nQuads < 5) {
527  for (Int_t iQ = 0; iQ < nQuads; iQ++) {
528 
529  AtProtoQuadrant quadrant = protoevent->GetQuadrantArray()->at(iQ);
530  quadrantArray.push_back(protoevent->GetQuadrantArray()->at(iQ));
531  std::vector<Double_t> *PhiArray = quadrantArray[iQ].GetPhiArray();
532 
533  for (double pval : *PhiArray) {
534  fPhiDistr[iQ]->Fill(pval);
535  }
536  PhiArray->clear();
537 
538  Int_t qNumHit = quadrant.GetNumHits();
539 
540  for (Int_t j = 0; j < qNumHit; j++) {
541 
542  AtHit *qhit = quadrant.GetHit(j);
543  auto position = qhit->GetPosition();
544 
545  Double_t radius = TMath::Sqrt(TMath::Power(position.X(), 2) + TMath::Power(position.Y(), 2));
546  fQHitPattern[iQ]->SetPoint(fQHitPattern[iQ]->GetN(), radius, position.Z());
547  fQELossPattern[iQ]->SetPoint(fQELossPattern[iQ]->GetN(), radius, qhit->GetCharge());
548  }
549  }
550  }
551 }
552 
553 void AtEventDrawTaskProto::DrawProtoHough() {}
554 
555 void AtEventDrawTaskProto::DrawProtoPatternAna()
556 {
557 
558  for (auto &i : fQELossPatternAna)
559  i->Set(0);
560 
561  fQVertex[2]->Reset(nullptr);
562  fQVertex[3]->Reset(nullptr);
563  fQKine[2]->Reset(nullptr);
564  fQKine[3]->Reset(nullptr);
565 
566  auto *protoeventAna = dynamic_cast<AtProtoEventAna *>(fProtoEventAnaArray->At(0));
567 
568  std::vector<Double_t> *Par0 = protoeventAna->GetPar0();
569  std::vector<Double_t> *Par1 = protoeventAna->GetPar1();
570 
571  // std::vector<std::pair<Double_t,Double_t>>* ELossHitPattern = protoeventAna->GetELossHitPattern();
572  std::vector<std::vector<std::pair<Double_t, Double_t>>> *QELossHitPattern = protoeventAna->GetQELossHitPattern();
573 
574  for (Int_t i = 0; i < QELossHitPattern->size(); i++) {
575  std::vector<std::pair<Double_t, Double_t>> ELossHitPattern = QELossHitPattern->at(i);
576  fFit[i]->SetParameter(0, Par0->at(i));
577  fFit[i]->SetParameter(1, Par1->at(i));
578 
579  for (auto HPbuffer : ELossHitPattern) {
580  Double_t radius = HPbuffer.second;
581  Double_t charge = HPbuffer.first;
582  fQELossPatternAna[i]->SetPoint(fQELossPatternAna[i]->GetN(), radius, charge);
583  }
584  }
585 
586  std::vector<Double_t> *vertex = protoeventAna->GetVertex();
587  std::vector<Double_t> *KineAA = protoeventAna->GetAngleFit();
588  std::vector<Double_t> *Chi2 = protoeventAna->GetChi2();
589  std::vector<Int_t> *NDF = protoeventAna->GetNDF();
590  fQVertex[0]->Fill(vertex->at(0), vertex->at(2));
591  fQVertex[1]->Fill(vertex->at(1), vertex->at(3));
592  fQVertex[2]->Fill(vertex->at(0), vertex->at(2));
593  fQVertex[3]->Fill(vertex->at(1), vertex->at(3));
594 
595  fQKine[0]->Fill(KineAA->at(0), KineAA->at(2));
596  fQKine[1]->Fill(KineAA->at(1), KineAA->at(3));
597  fQKine[2]->Fill(KineAA->at(0), KineAA->at(2));
598  fQKine[3]->Fill(KineAA->at(1), KineAA->at(3));
599 
600  std::cout << cYELLOW << " ==================================================================== " << std::endl;
601  std::cout << " AtEventDrawTask : Fit Results " << std::endl;
602  std::cout << " - Quadrant 0 - Quadrant 1 - Quadrant 2 - Quadrant 3 " << std::endl;
603  std::cout << " Angle : " << KineAA->at(0) << " " << KineAA->at(1) << " " << KineAA->at(2)
604  << " " << KineAA->at(3) << std::endl;
605  std::cout << " Vertex : " << vertex->at(0) << " " << vertex->at(1) << " " << vertex->at(2)
606  << " " << vertex->at(3) << std::endl;
607  std::cout << " Chi2 : " << Chi2->at(0) << " " << Chi2->at(1) << " " << Chi2->at(2)
608  << " " << Chi2->at(3) << std::endl;
609  std::cout << " NDF : " << NDF->at(0) << " " << NDF->at(1) << " " << NDF->at(2)
610  << " " << NDF->at(3) << std::endl;
611  std::cout << " ==================================================================== " << cNORMAL << std::endl;
612  std::cout << std::endl;
613 }
614 
615 // Draw functions ////
616 
617 void AtEventDrawTaskProto::DrawPadWave()
618 {
619 
620  fPadWave = new TH1I("fPadWave", "fPadWave", 512, 0, 511);
621  gROOT->GetListOfSpecials()->Add(fPadWave);
622  fCvsPadWave->cd();
623  fPadWave->Draw();
624 }
625 
626 void AtEventDrawTaskProto::DrawPadPlane()
627 {
628 
629  /*if(fPadPlane)
630  {
631  fPadPlane->Reset(0);
632  return;
633  }*/
634 
635  fPadPlane =
636  dynamic_cast<AtTpcProtoMap *>(fDetmap)->GetAtTpcPlane("ATTPC_Proto"); // NB: Do not change the pad plane name
637  fCvsPadPlane->cd();
638  // fPadPlane -> Draw("zcol");
639  // fPadPlane -> Draw("COL L0");
640  fPadPlane->Draw("COL L");
641  fPadPlane->SetMinimum(1.0);
642  gStyle->SetOptStat(0);
643  gStyle->SetPalette(103);
644  gPad->Update();
645 }
646 
647 void AtEventDrawTaskProto::DrawPadAll()
648 {
649 
650  fCvsPadAll->cd();
651 
652  for (auto &i : fPadAll) {
653  // fPadAll[i]->Reset(0);
654  // fPadAll[i] = new TH1I("fPadAll","fPadAll",512,0,511);
655  i->GetYaxis()->SetRangeUser(0, 2500);
656  i->SetLineColor(8);
657 
658  /*if (i<64) fPadAll[i]->SetLineColor(6); // Q1, pink
659  else if(i>=64 && i<127) fPadAll[i]->SetLineColor(8); // Q2, green
660  else if(i>=127 && i<190) fPadAll[i]->SetLineColor(7); // Q3, blue
661  else if(i>=190 && i<253) fPadAll[i]->SetLineColor(kOrange-3); // Q4, orange
662  else fPadAll[i]->SetLineColor(0); //white for non physical pads*/
663 
664  i->Draw("SAME");
665  }
666 }
667 
668 void AtEventDrawTaskProto::DrawMesh()
669 {
670 
671  fCvsMesh->cd();
672  fMesh = new TH1F("Mesh", "Mesh", 512, 0, 511);
673  fMesh->Draw();
674 }
675 
676 void AtEventDrawTaskProto::DrawProtoSpace() {}
677 
678 void AtEventDrawTaskProto::DrawProtoEL()
679 {
680 
681  for (Int_t i = 0; i < 4; i++) {
682  fQELossPattern[i] = new TGraph();
683  fQELossPattern[i]->SetMarkerStyle(22);
684  fQELossPattern[i]->SetMarkerSize(0.7);
685  fQELossPattern[i]->SetPoint(1, 0, 0);
686  fQELossPatternAna[i] = new TGraph();
687  fQELossPatternAna[i]->SetMarkerStyle(20);
688  fQELossPatternAna[i]->SetMarkerColor(kRed);
689  fQELossPatternAna[i]->SetMarkerSize(0.7);
690  fQELossPatternAna[i]->SetPoint(1, 0, 0);
691  if (i == 0) {
692  fCvsELQuadrant1->cd();
693  fQELossPattern[0]->Draw("AP");
694  if (fProtoEventAnaArray)
695  fQELossPatternAna[0]->Draw("P");
696  } else if (i == 1) {
697  fCvsELQuadrant2->cd();
698  fQELossPattern[1]->Draw("AP");
699  if (fProtoEventAnaArray)
700  fQELossPatternAna[1]->Draw("P");
701  } else if (i == 2) {
702  fCvsELQuadrant3->cd();
703  fQELossPattern[2]->Draw("AP");
704  if (fProtoEventAnaArray)
705  fQELossPatternAna[2]->Draw("P");
706  } else if (i == 3) {
707  fCvsELQuadrant4->cd();
708  fQELossPattern[3]->Draw("AP");
709  if (fProtoEventAnaArray)
710  fQELossPatternAna[3]->Draw("P");
711  }
712  }
713 }
714 
715 void AtEventDrawTaskProto::DrawProtoELAna()
716 {
717 
718  for (Int_t i = 0; i < 4; i++) {
719  fQELossPatternAna[i] = new TGraph();
720  fQELossPatternAna[i]->SetMarkerStyle(22);
721  fQELossPatternAna[i]->SetMarkerSize(0.7);
722  fQELossPatternAna[i]->SetMarkerStyle(kRed);
723  fQELossPatternAna[i]->SetPoint(1, 0, 0);
724  if (i == 0) {
725  fCvsELQuadrant1->cd();
726  fQELossPatternAna[0]->Draw("A*");
727  } else if (i == 1) {
728  fCvsELQuadrant2->cd();
729  fQELossPatternAna[1]->Draw("A*");
730  } else if (i == 2) {
731  fCvsELQuadrant3->cd();
732  fQELossPatternAna[2]->Draw("A*");
733  } else if (i == 3) {
734  fCvsELQuadrant4->cd();
735  fQELossPatternAna[3]->Draw("A*");
736  }
737  }
738 }
739 
740 void AtEventDrawTaskProto::DrawProtoVertex()
741 {
742 
743  for (Int_t i = 0; i < 4; i++) {
744  fQVertex[i] = new TH2F(Form("Vertex_%i", i), Form("Vertex%i", i), 1000, 0, 1000, 1000, 0, 1000);
745  fQVertex[i]->SetMarkerSize(1.2);
746  fQVertex[i]->SetMarkerStyle(22);
747  if (i == 0)
748  fQVertex[i]->SetMarkerColor(kRed);
749  else if (i == 1) {
750  fQVertex[i]->SetMarkerColor(kRed);
751  fQVertex[i]->SetMarkerStyle(20);
752  } else if (i == 2)
753  fQVertex[i]->SetMarkerColor(kBlue);
754  else if (i == 3) {
755  fQVertex[i]->SetMarkerColor(kBlue);
756  fQVertex[i]->SetMarkerStyle(20);
757  }
758  }
759 
760  fCvsVertex->cd();
761  fQVertex[0]->Draw();
762  fQVertex[1]->Draw("SAME");
763  fQVertex[2]->Draw("SAME");
764  fQVertex[3]->Draw("SAME");
765 }
766 
767 void AtEventDrawTaskProto::DrawProtoKine()
768 {
769 
770  for (Int_t i = 0; i < 4; i++) {
771  fQKine[i] = new TH2F(Form("Angle_Angle_Kinematics_%i", i), Form("Angle_Angle_Kinematics%i", i), 1000, 0, 180,
772  1000, 0, 180);
773  fQKine[i]->SetMarkerSize(1.2);
774  fQKine[i]->SetMarkerStyle(22);
775  if (i == 0)
776  fQKine[i]->SetMarkerColor(kRed);
777  else if (i == 1) {
778  fQKine[i]->SetMarkerColor(kRed);
779  fQKine[i]->SetMarkerStyle(20);
780  } else if (i == 2)
781  fQKine[i]->SetMarkerColor(kBlue);
782  else if (i == 3) {
783  fQKine[i]->SetMarkerColor(kBlue);
784  fQKine[i]->SetMarkerStyle(20);
785  }
786  }
787 
788  fCvsKineAA->cd();
789  fQKine[0]->Draw();
790  fQKine[1]->Draw("SAME");
791  fQKine[2]->Draw("SAME");
792  fQKine[3]->Draw("SAME");
793 }
794 
795 void AtEventDrawTaskProto::DrawProtoAux()
796 {
797 
798  fCvsAux->Divide(3, 3);
799  for (Int_t i = 0; i < 9; i++) {
800  fAuxChannels[i] = new TH1F(Form("Auxiliary_Channel_%i", i), Form("AuxChannel%i", i), 512, 0, 511);
801  fCvsAux->cd(1 + i);
802  fAuxChannels[i]->Draw();
803  }
804 }
805 
807 
808 void AtEventDrawTaskProto::UpdateCvsPadWave()
809 {
810  fCvsPadWave->Modified();
811  fCvsPadWave->Update();
812 }
813 
814 void AtEventDrawTaskProto::UpdateCvsPadPlane()
815 {
816  fCvsPadPlane->Modified();
817  fCvsPadPlane->Update();
818 }
819 
820 void AtEventDrawTaskProto::UpdateCvsPadAll()
821 {
822  fCvsPadAll->Modified();
823  fCvsPadAll->Update();
824 }
825 
826 void AtEventDrawTaskProto::UpdateCvsMesh()
827 {
828 
829  fCvsMesh->Modified();
830  fCvsMesh->Update();
831 }
832 
833 void AtEventDrawTaskProto::UpdateCvsProtoQ()
834 {
835 
836  fCvsQuadrant1->Modified();
837  fCvsQuadrant1->Update();
838  fCvsQuadrant2->Modified();
839  fCvsQuadrant2->Update();
840  fCvsQuadrant3->Modified();
841  fCvsQuadrant3->Update();
842  fCvsQuadrant4->Modified();
843  fCvsQuadrant4->Update();
844 }
845 
846 void AtEventDrawTaskProto::UpdateCvsProtoEL()
847 {
848 
849  fCvsELQuadrant1->Modified();
850  fCvsELQuadrant1->Update();
851  fCvsELQuadrant2->Modified();
852  fCvsELQuadrant2->Update();
853  fCvsELQuadrant3->Modified();
854  fCvsELQuadrant3->Update();
855  fCvsELQuadrant4->Modified();
856  fCvsELQuadrant4->Update();
857 }
858 
859 void AtEventDrawTaskProto::UpdateCvsProtoVertex()
860 {
861 
862  fCvsVertex->Modified();
863  fCvsVertex->Update();
864 }
865 
866 void AtEventDrawTaskProto::UpdateCvsProtoKine()
867 {
868 
869  fCvsKineAA->Modified();
870  fCvsKineAA->Update();
871 }
872 
873 void AtEventDrawTaskProto::UpdateCvsProtoAux()
874 {
875 
876  // for(Int_t i = 0;i<4;i++){
877  // fCvsAux->cd(1);
878  TPad *Pad_1 = dynamic_cast<TPad *>(fCvsAux->GetPad(1));
879  Pad_1->Modified();
880  Pad_1->Update();
881  TPad *Pad_2 = dynamic_cast<TPad *>(fCvsAux->GetPad(2));
882  Pad_2->Modified();
883  Pad_2->Update();
884  TPad *Pad_3 = dynamic_cast<TPad *>(fCvsAux->GetPad(3));
885  Pad_3->Modified();
886  Pad_3->Update();
887  TPad *Pad_4 = dynamic_cast<TPad *>(fCvsAux->GetPad(4));
888  Pad_4->Modified();
889  Pad_4->Update();
890  TPad *Pad_5 = dynamic_cast<TPad *>(fCvsAux->GetPad(5));
891  Pad_5->Modified();
892  Pad_5->Update();
893  TPad *Pad_6 = dynamic_cast<TPad *>(fCvsAux->GetPad(6));
894  Pad_6->Modified();
895  Pad_6->Update();
896  TPad *Pad_7 = dynamic_cast<TPad *>(fCvsAux->GetPad(7));
897  Pad_7->Modified();
898  Pad_7->Update();
899  TPad *Pad_8 = dynamic_cast<TPad *>(fCvsAux->GetPad(8));
900  Pad_8->Modified();
901  Pad_8->Update();
902  TPad *Pad_9 = dynamic_cast<TPad *>(fCvsAux->GetPad(9));
903  Pad_9->Modified();
904  Pad_9->Update();
905  fCvsAux->Modified();
906  fCvsAux->Update();
907  //}
908 }
909 
910 void AtEventDrawTaskProto::SelectPad(const char *rawevt)
911 {
912 
913  try {
914  int event = gPad->GetEvent();
915  if (event != 11)
916  return; // may be comment this line
917  TObject *select = gPad->GetSelected();
918  if (!select)
919  return;
920  if (select->InheritsFrom(TH2Poly::Class())) {
921  auto *h = dynamic_cast<TH2Poly *>(select);
922  gPad->GetCanvas()->FeedbackMode(kTRUE);
923  AtRawEvent *tRawEvent = nullptr;
924  tRawEvent = dynamic_cast<AtRawEvent *>(gROOT->GetListOfSpecials()->FindObject(rawevt));
925  if (tRawEvent == nullptr) {
926  std::cout
927  << " = AtEventDrawTaskProto::SelectPad NULL pointer for the AtRawEvent! Please select an event first "
928  << std::endl;
929  return;
930  }
931 
932  int pyold = gPad->GetUniqueID();
933  int px = gPad->GetEventX();
934  int py = gPad->GetEventY();
935  float uxmin = gPad->GetUxmin();
936  float uxmax = gPad->GetUxmax();
937  int pxmin = gPad->XtoAbsPixel(uxmin);
938  int pxmax = gPad->XtoAbsPixel(uxmax);
939  if (pyold)
940  gVirtualX->DrawLine(pxmin, pyold, pxmax, pyold);
941  gVirtualX->DrawLine(pxmin, py, pxmax, py);
942  gPad->SetUniqueID(py);
943  Float_t upx = gPad->AbsPixeltoX(px);
944  Float_t upy = gPad->AbsPixeltoY(py);
945  Double_t x = gPad->PadtoX(upx);
946  Double_t y = gPad->PadtoY(upy);
947  Int_t bin = h->FindBin(x, y);
948  const char *bin_name = h->GetBinName(bin);
949  // std::cout<<" X : "<<x<<" Y: "<<y<<std::endl;
950  // std::cout<<bin_name<<std::endl;
951  std::cout << " ==========================" << std::endl;
952  std::cout << " Bin number selected : " << bin << " Bin name :" << bin_name << std::endl;
953 
954  AtMap *tmap = nullptr;
955  tmap = dynamic_cast<AtMap *>(gROOT->GetListOfSpecials()->FindObject("fMap"));
956  // new AtTpcProtoMap();
957  // TString map = "/Users/yassidayyad/fair_install/AtTPCROOT_v2_06042015/scripts/proto.map";
958  // tmap->SetProtoMap(map.Data());
959  // Int_t tPadNum = tmap->BinToPad(bin);
960 
961  Int_t tPadNum = tmap->BinToPad(bin);
962 
963  std::cout << " Bin : " << bin << " to Pad : " << tPadNum << std::endl;
964  AtPad *tPad = tRawEvent->GetPad(tPadNum);
965 
966  // Check to make sure pad is valid
967  if (!tPad)
968  return;
969 
970  std::cout << " Event ID (Select Pad) : " << tRawEvent->GetEventID() << std::endl;
971  std::cout << " Raw Event Pad Num " << tPad->GetPadNum() << std::endl;
972  std::cout << std::endl;
973  // TH1D* tPadWaveSub = NULL;
974  // tPadWaveSub = new TH1D("tPadWaveSub","tPadWaveSub",512.0,0.0,511.0);
975  // tPadWaveSub->SetLineColor(kRed);
976  TH1I *tPadWave = nullptr;
977  tPadWave = dynamic_cast<TH1I *>(gROOT->GetListOfSpecials()->FindObject("fPadWave"));
978  auto rawadc = tPad->GetRawADC();
979  auto adc = tPad->GetADC();
980  if (tPadWave == nullptr) {
981  std::cout << " = AtEventDrawTask::SelectPad NULL pointer for the TH1I! Please select an event first "
982  << std::endl;
983  return;
984  }
985  tPadWave->Reset();
986  // tPadWaveSub->Reset();
987  for (Int_t i = 0; i < 512; i++) {
988 
989  // tPadWave->SetBinContent(i,rawadc[i]);
990  tPadWave->SetBinContent(i, adc[i]);
991  // tPadWaveSub->SetBinContent(i,adc[i]);
992  }
993 
994  TCanvas *tCvsPadWave = nullptr;
995  tCvsPadWave = dynamic_cast<TCanvas *>(gROOT->GetListOfSpecials()->FindObject("fCvsPadWave"));
996  if (tCvsPadWave == nullptr) {
997  std::cout << " = AtEventDrawTask::SelectPad NULL pointer for the TCanvas! Please select an event first "
998  << std::endl;
999  return;
1000  }
1001  tCvsPadWave->cd();
1002  tPadWave->Draw();
1003  // tPadWaveSub->Draw("SAME");
1004  tCvsPadWave->Update();
1005  }
1006 
1007  } catch (const std::exception &e) {
1008 
1009  std::cout << cRED << " Exception caught in Select Pad " << e.what() << cNORMAL << "\n";
1010  }
1011 }
1012 
1013 void AtEventDrawTaskProto::SetHitAttributes(Color_t color, Size_t size, Style_t style)
1014 {
1015  fHitColor = color;
1016  fHitSize = size;
1017  fHitStyle = style;
1018 }
1019 
1020 void AtEventDrawTaskProto::Set3DHitStyleBar()
1021 {
1022  f3DHitStyle = 0;
1023 }
1024 
1025 void AtEventDrawTaskProto::Set3DHitStyleBox()
1026 {
1027  f3DHitStyle = 1;
1028 }
1029 
1030 EColor AtEventDrawTaskProto::GetTrackColor(int i)
1031 {
1032  std::vector<EColor> colors = {kAzure, kOrange, kViolet, kTeal, kMagenta, kBlue, kViolet, kYellow, kCyan, kAzure};
1033  if (i < 10) {
1034  return colors.at(i);
1035  } else
1036  return kAzure;
1037 }
AtMap
Definition: AtMap.h:33
AtEventDrawTaskProto::fAuxChannels
TH1F * fAuxChannels[9]
Definition: AtEventDrawTaskProto.h:106
AtEventDrawTaskProto::UpdateCvsProtoEL
void UpdateCvsProtoEL()
Definition: AtEventDrawTaskProto.cxx:846
AtPad.h
AtEventDrawTaskProto::fHitColor
Color_t fHitColor
Definition: AtEventDrawTaskProto.h:85
AtEventDrawTaskProto::UpdateCvsProtoKine
void UpdateCvsProtoKine()
Definition: AtEventDrawTaskProto.cxx:866
AtEventDrawTaskProto::DrawHitPoints
void DrawHitPoints()
Definition: AtEventDrawTaskProto.cxx:260
AtEventDrawTaskProto::GetTrackColor
EColor GetTrackColor(int i)
Definition: AtEventDrawTaskProto.cxx:1030
AtAuxPad::GetAuxName
std::string GetAuxName() const
Definition: AtAuxPad.h:38
AtEventDrawTaskProto::fPadPlanePal
TPaletteAxis * fPadPlanePal
Definition: AtEventDrawTaskProto.h:90
AtRawEvent.h
AtEventDrawTaskProto::fCvsQuadrant1
TCanvas * fCvsQuadrant1
Definition: AtEventDrawTaskProto.h:112
AtEventDrawTaskProto::fHoughFit
TF1 * fHoughFit[4]
Definition: AtEventDrawTaskProto.h:101
AtBaseEvent.h
AtPatternEvent
Definition: AtPatternEvent.h:19
AtEvent.h
AtRawEvent::GetPad
AtPad * GetPad(Int_t padNum)
Definition: AtRawEvent.h:124
AtEventManagerProto::Instance
static AtEventManagerProto * Instance()
Definition: AtEventManagerProto.cxx:49
AtEventDrawTaskProto::Exec
virtual void Exec(Option_t *option)
Definition: AtEventDrawTaskProto.cxx:202
AtEventDrawTaskProto::fCvsQuadrant3
TCanvas * fCvsQuadrant3
Definition: AtEventDrawTaskProto.h:114
AtAuxPad.h
AtProtoQuadrant::GetHit
AtHit * GetHit(Int_t hitNo)
Definition: AtProtoQuadrant.cxx:78
AtProtoEventAna
Definition: AtProtoEventAna.h:14
ClassImp
ClassImp(AtEventDrawTaskProto)
AtEventDrawTaskProto::fPhiDistr
TH1D * fPhiDistr[5]
Definition: AtEventDrawTaskProto.h:95
AtEventDrawTaskProto::fCvsELQuadrant2
TCanvas * fCvsELQuadrant2
Definition: AtEventDrawTaskProto.h:117
AtEventDrawTaskProto::AtEventDrawTaskProto
AtEventDrawTaskProto()
Definition: AtEventDrawTaskProto.cxx:71
AtPad::GetValidPad
Bool_t GetValidPad() const
Definition: AtPad.h:97
AtBaseEvent::GetAuxPads
const AuxPadMap & GetAuxPads() const
Definition: AtBaseEvent.h:79
AtEventDrawTaskProto::fQKine
TH2F * fQKine[4]
Definition: AtEventDrawTaskProto.h:105
AtEventDrawTaskProto::fPatternEventArray
TClonesArray * fPatternEventArray
Definition: AtEventDrawTaskProto.h:131
AtEventManagerProto::GetCvsPadPlane
TCanvas * GetCvsPadPlane()
Definition: AtEventManagerProto.h:40
cGREEN
constexpr auto cGREEN
Definition: AtEventDrawTaskProto.cxx:65
AtEventDrawTaskProto::Reset
void Reset()
Definition: AtEventDrawTaskProto.cxx:225
cNORMAL
constexpr auto cNORMAL
Definition: AtEventDrawTaskProto.cxx:64
AtEventDrawTaskProto::DrawMesh
virtual void DrawMesh()
Definition: AtEventDrawTaskProto.cxx:668
AtEventDrawTaskProto::fLineArray
TEveLine * fLineArray[20]
Definition: AtEventDrawTaskProto.h:144
AtEventManagerProto::GetCvsAux
TCanvas * GetCvsAux()
Definition: AtEventManagerProto.h:58
AtEventDrawTaskProto::fhitBoxSet
TEveBoxSet * fhitBoxSet
Definition: AtEventDrawTaskProto.h:134
AtEventDrawTaskProto::DrawProtoPattern
void DrawProtoPattern()
Definition: AtEventDrawTaskProto.cxx:512
AtEventDrawTaskProto::fIsLinearHough
Bool_t fIsLinearHough
Definition: AtEventDrawTaskProto.h:83
AtEventDrawTaskProto::fProtoEventAnaArray
TClonesArray * fProtoEventAnaArray
Definition: AtEventDrawTaskProto.h:130
AtEventDrawTaskProto::fRawEventArray
TClonesArray * fRawEventArray
Definition: AtEventDrawTaskProto.h:128
AtEventDrawTaskProto::fCvsELQuadrant1
TCanvas * fCvsELQuadrant1
Definition: AtEventDrawTaskProto.h:116
AtProtoQuadrant
Definition: AtProtoQuadrant.h:17
AtTpcProtoMap
Definition: AtTpcProtoMap.h:26
AtEventDrawTaskProto::DrawProtoPatternAna
void DrawProtoPatternAna()
Definition: AtEventDrawTaskProto.cxx:555
AtTrack::GetHitArrayObject
std::vector< AtHit > GetHitArrayObject()
Definition: AtTrack.h:82
AtEventDrawTaskProto::UpdateCvsProtoVertex
void UpdateCvsProtoVertex()
Definition: AtEventDrawTaskProto.cxx:859
AtEventDrawTaskProto::DrawProtoHough
virtual void DrawProtoHough()
Definition: AtEventDrawTaskProto.cxx:553
AtEvent
Definition: AtEvent.h:22
AtEventDrawTaskProto::Set3DHitStyleBox
void Set3DHitStyleBox()
Definition: AtEventDrawTaskProto.cxx:1025
AtEventManagerProto::GetCvsMesh
TCanvas * GetCvsMesh()
Definition: AtEventManagerProto.h:46
AtEventDrawTaskProto::SetProtoMap
void SetProtoMap(TString map)
Definition: AtEventDrawTaskProto.h:46
AtEventDrawTaskProto::UpdateCvsPadPlane
void UpdateCvsPadPlane()
Definition: AtEventDrawTaskProto.cxx:814
AtEventDrawTaskProto::fDetmap
AtMap * fDetmap
Definition: AtEventDrawTaskProto.h:141
AtEventManagerProto.h
AtEventDrawTaskProto::fCvsPadAll
TCanvas * fCvsPadAll
Definition: AtEventDrawTaskProto.h:110
AtEventDrawTaskProto.h
AtRawEvent
Definition: AtRawEvent.h:34
AtProtoEvent.h
cYELLOW
constexpr auto cYELLOW
Definition: AtEventDrawTaskProto.cxx:63
AtEventDrawTaskProto::fEventManager
AtEventManagerProto * fEventManager
AtTPCROOT objects.
Definition: AtEventDrawTaskProto.h:139
AtEventDrawTaskProto::Set3DHitStyleBar
void Set3DHitStyleBar()
Definition: AtEventDrawTaskProto.cxx:1020
AtEventDrawTaskProto::fHitSize
Size_t fHitSize
Definition: AtEventDrawTaskProto.h:86
AtEventDrawTaskProto::UpdateCvsPadAll
void UpdateCvsPadAll()
Definition: AtEventDrawTaskProto.cxx:820
AtEventDrawTaskProto::DrawPadWave
virtual void DrawPadWave()
Definition: AtEventDrawTaskProto.cxx:617
AtProtoEventAna.h
AtEventDrawTaskProto::fRawevent
AtRawEvent * fRawevent
Definition: AtEventDrawTaskProto.h:142
AtProtoQuadrant::GetNumHits
std::size_t GetNumHits()
Definition: AtProtoQuadrant.cxx:65
AtHit::GetTimeStamp
Int_t GetTimeStamp() const
Definition: AtHit.h:86
AtEventManagerProto::GetDrawPatternRecognition
Bool_t GetDrawPatternRecognition()
Definition: AtEventManagerProto.h:60
AtEventDrawTaskProto::fCvsMesh
TCanvas * fCvsMesh
Definition: AtEventDrawTaskProto.h:111
AtEventDrawTaskProto::DrawProtoKine
virtual void DrawProtoKine()
Definition: AtEventDrawTaskProto.cxx:767
AtEventDrawTaskProto::Init
virtual InitStatus Init()
Definition: AtEventDrawTaskProto.cxx:125
AtHit::GetPosition
const XYZPoint & GetPosition() const
Definition: AtHit.h:79
AtEventDrawTaskProto::fCvsAux
TCanvas * fCvsAux
Definition: AtEventDrawTaskProto.h:122
AtHit.h
AtEventDrawTaskProto::fProtoEventArray
TClonesArray * fProtoEventArray
Definition: AtEventDrawTaskProto.h:129
AtEventDrawTaskProto::DrawProtoAux
virtual void DrawProtoAux()
Definition: AtEventDrawTaskProto.cxx:795
AtEventDrawTaskProto::fCvsKineAA
TCanvas * fCvsKineAA
Definition: AtEventDrawTaskProto.h:121
AtEventDrawTaskProto::fCvsPadWave
TCanvas * fCvsPadWave
Definition: AtEventDrawTaskProto.h:108
AtEventDrawTaskProto::f3DHitStyle
Int_t f3DHitStyle
Definition: AtEventDrawTaskProto.h:80
y
const double * y
Definition: lmcurve.cxx:20
AtTrack
Definition: AtTrack.h:25
AtEventDrawTaskProto::fQELossPatternAna
TGraph * fQELossPatternAna[4]
Definition: AtEventDrawTaskProto.h:102
AtEventDrawTaskProto::DrawProtoEL
virtual void DrawProtoEL()
Definition: AtEventDrawTaskProto.cxx:678
AtEventDrawTaskProto::DrawProtoELAna
virtual void DrawProtoELAna()
Definition: AtEventDrawTaskProto.cxx:715
AtEventManagerProto::GetCvsPadAll
TCanvas * GetCvsPadAll()
Definition: AtEventManagerProto.h:42
AtTrack.h
AtEventDrawTaskProto::UpdateCvsProtoQ
void UpdateCvsProtoQ()
Definition: AtEventDrawTaskProto.cxx:833
AtPatternEvent.h
AtEventDrawTaskProto::fCvsQuadrant2
TCanvas * fCvsQuadrant2
Definition: AtEventDrawTaskProto.h:113
AtEventDrawTaskProto::fHitSet
TEvePointSet * fHitSet
Definition: AtEventDrawTaskProto.h:133
AtEventDrawTaskProto::kIsPRDrawn
Bool_t kIsPRDrawn
Definition: AtEventDrawTaskProto.h:148
AtEventDrawTaskProto::fIsCircularHough
Bool_t fIsCircularHough
Definition: AtEventDrawTaskProto.h:82
AtEventDrawTaskProto::fCvsQuadrant4
TCanvas * fCvsQuadrant4
Definition: AtEventDrawTaskProto.h:115
AtEventDrawTaskProto::fMesh
TH1F * fMesh
Definition: AtEventDrawTaskProto.h:98
AtEventDrawTaskProto
Definition: AtEventDrawTaskProto.h:31
AtEvent::GetMesh
const TraceArray & GetMesh() const
Definition: AtEvent.h:111
AtEventDrawTaskProto::fQELossPattern
TGraph * fQELossPattern[4]
Definition: AtEventDrawTaskProto.h:100
cRED
constexpr auto cRED
Definition: AtEventDrawTaskProto.cxx:62
AtPad::GetPadNum
Int_t GetPadNum() const
Definition: AtPad.h:96
AtPad::GetADC
const trace & GetADC() const
Definition: AtPad.cxx:97
AtEventDrawTaskProto::fQHitPattern
TGraph * fQHitPattern[4]
Definition: AtEventDrawTaskProto.h:99
AtProtoEvent
Definition: AtProtoEvent.h:16
AtProtoQuadrant.h
AtEventDrawTaskProto::fCvsVertex
TCanvas * fCvsVertex
Definition: AtEventDrawTaskProto.h:120
AtBaseEvent::GetEventID
ULong_t GetEventID() const
Definition: AtBaseEvent.h:67
AtEventDrawTaskProto::SelectPad
static void SelectPad(const char *rawevt)
Definition: AtEventDrawTaskProto.cxx:910
AtEventDrawTaskProto::fLineNum
Int_t fLineNum
Definition: AtEventDrawTaskProto.h:145
AtEventDrawTaskProto::DrawPadPlane
virtual void DrawPadPlane()
Definition: AtEventDrawTaskProto.cxx:626
AtEventDrawTaskProto::DrawProtoVertex
virtual void DrawProtoVertex()
Definition: AtEventDrawTaskProto.cxx:740
AtEventDrawTaskProto::fMap
TString fMap
Definition: AtEventDrawTaskProto.h:125
AtProtoEvent::GetNumQuadrants
std::size_t GetNumQuadrants()
Definition: AtProtoEvent.cxx:27
AtEventDrawTaskProto::fFit
TF1 * fFit[4]
Definition: AtEventDrawTaskProto.h:103
AtEventDrawTaskProto::~AtEventDrawTaskProto
virtual ~AtEventDrawTaskProto()
Definition: AtEventDrawTaskProto.cxx:119
AtMap.h
AtRawEvent::GetNumPads
Int_t GetNumPads() const
Definition: AtRawEvent.h:122
AtEventDrawTaskProto::fIsRawData
Bool_t fIsRawData
Definition: AtEventDrawTaskProto.h:84
AtEventDrawTaskProto::fQVertex
TH2F * fQVertex[4]
Definition: AtEventDrawTaskProto.h:104
AtEventDrawTaskProto::fHitStyle
Style_t fHitStyle
Definition: AtEventDrawTaskProto.h:87
AtMap::BinToPad
virtual Int_t BinToPad(Int_t binval)=0
AtEventDrawTaskProto::UpdateCvsMesh
void UpdateCvsMesh()
Definition: AtEventDrawTaskProto.cxx:826
AtEventDrawTaskProto::DrawProtoSpace
virtual void DrawProtoSpace()
Definition: AtEventDrawTaskProto.cxx:676
AtPad
Container class for AtPadBase objects.
Definition: AtPad.h:38
AtEventDrawTaskProto::fPadAll
TH1I * fPadAll[2015]
Definition: AtEventDrawTaskProto.h:94
AtEventDrawTaskProto::fCvsELQuadrant3
TCanvas * fCvsELQuadrant3
Definition: AtEventDrawTaskProto.h:118
AtEventDrawTaskProto::fHitSetPR
TEvePointSet * fHitSetPR[20]
Definition: AtEventDrawTaskProto.h:135
AtTpcProtoMap.h
AtEventDrawTaskProto::fHoughLinearFit
TF1 * fHoughLinearFit
Definition: AtEventDrawTaskProto.h:124
AtPad::GetRawADC
const rawTrace & GetRawADC() const
Definition: AtPad.h:104
AtEventManagerProto::GetCvsPadWave
TCanvas * GetCvsPadWave()
Definition: AtEventManagerProto.h:41
AtEventDrawTaskProto::DrawPadAll
virtual void DrawPadAll()
Definition: AtEventDrawTaskProto.cxx:647
AtEventDrawTaskProto::fHitArray
TClonesArray * fHitArray
Definition: AtEventDrawTaskProto.h:127
AtAuxPad
Definition: AtAuxPad.h:25
AtEventDrawTaskProto::SetHitAttributes
void SetHitAttributes(Color_t, Size_t, Style_t)
Definition: AtEventDrawTaskProto.cxx:1013
AtProtoEventAna::GetPar0
std::vector< Double_t > * GetPar0()
Definition: AtProtoEventAna.cxx:32
AtEventDrawTaskProto::fCvsELQuadrant4
TCanvas * fCvsELQuadrant4
Definition: AtEventDrawTaskProto.h:119
AtEventDrawTaskProto::fPadPlane
TH2Poly * fPadPlane
Definition: AtEventDrawTaskProto.h:97
AtEventDrawTaskProto::fPadWave
TH1I * fPadWave
Definition: AtEventDrawTaskProto.h:96
AtEventDrawTaskProto::UpdateCvsProtoAux
void UpdateCvsProtoAux()
Definition: AtEventDrawTaskProto.cxx:873
AtHit::GetCharge
Double_t GetCharge() const
Definition: AtHit.h:82
AtEventDrawTaskProto::fCvsPadPlane
TCanvas * fCvsPadPlane
Definition: AtEventDrawTaskProto.h:109
AtHit
Point in space with charge.
Definition: AtHit.h:27
AtEventDrawTaskProto::UpdateCvsPadWave
void UpdateCvsPadWave()
Update functions //////.
Definition: AtEventDrawTaskProto.cxx:808
Generated on Sat Nov 11 2023 15:30:37 for ATTPCROOT by   doxygen 1.8.18