AnitaRFCanvasMaker.cxx
1 #include <fstream>
9 #include <iostream>
10 #include "MagicDisplayConventions.h"
11 #include "AnitaRFCanvasMaker.h"
12 #include "AnitaConventions.h"
13 #include "AnitaGeomTool.h"
14 #include "UsefulAnitaEvent.h"
15 #include "RawAnitaHeader.h"
16 #include "TurfRate.h"
17 #include "SummedTurfRate.h"
18 #include "SurfHk.h"
19 #include "AveragedSurfHk.h"
20 
21 #include "AnitaVersion.h"
22 #include "TString.h"
23 #include "TObjArray.h"
24 #include "TObjString.h"
25 #include "TVector3.h"
26 #include "TROOT.h"
27 #include "TPaveText.h"
28 #include "TPad.h"
29 #include "TText.h"
30 #include "TLatex.h"
31 #include "TGraph.h"
32 #include "WaveformGraph.h"
33 #include "TStyle.h"
34 #include "TCanvas.h"
35 #include "TAxis.h"
36 #include "TH1.h"
37 #include "THStack.h"
38 #include "TList.h"
39 #include "TObject.h"
40 #include "TTimeStamp.h"
41 #include "TMath.h"
42 #include "TMultiGraph.h"
43 
44 AnitaRFCanvasMaker* AnitaRFCanvasMaker::fgInstance = 0;
45 
46 TH1D *histTurfRate[6]={0};
47 TH1D *histSumTurfRate[6]={0};
48 TH1D *histAntMask[2]={0};
49 TH1D *histSumAntMask[2]={0};
50 TH1D *histPhiMask=0;
51 TH1D *histSumPhiMask=0;
52 
53 
54 TH1D *histSurfHk[5][ACTIVE_SURFS]={{0}};
55 TH1D *histSurfHkPhi[5][PHI_SECTORS]={{0}};
56 TH1D *histBadThreshold=0;
57 TH1D *histBandMask=0;
58 THStack *histSurfHkStack[5];
59 THStack *histSurfHkPhiStack[5];
60 TH1F *surfHkFramey[5]={0};
61 TH1F *surfHkTimeFramey[5]={0};
62 TMultiGraph *mgSurfTime[5]={0};
63 TGraph *grSurfL2Scaler[TRIGGER_SURFS][L2S_PER_SURF]={{0}};
64 TGraph *grSurfL1Scaler[TRIGGER_SURFS][L2S_PER_SURF]={{0}};
65 TGraph *grSurfScaler[TRIGGER_SURFS][SCALERS_PER_SURF]={{0}};
66 TGraph *grSurfThresh[TRIGGER_SURFS][SCALERS_PER_SURF]={{0}};
67 TGraph *grSurfRfPwr[ACTIVE_SURFS][RFCHAN_PER_SURF]={{0}};
68 
69 
70 TH1D *histAvgSurfHk[3][ACTIVE_SURFS]={{0}};
71 TH1D *histAvgSurfHkPhi[3][PHI_SECTORS]={{0}};
72 TH1D *histAvgSurfBadThreshold=0;
73 TH1D *histAvgSurfBandMask=0;
74 THStack *histAvgSurfHkStack[3];
75 THStack *histAvgSurfHkPhiStack[3];
76 TH1F *avgSurfHkFramey[3]={0};
77 
78 AnitaRFCanvasMaker::AnitaRFCanvasMaker()
79 {
80  //Default constructor
81  fTurfL1Max=0;
82  fTurfL1Min=0;
83  fTurfL2Max=0;
84  fTurfL2Min=0;
85  fTurfL3Max=0;
86  fTurfL3Min=0;
87  fSumTurfL1Max=0;
88  fSumTurfL1Min=0;
89  fSumTurfL2Max=0;
90  fSumTurfL2Min=0;
91  fSumTurfL3Max=0;
92  fSumTurfL3Min=0;
93  fSurfUseLog=0;
94  fAvgSurfUseLog=0;
95  fFixTurfYScale=0;
96  fFixSurfYScale=0;
97  fSurfKelvinView=1;
98  fAvgSurfKelvinView=1;
99  fNumSurfHks=0;
100  fgInstance=this;
101 
102 }
103 
104 AnitaRFCanvasMaker::~AnitaRFCanvasMaker()
105 {
106  //Default destructor
107 }
108 
109 
110 
111 //______________________________________________________________________________
112 AnitaRFCanvasMaker* AnitaRFCanvasMaker::Instance()
113 {
114  //static function
115  return (fgInstance) ? (AnitaRFCanvasMaker*) fgInstance : new AnitaRFCanvasMaker();
116 }
117 
118 
119 TPad *AnitaRFCanvasMaker::getTurfRateCanvas(TurfRate *turfPtr, TPad *useCan)
120 {
121  TPad *canTurfRate;
122  TPad *plotPad;
123  if(!useCan) {
124  canTurfRate = (TPad*) gROOT->FindObject("canTurfRate");
125  if(!canTurfRate) {
126  canTurfRate = new TCanvas("canTurfRate","canTurfRate",1000,600);
127  }
128  canTurfRate->Clear();
129  canTurfRate->SetTopMargin(0);
130  plotPad = new TPad("canTurfRateMain","canTurfRateMain",0,0,1,0.9);
131  plotPad->Draw();
132  }
133  else {
134  plotPad=useCan;
135  }
136  plotPad->cd();
137  plotPad->Clear();
138 
139  const char *histNames[6]={"histUpperL1","histLowerL1","histUpperL2","histLowerL2","histNadirL","histL3"};
140  const char *histTitles[6]={"Upper L1","Lower L1","Upper L2","Lower L2","Nadir L1/2","L3"};
141 
142  for(int i=0;i<6;i++) {
143  if(histTurfRate[i]) {
144  histTurfRate[i]->Reset();
145  }
146  else {
147  histTurfRate[i]= new TH1D(histNames[i],histTitles[i],PHI_SECTORS,0.5,PHI_SECTORS+0.5);
148  }
149  }
150  const char *maskNames[2]={"histAntMask0","histAntMask1"};
151  for(int i=0;i<2;i++) {
152  if(histAntMask[i])
153  histAntMask[i]->Reset();
154  else {
155  histAntMask[i] = new TH1D(maskNames[i],maskNames[i],PHI_SECTORS,0.5,PHI_SECTORS+0.5);
156  }
157  }
158  if(histPhiMask)
159  histPhiMask->Reset();
160  else
161  histPhiMask = new TH1D("histPhiMask","histPhiMask",PHI_SECTORS,0.5,PHI_SECTORS+0.5);
162 
163 
164 
165  Double_t l1Max=0;
166  Double_t l2Max=0;
167  Double_t l3Max=0;
168  int maskedAnts[2][PHI_SECTORS];
169  memset(maskedAnts,0,2*PHI_SECTORS*sizeof(int));
170  for(int phi=0;phi<PHI_SECTORS;phi++) {
171  // if(turfPtr->getL1Rate(phi,0)>l1Max)
172  // l1Max=turfPtr->getL1Rate(phi,0);
173  // if(turfPtr->getL1Rate(phi,1)>l1Max)
174  // l1Max=turfPtr->getL1Rate(phi,1);
175  // if(turfPtr->getL2Rate(phi,0)>l2Max)
176  // l2Max=turfPtr->getL2Rate(phi,0);
177  // if(turfPtr->getL2Rate(phi,1)>l2Max)
178  // l2Max=turfPtr->getL2Rate(phi,1);
179  // if(turfPtr->isAntMasked(phi,0))
180  // maskedAnts[0][phi]=1;
181  // if(turfPtr->isAntMasked(phi,1))
182  // maskedAnts[1][phi]=1;
183  if(turfPtr->getL3Rate(phi)>l3Max)
184  l3Max=turfPtr->getL3Rate(phi);
185 
186 
187  // histTurfRate[0]->Fill(phi+1,1e-3*turfPtr->getL1Rate(phi,0));
188  // histTurfRate[1]->Fill(phi+1,1e-3*turfPtr->getL1Rate(phi,1));
189  // histTurfRate[2]->Fill(phi+1,turfPtr->getL2Rate(phi,0));
190  // histTurfRate[3]->Fill(phi+1,turfPtr->getL2Rate(phi,1));
191  // histTurfRate[4]->Fill(phi+1,turfPtr->getNadirL12Rate(phi));
192  histTurfRate[5]->Fill(phi+1,turfPtr->getL3Rate(phi));
193 
194  if(turfPtr->phiTrigMask & (1<<phi))
195  histPhiMask->Fill(phi+1);
196 
197 
198  }
199  l1Max*=1.1e-3;
200  l2Max*=1.1;
201  l3Max*=1.1;
202  plotPad->SetRightMargin(0.0);
203  plotPad->SetLeftMargin(0.1);
204  plotPad->SetTopMargin(0.05);
205  plotPad->SetBottomMargin(0.1);
206  plotPad->Divide(1,6,0,0);
207 
208  TLatex texy;
209  texy.SetTextAlign(21);
210  texy.SetTextAngle(270);
211  texy.SetTextSize(0.17);
212 
213  if(!fFixTurfYScale) {
214  if(fTurfL1Max)
215  l1Max=fTurfL1Max;
216  histTurfRate[0]->SetMaximum(l1Max);
217  histTurfRate[1]->SetMaximum(l1Max);
218  if(fTurfL2Max)
219  l2Max=fTurfL2Max;
220  histTurfRate[2]->SetMaximum(l2Max);
221  histTurfRate[3]->SetMaximum(l2Max);
222  }
223  histPhiMask->Scale(l3Max);
224  // histTurfRate[5]->SetMaximum(l3Max);
225 
226 
227 
228  for(int ring=0;ring<2;ring++) {
229  for(int phi=0;phi<PHI_SECTORS;phi++) {
230  if(maskedAnts[ring][phi]) {
231  histAntMask[ring]->Fill(phi+1,l1Max);
232  }
233  }
234  histAntMask[ring]->SetLineWidth(0);
235  histAntMask[ring]->SetFillColor(kGray);
236  histAntMask[ring]->SetFillStyle(3001);
237  }
238 
239  histPhiMask->SetLineWidth(0);
240  histPhiMask->SetFillColor(kGray);
241  histPhiMask->SetFillStyle(3001);
242 
243  for(int i=0;i<6;i++) {
244  TPad* paddy = (TPad*)plotPad->cd(i+1);
245  // if(i==4)
246  paddy->SetBottomMargin(0.12);
247  if(i==5)
248  paddy->SetBottomMargin(0.18);
249  paddy->SetRightMargin(0.05);
250  histTurfRate[i]->SetFillStyle(3001);
251  histTurfRate[i]->SetFillColor(getNiceColour(i));
252  histTurfRate[i]->SetLineColor(getNiceColour(i));
253  if(i==5) {
254  histTurfRate[i]->SetXTitle("Phi Sector");
255  }
256  if(i<2)
257  histTurfRate[i]->SetYTitle("Rate (kHz)");
258  else
259  histTurfRate[i]->SetYTitle("Rate (Hz)");
260  histTurfRate[i]->SetStats(0);
261  histTurfRate[i]->GetYaxis()->SetNoExponent(1);
262  histTurfRate[i]->GetXaxis()->SetLabelSize(0.08);
263  histTurfRate[i]->GetYaxis()->SetLabelSize(0.08);
264  histTurfRate[i]->GetXaxis()->SetTitleSize(0.12);
265  histTurfRate[i]->GetYaxis()->SetTitleSize(0.12);
266  histTurfRate[i]->GetXaxis()->SetTitleOffset(0.65);
267  histTurfRate[i]->GetYaxis()->SetTitleOffset(0.4);
268  histTurfRate[i]->SetTitle("");
269  histTurfRate[i]->Draw();
270  if(i<2) {
271  histAntMask[i%2]->Draw("same");
272  }
273  texy.DrawTextNDC(0.96,0.5,histTitles[i]);
274 
275  if(i==5)
276  histPhiMask->Draw("same");
277 
278  }
279  plotPad->Update();
280  if(useCan)
281  return plotPad;
282  else
283  return canTurfRate;
284 }
285 
286 TPad *AnitaRFCanvasMaker::getTurfInfoCanvas(TurfRate *turfPtr,TPad *useCan)
287 {
288  char textLabel[180];
289  TPad *topPad;
290  if(!useCan) {
291  topPad = new TPad("padTurfInfo","padTurfInfo",0.2,0.9,0.8,1);
292  topPad->Draw();
293  }
294  else {
295  topPad=useCan;
296  }
297  topPad->Clear();
298  topPad->SetTopMargin(0.05);
299  topPad->cd();
300  TPaveText *leftPave = new TPaveText(0.2,0,0.8,0.9);
301  leftPave->SetBorderSize(0);
302  leftPave->SetFillColor(0);
303  leftPave->SetTextAlign(13);
304  sprintf(textLabel,"Run: %d",turfPtr->run);
305  TText *runText = leftPave->AddText(textLabel);
306  runText->SetTextColor(50);
307  TTimeStamp turfTime((time_t)turfPtr->realTime,0);
308  sprintf(textLabel,"Time: %s",turfTime.AsString("s"));
309  TText *timeText = leftPave->AddText(textLabel);
310  timeText->SetTextColor(1);
311  sprintf(textLabel,"ppsNum: %d",turfPtr->ppsNum);
312  TText *ppsText = leftPave->AddText(textLabel);
313  ppsText->SetTextColor(1);
314  leftPave->Draw();
315  return topPad;
316 }
317 
318 TPad *AnitaRFCanvasMaker::getSurfHkCanvas(SurfHk *surfPtr, TPad *useCan)
319 {
320  static MagicDisplaySurfHkDisplay::MagicDisplaySurfHkDisplay_t lastView=MagicDisplaySurfHkDisplay::kNotAView;
321  static int lastKelvinView=1;
322  gStyle->SetOptTitle(0);
323  TPad *canSurfHk;
324  TPad *plotPad;
325  if(!useCan) {
326  canSurfHk = (TPad*) gROOT->FindObject("canSurfHk");
327  if(!canSurfHk) {
328  canSurfHk = new TCanvas("canSurfHk","canSurfHk",1000,600);
329  }
330  canSurfHk->Clear();
331  canSurfHk->SetTopMargin(0);
332  plotPad = new TPad("canSurfHkMain","canSurfHkMain",0,0,1,0.9);
333  plotPad->Draw();
334  }
335  else {
336  plotPad=useCan;
337  }
338  plotPad->cd();
339  // std::cout << fSurfPhiView << "\t" << lastView << std::endl;
340  static int callCounter=0;
341  if(fSurfDisplay!=lastView || lastKelvinView!=fSurfKelvinView) {
342  plotPad->Clear();
343  surfHkFramey[0]=0;
344  surfHkFramey[1]=0;
345  surfHkFramey[2]=0;
346  }
347  lastView=fSurfDisplay;
348  lastKelvinView=fSurfKelvinView;
349  callCounter++;
350 
351  addToTimePlots(surfPtr);
352  if(fSurfDisplay==MagicDisplaySurfHkDisplay::kPhiView)
353  getSurfHkPhiCanvas(surfPtr,plotPad);
354  else if(fSurfDisplay==MagicDisplaySurfHkDisplay::kSurfView)
355  getSurfHkSurfCanvas(surfPtr,plotPad);
356  else if(fSurfDisplay==MagicDisplaySurfHkDisplay::kTimeView)
357  getSurfHkTimeCanvas(plotPad);
358  if(useCan)
359  return plotPad;
360  else
361  return canSurfHk;
362 }
363 
364 void AnitaRFCanvasMaker::getSurfHkSurfCanvas(SurfHk *surfPtr,TPad *plotPad) {
365  // plotPad->Clear();
366 
367  char actualName[180];
368  const char *histNames[5]={"histL2Scaler","histL1Scaler","histScaler","histThreshold","histRFPower"};
369  const char *histTitles[5]={"L2 Scaler","L1 Scaler","Scaler","Threshold","RF Power"};
370  const char *histYTitles[5]={"Rate (kHz)","Rate (kHz)","Rate (kHz)","DAC","RF Power (ADC)"};
371  int numBins[5]={ACTIVE_SURFS*L2S_PER_SURF,
372  ACTIVE_SURFS*L1S_PER_SURF,
373  ACTIVE_SURFS*SCALERS_PER_SURF,
374  ACTIVE_SURFS*SCALERS_PER_SURF,
375  ACTIVE_SURFS*RFCHAN_PER_SURF};
376 
377 
378  if(histBadThreshold)
379  delete histBadThreshold;
380  // histBadThreshold->Reset();
381  // else
382  histBadThreshold = new TH1D("histBadThreshold","histBadThreshold",
383  ACTIVE_SURFS*SCALERS_PER_SURF,-0.5,
384  (ACTIVE_SURFS*SCALERS_PER_SURF)-0.5);
385  if(histBandMask)
386  delete histBandMask;
387  // histBandMask->Reset();
388  // else
389  histBandMask = new TH1D("histBandMask","histBandMask",
390  ACTIVE_SURFS*SCALERS_PER_SURF,-0.5,
391  (ACTIVE_SURFS*SCALERS_PER_SURF)-0.5);
392  Int_t maskedBands[ACTIVE_SURFS*SCALERS_PER_SURF]={0};
393 
394  for(int i=0;i<5;i++) {
395  if(histSurfHkStack[i])
396  delete histSurfHkStack[i];
397  sprintf(actualName,"%s_base",histNames[i]);
398  histSurfHkStack[i] = new THStack(actualName,histTitles[i]);
399 
400 
401  for(int surf=0;surf<ACTIVE_SURFS;surf++){
402  if(histSurfHk[i][surf]) {
403  delete histSurfHk[i][surf];
404  }
405 
406  sprintf(actualName,"%s_%d",histNames[i],surf);
407  histSurfHk[i][surf]= new TH1D(actualName,histTitles[i],numBins[i],-0.5,numBins[i]-0.5);
408  }
409  }
410 
411 
412 
413  for(int surf=0;surf<ACTIVE_SURFS;surf++) {
414  // for(int l2=0;l2<L2S_PER_SURF;l2++) {
415  // histSurfHk[0][surf]->Fill(l2+L2S_PER_SURF*surf,surfPtr->getL2ScalerFromSurfChan(surf,l2));
416  // }
417  // for(int l1=0;l1<L1S_PER_SURF;l1++) {
418  // histSurfHk[1][surf]->Fill(l1+L1S_PER_SURF*surf,surfPtr->getL1ScalerFromSurfChan(surf,l1));
419  // }
420 
421  for(int scl=0;scl<SCALERS_PER_SURF;scl++) {
422  // maskedBands[scl+surf*SCALERS_PER_SURF]=surfPtr->isBandMasked(surf,scl);
423  // histSurfHk[2][surf]->Fill(scl+surf*SCALERS_PER_SURF,
424  // surfPtr->getScalerFromSurfChan(surf,scl));
425  // histSurfHk[3][surf]->Fill(scl+surf*SCALERS_PER_SURF,
426  // surfPtr->getThresholdFromSurfChan(surf,scl));
427 
428  // if(!surfPtr->globalThreshold &&
429  // (surfPtr->getThresholdFromSurfChan(surf,scl)!=surfPtr->getSetThresholdFromSurfChan(surf,scl))){
430  // histBadThreshold->Fill(scl+surf*SCALERS_PER_SURF,
431  // surfPtr->getThresholdFromSurfChan(surf,scl));
432  // }
433 
434  }
435  for(int chan=0;chan<RFCHAN_PER_SURF;chan++) {
436  if(fSurfKelvinView==1) {
437  histSurfHk[4][surf]->Fill(chan+surf*RFCHAN_PER_SURF,
438  surfPtr->getRFPowerInK(surf,chan));
439  }
440  else {
441  histSurfHk[4][surf]->Fill(chan+surf*RFCHAN_PER_SURF,
442  surfPtr->getRawRFPower(surf,chan));
443  }
444  }
445 
446 
447  for(int i=0;i<5;i++) {
448  histSurfHk[i][surf]->SetFillColor(getNiceColour(surf%2));
449  histSurfHkStack[i]->Add(histSurfHk[i][surf]);
450  }
451 
452  }
453 
454  histBadThreshold->SetFillColor(kRed+1);
455  histSurfHkStack[3]->Add(histBadThreshold);
456 
457 
458  if(!plotPad->cd(5)) {
459  plotPad->Clear();
460  surfHkFramey[0]=0;
461  surfHkFramey[1]=0;
462  surfHkFramey[2]=0;
463  surfHkFramey[3]=0;
464  surfHkFramey[4]=0;
465  plotPad->SetRightMargin(0.0);
466  plotPad->SetLeftMargin(0.1);
467  plotPad->SetTopMargin(0.05);
468  plotPad->SetBottomMargin(0.0);
469  plotPad->Divide(1,5,0,0);
470  }
471 
472  TLatex texy;
473  texy.SetTextAlign(21);
474  texy.SetTextAngle(270);
475  texy.SetTextSize(0.17);
476 
477 
478 
479  for(int i=0;i<5;i++) {
480  Double_t maxVal=histSurfHkStack[i]->GetMaximum("nostack");
481  TPad* paddy = (TPad*)plotPad->cd(i+1);
482  if(!surfHkFramey[i]) {
483  paddy->SetBottomMargin(0.15);
484  paddy->Clear();
485  paddy->SetBottomMargin(0.18);
486  paddy->SetRightMargin(0.05);
487 
488  surfHkFramey[i]=paddy->DrawFrame(0,0,numBins[i],maxVal*1.05);
489 
490 
491  surfHkFramey[i]->GetYaxis()->SetTitle(histYTitles[i]);
492  if(i==4) {
493  if(fSurfKelvinView) {
494  surfHkFramey[i]->GetYaxis()->SetTitle("RF Power (K)");
495  }
496  }
497  surfHkFramey[i]->GetXaxis()->SetTitle("Logical Channel");
498  surfHkFramey[i]->GetYaxis()->SetNoExponent(1);
499  surfHkFramey[i]->GetXaxis()->SetLabelSize(0.08);
500  surfHkFramey[i]->GetYaxis()->SetLabelSize(0.08);
501  surfHkFramey[i]->GetXaxis()->SetTitleSize(0.09);
502  surfHkFramey[i]->GetYaxis()->SetTitleSize(0.09);
503  surfHkFramey[i]->GetXaxis()->SetTitleOffset(0.8);
504  surfHkFramey[i]->GetYaxis()->SetTitleOffset(0.6);
505  surfHkFramey[i]->GetYaxis()->SetTickLength(-0.01);
506  surfHkFramey[i]->GetYaxis()->SetLabelOffset(0.015);
507  surfHkFramey[i]->GetXaxis()->SetTickLength(-0.01);
508  surfHkFramey[i]->GetXaxis()->SetLabelOffset(0.015);
509  surfHkFramey[i]->SetTitle("");
510  }
511  else {
512  if(!fFixSurfYScale) {
513  surfHkFramey[i]->GetYaxis()->SetRangeUser(0,maxVal*1.05);
514  }
515  gPad->SetLogy(0);
516  if(fSurfUseLog) {
517  surfHkFramey[i]->GetYaxis()->SetRangeUser(0.1,maxVal*2);
518  gPad->SetLogy(1);
519  }
520 
521  }
522  for(int surf=0;surf<ACTIVE_SURFS;surf++) {
523  histSurfHk[i][surf]->Draw("same hist");
524  }
525  if(i==0) {
526  maxVal*=1.1;
527  for(int i=0;i<ACTIVE_SURFS*SCALERS_PER_SURF;i++) {
528  if(maskedBands[i])
529  histBandMask->Fill(i,maxVal);
530  }
531  histBandMask->SetLineWidth(0);
532  histBandMask->SetFillColor(kGray);
533  histBandMask->SetFillStyle(3001);
534  histBandMask->Draw("same hist");
535  }
536  }
537  plotPad->Update();
538 }
539 
540 
541 
542 void AnitaRFCanvasMaker::getSurfHkPhiCanvas(SurfHk *surfPtr,TPad *plotPad) {
543  // plotPad->Clear();
544  AnitaGeomTool* fARFCGeomTool=AnitaGeomTool::Instance();
545  char actualName[180];
546 
547  const int numPhiHistBins=PHI_SECTORS*4*2; // phi * ring * pol with an extra space
548 
549  const char *histNames[5]={"histL2ScalerPhi","histL1ScalerPhi","histScalerPhi","histThresholdPhi","histRFPowerPhi"};
550  const char *histTitles[5]={"L2 Scaler","L1 Scaler","Scaler","Threshold","RF Power"};
551  const char *histYTitles[5]={"Rate (kHz)","Rate (kHz)","Rate (kHz)","DAC","RF Power (ADC)"};
552  int numBins[5]={PHI_SECTORS,PHI_SECTORS*3,
553  numPhiHistBins,numPhiHistBins,numPhiHistBins};
554 
555  if(histBadThreshold)
556  delete histBadThreshold;
557  histBadThreshold = new TH1D("histBadThreshold","histBadThreshold",
558  numPhiHistBins,-0.5,
559  (numPhiHistBins)-0.5);
560  if(histBandMask)
561  delete histBandMask;
562  // histBandMask->Reset();
563  // else
564  histBandMask = new TH1D("histBandMask","histBandMask",
565  numPhiHistBins,-0.5,
566  (numPhiHistBins)-0.5);
567  Int_t maskedBands[numPhiHistBins]={0};
568 
569  for(int i=0;i<5;i++) {
570  if(histSurfHkPhiStack[i])
571  delete histSurfHkPhiStack[i];
572  histSurfHkPhiStack[i] = new THStack(histNames[i],histTitles[i]);
573  sprintf(actualName,"%s_base",histNames[i]);
574 
575 
576  for(int phi=0;phi<PHI_SECTORS;phi++){
577  if(histSurfHkPhi[i][phi]) {
578  delete histSurfHkPhi[i][phi];
579  // histSurfHkPhi[i][phi]->Reset();
580  }
581 
582  sprintf(actualName,"%s_%d",histNames[i],phi);
583  histSurfHkPhi[i][phi]= new TH1D(actualName,histTitles[i],
584  numBins[i],-0.5,
585  numBins[i]-0.5);
586 
587  }
588  }
589 
590 
591  for(int phi=0;phi<PHI_SECTORS;phi++) {
592  // histSurfHkPhi[0][phi]->Fill(phi,surfPtr->getL2Scaler(phi));
593  for(int ring=0;ring<3;ring++) {
594  //First step is the scalers and thresholds
595 
596 
597  for(int pol=0;pol<2;pol++) {
598  int binIndex=pol+ring*2+phi*8;
599 
600 #ifdef MULTIVERSION_ANITA_ENABLED
601  int v = AnitaVersion::get();
602 
603  if (v == 3 && ring == 0 || v ==4 && pol == 0) //avoid counting too many times
604  {
605  histSurfHkPhi[1][phi]->Fill(ring+3*phi,surfPtr->getL1Scaler(phi,AnitaPol::AnitaPol_t(pol), (AnitaRing::AnitaRing_t)ring));
606  }
607 
608  maskedBands[binIndex]=surfPtr->isMasked(phi,(AnitaRing::AnitaRing_t)ring,
609  (AnitaTrigPol::AnitaTrigPol_t)pol);
610  histSurfHkPhi[2][phi]->Fill(binIndex,surfPtr->getScaler(phi,(AnitaRing::AnitaRing_t)ring,
611  (AnitaTrigPol::AnitaTrigPol_t)pol));
612  histSurfHkPhi[3][phi]->Fill(binIndex,surfPtr->getThreshold(phi,(AnitaRing::AnitaRing_t)ring,
613  (AnitaTrigPol::AnitaTrigPol_t)pol));
614 #else
615  //nada
616 #endif
617 
618 
619  }
620 
621 
622  //Now for the RF power
623  //Argh
624  for(int pol=0;pol<2;pol++) {
625  Int_t surf,rfChan;
626  Int_t chanIndex=
627  fARFCGeomTool->getChanIndexFromRingPhiPol((AnitaRing::AnitaRing_t)ring,phi,(AnitaPol::AnitaPol_t)pol);
628  fARFCGeomTool->getSurfChanFromChanIndex(chanIndex,surf,rfChan);
629  Int_t index=pol + ring*2 + phi*8;
630 
631  if(fSurfKelvinView==1) {
632  histSurfHkPhi[4][phi]->Fill(index,
633  surfPtr->getRFPowerInK(surf,rfChan));
634  }
635  else {
636  histSurfHkPhi[4][phi]->Fill(index,
637  surfPtr->getRawRFPower(surf,rfChan));
638  }
639 
640  }
641  }
642 
643  for(int i=0;i<5;i++) {
644  histSurfHkPhi[i][phi]->SetFillColor(getNiceColour(phi%8));
645  histSurfHkPhiStack[i]->Add(histSurfHkPhi[i][phi]);
646  }
647  }
648  histBadThreshold->SetFillColor(kRed+1);
649  histSurfHkPhiStack[1]->Add(histBadThreshold);
650 
651 
652 
653 
654 
655  if(!plotPad->cd(5)) {
656  plotPad->Clear();
657  surfHkFramey[0]=0;
658  surfHkFramey[1]=0;
659  surfHkFramey[2]=0;
660  surfHkFramey[3]=0;
661  surfHkFramey[4]=0;
662  plotPad->SetRightMargin(0.0);
663  plotPad->SetLeftMargin(0.1);
664  plotPad->SetTopMargin(0.05);
665  plotPad->SetBottomMargin(0.0);
666  plotPad->Divide(1,5,0,0);
667  }
668 
669  TLatex texy;
670  texy.SetTextAlign(21);
671  texy.SetTextAngle(270);
672  texy.SetTextSize(0.17);
673 
674 
675  char label[10];
676  for(int i=0;i<5;i++) {
677  Double_t maxVal=histSurfHkPhiStack[i]->GetMaximum("nostack");
678  TPad* paddy = (TPad*)plotPad->cd(i+1);
679  if(!surfHkFramey[i]) {
680  paddy->SetBottomMargin(0.15);
681  paddy->Clear();
682  paddy->SetBottomMargin(0.18);
683  paddy->SetRightMargin(0.05);
684 
685  surfHkFramey[i]=paddy->DrawFrame(0,0,numBins[i],maxVal*1.05);
686  surfHkFramey[i]->GetYaxis()->SetTitle(histYTitles[i]);;
687  if(i==4) {
688  if(fSurfKelvinView) {
689  surfHkFramey[i]->GetYaxis()->SetTitle("RF Power (K)");
690  }
691  else {
692  surfHkFramey[i]->GetYaxis()->SetTitle("RF Power (ADC)");
693  }
694  }
695  surfHkFramey[i]->GetXaxis()->SetTitle("Phi Sector");
696  surfHkFramey[i]->SetBins(numBins[i],-0.5,
697  (numBins[i])-0.5);
698  for(int phi=0;phi<16;phi++) {
699  sprintf(label,"%d",phi+1);
700  surfHkFramey[i]->GetXaxis()->SetBinLabel((numBins[i]/16)*phi+(numBins[i]/32)+1,label);
701  }
702 
703 
704  surfHkFramey[i]->GetYaxis()->SetNoExponent(1);
705  surfHkFramey[i]->GetXaxis()->SetLabelSize(0.08);
706  surfHkFramey[i]->GetYaxis()->SetLabelSize(0.08);
707  surfHkFramey[i]->GetXaxis()->SetTitleSize(0.09);
708  surfHkFramey[i]->GetYaxis()->SetTitleSize(0.09);
709  surfHkFramey[i]->GetXaxis()->SetTitleOffset(0.8);
710  surfHkFramey[i]->GetYaxis()->SetTitleOffset(0.6);
711  surfHkFramey[i]->GetYaxis()->SetTickLength(-0.01);
712  surfHkFramey[i]->GetYaxis()->SetLabelOffset(0.015);
713  surfHkFramey[i]->GetXaxis()->SetTickLength(-0.01);
714  surfHkFramey[i]->GetXaxis()->SetLabelOffset(0.015);
715  surfHkFramey[i]->SetTitle("");
716  }
717  else {
718  if(!fFixSurfYScale) {
719  surfHkFramey[i]->GetYaxis()->SetRangeUser(0,maxVal*1.05);
720  }
721  gPad->SetLogy(0);
722  if(fSurfUseLog) {
723  surfHkFramey[i]->GetYaxis()->SetRangeUser(0.1,maxVal*2);
724  gPad->SetLogy(1);
725  }
726  }
727  for(int phi=0;phi<PHI_SECTORS;phi++) {
728  histSurfHkPhi[i][phi]->Draw("same hist");
729  }
730  if(i==0) {
731  maxVal*=1.1;
732  for(int i=0;i<numPhiHistBins;i++) {
733  if(maskedBands[i])
734  histBandMask->Fill(i,maxVal);
735  }
736  histBandMask->SetLineWidth(0);
737  histBandMask->SetFillColor(kGray);
738  histBandMask->SetFillStyle(3001);
739  histBandMask->Draw("same hist");
740  }
741  }
742  plotPad->Update();
743 }
744 
745 void AnitaRFCanvasMaker::getSurfHkTimeCanvas(TPad *plotPad) {
746  char graphName[180];
747  plotPad->Clear();
748  for(int i=0;i<5;i++) {
749  if(mgSurfTime[i]) delete mgSurfTime[i];
750  mgSurfTime[i]=0;
751  }
752  if(!plotPad->cd(4)) {
753  plotPad->Clear();
754  plotPad->SetRightMargin(0);
755  plotPad->SetLeftMargin(0.1);
756  plotPad->SetTopMargin(0.05);
757  plotPad->SetBottomMargin(0.1);
758  plotPad->Divide(1,5,0,0);
759  // for(int pad=1;pad<=3;pad++) {
760 // plotPad->cd(pad);
761 // gPad->SetRightMargin(0.05);
762 // }
763  }
764 
765  Int_t numPoints=fNumSurfHks;
766  if(numPoints>MAX_SURF_HK_TIME_POINTS) numPoints=MAX_SURF_HK_TIME_POINTS;
767  // Double_t minTime=TMath::MinElement(numPoints,fTimeVals);
768 // Double_t maxTime=TMath::MaxElement(numPoints,fTimeVals);
769 
770 // Double_t minScaler=TMath::MinElement(numPoints*TRIGGER_SURFS*SCALERS_PER_SURF,fScalerVals[0][0]);
771 // Double_t maxScaler=TMath::MaxElement(numPoints*TRIGGER_SURFS*SCALERS_PER_SURF,fScalerVals[0][0]);
772 // Double_t minThresh=TMath::MinElement(numPoints*TRIGGER_SURFS*SCALERS_PER_SURF,fThreshVals[0][0]);
773 // Double_t maxThresh=TMath::MaxElement(numPoints*TRIGGER_SURFS*SCALERS_PER_SURF,fThreshVals[0][0]);
774 // Double_t minRfPwr=TMath::MinElement(numPoints*NUM_SURF*RFCHAN_PER_SURF,fRfPowVals[0][0]);
775 // Double_t maxRfPwr=TMath::MaxElement(numPoints*NUM_SURF*RFCHAN_PER_SURF,fRfPowVals[0][0]);
776 
777  plotPad->cd(1);
778  gPad->Clear();
779  gPad->SetRightMargin(0.05);
780  // if(mgSurfTime[0]) delete mgSurfTime[0];
781  mgSurfTime[0] = new TMultiGraph();
782  for(int surf=0;surf<TRIGGER_SURFS;surf++) {
783  for(int scl=0;scl<L2S_PER_SURF;scl++) {
784  //Will change this in a bit
785  grSurfL2Scaler[surf][scl] = new TGraph(numPoints,fTimeVals,fL2ScalerVals[surf][scl]);
786  grSurfL2Scaler[surf][scl]->SetLineColor(getNiceColour(surf));
787  grSurfL2Scaler[surf][scl]->SetMarkerColor(getNiceColour(surf));
788  grSurfL2Scaler[surf][scl]->SetMarkerStyle(getMarker(scl));
789 
790  sprintf(graphName,"grSurfL2Scaler%d_%d",surf,scl);
791  grSurfL2Scaler[surf][scl]->SetName(graphName);
792 
793  mgSurfTime[0]->Add(grSurfL2Scaler[surf][scl],"lp");
794  }
795  }
796  mgSurfTime[0]->Draw("alp");
797  mgSurfTime[0]->GetYaxis()->SetTitle("L2 Scaler (kHz)");
798  mgSurfTime[0]->GetXaxis()->SetTimeDisplay(1);
799  plotPad->Update();
800 
801 
802  plotPad->cd(2);
803  gPad->Clear();
804  gPad->SetRightMargin(0.05);
805  // if(mgSurfTime[1]) delete mgSurfTime[1];
806  mgSurfTime[1] = new TMultiGraph();
807  for(int surf=0;surf<TRIGGER_SURFS;surf++) {
808  for(int scl=0;scl<L1S_PER_SURF;scl++) {
809  //Will change this in a bit
810  grSurfL1Scaler[surf][scl] = new TGraph(numPoints,fTimeVals,fL1ScalerVals[surf][scl]);
811  grSurfL1Scaler[surf][scl]->SetLineColor(getNiceColour(surf));
812  grSurfL1Scaler[surf][scl]->SetMarkerColor(getNiceColour(surf));
813  grSurfL1Scaler[surf][scl]->SetMarkerStyle(getMarker(scl));
814 
815  sprintf(graphName,"grSurfL2Scaler%d_%d",surf,scl);
816  grSurfL1Scaler[surf][scl]->SetName(graphName);
817 
818  mgSurfTime[1]->Add(grSurfL1Scaler[surf][scl],"lp");
819  }
820  }
821  mgSurfTime[1]->Draw("alp");
822  mgSurfTime[1]->GetYaxis()->SetTitle("L1 Scaler (kHz)");
823  mgSurfTime[1]->GetXaxis()->SetTimeDisplay(1);
824  plotPad->Update();
825 
826 
827 
828  plotPad->cd(3);
829  gPad->Clear();
830  gPad->SetRightMargin(0.05);
831  // if(mgSurfTime[0]) delete mgSurfTime[0];
832  mgSurfTime[2] = new TMultiGraph();
833  for(int surf=0;surf<TRIGGER_SURFS;surf++) {
834  for(int scl=0;scl<SCALERS_PER_SURF;scl++) {
835  //Will change this in a bit
836  grSurfScaler[surf][scl] = new TGraph(numPoints,fTimeVals,fScalerVals[surf][scl]);
837  grSurfScaler[surf][scl]->SetLineColor(getNiceColour(surf));
838  grSurfScaler[surf][scl]->SetMarkerColor(getNiceColour(surf));
839  grSurfScaler[surf][scl]->SetMarkerStyle(getMarker(scl));
840 
841  sprintf(graphName,"grSurfScaler%d_%d",surf,scl);
842  grSurfScaler[surf][scl]->SetName(graphName);
843 
844  mgSurfTime[2]->Add(grSurfScaler[surf][scl],"lp");
845  }
846  }
847  mgSurfTime[2]->Draw("alp");
848  mgSurfTime[2]->GetYaxis()->SetTitle("Scaler (kHz)");
849  mgSurfTime[2]->GetXaxis()->SetTimeDisplay(1);
850  plotPad->Update();
851 
852 
853 
854  plotPad->cd(4);
855  gPad->Clear();
856  gPad->SetRightMargin(0.05);
857  // if(mgSurfTime[1]) delete mgSurfTime[1];
858  mgSurfTime[3] = new TMultiGraph();
859  for(int surf=0;surf<TRIGGER_SURFS;surf++) {
860  for(int scl=0;scl<SCALERS_PER_SURF;scl++) {
861  //Will change this in a bit
862  // if(grSurfThresh[surf][scl]) delete grSurfThresh[surf][scl];
863  grSurfThresh[surf][scl] = new TGraph(numPoints,fTimeVals,fThreshVals[surf][scl]);
864  grSurfThresh[surf][scl]->SetLineColor(getNiceColour(surf));
865  grSurfThresh[surf][scl]->SetMarkerColor(getNiceColour(surf));
866  grSurfThresh[surf][scl]->SetMarkerStyle(getMarker(scl));
867 
868 
869  sprintf(graphName,"grSurfThresh%d_%d",surf,scl);
870  grSurfThresh[surf][scl]->SetName(graphName);
871 
872 
873  mgSurfTime[3]->Add(grSurfThresh[surf][scl],"lp");
874  }
875  }
876  mgSurfTime[3]->Draw("alp");
877  mgSurfTime[3]->GetYaxis()->SetTitle("Threshold (DAC)");
878  plotPad->Update();
879 
880 
881  plotPad->cd(5);
882  gPad->Clear();
883  gPad->SetRightMargin(0.05);
884  // if(mgSurfTime[2]) delete mgSurfTime[2];
885  mgSurfTime[4] = new TMultiGraph();
886  for(int surf=0;surf<ACTIVE_SURFS;surf++) {
887  for(int scl=0;scl<RFCHAN_PER_SURF;scl++) {
888  //Will change this in a bit
889  grSurfRfPwr[surf][scl] = new TGraph(numPoints,fTimeVals,fRfPowVals[surf][scl]);
890  grSurfRfPwr[surf][scl]->SetLineColor(getNiceColour(surf));
891  grSurfRfPwr[surf][scl]->SetMarkerColor(getNiceColour(surf));
892  grSurfRfPwr[surf][scl]->SetMarkerStyle(getMarker(scl));
893 
894 
895  sprintf(graphName,"grSurfRfPwr%d_%d",surf,scl);
896  grSurfRfPwr[surf][scl]->SetName(graphName);
897 
898  mgSurfTime[4]->Add(grSurfRfPwr[surf][scl],"lp");
899  }
900  }
901  mgSurfTime[4]->Draw("alp");
902  mgSurfTime[4]->GetXaxis()->SetTitle("Time");
903  mgSurfTime[4]->GetYaxis()->SetTitle("RF Power (K)");
904  mgSurfTime[4]->GetXaxis()->SetTimeDisplay(1);
905 
906 
907 
908 
909  plotPad->Update();
910 }
911 
912 
913 
914 TPad *AnitaRFCanvasMaker::getSurfInfoCanvas(SurfHk *surfPtr,TPad *useCan)
915 {
916  char textLabel[180];
917  TPad *topPad;
918  if(!useCan) {
919  topPad = new TPad("padSurfInfo","padSurfInfo",0.2,0.9,0.8,1);
920  topPad->Draw();
921  }
922  else {
923  topPad=useCan;
924  }
925  topPad->Clear();
926  topPad->SetTopMargin(0.05);
927  topPad->Divide(2,1);
928  topPad->cd(1);
929  TPaveText *leftPave = new TPaveText(0.05,0,0.95,0.9);
930  leftPave->SetBorderSize(0);
931  leftPave->SetFillColor(0);
932  leftPave->SetTextAlign(13);
933  sprintf(textLabel,"Run: %d",surfPtr->run);
934  TText *runText = leftPave->AddText(textLabel);
935  runText->SetTextColor(50);
936  TTimeStamp surfTime((time_t)surfPtr->realTime,0);
937  sprintf(textLabel,"Time: %s",surfTime.AsString("s"));
938  TText *timeText = leftPave->AddText(textLabel);
939  timeText->SetTextColor(1);
940  sprintf(textLabel,"ms: %8.6f ms",1e-3*surfPtr->payloadTimeUs);
941  TText *msText = leftPave->AddText(textLabel);
942  msText->SetTextColor(1);
943  leftPave->Draw();
944 
945  topPad->cd(2);
946  TPaveText *rightPave = new TPaveText(0.05,0,0.95,0.9);
947  rightPave->SetBorderSize(0);
948  rightPave->SetFillColor(0);
949  rightPave->SetTextAlign(13);
950  sprintf(textLabel,"Global: %d",surfPtr->globalThreshold);
951  TText *globalText = rightPave->AddText(textLabel);
952  globalText->SetTextColor(1);
953  sprintf(textLabel,"Goal Rates: (%d %d %d %d) kHz",
954  surfPtr->scalerGoals[0],surfPtr->scalerGoals[1],
955  surfPtr->scalerGoals[2],surfPtr->scalerGoals[3]);
956  TText *goalText = rightPave->AddText(textLabel);
957  goalText->SetTextColor(1);
958  sprintf(textLabel,"Error Flag: %#x",surfPtr->errorFlag);
959  TText *errorText = rightPave->AddText(textLabel);
960  errorText->SetTextColor(1);
961  rightPave->Draw();
962  return topPad;
963 
964 }
965 
966 
967 
968 TPad *AnitaRFCanvasMaker::getSumTurfRateCanvas(SummedTurfRate *sumTurfPtr, TPad *useCan)
969 {
970  TPad *canTurfRate;
971  TPad *plotPad;
972  if(!useCan) {
973  canTurfRate = (TPad*) gROOT->FindObject("canTurfRate");
974  if(!canTurfRate) {
975  canTurfRate = new TCanvas("canTurfRate","canTurfRate",1000,600);
976  }
977  canTurfRate->Clear();
978  canTurfRate->SetTopMargin(0);
979  plotPad = new TPad("canTurfRateMain","canTurfRateMain",0,0,1,0.9);
980  plotPad->Draw();
981  }
982  else {
983  plotPad=useCan;
984  }
985  plotPad->cd();
986  plotPad->Clear();
987 
988  const char *histNames[6]={"histSumUpperL1","histSumLowerL1","histSumUpperL2","histSumLowerL2","histSumNadirL","histSumL3"};
989  const char *histTitles[6]={"Upper L1","Lower L1","Upper L2","Lower L2","Nadir L1/2","L3"};
990 
991  for(int i=0;i<6;i++) {
992  if(histSumTurfRate[i]) {
993  delete histSumTurfRate[i];
994  // histSumTurfRate[i]->Reset();
995  }
996  // else {
997  histSumTurfRate[i]= new TH1D(histNames[i],histTitles[i],PHI_SECTORS,0.5,PHI_SECTORS+0.5);
998  // }
999  }
1000  const char *maskNames[2]={"histSumAntMask0","histSumAntMask1"};
1001  for(int i=0;i<2;i++) {
1002  if(histSumAntMask[i])
1003  delete histSumAntMask[i];
1004  // histSumAntMask[i]->Reset();
1005  // else {
1006  histSumAntMask[i] = new TH1D(maskNames[i],maskNames[i],PHI_SECTORS,0.5,PHI_SECTORS+0.5);
1007  // }
1008  }
1009 
1010  if(histSumPhiMask)
1011  delete histSumPhiMask;
1012  // histSumPhiMask->Reset();
1013  // else
1014  histSumPhiMask = new TH1D("histSumPhiMask","histSumPhiMask",PHI_SECTORS,0.5,PHI_SECTORS+0.5);
1015 
1016  Double_t l1Max=0;
1017  Double_t l2Max=0;
1018  Double_t l3Max=0;
1019  int maskedAnts[2][PHI_SECTORS];
1020  memset(maskedAnts,0,2*PHI_SECTORS*sizeof(int));
1021 
1022  for(int phi=0;phi<PHI_SECTORS;phi++) {
1023  // if(sumTurfPtr->getL1Rate(phi,0)>l1Max)
1024  // l1Max=sumTurfPtr->getL1Rate(phi,0);
1025  // if(sumTurfPtr->getL1Rate(phi,1)>l1Max)
1026  // l1Max=sumTurfPtr->getL1Rate(phi,1);
1027  // if(sumTurfPtr->getL2Rate(phi,0)>l2Max)
1028  // l2Max=sumTurfPtr->getL2Rate(phi,0);
1029  // if(sumTurfPtr->getL2Rate(phi,1)>l2Max)
1030  // l2Max=sumTurfPtr->getL2Rate(phi,1);
1031  // if(sumTurfPtr->isAntMasked(phi,0))
1032  // maskedAnts[0][phi]=1;
1033  // if(sumTurfPtr->isAntMasked(phi,1))
1034  // maskedAnts[1][phi]=1;
1035  if(sumTurfPtr->getL3Rate(phi)>l3Max)
1036  l3Max=sumTurfPtr->getL3Rate(phi);
1037 
1038 
1039  // histSumTurfRate[0]->Fill(phi+1,(1e-3*sumTurfPtr->getL1Rate(phi,0)));
1040  // histSumTurfRate[1]->Fill(phi+1,(1e-3*sumTurfPtr->getL1Rate(phi,1)));
1041  // histSumTurfRate[2]->Fill(phi+1,(sumTurfPtr->getL2Rate(phi,0)));
1042  // histSumTurfRate[3]->Fill(phi+1,(sumTurfPtr->getL2Rate(phi,1)));
1043  // histSumTurfRate[4]->Fill(phi+1,sumTurfPtr->getNadirL12Rate(phi));
1044  histSumTurfRate[5]->Fill(phi+1,sumTurfPtr->getL3Rate(phi));
1045 
1046  if(sumTurfPtr->phiTrigMask & (1<<phi))
1047  histSumPhiMask->Fill(phi+1);
1048 
1049  }
1050 
1051  float scale=1./sumTurfPtr->numRates;
1052  for(int i=0;i<6;i++)
1053  histSumTurfRate[i]->Scale(scale);
1054 
1055  l1Max*=1.1e-3;
1056  l2Max*=1.1;
1057  l3Max*=1.1;
1058  l1Max*=scale;
1059  l2Max*=scale;
1060  plotPad->SetRightMargin(0.0);
1061  plotPad->SetLeftMargin(0.1);
1062  plotPad->SetTopMargin(0.05);
1063  plotPad->SetBottomMargin(0.1);
1064  plotPad->Divide(1,6,0,0);
1065 
1066  // histSumTurfRate[5]->SetMaximum(l3Max);
1067  histSumPhiMask->Scale(l3Max);
1068 
1069 
1070  TLatex texy;
1071  texy.SetTextAlign(21);
1072  texy.SetTextAngle(270);
1073  texy.SetTextSize(0.17);
1074 
1075  if(!fFixSumTurfYScale) {
1076  if(fSumTurfL1Max)
1077  l1Max=fSumTurfL1Max;
1078  histSumTurfRate[0]->SetMaximum(l1Max);
1079  histSumTurfRate[1]->SetMaximum(l1Max);
1080  if(fSumTurfL2Max)
1081  l2Max=fSumTurfL2Max;
1082  histSumTurfRate[2]->SetMaximum(l2Max);
1083  histSumTurfRate[3]->SetMaximum(l2Max);
1084  }
1085 
1086 
1087  for(int ring=0;ring<2;ring++) {
1088  for(int phi=0;phi<PHI_SECTORS;phi++) {
1089  if(maskedAnts[ring][phi]) {
1090  // std::cout << ring << "\t" << phi << "\t" << maskedAnts[ring][phi] << std::endl;
1091  histSumAntMask[ring]->Fill(phi+1,l1Max);
1092  }
1093  }
1094  histSumAntMask[ring]->SetLineWidth(0);
1095  histSumAntMask[ring]->SetFillColor(kGray);
1096  histSumAntMask[ring]->SetFillStyle(3001);
1097  }
1098 
1099  histSumPhiMask->SetLineWidth(0);
1100  histSumPhiMask->SetFillColor(kGray);
1101  histSumPhiMask->SetFillStyle(3001);
1102 
1103  for(int i=0;i<6;i++) {
1104  TPad* paddy = (TPad*)plotPad->cd(i+1);
1105  // if(i==4)
1106  paddy->SetBottomMargin(0.12);
1107  if(i==5) {
1108  paddy->SetBottomMargin(0.18);
1109  }
1110  paddy->SetRightMargin(0.05);
1111  histSumTurfRate[i]->SetFillStyle(3001);
1112  histSumTurfRate[i]->SetFillColor(getNiceColour(i));
1113  histSumTurfRate[i]->SetLineColor(getNiceColour(i));
1114  if(i==5)
1115  histSumTurfRate[i]->SetXTitle("Phi Sector");
1116  if(i<2)
1117  histSumTurfRate[i]->SetYTitle("Rate (kHz)");
1118  else
1119  histSumTurfRate[i]->SetYTitle("Rate (Hz)");
1120  histSumTurfRate[i]->SetStats(0);
1121  histSumTurfRate[i]->GetYaxis()->SetNoExponent(1);
1122  histSumTurfRate[i]->GetXaxis()->SetLabelSize(0.08);
1123  histSumTurfRate[i]->GetYaxis()->SetLabelSize(0.08);
1124  histSumTurfRate[i]->GetXaxis()->SetTitleSize(0.12);
1125  histSumTurfRate[i]->GetYaxis()->SetTitleSize(0.12);
1126  histSumTurfRate[i]->GetXaxis()->SetTitleOffset(0.65);
1127  histSumTurfRate[i]->GetYaxis()->SetTitleOffset(0.4);
1128  histSumTurfRate[i]->SetTitle("");
1129  histSumTurfRate[i]->Draw();
1130  if(i<2) {
1131  histSumAntMask[i%2]->Draw("same");
1132  }
1133  texy.DrawTextNDC(0.96,0.5,histTitles[i]);
1134 
1135 
1136  if(i==5)
1137  histSumPhiMask->Draw("same");
1138 
1139  }
1140  plotPad->Update();
1141  if(useCan)
1142  return plotPad;
1143  else
1144  return canTurfRate;
1145 }
1146 
1147 TPad *AnitaRFCanvasMaker::getSumTurfInfoCanvas(SummedTurfRate *sumTurfPtr,TPad *useCan)
1148 {
1149  char textLabel[180];
1150  TPad *topPad;
1151  if(!useCan) {
1152  topPad = new TPad("padTurfInfo","padTurfInfo",0.2,0.9,0.8,1);
1153  topPad->Draw();
1154  }
1155  else {
1156  topPad=useCan;
1157  }
1158  topPad->Clear();
1159  topPad->SetTopMargin(0.05);
1160  topPad->cd();
1161  TPaveText *leftPave = new TPaveText(0.2,0,0.8,0.9);
1162  leftPave->SetBorderSize(0);
1163  leftPave->SetFillColor(0);
1164  leftPave->SetTextAlign(13);
1165  sprintf(textLabel,"Run: %d",sumTurfPtr->run);
1166  TText *runText = leftPave->AddText(textLabel);
1167  runText->SetTextColor(50);
1168  TTimeStamp turfTime((time_t)sumTurfPtr->realTime,0);
1169  sprintf(textLabel,"Time: %s",turfTime.AsString("s"));
1170  TText *timeText = leftPave->AddText(textLabel);
1171  timeText->SetTextColor(1);
1172  sprintf(textLabel,"Num Rates: %d",sumTurfPtr->numRates);
1173  TText *numRatesText = leftPave->AddText(textLabel);
1174  numRatesText->SetTextColor(1);
1175  sprintf(textLabel,"Delta T: %d",sumTurfPtr->deltaT);
1176  TText *deltatText = leftPave->AddText(textLabel);
1177  deltatText->SetTextColor(1);
1178  leftPave->Draw();
1179  return topPad;
1180 }
1181 
1182 
1183 TPad *AnitaRFCanvasMaker::getAvgSurfHkCanvas(AveragedSurfHk *avgSurfPtr, TPad *useCan)
1184 {
1185  static MagicDisplaySurfHkDisplay::MagicDisplaySurfHkDisplay_t lastView=MagicDisplaySurfHkDisplay::kNotAView;
1186  static int lastKelvinView=1;
1187  gStyle->SetOptTitle(0);
1188  TPad *canAvgSurfHk;
1189  TPad *plotPad;
1190  if(!useCan) {
1191  canAvgSurfHk = (TPad*) gROOT->FindObject("canAvgSurfHk");
1192  if(!canAvgSurfHk) {
1193  canAvgSurfHk = new TCanvas("canAvgSurfHk","canAvgSurfHk",1000,600);
1194  }
1195  canAvgSurfHk->Clear();
1196  canAvgSurfHk->SetTopMargin(0);
1197  plotPad = new TPad("canAvgSurfHkMain","canAvgSurfHkMain",0,0,1,0.9);
1198  plotPad->Draw();
1199  }
1200  else {
1201  plotPad=useCan;
1202  }
1203  plotPad->cd();
1204  // std::cout << fAvgSurfPhiView << "\t" << lastView << std::endl;
1205  if(fAvgSurfDisplay!=lastView || lastKelvinView!=fAvgSurfKelvinView) {
1206  plotPad->Clear();
1207  avgSurfHkFramey[0]=0;
1208  avgSurfHkFramey[1]=0;
1209  avgSurfHkFramey[2]=0;
1210  }
1211  lastView=fAvgSurfDisplay;
1212  lastKelvinView=fAvgSurfKelvinView;
1213 
1214 
1215  if(fAvgSurfDisplay==MagicDisplaySurfHkDisplay::kPhiView)
1216  getAvgSurfHkPhiCanvas(avgSurfPtr,plotPad);
1217  else if(fAvgSurfDisplay==MagicDisplaySurfHkDisplay::kSurfView)
1218  getAvgSurfHkSurfCanvas(avgSurfPtr,plotPad);
1219  if(useCan)
1220  return plotPad;
1221  else
1222  return canAvgSurfHk;
1223 }
1224 
1225 void AnitaRFCanvasMaker::getAvgSurfHkSurfCanvas(AveragedSurfHk *avgSurfPtr,TPad *plotPad) {
1226  // plotPad->Clear();
1227 
1228  char actualName[180];
1229  const char *histNames[3]={"histAvgScaler","histAvgThreshold","histAvgRFPower"};
1230  const char *histTitles[3]={"Scaler","Threshold","RF Power"};
1231 
1232  if(histAvgSurfBadThreshold)
1233  delete histAvgSurfBadThreshold;
1234  // histAvgSurfBadThreshold->Reset();
1235  // else
1236  histAvgSurfBadThreshold = new TH1D("histAvgSurfBadThreshold","histAvgSurfBadThreshold",
1237  ACTIVE_SURFS*SCALERS_PER_SURF,-0.5,
1238  (ACTIVE_SURFS*SCALERS_PER_SURF)-0.5);
1239  if(histAvgSurfBandMask)
1240  delete histAvgSurfBandMask;
1241  // histAvgSurfBandMask->Reset();
1242  // else
1243  histAvgSurfBandMask = new TH1D("histAvgSurfBandMask","histAvgSurfBandMask",
1244  ACTIVE_SURFS*SCALERS_PER_SURF,-0.5,
1245  (ACTIVE_SURFS*SCALERS_PER_SURF)-0.5);
1246  Int_t maskedBands[ACTIVE_SURFS*SCALERS_PER_SURF]={0};
1247 
1248  for(int i=0;i<3;i++) {
1249  if(histAvgSurfHkStack[i])
1250  delete histAvgSurfHkStack[i];
1251  histAvgSurfHkStack[i] = new THStack(histNames[i],histTitles[i]);
1252  sprintf(actualName,"%s_base",histNames[i]);
1253 
1254 
1255  for(int surf=0;surf<ACTIVE_SURFS;surf++){
1256  if(histAvgSurfHk[i][surf]) {
1257  delete histAvgSurfHk[i][surf];
1258  // histAvgSurfHk[i][surf]->Reset();
1259  }
1260  // else {
1261  sprintf(actualName,"%s_%d",histNames[i],surf);
1262  if(i<2) {
1263  histAvgSurfHk[i][surf]= new TH1D(actualName,histTitles[i],
1264  ACTIVE_SURFS*SCALERS_PER_SURF,-0.5,
1265  (ACTIVE_SURFS*SCALERS_PER_SURF)-0.5);
1266  }
1267  else {
1268  histAvgSurfHk[i][surf]= new TH1D(actualName,histTitles[i],
1269  ACTIVE_SURFS*RFCHAN_PER_SURF,-0.5,
1270  (ACTIVE_SURFS*RFCHAN_PER_SURF)-0.5);
1271  }
1272 
1273  }
1274  }
1275 
1276  Float_t maxVals[3]={0};
1277 
1278  for(int surf=0;surf<ACTIVE_SURFS;surf++) {
1279  for(int scl=0;scl<SCALERS_PER_SURF;scl++) {
1280  // maskedBands[scl+surf*SCALERS_PER_SURF]=
1281  // avgSurfPtr->isBandMasked(surf,scl);
1282 
1283  histAvgSurfHk[0][surf]->Fill(scl+surf*SCALERS_PER_SURF,
1284  avgSurfPtr->avgScaler[surf][scl]);
1285 
1286  Float_t error1=0;
1287  Float_t error2=0;
1288  if(avgSurfPtr->numHks>0) {
1289  error1=avgSurfPtr->rmsScaler[surf][scl];
1290  error2=avgSurfPtr->rmsThresh[surf][scl];
1291  }
1292  // std::cout << error1 << "\t" << error2 << "\n";
1293  histAvgSurfHk[0][surf]->SetBinError(1+scl+surf*SCALERS_PER_SURF,
1294  error1);
1295  histAvgSurfHk[1][surf]->Fill(scl+surf*SCALERS_PER_SURF,
1296  avgSurfPtr->avgThresh[surf][scl]);
1297  histAvgSurfHk[1][surf]->SetBinError(1+scl+surf*SCALERS_PER_SURF,
1298  error2);
1299 
1300  if(maxVals[0]<avgSurfPtr->avgScaler[surf][scl]+error1)
1301  maxVals[0]=avgSurfPtr->avgScaler[surf][scl]+error1;
1302  if(maxVals[1]<avgSurfPtr->avgThresh[surf][scl]+error2)
1303  maxVals[1]=avgSurfPtr->avgThresh[surf][scl]+error2;
1304 
1305 
1306  }
1307  for(int chan=0;chan<RFCHAN_PER_SURF;chan++) {
1308  Float_t error=0;
1309  if(avgSurfPtr->numHks>0) {
1310  if(fAvgSurfKelvinView==1) {
1311  error=avgSurfPtr->getRMSRFPowerInK(surf,chan);
1312  }
1313  else {
1314  error=avgSurfPtr->rmsRFPower[surf][chan];
1315  }
1316  }
1317  if(fAvgSurfKelvinView==1) {
1318  Double_t val=avgSurfPtr->getRFPowerInK(surf,chan);
1319  histAvgSurfHk[2][surf]->Fill(chan+surf*RFCHAN_PER_SURF,val);
1320  if(maxVals[2]<val+error)
1321  maxVals[2]=val+error;
1322  }
1323  else {
1324  histAvgSurfHk[2][surf]->Fill(chan+surf*RFCHAN_PER_SURF,
1325  avgSurfPtr->avgRFPower[surf][chan]);
1326  if(maxVals[2]<avgSurfPtr->avgRFPower[surf][chan]+error)
1327  maxVals[2]=avgSurfPtr->avgRFPower[surf][chan]+error;
1328  }
1329  histAvgSurfHk[2][surf]->SetBinError(1+chan+surf*RFCHAN_PER_SURF,
1330  error);
1331  }
1332  histAvgSurfHk[0][surf]->SetFillColor(getNiceColour(surf%2));
1333  histAvgSurfHk[1][surf]->SetFillColor(getNiceColour(surf%2));
1334  histAvgSurfHk[2][surf]->SetFillColor(getNiceColour(surf%2));
1335  // histAvgSurfHk[0][surf]->SetLineColor(getNiceColour(surf%2));
1336  // histAvgSurfHk[1][surf]->SetLineColor(getNiceColour(surf%2));
1337  // histAvgSurfHk[2][surf]->SetLineColor(getNiceColour(surf%2));
1338  histAvgSurfHkStack[0]->Add(histAvgSurfHk[0][surf]);
1339  histAvgSurfHkStack[1]->Add(histAvgSurfHk[1][surf]);
1340  histAvgSurfHkStack[2]->Add(histAvgSurfHk[2][surf]);
1341  }
1342  histAvgSurfBadThreshold->SetFillColor(kRed+1);
1343  histAvgSurfHkStack[1]->Add(histAvgSurfBadThreshold);
1344 
1345 
1346  if(!plotPad->cd(3)) {
1347  plotPad->Clear();
1348  avgSurfHkFramey[0]=0;
1349  avgSurfHkFramey[1]=0;
1350  avgSurfHkFramey[2]=0;
1351  plotPad->SetRightMargin(0.0);
1352  plotPad->SetLeftMargin(0.1);
1353  plotPad->SetTopMargin(0.05);
1354  plotPad->SetBottomMargin(0.0);
1355  plotPad->Divide(1,3,0,0);
1356  }
1357 
1358  TLatex texy;
1359  texy.SetTextAlign(21);
1360  texy.SetTextAngle(270);
1361  texy.SetTextSize(0.17);
1362 
1363 
1364 
1365  for(int i=0;i<3;i++) {
1366  // Double_t maxVal=histAvgSurfHkStack[i]->GetMaximum("nostack");
1367  Double_t maxVal=maxVals[i];
1368  TPad* paddy = (TPad*)plotPad->cd(i+1);
1369  if(!avgSurfHkFramey[i]) {
1370  paddy->SetBottomMargin(0.15);
1371  paddy->Clear();
1372  paddy->SetBottomMargin(0.18);
1373  paddy->SetRightMargin(0.05);
1374 
1375  if(i<2) {
1376  avgSurfHkFramey[i]=paddy->DrawFrame(0,0,ACTIVE_SURFS*SCALERS_PER_SURF,maxVal*1.05);
1377  }
1378  else {
1379  avgSurfHkFramey[i]=paddy->DrawFrame(0,0,ACTIVE_SURFS*RFCHAN_PER_SURF,maxVal*1.05);
1380  }
1381 
1382 
1383 
1384 
1385  if(i==0)
1386  avgSurfHkFramey[i]->GetYaxis()->SetTitle("Rate (kHz)");
1387  if(i==1)
1388  avgSurfHkFramey[i]->GetYaxis()->SetTitle("Threshold (DAC)");
1389  if(i==2) {
1390  if(fAvgSurfKelvinView) {
1391  avgSurfHkFramey[i]->GetYaxis()->SetTitle("RF Power (K)");
1392  }
1393  else {
1394  avgSurfHkFramey[i]->GetYaxis()->SetTitle("RF Power (ADC)");
1395  }
1396  }
1397  avgSurfHkFramey[i]->GetXaxis()->SetTitle("Logical Channel");
1398  avgSurfHkFramey[i]->GetYaxis()->SetNoExponent(1);
1399  avgSurfHkFramey[i]->GetXaxis()->SetLabelSize(0.08);
1400  avgSurfHkFramey[i]->GetYaxis()->SetLabelSize(0.08);
1401  avgSurfHkFramey[i]->GetXaxis()->SetTitleSize(0.09);
1402  avgSurfHkFramey[i]->GetYaxis()->SetTitleSize(0.09);
1403  avgSurfHkFramey[i]->GetXaxis()->SetTitleOffset(0.8);
1404  avgSurfHkFramey[i]->GetYaxis()->SetTitleOffset(0.6);
1405  avgSurfHkFramey[i]->GetYaxis()->SetTickLength(-0.01);
1406  avgSurfHkFramey[i]->GetYaxis()->SetLabelOffset(0.015);
1407  avgSurfHkFramey[i]->GetXaxis()->SetTickLength(-0.01);
1408  avgSurfHkFramey[i]->GetXaxis()->SetLabelOffset(0.015);
1409  avgSurfHkFramey[i]->SetTitle("");
1410  }
1411  else {
1412  if(!fFixAvgSurfYScale) {
1413  avgSurfHkFramey[i]->GetYaxis()->SetRangeUser(0,maxVal*1.05);
1414  }
1415  gPad->SetLogy(0);
1416  if(fAvgSurfUseLog) {
1417  avgSurfHkFramey[i]->GetYaxis()->SetRangeUser(0.1,maxVal*2);
1418  gPad->SetLogy(1);
1419  }
1420  }
1421  for(int surf=0;surf<ACTIVE_SURFS;surf++) {
1422  histAvgSurfHk[i][surf]->SetMarkerStyle(0);
1423  histAvgSurfHk[i][surf]->Draw("same bar e1");
1424  }
1425  if(i==0) {
1426  maxVal*=1.1;
1427  for(int i=0;i<ACTIVE_SURFS*SCALERS_PER_SURF;i++) {
1428  if(maskedBands[i])
1429  histAvgSurfBandMask->Fill(i,maxVal);
1430  }
1431  histAvgSurfBandMask->SetLineWidth(0);
1432  histAvgSurfBandMask->SetFillColor(kGray);
1433  histAvgSurfBandMask->SetFillStyle(3001);
1434  histAvgSurfBandMask->Draw("same");
1435  }
1436  }
1437  plotPad->Update();
1438 }
1439 
1440 
1441 
1442 void AnitaRFCanvasMaker::getAvgSurfHkPhiCanvas(AveragedSurfHk *avgSurfPtr,TPad *plotPad) {
1443  // plotPad->Clear();
1444  AnitaGeomTool* fARFCGeomTool=AnitaGeomTool::Instance();
1445  char actualName[180];
1446  const char *histNames[3]={"histAvgScalerPhi","histAvgThresholdPhi","histAvgRFPowerPhi"};
1447  const char *histTitles[3]={"Scaler","Threshold","RF Power"};
1448 
1449  if(histAvgSurfBadThreshold)
1450  delete histAvgSurfBadThreshold;
1451  // histAvgSurfBadThreshold->Reset();
1452  // else
1453  histAvgSurfBadThreshold = new TH1D("histAvgSurfBadThreshold","histAvgSurfBadThreshold",
1454  ACTIVE_SURFS*SCALERS_PER_SURF,-0.5,
1455  (ACTIVE_SURFS*SCALERS_PER_SURF)-0.5);
1456  if(histAvgSurfBandMask)
1457  delete histAvgSurfBandMask;
1458  // histAvgSurfBandMask->Reset();
1459  // else
1460  histAvgSurfBandMask = new TH1D("histAvgSurfBandMask","histAvgSurfBandMask",
1461  ACTIVE_SURFS*SCALERS_PER_SURF,-0.5,
1462  (ACTIVE_SURFS*SCALERS_PER_SURF)-0.5);
1463  Int_t maskedBands[ACTIVE_SURFS*SCALERS_PER_SURF]={0};
1464 
1465  for(int i=0;i<3;i++) {
1466  if(histAvgSurfHkPhiStack[i])
1467  delete histAvgSurfHkPhiStack[i];
1468  histAvgSurfHkPhiStack[i] = new THStack(histNames[i],histTitles[i]);
1469  sprintf(actualName,"%s_base",histNames[i]);
1470 
1471 
1472  for(int phi=0;phi<PHI_SECTORS;phi++){
1473  if(histAvgSurfHkPhi[i][phi]) {
1474  delete histAvgSurfHkPhi[i][phi];
1475  // histAvgSurfHkPhi[i][phi]->Reset();
1476  }
1477  // else {
1478  sprintf(actualName,"%s_%d",histNames[i],phi);
1479  if(i<2) {
1480  histAvgSurfHkPhi[i][phi]= new TH1D(actualName,histTitles[i],
1481  ACTIVE_SURFS*SCALERS_PER_SURF,-0.5,
1482  (ACTIVE_SURFS*SCALERS_PER_SURF)-0.5);
1483  }
1484  else {
1485  histAvgSurfHkPhi[i][phi]= new TH1D(actualName,histTitles[i],
1486  3*PHI_SECTORS*2,-0.5,
1487  (3*PHI_SECTORS*2)-0.5);
1488  }
1489 
1490  // }
1491  }
1492  }
1493 
1494  Float_t maxVals[3]={0};
1495 
1496  for(int ring=0;ring<3;ring++) {
1497  for(int phi=0;phi<PHI_SECTORS;phi++) {
1498  if(ring==2) {
1499  if(phi%2)
1500  continue;
1501  }
1502  for(int band=0;band<4;band++) {
1503  Int_t index=band+4*phi+64*ring;
1504  if(ring==2)
1505  index=128 + band+4*(phi/2);
1506  // maskedBands[index]=
1507  // avgSurfPtr->isBandMasked(phi,(AnitaRing::AnitaRing_t)ring,(AnitaBand::AnitaBand_t)band);
1508 
1509  // histAvgSurfHkPhi[0][phi]->Fill(index,avgSurfPtr->getScaler(phi,(AnitaRing::AnitaRing_t)ring,(AnitaBand::AnitaBand_t)band));
1510  // histAvgSurfHkPhi[0][phi]->SetBinError(index+1,avgSurfPtr->getScalerRMS(phi,(AnitaRing::AnitaRing_t)ring,(AnitaBand::AnitaBand_t)band));
1511 
1512  // if(avgSurfPtr->getScaler(phi,(AnitaRing::AnitaRing_t)ring,(AnitaBand::AnitaBand_t)band)>maxVals[0])
1513  // maxVals[0]=avgSurfPtr->getScaler(phi,(AnitaRing::AnitaRing_t)ring,(AnitaBand::AnitaBand_t)band);
1514 
1515  // histAvgSurfHkPhi[1][phi]->Fill(index,avgSurfPtr->getThreshold(phi,(AnitaRing::AnitaRing_t)ring,(AnitaBand::AnitaBand_t)band));
1516  // histAvgSurfHkPhi[1][phi]->SetBinError(index+1,avgSurfPtr->getThresholdRMS(phi,(AnitaRing::AnitaRing_t)ring,(AnitaBand::AnitaBand_t)band));
1517 
1518 
1519  // if(avgSurfPtr->getThreshold(phi,(AnitaRing::AnitaRing_t)ring,(AnitaBand::AnitaBand_t)band)>maxVals[1])
1520  // maxVals[1]=avgSurfPtr->getThreshold(phi,(AnitaRing::AnitaRing_t)ring,(AnitaBand::AnitaBand_t)band);
1521 
1522 
1523  }
1524 
1525  //Now for the RF power
1526  //Argh
1527  for(int pol=0;pol<2;pol++) {
1528  Int_t surf,rfChan;
1529  Int_t chanIndex=
1530  fARFCGeomTool->getChanIndexFromRingPhiPol((AnitaRing::AnitaRing_t)ring,phi,(AnitaPol::AnitaPol_t)pol);
1531  fARFCGeomTool->getSurfChanFromChanIndex(chanIndex,surf,rfChan);
1532  Int_t index=pol + 2 *phi + 32*ring;
1533 
1534  Float_t error=0;
1535  if(avgSurfPtr->numHks>0) {
1536  if(fAvgSurfKelvinView==1) {
1537  error=avgSurfPtr->getRMSRFPowerInK(surf,rfChan);
1538  }
1539  else {
1540  error=avgSurfPtr->rmsRFPower[surf][rfChan];
1541  }
1542  }
1543  if(fAvgSurfKelvinView==1) {
1544  Double_t val=avgSurfPtr->getRFPowerInK(surf,rfChan);
1545  histAvgSurfHkPhi[2][phi]->Fill(index,val);
1546  if(maxVals[2]<val+error)
1547  maxVals[2]=val+error;
1548  }
1549  else {
1550  histAvgSurfHkPhi[2][phi]->Fill(index,
1551  avgSurfPtr->avgRFPower[surf][rfChan]);
1552  if(maxVals[2]<avgSurfPtr->avgRFPower[surf][rfChan]+error)
1553  maxVals[2]=avgSurfPtr->avgRFPower[surf][rfChan]+error;
1554  }
1555  histAvgSurfHkPhi[2][phi]->SetBinError(index+1,
1556  error);
1557  // histAvgSurfHkPhi[2][phi]->Fill(index,
1558  // avgSurfPtr->avgRFPower[surf][rfChan]);
1559 
1560 
1561  }
1562  }
1563  }
1564  for(int phi=0;phi<PHI_SECTORS;phi++) {
1565  histAvgSurfHkPhi[0][phi]->SetFillColor(getNiceColour(phi%8));
1566  histAvgSurfHkPhi[1][phi]->SetFillColor(getNiceColour(phi%8));
1567  histAvgSurfHkPhi[2][phi]->SetFillColor(getNiceColour(phi%8));
1568  histAvgSurfHkPhiStack[0]->Add(histAvgSurfHkPhi[0][phi]);
1569  histAvgSurfHkPhiStack[1]->Add(histAvgSurfHkPhi[1][phi]);
1570  histAvgSurfHkPhiStack[2]->Add(histAvgSurfHkPhi[2][phi]);
1571  }
1572  histAvgSurfBadThreshold->SetFillColor(kRed+1);
1573  histAvgSurfHkPhiStack[1]->Add(histAvgSurfBadThreshold);
1574 
1575 
1576  if(!plotPad->cd(3)) {
1577  plotPad->Clear();
1578  avgSurfHkFramey[0]=0;
1579  avgSurfHkFramey[1]=0;
1580  avgSurfHkFramey[2]=0;
1581  plotPad->SetRightMargin(0.0);
1582  plotPad->SetLeftMargin(0.1);
1583  plotPad->SetTopMargin(0.05);
1584  plotPad->SetBottomMargin(0.0);
1585  plotPad->Divide(1,3,0,0);
1586  }
1587 
1588  TLatex texy;
1589  texy.SetTextAlign(21);
1590  texy.SetTextAngle(270);
1591  texy.SetTextSize(0.17);
1592 
1593 
1594  char label[10];
1595  for(int i=0;i<3;i++) {
1596  // Double_t maxVal=histAvgSurfHkPhiStack[i]->GetMaximum("nostack");
1597  Double_t maxVal=maxVals[i];
1598  TPad* paddy = (TPad*)plotPad->cd(i+1);
1599  if(!avgSurfHkFramey[i]) {
1600  paddy->SetBottomMargin(0.15);
1601  paddy->Clear();
1602  paddy->SetBottomMargin(0.18);
1603  paddy->SetRightMargin(0.05);
1604 
1605  if(i<2) {
1606  avgSurfHkFramey[i]=paddy->DrawFrame(0,0,ACTIVE_SURFS*SCALERS_PER_SURF,maxVal*1.05);
1607  // avgSurfHkFramey[i]->GetXaxis()->SetNdivisions(PHI_SECTORS);
1608  }
1609  else {
1610  avgSurfHkFramey[i]=paddy->DrawFrame(0,0,3*PHI_SECTORS*2,maxVal*1.05);
1611  }
1612 
1613 
1614 
1615 
1616  if(i==0)
1617  avgSurfHkFramey[i]->GetYaxis()->SetTitle("Rate (kHz)");
1618  if(i==1)
1619  avgSurfHkFramey[i]->GetYaxis()->SetTitle("Threshold (DAC)");
1620  if(i==2) {
1621  if(fAvgSurfKelvinView) {
1622  avgSurfHkFramey[i]->GetYaxis()->SetTitle("RF Power (K)");
1623  }
1624  else {
1625  avgSurfHkFramey[i]->GetYaxis()->SetTitle("RF Power (ADC)");
1626  }
1627  }
1628 
1629  avgSurfHkFramey[i]->GetXaxis()->SetTitle("Phi Sector");
1630  if(i<2) {
1631  // avgSurfHkFramey[i]->GetXaxis()->SetNdivisions(-16);
1632  avgSurfHkFramey[i]->SetBins(ACTIVE_SURFS*SCALERS_PER_SURF,-0.5,
1633  (ACTIVE_SURFS*SCALERS_PER_SURF)-0.5);
1634  for(int phi=0;phi<16;phi+=2) {
1635  sprintf(label,"%d",phi+1);
1636  avgSurfHkFramey[i]->GetXaxis()->SetBinLabel(4*phi+2,label);
1637  avgSurfHkFramey[i]->GetXaxis()->SetBinLabel(4*phi+66,label);
1638  if(phi%4==0) {
1639  avgSurfHkFramey[i]->GetXaxis()->SetBinLabel(2*phi+130,label);
1640  }
1641  }
1642 
1643  }
1644  else {
1645  avgSurfHkFramey[i]->SetBins(3*PHI_SECTORS*2,-0.5,
1646  (3*PHI_SECTORS*2)-0.5);
1647  for(int phi=0;phi<16;phi+=2) {
1648  sprintf(label,"%d",phi+1);
1649  avgSurfHkFramey[i]->GetXaxis()->SetBinLabel(2*phi +1,label);
1650  avgSurfHkFramey[i]->GetXaxis()->SetBinLabel(2*phi +33,label);
1651  avgSurfHkFramey[i]->GetXaxis()->SetBinLabel(2*phi +65,label);
1652  }
1653  }
1654 
1655 
1656  avgSurfHkFramey[i]->GetYaxis()->SetNoExponent(1);
1657  avgSurfHkFramey[i]->GetXaxis()->SetLabelSize(0.08);
1658  avgSurfHkFramey[i]->GetYaxis()->SetLabelSize(0.08);
1659  avgSurfHkFramey[i]->GetXaxis()->SetTitleSize(0.09);
1660  avgSurfHkFramey[i]->GetYaxis()->SetTitleSize(0.09);
1661  avgSurfHkFramey[i]->GetXaxis()->SetTitleOffset(0.8);
1662  avgSurfHkFramey[i]->GetYaxis()->SetTitleOffset(0.6);
1663  avgSurfHkFramey[i]->GetYaxis()->SetTickLength(-0.01);
1664  avgSurfHkFramey[i]->GetYaxis()->SetLabelOffset(0.015);
1665  avgSurfHkFramey[i]->GetXaxis()->SetTickLength(-0.01);
1666  avgSurfHkFramey[i]->GetXaxis()->SetLabelOffset(0.015);
1667  avgSurfHkFramey[i]->SetTitle("");
1668  }
1669  else {
1670  if(!fFixAvgSurfYScale) {
1671  avgSurfHkFramey[i]->GetYaxis()->SetRangeUser(0,maxVal*1.05);
1672  }
1673  gPad->SetLogy(0);
1674  if(fAvgSurfUseLog) {
1675  avgSurfHkFramey[i]->GetYaxis()->SetRangeUser(0.1,maxVal*2);
1676  gPad->SetLogy(1);
1677  }
1678  }
1679  for(int phi=0;phi<PHI_SECTORS;phi++) {
1680  histAvgSurfHkPhi[i][phi]->SetMarkerStyle(0);
1681  histAvgSurfHkPhi[i][phi]->Draw("same bar e1");
1682  }
1683  if(i==0) {
1684  maxVal*=1.1;
1685  for(int i=0;i<ACTIVE_SURFS*SCALERS_PER_SURF;i++) {
1686  if(maskedBands[i])
1687  histAvgSurfBandMask->Fill(i,maxVal);
1688  }
1689  histAvgSurfBandMask->SetLineWidth(0);
1690  histAvgSurfBandMask->SetFillColor(kGray);
1691  histAvgSurfBandMask->SetFillStyle(3001);
1692  histAvgSurfBandMask->Draw("same");
1693  }
1694  }
1695 
1696 
1697 
1698 
1699  plotPad->Update();
1700 }
1701 
1702 TPad *AnitaRFCanvasMaker::getAvgSurfInfoCanvas(AveragedSurfHk *avgSurfPtr,TPad *useCan)
1703 {
1704  char textLabel[180];
1705  TPad *topPad;
1706  if(!useCan) {
1707  topPad = new TPad("padAvgSurfInfo","padAvgSurfInfo",0.2,0.9,0.8,1);
1708  topPad->Draw();
1709  }
1710  else {
1711  topPad=useCan;
1712  }
1713  topPad->Clear();
1714  topPad->SetTopMargin(0.05);
1715  topPad->Divide(2,1);
1716  topPad->cd(1);
1717  TPaveText *leftPave = new TPaveText(0.05,0,0.95,0.9);
1718  leftPave->SetBorderSize(0);
1719  leftPave->SetFillColor(0);
1720  leftPave->SetTextAlign(13);
1721  sprintf(textLabel,"Run: %d",avgSurfPtr->run);
1722  TText *runText = leftPave->AddText(textLabel);
1723  runText->SetTextColor(50);
1724  TTimeStamp avgSurfTime((time_t)avgSurfPtr->realTime,0);
1725  sprintf(textLabel,"Time: %s",avgSurfTime.AsString("s"));
1726  TText *timeText = leftPave->AddText(textLabel);
1727  timeText->SetTextColor(1);
1728  sprintf(textLabel,"Num Hks: %d",avgSurfPtr->numHks);
1729  leftPave->AddText(textLabel);
1730  sprintf(textLabel,"Delta T: %d",avgSurfPtr->deltaT);
1731  leftPave->AddText(textLabel);
1732  leftPave->Draw();
1733 
1734  topPad->cd(2);
1735  TPaveText *rightPave = new TPaveText(0.05,0,0.95,0.9);
1736  rightPave->SetBorderSize(0);
1737  rightPave->SetFillColor(0);
1738  rightPave->SetTextAlign(13);
1739  sprintf(textLabel,"Global: %d",avgSurfPtr->globalThreshold);
1740  TText *globalText = rightPave->AddText(textLabel);
1741  globalText->SetTextColor(1);
1742  sprintf(textLabel,"Goal Rates: (%d %d %d) kHz",
1743  avgSurfPtr->scalerGoals[0],avgSurfPtr->scalerGoals[1],
1744  avgSurfPtr->scalerGoals[2]);
1745  TText *goalText = rightPave->AddText(textLabel);
1746  goalText->SetTextColor(1);
1747  sprintf(textLabel,"Had Error: %#x (%d)",avgSurfPtr->hadError,avgSurfPtr->hadError);
1748  TText *errorText = rightPave->AddText(textLabel);
1749  errorText->SetTextColor(1);
1750  rightPave->Draw();
1751  return topPad;
1752 
1753 }
1754 
1755 void AnitaRFCanvasMaker::addToTimePlots(SurfHk *surfPtr) {
1756  // std::cout <<fNumSurfHks << "\n";
1757  if(fNumSurfHks<MAX_SURF_HK_TIME_POINTS) {
1758  for(int surf=0;surf<TRIGGER_SURFS;surf++) {
1759  // for(int l2=0;l2<L2S_PER_SURF;l2++) {
1760  // fL2ScalerVals[surf][l2][fNumSurfHks]=surfPtr->getL2ScalerFromSurfChan(surf,l2);
1761  // }
1762  // for(int l1=0;l1<L1S_PER_SURF;l1++) {
1763  // fL1ScalerVals[surf][l1][fNumSurfHks]=surfPtr->getL1ScalerFromSurfChan(surf,l1);
1764  // }
1765  // for(int scl=0;scl<SCALERS_PER_SURF;scl++) {
1766  // fScalerVals[surf][scl][fNumSurfHks]=surfPtr->getScalerFromSurfChan(surf,scl);
1767  // fThreshVals[surf][scl][fNumSurfHks]=surfPtr->getThresholdFromSurfChan(surf,scl);
1768  // }
1769  // for(int chan=0;chan<RFCHAN_PER_SURF;chan++) {
1770  // fRfPowVals[surf][chan][fNumSurfHks]=surfPtr->getRFPowerInK(surf,chan);
1771  // }
1772  }
1773  fTimeVals[fNumSurfHks]=surfPtr->realTime+Double_t(1e-6*surfPtr->payloadTimeUs);
1774  }
1775  else {
1776  for(int surf=0;surf<TRIGGER_SURFS;surf++) {
1777  for(int l2=0;l2<L2S_PER_SURF;l2++) {
1778  memmove(&fL2ScalerVals[surf][l2][0],&fL2ScalerVals[surf][l2][1],sizeof(Double_t)*(MAX_SURF_HK_TIME_POINTS-1));
1779  // fL2ScalerVals[surf][l2][fNumSurfHks]=surfPtr->getL2ScalerFromSurfChan(surf,l2);
1780  }
1781  for(int l1=0;l1<L1S_PER_SURF;l1++) {
1782  memmove(&fL1ScalerVals[surf][l1][0],&fL1ScalerVals[surf][l1][1],sizeof(Double_t)*(MAX_SURF_HK_TIME_POINTS-1));
1783  // fL1ScalerVals[surf][l1][fNumSurfHks]=surfPtr->getL1ScalerFromSurfChan(surf,l1);
1784  }
1785  for(int scl=0;scl<SCALERS_PER_SURF;scl++) {
1786  memmove(&fScalerVals[surf][scl][0],&fScalerVals[surf][scl][1],sizeof(Double_t)*(MAX_SURF_HK_TIME_POINTS-1));
1787  memmove(&fThreshVals[surf][scl][0],&fThreshVals[surf][scl][1],sizeof(Double_t)*(MAX_SURF_HK_TIME_POINTS-1));
1788  fScalerVals[surf][scl][MAX_SURF_HK_TIME_POINTS-1]=surfPtr->scaler[surf][scl];
1789  fThreshVals[surf][scl][MAX_SURF_HK_TIME_POINTS-1]=surfPtr->threshold[surf][scl];
1790  }
1791  for(int chan=0;chan<RFCHAN_PER_SURF;chan++) {
1792  memmove(&fRfPowVals[surf][chan][0],&fRfPowVals[surf][chan][1],sizeof(Double_t)*(MAX_SURF_HK_TIME_POINTS-1));
1793  fRfPowVals[surf][chan][MAX_SURF_HK_TIME_POINTS-1]=surfPtr->getRFPowerInK(surf,chan);
1794  }
1795  }
1796  memmove(&fTimeVals[0],&fTimeVals[1],sizeof(Double_t)*(MAX_SURF_HK_TIME_POINTS-1));
1797  fTimeVals[MAX_SURF_HK_TIME_POINTS-1]=surfPtr->realTime;
1798  }
1799  fNumSurfHks++;
1800 }
AveragedSurfHk::getRMSRFPowerInK
Double_t getRMSRFPowerInK(int surf, int chan)
Returns the pseudo-calibrated RF power in K.
Definition: AveragedSurfHk.cxx:327
AnitaRFCanvasMaker::AnitaRFCanvasMaker
AnitaRFCanvasMaker()
Constructor.
Definition: AnitaRFCanvasMaker.cxx:78
SummedTurfRate::realTime
UInt_t realTime
Time in unixTime.
Definition: SummedTurfRate.h:33
SurfHk::scalerGoals
UShort_t scalerGoals[4]
Scaler goal for each ring, only use 3.
Definition: SurfHk.h:59
TurfRate::run
Int_t run
Run number, assigned offline.
Definition: TurfRate.h:38
AveragedSurfHk::rmsThresh
UShort_t rmsThresh[12][12]
The rms threhsold value per channel.
Definition: AveragedSurfHk.h:50
TurfRate::phiTrigMask
UShort_t phiTrigMask
Which phi sectors are masked off (VPol only in A3)?
Definition: TurfRate.h:56
AnitaRFCanvasMaker::fSumTurfL2Max
Int_t fSumTurfL2Max
Maximum summed TURF L2.
Definition: AnitaRFCanvasMaker.h:67
AveragedSurfHk::avgThresh
UShort_t avgThresh[12][12]
The mean threshold value per channel.
Definition: AveragedSurfHk.h:49
AnitaRFCanvasMaker::getSurfHkSurfCanvas
void getSurfHkSurfCanvas(SurfHk *surfPtr, TPad *plotPad)
Worker function.
Definition: AnitaRFCanvasMaker.cxx:364
AnitaRFCanvasMaker::getTurfInfoCanvas
TPad * getTurfInfoCanvas(TurfRate *turfPtr, TPad *useCan)
Returns the TurfRate info canvas, the canvas can be provided in useCan
Definition: AnitaRFCanvasMaker.cxx:286
AnitaRFCanvasMaker::fFixAvgSurfYScale
Int_t fFixAvgSurfYScale
Fixed or autoscaling averaged SURF.
Definition: AnitaRFCanvasMaker.h:83
AnitaRFCanvasMaker::getSurfHkTimeCanvas
void getSurfHkTimeCanvas(TPad *plotPad)
Worker function.
Definition: AnitaRFCanvasMaker.cxx:745
AnitaRFCanvasMaker::getAvgSurfHkSurfCanvas
void getAvgSurfHkSurfCanvas(AveragedSurfHk *avgSurfPtr, TPad *plotPad)
Worker function.
Definition: AnitaRFCanvasMaker.cxx:1225
AnitaRFCanvasMaker::fSumTurfL3Min
Int_t fSumTurfL3Min
Minimum summed TURF L3.
Definition: AnitaRFCanvasMaker.h:70
AnitaRFCanvasMaker::getAvgSurfHkPhiCanvas
void getAvgSurfHkPhiCanvas(AveragedSurfHk *avgSurfPtr, TPad *plotPad)
Worker function.
Definition: AnitaRFCanvasMaker.cxx:1442
AnitaRFCanvasMaker::getAvgSurfInfoCanvas
TPad * getAvgSurfInfoCanvas(AveragedSurfHk *avgSurfPtr, TPad *useCan)
Returns the averaged SURF hk info canvas, the canvas can be provided in useCan
Definition: AnitaRFCanvasMaker.cxx:1702
SurfHk::getThreshold
Int_t getThreshold(int phi, AnitaRing::AnitaRing_t ring, AnitaTrigPol::AnitaTrigPol_t pol)
Returns readback threhsold value for given ring-phi-pol.
Definition: SurfHk.cxx:330
AnitaRFCanvasMaker::getTurfRateCanvas
TPad * getTurfRateCanvas(TurfRate *turfPtr, TPad *useCan=0)
Returns the TurfRate histogram canvas, the canvas can be provided in useCan
Definition: AnitaRFCanvasMaker.cxx:119
AnitaRFCanvasMaker
The SURF and TURF hk display canvas maker.
Definition: AnitaRFCanvasMaker.h:33
AnitaRFCanvasMaker::getSurfHkPhiCanvas
void getSurfHkPhiCanvas(SurfHk *surfPtr, TPad *plotPad)
Worker function.
Definition: AnitaRFCanvasMaker.cxx:542
AveragedSurfHk::rmsScaler
UShort_t rmsScaler[12][12]
The rms scaler value per channel.
Definition: AveragedSurfHk.h:46
AnitaGeomTool::getSurfChanFromChanIndex
static Int_t getSurfChanFromChanIndex(Int_t chanIndex, Int_t &surf, Int_t &chan)
Convert logical index to surf and channel.
Definition: AnitaGeomTool.cxx:788
AnitaGeomTool::getChanIndexFromRingPhiPol
static Int_t getChanIndexFromRingPhiPol(AnitaRing::AnitaRing_t ring, Int_t phi, AnitaPol::AnitaPol_t pol)
Convert ring-phi-pol to logical index.
Definition: AnitaGeomTool.cxx:600
AveragedSurfHk::scalerGoals
UShort_t scalerGoals[3]
The scaler goals for the four bands.
Definition: AveragedSurfHk.h:43
AnitaRFCanvasMaker::Instance
static AnitaRFCanvasMaker * Instance()
Instance generator.
Definition: AnitaRFCanvasMaker.cxx:112
AnitaRFCanvasMaker::getSurfInfoCanvas
TPad * getSurfInfoCanvas(SurfHk *surfPtr, TPad *useCan)
Returns the SURF hk info canvas, the canvas can be provided in useCan
Definition: AnitaRFCanvasMaker.cxx:914
AnitaRFCanvasMaker::~AnitaRFCanvasMaker
~AnitaRFCanvasMaker()
Destructor.
Definition: AnitaRFCanvasMaker.cxx:104
AnitaRFCanvasMaker::fSumTurfL3Max
Int_t fSumTurfL3Max
Maximum summed TURF L3.
Definition: AnitaRFCanvasMaker.h:69
AnitaRFCanvasMaker::fFixTurfYScale
Int_t fFixTurfYScale
Fixed or autoscaling TURF.
Definition: AnitaRFCanvasMaker.h:74
AnitaRFCanvasMaker::fTurfL2Min
Int_t fTurfL2Min
Minimum TURF L2.
Definition: AnitaRFCanvasMaker.h:62
SurfHk::realTime
UInt_t realTime
Time in unixTime.
Definition: SurfHk.h:54
SurfHk::getRawRFPower
Double_t getRawRFPower(int surf, int chan)
Returns the measured adc value of the RF power while masking the top bit (the "phase" bit) ...
Definition: SurfHk.cxx:410
SurfHk::getRFPowerInK
Double_t getRFPowerInK(int surf, int chan)
Returns the pseudo-calibrated RF power in K.
Definition: SurfHk.cxx:381
AnitaRFCanvasMaker::getSumTurfRateCanvas
TPad * getSumTurfRateCanvas(SummedTurfRate *sumTurfPtr, TPad *useCan=0)
Returns the summed TURF rate histogram canvas, the canvas can be provided in useCan ...
Definition: AnitaRFCanvasMaker.cxx:968
TurfRate::realTime
UInt_t realTime
Time in unixTime.
Definition: TurfRate.h:39
SummedTurfRate::deltaT
UShort_t deltaT
Time span of data in seconds.
Definition: SummedTurfRate.h:36
TurfRate::getL3Rate
Int_t getL3Rate(int phi)
Returns l3 rate in phi sector.
Definition: TurfRate.h:79
SurfHk
SurfHk – The raw SURF scaler+threshold data.
Definition: SurfHk.h:24
SurfHk::payloadTimeUs
UInt_t payloadTimeUs
Subsecond time of readout in us.
Definition: SurfHk.h:56
MagicDisplaySurfHkDisplay::MagicDisplaySurfHkDisplay_t
enum MagicDisplaySurfHkDisplay::EMagicDisplaySurfHkDisplay MagicDisplaySurfHkDisplay_t
Enumeration for plot style.
AnitaRFCanvasMaker::fTurfL3Max
Int_t fTurfL3Max
Maximum TURF L3.
Definition: AnitaRFCanvasMaker.h:63
AnitaRFCanvasMaker::fFixSumTurfYScale
Int_t fFixSumTurfYScale
Fixed or autoscaling summed TURF.
Definition: AnitaRFCanvasMaker.h:81
TurfRate::ppsNum
UShort_t ppsNum
ppsNum of data
Definition: TurfRate.h:41
AnitaRing::AnitaRing_t
enum AnitaRing::EAnitaRing AnitaRing_t
Ring enumeration.
SummedTurfRate
SummedTurfRate – The Summed Turf Rate data.
Definition: SummedTurfRate.h:21
AnitaTrigPol::AnitaTrigPol_t
enum AnitaTrigPol::EAnitaTrigPol AnitaTrigPol_t
Polarisation enumeration.
AnitaRFCanvasMaker::fAvgSurfUseLog
Int_t fAvgSurfUseLog
Log or linear?
Definition: AnitaRFCanvasMaker.h:72
AveragedSurfHk::hadError
UInt_t hadError
Flag for errors.
Definition: AveragedSurfHk.h:40
AnitaRFCanvasMaker::fAvgSurfKelvinView
Int_t fAvgSurfKelvinView
ADC or Kelvin view.
Definition: AnitaRFCanvasMaker.h:85
SurfHk::getL1Scaler
Int_t getL1Scaler(int phi, AnitaPol::AnitaPol_t pol, AnitaRing::AnitaRing_t ring)
Returns the L1 scaler value for given phi-ring-pol.
Definition: SurfHk.cxx:291
SurfHk::globalThreshold
UShort_t globalThreshold
Global threshold if set.
Definition: SurfHk.h:57
AveragedSurfHk::rmsRFPower
UShort_t rmsRFPower[12][8]
The rms RF power value per channel.
Definition: AveragedSurfHk.h:53
SummedTurfRate::run
Int_t run
Run number, assigned offline.
Definition: SummedTurfRate.h:32
AnitaRFCanvasMaker::fTurfL2Max
Int_t fTurfL2Max
Maximum TURF L2.
Definition: AnitaRFCanvasMaker.h:61
SummedTurfRate::getL3Rate
Int_t getL3Rate(int phi, AnitaPol::AnitaPol_t pol=AnitaPol::kVertical)
Definition: SummedTurfRate.h:66
AnitaRFCanvasMaker::fTurfL3Min
Int_t fTurfL3Min
Minimum TURF L3.
Definition: AnitaRFCanvasMaker.h:64
AveragedSurfHk::avgRFPower
UShort_t avgRFPower[12][8]
The mean RF power value per channel.
Definition: AveragedSurfHk.h:52
AnitaRFCanvasMaker::getSurfHkCanvas
TPad * getSurfHkCanvas(SurfHk *surfPtr, TPad *useCan=0)
Returns the SURF hk histogram canvas, the canvas can be provided in useCan
Definition: AnitaRFCanvasMaker.cxx:318
AnitaRFCanvasMaker::fSurfUseLog
Int_t fSurfUseLog
Log or linear?
Definition: AnitaRFCanvasMaker.h:71
SurfHk::scaler
UShort_t scaler[12][16]
Scaler values, multiple by 1000 to get Hz.
Definition: SurfHk.h:62
AveragedSurfHk::numHks
UShort_t numHks
Number of SURF Hk reads that are included in average.
Definition: AveragedSurfHk.h:38
SurfHk::errorFlag
UShort_t errorFlag
Error flag.
Definition: SurfHk.h:58
SurfHk::isMasked
Int_t isMasked(int phi, AnitaRing::AnitaRing_t ring, AnitaTrigPol::AnitaTrigPol_t pol)
Returns 1 if given phi-ring-pol is masked.
Definition: SurfHk.cxx:350
AveragedSurfHk::deltaT
UShort_t deltaT
Time span of the averaging.
Definition: AveragedSurfHk.h:39
AveragedSurfHk::getRFPowerInK
Double_t getRFPowerInK(int surf, int chan)
Returns the pseudo-calibrated RF power in K.
Definition: AveragedSurfHk.cxx:310
AnitaRFCanvasMaker::fgInstance
static AnitaRFCanvasMaker * fgInstance
Protect against multiple instances.
Definition: AnitaRFCanvasMaker.h:91
AnitaRFCanvasMaker::getSumTurfInfoCanvas
TPad * getSumTurfInfoCanvas(SummedTurfRate *sumTurfPtr, TPad *useCan)
Returns the summed TURF Rate info canvas, the canvas can be provided in useCan
Definition: AnitaRFCanvasMaker.cxx:1147
AnitaRFCanvasMaker::fSumTurfL1Max
Int_t fSumTurfL1Max
Maximum summed TURF L1.
Definition: AnitaRFCanvasMaker.h:65
AveragedSurfHk::run
Int_t run
Assigned offline.
Definition: AveragedSurfHk.h:35
TurfRate
TurfRate – The Turf Rate data.
Definition: TurfRate.h:21
AnitaRFCanvasMaker::fFixSurfYScale
Int_t fFixSurfYScale
Fixed or autoscaling SURF.
Definition: AnitaRFCanvasMaker.h:75
AveragedSurfHk::globalThreshold
UShort_t globalThreshold
Global trheshold (if in global threshold mode)
Definition: AveragedSurfHk.h:41
AnitaRFCanvasMaker::fTurfL1Min
Int_t fTurfL1Min
Minimum TURF L1.
Definition: AnitaRFCanvasMaker.h:60
SurfHk::getScaler
Int_t getScaler(int phi, AnitaRing::AnitaRing_t ring, AnitaTrigPol::AnitaTrigPol_t pol)
Returns scaler value for given ring-phi-pol.
Definition: SurfHk.cxx:321
SummedTurfRate::numRates
UShort_t numRates
Number of rates in the sum.
Definition: SummedTurfRate.h:35
AnitaRFCanvasMaker::getAvgSurfHkCanvas
TPad * getAvgSurfHkCanvas(AveragedSurfHk *avgSurfPtr, TPad *useCan=0)
Returns the averaged SURF hk histogram canvas, the canvas can be provided in useCan ...
Definition: AnitaRFCanvasMaker.cxx:1183
AnitaRFCanvasMaker::fSumTurfL2Min
Int_t fSumTurfL2Min
Minimum summed TURF L2.
Definition: AnitaRFCanvasMaker.h:68
AnitaRFCanvasMaker::fTurfL1Max
Int_t fTurfL1Max
Maximum TURF L1.
Definition: AnitaRFCanvasMaker.h:59
AnitaRFCanvasMaker::fSumTurfL1Min
Int_t fSumTurfL1Min
Minimum summed TURF L1.
Definition: AnitaRFCanvasMaker.h:66
AveragedSurfHk::realTime
UInt_t realTime
Basically unixTime.
Definition: AveragedSurfHk.h:36
AnitaPol::AnitaPol_t
enum AnitaPol::EAnitaPol AnitaPol_t
Polarisation enumeration.
AnitaGeomTool::Instance
static AnitaGeomTool * Instance(int anita_version=0)
Instance generator. If version_number == 0, uses AnitaVersion::get();.
Definition: AnitaGeomTool.cxx:431
AnitaGeomTool
AnitaGeomTool – The ANITA Geometry Tool.
Definition: AnitaGeomTool.h:48
AnitaRFCanvasMaker::fSurfKelvinView
Int_t fSurfKelvinView
ADC or Kelvin view.
Definition: AnitaRFCanvasMaker.h:79
AveragedSurfHk::avgScaler
UShort_t avgScaler[12][12]
The mean scaler value per channel.
Definition: AveragedSurfHk.h:45
SurfHk::run
Int_t run
Run number from offline.
Definition: SurfHk.h:53
SurfHk::threshold
UShort_t threshold[12][16]
Threshold values in DAC counts.
Definition: SurfHk.h:65
SummedTurfRate::phiTrigMask
UShort_t phiTrigMask
Which phi sectors are masked off?
Definition: SummedTurfRate.h:52
AveragedSurfHk
AveragedSurfHk – The Averaged SURF Housekeeping data.
Definition: AveragedSurfHk.h:23
Generated on Tue Mar 23 2021 12:52:25 for ANITA Software by   doxygen 1.8.14