ATLAS Offline Software
Public Member Functions | List of all members
dqm_algorithms::BinsDiffFromStripMedian Struct Reference

#include <BinsDiffFromStripMedian.h>

Inheritance diagram for dqm_algorithms::BinsDiffFromStripMedian:
Collaboration diagram for dqm_algorithms::BinsDiffFromStripMedian:

Public Member Functions

 BinsDiffFromStripMedian ()
 
 ~BinsDiffFromStripMedian ()
 
BinsDiffFromStripMedian * clone ()
 
dqm_core::Result * execute (const std::string &, const TObject &, const dqm_core::AlgorithmConfig &)
 
void FindStripMedian (std::vector< double > onestrip, std::vector< double > &stripsMedian)
 
colorcluster MakeCluster (const int r0, const int r2, bin &onebin, std::vector< std::vector< colorbin > > &ColorBinMap)
 
void printDescription (std::ostream &out)
 

Detailed Description

Definition at line 25 of file BinsDiffFromStripMedian.h.

Constructor & Destructor Documentation

◆ BinsDiffFromStripMedian()

dqm_algorithms::BinsDiffFromStripMedian::BinsDiffFromStripMedian ( )

Definition at line 28 of file BinsDiffFromStripMedian.cxx.

29 {
30  dqm_core::AlgorithmManager::instance().registerAlgorithm("BinsDiffFromStripMedian", this);
31 }

◆ ~BinsDiffFromStripMedian()

dqm_algorithms::BinsDiffFromStripMedian::~BinsDiffFromStripMedian ( )

Definition at line 33 of file BinsDiffFromStripMedian.cxx.

34 {
35 }

Member Function Documentation

◆ clone()

dqm_algorithms::BinsDiffFromStripMedian * dqm_algorithms::BinsDiffFromStripMedian::clone ( )

Definition at line 38 of file BinsDiffFromStripMedian.cxx.

39 {
40 
41  return new BinsDiffFromStripMedian();
42 }

◆ execute()

dqm_core::Result * dqm_algorithms::BinsDiffFromStripMedian::execute ( const std::string &  name,
const TObject &  object,
const dqm_core::AlgorithmConfig &  config 
)

Definition at line 46 of file BinsDiffFromStripMedian.cxx.

49 {
50  const TH1* histogram;
51 
52  if( object.IsA()->InheritsFrom( "TH1" ) ) {
53  histogram = static_cast<const TH1*>(&object);
54  if (histogram->GetDimension() > 2 ){
55  throw dqm_core::BadConfig( ERS_HERE, name, "dimension > 2 " );
56  }
57  } else {
58  throw dqm_core::BadConfig( ERS_HERE, name, "does not inherit from TH1" );
59  }
60 
61  const double minstat = dqm_algorithms::tools::GetFirstFromMap( "MinStat", config.getParameters(), -1);
62  const double ignoreval = dqm_algorithms::tools::GetFirstFromMap( "ignoreval", config.getParameters(), -99999);
63  const bool publish = (bool) dqm_algorithms::tools::GetFirstFromMap( "PublishBins", config.getParameters(), 1);
64  const int Nmaxpublish = (int) dqm_algorithms::tools::GetFirstFromMap( "MaxPublish", config.getParameters(), 20);
65  const bool VisualMode = (bool) dqm_algorithms::tools::GetFirstFromMap( "VisualMode", config.getParameters(), 1);
66  const int NpublishRed = (int) dqm_algorithms::tools::GetFirstFromMap( "PublishRedBins",config.getParameters(), 0);
67  const bool ClusterResult = (bool) dqm_algorithms::tools::GetFirstFromMap( "ClusterResult", config.getParameters(), 0);
68  const double suppressFactor = dqm_algorithms::tools::GetFirstFromMap("SuppressFactor", config.getParameters(), 0.05);
69  const double suppressRedFactor = dqm_algorithms::tools::GetFirstFromMap("SuppressRedFactor", config.getParameters(), 0.01);
70  if ( histogram->GetEntries() < minstat ) {
71  dqm_core::Result *result = new dqm_core::Result(dqm_core::Result::Undefined);
72  result->tags_["InsufficientEntries"] = histogram->GetEntries();
73  return result;
74  }
75 
76  double gthreshold;
77  double rthreshold;
78  try {
79  rthreshold = dqm_algorithms::tools::GetFromMap( "MaxDeviation", config.getRedThresholds() );
80  gthreshold = dqm_algorithms::tools::GetFromMap( "MaxDeviation", config.getGreenThresholds() );
81  }
82  catch( dqm_core::Exception & ex ) {
83  throw dqm_core::BadConfig( ERS_HERE, name, ex.what(), ex );
84  }
85 
86  std::vector<int> range=dqm_algorithms::tools::GetBinRange(histogram, config.getParameters());
87  std::vector<double> stripsMedian;
88  std::vector<double> stripsAvg;
89  std::vector<double> stripsVariance;
90  double maxInMap=0;
91  for ( int i = range[0]; i <= range[1]; ++i ) {
92  std::vector<double> onestrip;
93  double stripSum=0;
94  for ( int j = range[2]; j <= range[3]; ++j ) {
95  if (histogram->GetBinContent(i,j) == ignoreval) continue;
96  float binvalue = histogram->GetBinContent(i,j);
97  onestrip.push_back(binvalue);
98  stripSum += binvalue;
99  if(binvalue > maxInMap) {
100  maxInMap = binvalue;
101  }
102  }
103  stripsAvg.push_back(stripSum/onestrip.size());
104  FindStripMedian(std::move(onestrip),stripsMedian);
105  }
106  for ( int i = range[0]; i <= range[1]; ++i ) {
107  float sumdiff2=0;
108  int counter=0;
109  for ( int j = range[2]; j <= range[3]; ++j ) {
110  if (histogram->GetBinContent(i,j) == ignoreval) continue;
111  double binvalue = histogram->GetBinContent(i,j);
112  double diff=binvalue-stripsAvg[i-range[0]];
113  sumdiff2 +=std::pow(diff,2);
114  counter++;
115  }
116  double variance=-1;
117  if(counter!=0) variance = sumdiff2 / counter ;
118  stripsVariance.push_back(variance);
119  }
120  dqm_core::Result* result = new dqm_core::Result();
121  std::vector<bin> redbins;
122  std::vector<bin> yellowbins;
123  std::vector<bin> Allbins;
124  for ( int k = range[0]; k <= range[1]; ++k ) {
125  for ( int l = range[2]; l <= range[3]; ++l ) {
126  double binvalue = histogram->GetBinContent(k,l);
127  if (binvalue== ignoreval) continue;
128  double strip_median = stripsMedian[k-range[0]];
129  if(stripsMedian[k-range[0]]==0 && stripsVariance[k-range[0]]==0) continue; // skip empty strip
130  else if(stripsMedian[k-range[0]]==0 && stripsVariance[k-range[0]]!=0 && stripsAvg[k-range[0]]!=0) strip_median = stripsAvg[k-range[0]];
131  else if(stripsMedian[k-range[0]]==0 && stripsVariance[k-range[0]]!=0 && stripsAvg[k-range[0]]==0) continue;
132  double outstandingRatio=0;
133  if(std::abs(strip_median) > 0.00001 ) outstandingRatio= (binvalue-strip_median)/std::sqrt(std::abs(strip_median));
134  else continue;
135  double eta = histogram->GetXaxis()->GetBinCenter(k);
136  double phi = histogram->GetYaxis()->GetBinCenter(l);
137  bin onebin = {eta,phi,k,l,binvalue,outstandingRatio};
138  Allbins.push_back(onebin);
139  if (maxInMap == 0) continue;
140  if(std::abs(outstandingRatio) > rthreshold ) {
141  if( VisualMode && (binvalue / maxInMap < suppressRedFactor) )
142  continue;
143  redbins.push_back(onebin);
144  }
145  else if(std::abs(outstandingRatio) > gthreshold ){
146  if( VisualMode && (binvalue / maxInMap < suppressFactor) )
147  continue;
148  yellowbins.push_back(onebin);
149  }
150  }
151  }
152  int count_red_c = 0;
153  int count_yellow_c = 0;
154  std::vector<std::vector<colorbin> > ColorBinMap;
155 if(ClusterResult){
156  // initialize ColorBinMap
157  for ( int k = range[0]; k <= range[1]; ++k ) {
158  std::vector<colorbin> oneColorStrip;
159  for ( int l = range[2]; l <= range[3]; ++l ) {
160  colorbin oneColorBin = {static_cast<double>(k), static_cast<double>(l), -1, -1, -1, green, 1};
161  oneColorStrip.push_back(oneColorBin);
162  }
163  ColorBinMap.push_back(std::move(oneColorStrip));
164  }
165 
166 // map redbins and yellowbins to ColorBinMap
167  for(unsigned int i=0;i<redbins.size();i++){
168  int k=redbins[i].m_ix;
169  int l=redbins[i].m_iy;
170 
171  ColorBinMap[k-range[0]][l-range[2]].m_eta = redbins[i].m_eta;
172 
173  ColorBinMap[k-range[0]][l-range[2]].m_phi = redbins[i].m_phi;
174  ColorBinMap[k-range[0]][l-range[2]].m_value = redbins[i].m_value;
175  ColorBinMap[k-range[0]][l-range[2]].m_color = red;
176 
177  }
178 
179 
180  for(unsigned int i=0;i<yellowbins.size();i++){
181  int k=yellowbins[i].m_ix;
182  int l=yellowbins[i].m_iy;
183  ColorBinMap[k-range[0]][l-range[2]].m_eta = yellowbins[i].m_eta;
184  ColorBinMap[k-range[0]][l-range[2]].m_phi = yellowbins[i].m_phi;
185  ColorBinMap[k-range[0]][l-range[2]].m_value = yellowbins[i].m_value;
186  ColorBinMap[k-range[0]][l-range[2]].m_color = yellow;
187  }
188 
189 
190 // cluster bad bins
191  std::vector<colorcluster > clusterArray;
192  for(unsigned int i=0;i<redbins.size();i++){
193  const int k=redbins[i].m_ix;
194  const int l=redbins[i].m_iy;
195  if(ColorBinMap[k-range[0]][l-range[2]].m_color != green){
196  colorcluster onecluster = MakeCluster(range[0],range[2],redbins[i],ColorBinMap);
197  if(onecluster.m_size > 1) clusterArray.push_back(onecluster);
198  }
199  }
200  for(unsigned int i=0;i<yellowbins.size();i++){
201  const int k=yellowbins[i].m_ix;
202  const int l=yellowbins[i].m_iy;
203  if(ColorBinMap[k-range[0]][l-range[2]].m_color != green){
204  colorcluster onecluster = MakeCluster(range[0],range[2],yellowbins[i],ColorBinMap);
205  if(onecluster.m_size > 1) clusterArray.push_back(onecluster);
206  }
207  }
208 
209  // publish clusters here:
210  for(unsigned int i=0;i<clusterArray.size();i++){
211  std::string tag;
212  if(clusterArray[i].m_color==red){
213  tag = std::format(
214  "CR{}-(eta,phi)(r)(size)=({:.3f},{:.3f})({:.3f})({})",
215  count_red_c,
216  clusterArray[i].m_eta,
217  clusterArray[i].m_phi,
218  clusterArray[i].m_radius,
219  clusterArray[i].m_size);
220  count_red_c++;
221  }
222  else if(clusterArray[i].m_color==yellow){
223  tag = std::format(
224  "CY{}-(eta,phi)(r)(size)=({:.3f},{:.3f})({:.3f})({})",
225  count_yellow_c,
226  clusterArray[i].m_eta,
227  clusterArray[i].m_phi,
228  clusterArray[i].m_radius,
229  clusterArray[i].m_size);
230  count_yellow_c++;
231  }
232  result->tags_[tag] = clusterArray[i].m_value;
233  }
234  result->tags_["NRedClusters"] = count_red_c;
235  result->tags_["NYellowClusters"] = count_yellow_c;
236 
237  }
238 
239 
240  std::sort(redbins.begin(),redbins.end(),mySortfunc);
241  std::sort(yellowbins.begin(),yellowbins.end(),mySortfunc);
242  std::sort(Allbins.begin(),Allbins.end(),mySortfunc_ratio);
243 // publish red bins
244  int count_red=0;
245  for(unsigned int i=0;i<redbins.size();i++){
246  if(ClusterResult && ColorBinMap[redbins[i].m_ix-range[0]][redbins[i].m_iy-range[2]].m_status==0 ) continue;
247  if(publish){
248  char tmp[500];
249  sprintf(tmp,"R%i-(eta,phi)[OSRatio]=(%0.3f,%0.3f)[%0.2e]",count_red,redbins[i].m_eta,redbins[i].m_phi,redbins[i].m_outstandingRatio);
250  std::string tag = tmp;
251  result->tags_[tag] = redbins[i].m_value;
252  }
253  count_red++;
254  if(NpublishRed > 0){
255  if(count_red > NpublishRed) break;
256  }
257  }
258 
259 // publish yellow bins
260  int count_yellow=0;
261  for(unsigned int i=0;i<yellowbins.size();i++){
262  if(ClusterResult &&ColorBinMap[yellowbins[i].m_ix-range[0]][yellowbins[i].m_iy-range[2]].m_status==0) continue;
263  if(publish && (count_red+count_yellow) < Nmaxpublish ){
264  char tmp[500];
265  sprintf(tmp,"Y%i-(eta,phi)[OSRatio]=(%0.3f,%0.3f)[%.2e]",count_yellow,yellowbins[i].m_eta,yellowbins[i].m_phi,yellowbins[i].m_outstandingRatio);
266  std::string tag = tmp;
267  result->tags_[tag] = yellowbins[i].m_value;
268  }
269  count_yellow++;
270  }
271  result->tags_["NRedBins"] = count_red; // count_red is the number of red bins printed
272  result->tags_["NYellowBins"] = count_yellow; // count_yellow is the number of yellow bins printed
273 
274  if(count_red+count_yellow==0 && Allbins.size()>=5 ){
275  for(int i=0;i<5;i++){
276  char tmptmp[500];
277  sprintf(tmptmp,"LeadingBin%i-(eta,phi)=(%0.3f,%0.3f)",i,Allbins[i].m_eta,Allbins[i].m_phi);
278  std::string tagtag = tmptmp;
279  result->tags_[tagtag] = Allbins[i].m_value;
280  }
281 
282  }
283 
284 
285  if(count_red>0 || count_red_c>0) result->status_ = dqm_core::Result::Red;
286  else if (count_yellow>0||count_yellow_c>0) result->status_ = dqm_core::Result::Yellow;
287  else result->status_ = dqm_core::Result::Green;
288 
289  return result;
290 
291 }

◆ FindStripMedian()

void dqm_algorithms::BinsDiffFromStripMedian::FindStripMedian ( std::vector< double >  onestrip,
std::vector< double > &  stripsMedian 
)

Definition at line 293 of file BinsDiffFromStripMedian.cxx.

293  {
294  double median=0;
295 
296  std::sort(onestrip_tmp.begin(),onestrip_tmp.end());
297  int index1=onestrip_tmp.size()/4;
298 
299  int index2=onestrip_tmp.size()/2;
300  int index3=3*onestrip_tmp.size()/4;
301  median = (onestrip_tmp[index1]+onestrip_tmp[index2]+onestrip_tmp[index3])/3.0;
302  stripsMedian.push_back(median);
303 }

◆ MakeCluster()

colorcluster dqm_algorithms::BinsDiffFromStripMedian::MakeCluster ( const int  r0,
const int  r2,
bin &  onebin,
std::vector< std::vector< colorbin > > &  ColorBinMap 
)

Definition at line 399 of file BinsDiffFromStripMedian.cxx.

399  {
400  colorcluster onecluster={0,0,0,0,green,-1};
401  if(ColorBinMap[onebin.m_ix-r0][onebin.m_iy-r2].m_status==0)
402  return onecluster;
403  std::vector<colorbin> LookAtList;
404  if(ColorBinMap[onebin.m_ix-r0][onebin.m_iy-r2].m_color!=green){
405  LookAtList.push_back(ColorBinMap[onebin.m_ix-r0][onebin.m_iy-r2]);
406  ColorBinMap[onebin.m_ix-r0][onebin.m_iy-r2].m_status=0;
407  AddToList(r0,r2,onebin.m_ix,onebin.m_iy,ColorBinMap, LookAtList);
408  if(LookAtList.size()>1){
409  onecluster.m_size = LookAtList.size();
410  onecluster.m_value = CalVal(LookAtList);
411  if(ColorBinMap[onebin.m_ix-r0][onebin.m_iy-r2].m_color==red)
412  onecluster.m_color = red;
413  else onecluster.m_color = yellow;
414  onecluster.m_eta = CalEta(LookAtList);
415  onecluster.m_phi = CalPhi(LookAtList);
416  onecluster.m_radius = CalR(LookAtList,onecluster.m_eta,onecluster.m_phi);
417  }
418  else ColorBinMap[onebin.m_ix-r0][onebin.m_iy-r2].m_status=1;
419  }
420  return onecluster;
421 }

◆ printDescription()

void dqm_algorithms::BinsDiffFromStripMedian::printDescription ( std::ostream &  out)

Definition at line 424 of file BinsDiffFromStripMedian.cxx.

425 {
426 
427  out<<"BinsDiffFromStripMedian: Calculates smoothed strip median and then find out bins which are aliens "<<std::endl;
428 
429  out<<"Mandatory Green/Red Threshold is the value of outstandingRatio=(bin value)/(strip median) based on which to give Green/Red result\n"<<std::endl;
430 
431  out<<"Optional Parameter: MinStat: Minimum histogram statistics needed to perform Algorithm"<<std::endl;
432  out<<"Optional Parameter: ignoreval: valued to be ignored for being processed"<<std::endl;
433  out<<"Optional Parameter: PublishBins: Save bins which are different from average in Result (on:1,off:0,default is 1)"<<std::endl;
434  out<<"Optional Parameter: MaxPublish: Max number of bins to save (default 20)"<<std::endl;
435  out<<"Optional Parameter: VisualMode: is to make the evaluation process similar to the shift work, so one will get resonable result efficiently."<<std::endl;
436 
437 }
The documentation for this struct was generated from the following files:
mySortfunc
bool mySortfunc(const bin &i, const bin &j)
Definition: BinsDiffFromStripMedian.cxx:24
colorbin
Definition: BinsDiffFromStripMedian.h:53
colorcluster::m_phi
double m_phi
Definition: BinsDiffFromStripMedian.h:66
dqm_algorithms::tools::GetBinRange
std::vector< int > GetBinRange(const TH1 *histogram, const std::map< std::string, double > &params)
Definition: AlgorithmHelper.cxx:380
dqm_algorithms::BinsDiffFromStripMedian::BinsDiffFromStripMedian
BinsDiffFromStripMedian()
Definition: BinsDiffFromStripMedian.cxx:28
Undefined
@ Undefined
Definition: MaterialTypes.h:8
get_generator_info.result
result
Definition: get_generator_info.py:21
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
vtune_athena.format
format
Definition: vtune_athena.py:14
IsA
#define IsA
Declare the TObject style functions.
Definition: xAODTEventBranch.h:59
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:70
bin
Definition: BinsDiffFromStripMedian.h:43
mc.diff
diff
Definition: mc.SFGenPy8_MuMu_DD.py:14
bin::m_iy
int m_iy
Definition: BinsDiffFromStripMedian.h:48
mySortfunc_ratio
bool mySortfunc_ratio(const bin &i, const bin &j)
Definition: BinsDiffFromStripMedian.cxx:25
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:157
InDet::median
float median(std::vector< float > &Vec)
Definition: BTagVrtSec.cxx:35
CalPhi
double CalPhi(std::vector< colorbin > &LookAtList)
Definition: BinsDiffFromStripMedian.cxx:368
MCP::ScaleSmearParam::r2
@ r2
config
Definition: PhysicsAnalysis/AnalysisCommon/AssociationUtils/python/config.py:1
colorcluster::m_radius
double m_radius
Definition: BinsDiffFromStripMedian.h:67
bin::m_ix
int m_ix
Definition: BinsDiffFromStripMedian.h:47
colorcluster::m_eta
double m_eta
Definition: BinsDiffFromStripMedian.h:65
instance
std::map< std::string, double > instance
Definition: Run_To_Get_Tags.h:8
Trk::index3
@ index3
Definition: BoundarySurfaceFace.h:50
CalR
double CalR(std::vector< colorbin > &LookAtList, double eta, double phi)
Definition: BinsDiffFromStripMedian.cxx:388
Trk::index1
@ index1
Definition: BoundarySurfaceFace.h:48
yellow
@ yellow
Definition: BinsDiffFromStripMedian.h:18
lumiFormat.i
int i
Definition: lumiFormat.py:85
Result
ICscStripFitter::Result Result
Definition: CalibCscStripFitter.cxx:13
colorcluster::m_value
double m_value
Definition: BinsDiffFromStripMedian.h:68
TRT_PAI_physicsConstants::r0
const double r0
electron radius{cm}
Definition: TRT_PAI_physicsConstants.h:22
plotBeamSpotVxVal.range
range
Definition: plotBeamSpotVxVal.py:194
python.handimod.Green
int Green
Definition: handimod.py:523
DeMoUpdate.tmp
string tmp
Definition: DeMoUpdate.py:1167
CalVal
double CalVal(std::vector< colorbin > &LookAtList)
Definition: BinsDiffFromStripMedian.cxx:380
colorcluster::m_size
int m_size
Definition: BinsDiffFromStripMedian.h:70
python.handimod.Red
Red
Definition: handimod.py:550
Trk::index2
@ index2
Definition: BoundarySurfaceFace.h:49
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
green
@ green
Definition: BinsDiffFromStripMedian.h:18
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
colorcluster
Definition: BinsDiffFromStripMedian.h:63
std::sort
void sort(typename std::reverse_iterator< DataModel_detail::iterator< DVL > > beg, typename std::reverse_iterator< DataModel_detail::iterator< DVL > > end, const Compare &comp)
Specialization of sort for DataVector/List.
Definition: DVL_algorithms.h:623
dqm_algorithms::tools::GetFromMap
const T & GetFromMap(const std::string &pname, const std::map< std::string, T > &params)
Definition: AlgorithmHelper.h:114
pickleTool.object
object
Definition: pickleTool.py:29
dqm_algorithms::BinsDiffFromStripMedian::MakeCluster
colorcluster MakeCluster(const int r0, const int r2, bin &onebin, std::vector< std::vector< colorbin > > &ColorBinMap)
Definition: BinsDiffFromStripMedian.cxx:399
CaloCondBlobAlgs_fillNoiseFromASCII.tag
string tag
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:23
dqm_algorithms::BinsDiffFromStripMedian::FindStripMedian
void FindStripMedian(std::vector< double > onestrip, std::vector< double > &stripsMedian)
Definition: BinsDiffFromStripMedian.cxx:293
test_pyathena.counter
counter
Definition: test_pyathena.py:15
dqm_algorithms::tools::GetFirstFromMap
double GetFirstFromMap(const std::string &paramName, const std::map< std::string, double > &params)
Definition: AlgorithmHelper.cxx:339
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
xAOD::bool
setBGCode setTAP setLVL2ErrorBits bool
Definition: TrigDecision_v1.cxx:60
red
@ red
Definition: BinsDiffFromStripMedian.h:18
colorcluster::m_color
double m_color
Definition: BinsDiffFromStripMedian.h:69
CalEta
double CalEta(std::vector< colorbin > &LookAtList)
Definition: BinsDiffFromStripMedian.cxx:356
AddToList
void AddToList(const int r0, const int r2, int i, int j, std::vector< std::vector< colorbin > > &ColorBinMap, std::vector< colorbin > &LookAtList)
Definition: BinsDiffFromStripMedian.cxx:304
histogram
std::string histogram
Definition: chains.cxx:52
fitman.k
k
Definition: fitman.py:528
Generated on Mon Sep 29 2025 22:03:05 for ATLAS Offline Software by   doxygen 1.8.18