ATLAS Offline Software
Public Member Functions | Private Member Functions | Private Attributes | List of all members
AFP_NoisyPixelTool Class Reference

#include <AFP_NoisyPixelTool.h>

Inheritance diagram for AFP_NoisyPixelTool:
Collaboration diagram for AFP_NoisyPixelTool:

Public Member Functions

 AFP_NoisyPixelTool ()
 
int Identify (std::shared_ptr< const TH2F > input, std::vector< TH2F > &output) const override
 
std::vector< std::vector< double > > makeFits (std::shared_ptr< const TH2F > input) const
 
void setThreshNoisy (double t)
 
double getThreshNoisy () const
 
void setThreshLeff (double t)
 
double getThreshLeff () const
 
void setSensitivity (double s)
 
double getSensitivity () const
 
void setMethods (const std::vector< std::string > &m)
 
const std::vector< std::string > & getMethods () const
 

Private Member Functions

std::vector< std::pair< int, int > > getLegitPixels (std::shared_ptr< const TH2F > input, const int col_ID, const int row_ID, const std::string &method) const
 
TH2F countInactivePixelsAround (std::shared_ptr< const TH2F > input) const
 
double getNeighbours (std::shared_ptr< const TH2F > input, int row_ID, int col_ID) const
 
std::tuple< TH2F, TH2F, TH2F, TH2F > findLEffAndNoisyPixels (std::shared_ptr< const TH2F > input, const TH2F &inact, const std::string &method) const
 
void filterLEffPixelsAroundNoisy (std::shared_ptr< const TH2F > input, const TH2F &inact, TH2F &fleff, TH2F &fnoisy, TH2F &eleff, TH2F &enoisy, const std::string &method) const
 

Private Attributes

double m_threshNoisy
 
double m_threshLEff
 
double m_sensitivity
 
std::vector< std::string > m_methods
 

Detailed Description

Definition at line 22 of file AFP_NoisyPixelTool.h.

Constructor & Destructor Documentation

◆ AFP_NoisyPixelTool()

AFP_NoisyPixelTool::AFP_NoisyPixelTool ( )
inline

Definition at line 24 of file AFP_NoisyPixelTool.h.

24 : m_threshNoisy(1.4), m_threshLEff(0.6), m_sensitivity(0.0), m_methods({"2_ROW","2_COL"}) {}

Member Function Documentation

◆ countInactivePixelsAround()

TH2F AFP_NoisyPixelTool::countInactivePixelsAround ( std::shared_ptr< const TH2F >  input) const
private

Definition at line 188 of file AFP_NoisyPixelTool.cxx.

189 {
190  TH2F tmp_inact_pix_around(*input);
191  tmp_inact_pix_around.SetName("tmp_inact_pix_around");
192  tmp_inact_pix_around.Reset();
193 
194  for(int col_ID=1; col_ID<=input->GetNbinsY(); col_ID++)
195  {
196  for(int row_ID=1; row_ID<=input->GetNbinsX(); row_ID++)
197  {
198  int inactive_pixels_around=0;
199  auto legit_pixels=getLegitPixels(input, col_ID, row_ID);
200 
201  for(auto legpix : legit_pixels)
202  {
203  if(input->GetBinContent(legpix.first, legpix.second)<1) ++inactive_pixels_around;
204  }
205 
206  tmp_inact_pix_around.SetBinContent(row_ID,col_ID, inactive_pixels_around+0.01);
207  }
208  }
209 
210  return tmp_inact_pix_around;
211 }

◆ filterLEffPixelsAroundNoisy()

void AFP_NoisyPixelTool::filterLEffPixelsAroundNoisy ( std::shared_ptr< const TH2F >  input,
const TH2F &  inact,
TH2F &  fleff,
TH2F &  fnoisy,
TH2F &  eleff,
TH2F &  enoisy,
const std::string &  method 
) const
private

Definition at line 291 of file AFP_NoisyPixelTool.cxx.

292 {
293  for(int col_ID=1; col_ID<=input->GetNbinsY(); col_ID++)
294  {
295  for(int row_ID=1; row_ID<=input->GetNbinsX(); row_ID++)
296  {
297  if(input->GetBinContent(row_ID,col_ID)==0) continue;
298 
299  int inactive_pixels_around=tmp_inact_pix_around.GetBinContent(row_ID, col_ID);
300  int leff_pixels_around=0;
301  auto legit_pixels=getLegitPixels(input, col_ID,row_ID);
302  for(auto legpix : legit_pixels)
303  {
304  if(tmp_found_leff.GetBinContent(legpix.first,legpix.second)>0) leff_pixels_around++;
305  }
306 
307  if(leff_pixels_around!=0 && inactive_pixels_around==0)
308  {
309  //if low eff. pixels around > 0, recalculate avarage
310  double re_av=0.;
311  int npix=0;
312 
313  auto legit_pixels=getLegitPixels(input, col_ID,row_ID, method);
314  for(auto legpix : legit_pixels)
315  {
316  if(tmp_found_leff.GetBinContent(legpix.first,legpix.second)==0)
317  {
318  re_av+=input->GetBinContent(legpix.first,legpix.second);
319  npix++;
320  }
321  }
322 
323  if(npix==0)
324  {
325  re_av=0;
326  for(auto legpix : legit_pixels)
327  {
328  re_av+=input->GetBinContent(legpix.first,legpix.second);
329  }
330 
331  if(re_av/input->GetBinContent(row_ID,col_ID)<1.5 && re_av/input->GetBinContent(row_ID,col_ID)>0.5) re_av=1;
332  }
333  else
334  {
335  re_av/=npix;
336  }
337 
338  double ratio_noisy = m_sensitivity+input->GetBinContent(row_ID,col_ID)/re_av;
339  double ratio_leff = input->GetBinContent(row_ID,col_ID)/re_av;
340  if(re_av==1)
341  {
342  tmp_eff_leff.SetBinContent(row_ID,col_ID,1);
343  tmp_eff_noisy.SetBinContent(row_ID,col_ID,1);
344  }
345 
346  if(row_ID!=input->GetNbinsX() && row_ID!=1 && col_ID!=1 && col_ID!=input->GetNbinsY())
347  {
348  if( ((ratio_noisy>m_threshNoisy && re_av!=1) || re_av==1) )
349  {
350  tmp_found_noisy.SetBinContent(row_ID,col_ID,1);
351  if(re_av!=1) tmp_eff_noisy.SetBinContent(row_ID,col_ID,100.*ratio_noisy);
352  }
353  if( ((ratio_leff<m_threshLEff && re_av!=1) || re_av==1) )
354  {
355  tmp_found_leff.SetBinContent(row_ID,col_ID,1);
356  if(re_av!=1) tmp_eff_leff.SetBinContent(row_ID,col_ID,100.*ratio_leff);
357  }
358  }
359  }
360  }
361  }
362 
363  return;
364 }

◆ findLEffAndNoisyPixels()

std::tuple< TH2F, TH2F, TH2F, TH2F > AFP_NoisyPixelTool::findLEffAndNoisyPixels ( std::shared_ptr< const TH2F >  input,
const TH2F &  inact,
const std::string &  method 
) const
private

Definition at line 222 of file AFP_NoisyPixelTool.cxx.

223 {
224  TH2F tmp_found_leff(*input);
225  tmp_found_leff.SetName("tmp_found_leff");
226  tmp_found_leff.Reset();
227 
228  TH2F tmp_found_noisy(*input);
229  tmp_found_noisy.SetName("tmp_found_noisy");
230  tmp_found_noisy.Reset();
231 
232  TH2F tmp_eff_leff(*input);
233  tmp_eff_leff.SetName("tmp_eff_leff");
234  tmp_eff_leff.Reset();
235 
236  TH2F tmp_eff_noisy(*input);
237  tmp_eff_noisy.SetName("tmp_eff_noisy");
238  tmp_eff_noisy.Reset();
239 
240  for(int col_ID=1; col_ID<=input->GetNbinsY(); col_ID++)
241  {
242  for(int row_ID=1; row_ID<=input->GetNbinsX(); row_ID++)
243  {
244  if(input->GetBinContent(row_ID, col_ID)!=0 && tmp_inact_pix_around.GetBinContent(row_ID, col_ID)<0.1)
245  {
246  double npixels=getNeighbours(input, row_ID, col_ID);
247 
248  double sum=0.;
249  auto legit_pixels=getLegitPixels(input, col_ID, row_ID, method);
250  for(auto legpix : legit_pixels)
251  {
252  sum+=input->GetBinContent(legpix.first,legpix.second);
253  }
254 
255  double av_noisy=0;
256  double av_leff=0;
257 
258  // TODO: something about edges?
259  if(method=="2_ROW" || method=="2_COL")
260  {
261  av_noisy=sum/(std::abs(npixels-4)*0.5);
262  av_leff=sum/2.;
263  }
264  else if(method=="4_PIX")
265  {
266  av_noisy=sum/(std::ceil(npixels*0.5));
267  av_leff=sum/4.;
268  }
269  else if(method=="8_PIX")
270  {
271  av_noisy=sum/(npixels);
272  av_leff=sum/8.;
273  }
274 
275 
276  double ratio_leff = input->GetBinContent(row_ID,col_ID)/av_leff;
277  double ratio_noisy = input->GetBinContent(row_ID,col_ID)/av_noisy;
278  tmp_eff_leff.SetBinContent(row_ID,col_ID,100.*ratio_leff);
279  tmp_eff_noisy.SetBinContent(row_ID,col_ID,100.*ratio_noisy);
280 
281  if(ratio_leff < m_threshLEff) tmp_found_leff.SetBinContent(row_ID,col_ID,1.);
282  if(ratio_noisy > m_threshNoisy) tmp_found_noisy.SetBinContent(row_ID,col_ID,1.);
283  }
284  }
285  }
286 
287  return {tmp_found_leff,tmp_found_noisy,tmp_eff_leff,tmp_eff_noisy};
288 }

◆ getLegitPixels()

std::vector< std::pair< int, int > > AFP_NoisyPixelTool::getLegitPixels ( std::shared_ptr< const TH2F >  input,
const int  col_ID,
const int  row_ID,
const std::string &  method = "8_PIX" 
) const
private

Definition at line 163 of file AFP_NoisyPixelTool.cxx.

164 {
165  // method="8_PIX" means to investigate all pixels around
166 
167  std::vector<std::pair<int,int>> legit_pixels={};
168 
169  for(int r=-1; r<2; r++)
170  {
171  for(int c=-1; c<2; c++)
172  {
173  if( (row_ID+r)>=1 && (col_ID+c)>=1 && (col_ID+c)<=input->GetNbinsY() && (row_ID+r)<=input->GetNbinsX() && (r!=0 || c!=0))
174  {
175  if( (method=="2_ROW" && c==0) || (method=="2_COL" && r==0)
176  || (method=="4_PIX" && (c==0 || r==0)) || (method=="8_PIX") )
177  {
178  legit_pixels.push_back(std::pair<int,int>(row_ID+r,col_ID+c));
179  }
180  }
181  }
182  }
183 
184  return legit_pixels;
185 }

◆ getMethods()

const std::vector<std::string>& AFP_NoisyPixelTool::getMethods ( ) const
inline

Definition at line 40 of file AFP_NoisyPixelTool.h.

40 {return m_methods;}

◆ getNeighbours()

double AFP_NoisyPixelTool::getNeighbours ( std::shared_ptr< const TH2F >  input,
int  row_ID,
int  col_ID 
) const
private

Definition at line 214 of file AFP_NoisyPixelTool.cxx.

215 {
216  if( row_ID!=input->GetNbinsX() && row_ID!=1 && col_ID!=1 && col_ID!=input->GetNbinsY()) return 8.;
217  else if( (row_ID==input->GetNbinsX() || row_ID==1) && (col_ID==1 || col_ID==input->GetNbinsY())) return 3.;
218  else return 5;
219 }

◆ getSensitivity()

double AFP_NoisyPixelTool::getSensitivity ( ) const
inline

Definition at line 37 of file AFP_NoisyPixelTool.h.

37 {return m_sensitivity;}

◆ getThreshLeff()

double AFP_NoisyPixelTool::getThreshLeff ( ) const
inline

Definition at line 34 of file AFP_NoisyPixelTool.h.

34 {return m_threshLEff;}

◆ getThreshNoisy()

double AFP_NoisyPixelTool::getThreshNoisy ( ) const
inline

Definition at line 31 of file AFP_NoisyPixelTool.h.

31 {return m_threshNoisy;}

◆ Identify()

int AFP_NoisyPixelTool::Identify ( std::shared_ptr< const TH2F >  input,
std::vector< TH2F > &  output 
) const
overridevirtual

Implements IAFP_GenericPixelTool.

Definition at line 7 of file AFP_NoisyPixelTool.cxx.

8 {
9  if(output.size()!=1)
10  {
11  return 0;
12  }
13 
14  output.reserve(4);
15 
16  TH2F& template_output = output.at(0);
17  template_output.Reset();
18 
19  TH2F tmp_output1(template_output);
20  tmp_output1.SetNameTitle(Form("leffpixels_found_%s",template_output.GetName()), Form("low efficiency pixels, found, %s", template_output.GetTitle()));
21 
22  TH2F tmp_output2(template_output);
23  tmp_output2.SetNameTitle(Form("noisypixels_eff_%s",template_output.GetName()), Form("noisy pixels, efficiency, %s", template_output.GetTitle()));
24 
25  TH2F tmp_output3(template_output);
26  tmp_output3.SetNameTitle(Form("leffpixels_eff_%s",template_output.GetName()), Form("low efficiency pixels, efficiency, %s", template_output.GetTitle()));
27  TH2F& noisypixels_found_output = output.at(0);
28  noisypixels_found_output.SetNameTitle(Form("noisypixels_found_%s",template_output.GetName()), Form("noisy pixels, found, %s", template_output.GetTitle()));
29 
30  output.push_back(tmp_output1);
31  output.push_back(tmp_output2);
32  output.push_back(tmp_output3);
33 
34  TH2F& leffpixels_found_output = output.at(1);
35  TH2F& noisypixels_eff_output = output.at(2);
36  TH2F& leffpixels_eff_output = output.at(3);
37 
38 
39  if(input->GetMaximum()<0.5) return 0;
40 
41  std::vector<TH2F> vec_found_leff{},vec_found_noisy{},vec_eff_leff{},vec_eff_noisy{};
42 
43  for(const auto& method : m_methods)
44  {
45  TH2F tmp_eff_noisy, tmp_eff_leff;
46  TH2F tmp_found_leff, tmp_found_noisy;
47 
48  if(method!="FIT")
49  {
50  // count inactive pixels around each pixel
51  TH2F tmp_inact_pix_around=countInactivePixelsAround(input);
52 
53  // find low eff. and noisy pixels
54  std::tie(tmp_found_leff,tmp_found_noisy,tmp_eff_leff, tmp_eff_noisy) = findLEffAndNoisyPixels(input, tmp_inact_pix_around, method);
55 
56  // reconsider some pixels
57  filterLEffPixelsAroundNoisy(input, tmp_inact_pix_around, tmp_found_leff,tmp_found_noisy,tmp_eff_leff,tmp_eff_noisy, method);
58  }
59  else
60  {
61  // method is "FIT"
62 
63  tmp_eff_noisy=TH2F(*input);
64  tmp_eff_noisy.SetName("tmp_eff_noisy");
65  tmp_eff_noisy.Reset();
66  tmp_eff_leff=TH2F(*input);
67  tmp_eff_leff.SetName("tmp_eff_leff");
68  tmp_eff_leff.Reset();
69  tmp_found_noisy=TH2F(*input);
70  tmp_found_noisy.SetName("tmp_found_noisy");
71  tmp_found_noisy.Reset();
72  tmp_found_leff=TH2F(*input);
73  tmp_found_leff.SetName("tmp_found_leff");
74  tmp_found_leff.Reset();
75 
76  auto p=makeFits(input);
77 
78  const double Threshold_LEFF=5.;
79  const double Threshold_NOISY=(m_threshNoisy-1)*100;
80 
81  for(int col_ID=1; col_ID<=input->GetNbinsY(); col_ID++)
82  {
83  for(int row_ID=1; row_ID<=input->GetNbinsX(); row_ID++)
84  {
85  double ratio_leff=0, ratio_noisy=0;
86  double gauss_helper_12 = (col_ID-p[1][row_ID])/p[2][row_ID];
87  double gauss_helper_45 = (col_ID-p[4][row_ID])/p[5][row_ID];
88  double fit = p[0][row_ID]*exp(-0.5*gauss_helper_12*gauss_helper_12)
89  + p[3][row_ID]*exp(-0.5*gauss_helper_45*gauss_helper_45) + p[6][row_ID];
90  double sigma=std::sqrt(fit);
91  if(sigma<1) sigma=1;
92 
93  double bin_content=input->GetBinContent(row_ID,col_ID);
94 
95  if(fit>=bin_content) ratio_leff = std::abs(fit-bin_content)/sigma;
96  else ratio_noisy = std::abs(fit-bin_content)/sigma;
97 
98  if(bin_content!=0)
99  {
100  if( ratio_leff > Threshold_LEFF) tmp_found_leff.SetBinContent(row_ID,col_ID,1);
101  if( ratio_noisy > Threshold_NOISY) tmp_found_noisy.SetBinContent(row_ID,col_ID,1);
102  }
103  tmp_eff_leff.SetBinContent(row_ID,col_ID,100.*ratio_leff);
104  tmp_eff_noisy.SetBinContent(row_ID,col_ID,100.*ratio_noisy);
105  }
106  }
107  }
108 
109  // save output for this method
110  vec_found_leff.push_back(tmp_found_leff);
111  vec_found_noisy.push_back(tmp_found_noisy);
112  vec_eff_leff.push_back(tmp_eff_leff);
113  vec_eff_noisy.push_back(tmp_eff_noisy);
114  }
115 
116  // sum found pixels for all methods, set efficiency to the maximum of all methods
117  for(unsigned int m=0; m<m_methods.size(); m++)
118  {
119  for(int col_ID=1; col_ID<=input->GetNbinsY(); col_ID++)
120  {
121  for(int row_ID=1; row_ID<=input->GetNbinsX(); row_ID++)
122  {
123  noisypixels_found_output.Fill(row_ID,col_ID, vec_found_noisy[m].GetBinContent(row_ID,col_ID));
124  leffpixels_found_output.Fill(row_ID,col_ID, vec_found_leff[m].GetBinContent(row_ID,col_ID));
125 
126  if(m==0)
127  {
128  noisypixels_eff_output.SetBinContent(row_ID,col_ID, vec_eff_noisy[m].GetBinContent(row_ID,col_ID));
129  leffpixels_eff_output.SetBinContent(row_ID,col_ID, vec_eff_leff[m].GetBinContent(row_ID,col_ID));
130  }
131  else
132  {
133  if(noisypixels_eff_output.GetBinContent(row_ID,col_ID)<vec_eff_noisy[m].GetBinContent(row_ID,col_ID))
134  {
135  noisypixels_eff_output.SetBinContent(row_ID,col_ID, vec_eff_noisy[m].GetBinContent(row_ID,col_ID));
136  }
137  if(leffpixels_eff_output.GetBinContent(row_ID,col_ID)>vec_eff_leff[m].GetBinContent(row_ID,col_ID))
138  {
139  leffpixels_eff_output.SetBinContent(row_ID,col_ID, vec_eff_leff[m].GetBinContent(row_ID,col_ID));
140  }
141  }
142  }
143  }
144  }
145 
146  // report only pixels that are identified by all methods
147  for(int col_ID=1; col_ID<=input->GetNbinsY(); col_ID++)
148  {
149  for(int row_ID=1; row_ID<=input->GetNbinsX(); row_ID++)
150  {
151  if(noisypixels_found_output.GetBinContent(row_ID,col_ID)==m_methods.size()) noisypixels_found_output.SetBinContent(row_ID,col_ID,1);
152  else noisypixels_found_output.SetBinContent(row_ID,col_ID,0);
153 
154  if(leffpixels_found_output.GetBinContent(row_ID,col_ID)==m_methods.size()) leffpixels_found_output.SetBinContent(row_ID,col_ID,1);
155  else leffpixels_found_output.SetBinContent(row_ID,col_ID,0);
156  }
157  }
158 
159  return 0;
160 }

◆ makeFits()

std::vector< std::vector< double > > AFP_NoisyPixelTool::makeFits ( std::shared_ptr< const TH2F >  input) const

Definition at line 367 of file AFP_NoisyPixelTool.cxx.

368 {
369  const int nParams=7;
370  std::vector<std::vector<double>> params(nParams, std::vector<double>(input->GetNbinsX()+1, 0.));
371 
372  for(int row_ID=0; row_ID<=input->GetNbinsX(); row_ID++)
373  {
374  std::string srow_ID = std::to_string(row_ID);
375  std::unique_ptr<TH1F> hist(new TH1F(("ROW"+srow_ID).c_str(), ("ROW"+srow_ID).c_str(), input->GetNbinsY(), 0.5, input->GetNbinsX()+0.5));
376 
377  for(int col_ID=1; col_ID<=input->GetNbinsY(); col_ID++)
378  {
379  hist->Fill(col_ID, 1.0*input->GetBinContent(row_ID,col_ID));
380  }
381 
382  //Set double gaussian fit with starting parameters
383  std::shared_ptr<TF1> FIT_2(new TF1("gaus","gaus(0)+gaus(3)+[6]",0,input->GetNbinsY(),nParams));
384  if(row_ID==1)
385  {
386  FIT_2->SetParameters(25000,hist->GetMean(),hist->GetStdDev()/std::sqrt(2),
387  5000,hist->GetMean(),hist->GetStdDev()/std::sqrt(2),
388  std::max(hist->GetBinContent(2),std::max(hist->GetBinContent(3),hist->GetBinContent(4))) );
389  }
390  else
391  {
392  for(int par=0;par<nParams;++par)
393  {
394  FIT_2->SetParameter(par,params.at(par).at(row_ID-1));
395  }
396  }
397 
398  //fit
399  hist->Fit(FIT_2.get(),"Q");
400 
401  for(int par=0;par<nParams;++par)
402  {
403  params.at(par).at(row_ID-1)=FIT_2->GetParameter(par);
404  }
405  }
406 
407  return params;
408 }

◆ setMethods()

void AFP_NoisyPixelTool::setMethods ( const std::vector< std::string > &  m)
inline

Definition at line 39 of file AFP_NoisyPixelTool.h.

39 {m_methods=m;}

◆ setSensitivity()

void AFP_NoisyPixelTool::setSensitivity ( double  s)
inline

Definition at line 36 of file AFP_NoisyPixelTool.h.

36 {m_sensitivity=s;}

◆ setThreshLeff()

void AFP_NoisyPixelTool::setThreshLeff ( double  t)
inline

Definition at line 33 of file AFP_NoisyPixelTool.h.

33 {m_threshLEff=t;}

◆ setThreshNoisy()

void AFP_NoisyPixelTool::setThreshNoisy ( double  t)
inline

Definition at line 30 of file AFP_NoisyPixelTool.h.

30 {m_threshNoisy=t;}

Member Data Documentation

◆ m_methods

std::vector<std::string> AFP_NoisyPixelTool::m_methods
private

Definition at line 48 of file AFP_NoisyPixelTool.h.

◆ m_sensitivity

double AFP_NoisyPixelTool::m_sensitivity
private

Definition at line 46 of file AFP_NoisyPixelTool.h.

◆ m_threshLEff

double AFP_NoisyPixelTool::m_threshLEff
private

Definition at line 45 of file AFP_NoisyPixelTool.h.

◆ m_threshNoisy

double AFP_NoisyPixelTool::m_threshNoisy
private

Definition at line 44 of file AFP_NoisyPixelTool.h.

The documentation for this class was generated from the following files:
RunTileTBRec.method
method
Definition: RunTileTBRec.py:73
beamspotman.r
def r
Definition: beamspotman.py:676
pdg_comparison.sigma
sigma
Definition: pdg_comparison.py:324
python.SystemOfUnits.s
int s
Definition: SystemOfUnits.py:131
python.SystemOfUnits.m
int m
Definition: SystemOfUnits.py:91
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
max
#define max(a, b)
Definition: cfImp.cxx:41
TH2F
Definition: rootspy.cxx:420
plotmaker.hist
hist
Definition: plotmaker.py:148
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
drawFromPickle.exp
exp
Definition: drawFromPickle.py:36
python.TrigEgammaMonitorHelper.TH2F
def TH2F(name, title, nxbins, bins_par2, bins_par3, bins_par4, bins_par5=None, bins_par6=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:45
AFP_NoisyPixelTool::getNeighbours
double getNeighbours(std::shared_ptr< const TH2F > input, int row_ID, int col_ID) const
Definition: AFP_NoisyPixelTool.cxx:214
AFP_NoisyPixelTool::makeFits
std::vector< std::vector< double > > makeFits(std::shared_ptr< const TH2F > input) const
Definition: AFP_NoisyPixelTool.cxx:367
convertTimingResiduals.sum
sum
Definition: convertTimingResiduals.py:55
AFP_NoisyPixelTool::getLegitPixels
std::vector< std::pair< int, int > > getLegitPixels(std::shared_ptr< const TH2F > input, const int col_ID, const int row_ID, const std::string &method) const
Definition: AFP_NoisyPixelTool.cxx:163
AFP_NoisyPixelTool::m_threshLEff
double m_threshLEff
Definition: AFP_NoisyPixelTool.h:45
AFP_NoisyPixelTool::findLEffAndNoisyPixels
std::tuple< TH2F, TH2F, TH2F, TH2F > findLEffAndNoisyPixels(std::shared_ptr< const TH2F > input, const TH2F &inact, const std::string &method) const
Definition: AFP_NoisyPixelTool.cxx:222
PlotPulseshapeFromCool.input
input
Definition: PlotPulseshapeFromCool.py:106
AFP_NoisyPixelTool::m_threshNoisy
double m_threshNoisy
Definition: AFP_NoisyPixelTool.h:44
TH2F::GetBinContent
double GetBinContent(int) const
Definition: rootspy.cxx:425
MuonValidation_CreateResolutionProfiles.fit
def fit(h, emin, emax)
Definition: MuonValidation_CreateResolutionProfiles.py:69
TH2F::SetBinContent
void SetBinContent(int, double)
Definition: rootspy.cxx:426
merge.output
output
Definition: merge.py:17
AFP_NoisyPixelTool::m_sensitivity
double m_sensitivity
Definition: AFP_NoisyPixelTool.h:46
createCoolChannelIdFile.par
par
Definition: createCoolChannelIdFile.py:29
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
AFP_NoisyPixelTool::countInactivePixelsAround
TH2F countInactivePixelsAround(std::shared_ptr< const TH2F > input) const
Definition: AFP_NoisyPixelTool.cxx:188
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
PowhegControl_ttFCNC_NLO.params
params
Definition: PowhegControl_ttFCNC_NLO.py:226
python.compressB64.c
def c
Definition: compressB64.py:93
AFP_NoisyPixelTool::m_methods
std::vector< std::string > m_methods
Definition: AFP_NoisyPixelTool.h:48
AFP_NoisyPixelTool::filterLEffPixelsAroundNoisy
void filterLEffPixelsAroundNoisy(std::shared_ptr< const TH2F > input, const TH2F &inact, TH2F &fleff, TH2F &fnoisy, TH2F &eleff, TH2F &enoisy, const std::string &method) const
Definition: AFP_NoisyPixelTool.cxx:291
Generated on Sat Oct 5 2024 21:35:59 for ATLAS Offline Software by   doxygen 1.8.18