ATLAS Offline Software
Loading...
Searching...
No Matches
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
dqm_algorithms::BinPrint Class Reference

#include <BinPrint.h>

Inheritance diagram for dqm_algorithms::BinPrint:
Collaboration diagram for dqm_algorithms::BinPrint:

Public Member Functions

 BinPrint ()
virtual ~BinPrint ()
virtual dqm_core::Algorithm * clone ()
virtual dqm_core::Result * execute (const std::string &name, const TObject &data, const dqm_core::AlgorithmConfig &config)
virtual void printDescription (std::ostream &out)

Protected Member Functions

int UseValue_GetFromMap (const std::map< std::string, double > &params)
int TypeValue_GetFromMap (const std::map< std::string, double > &params)
double Value_GetFromMap (const std::map< std::string, double > &params)
int UseMaskValue_GetFromMap (const std::map< std::string, double > &params)
double MaskValue_GetFromMap (const std::map< std::string, double > &params)
std::vector< bool > Mask1D_GetFromMap (const std::map< std::string, double > &params)
std::vector< std::vector< bool > > Mask2D_GetFromMap (const std::map< std::string, double > &params)

Protected Attributes

std::string m_name
int m_NbinsX {}
int m_NbinsY {}
int m_UnMask_All {}
int m_UseValue {}
int m_TypeValue {}
double m_Value {}
int m_UseMaskValue {}
double m_MaskValue {}

Detailed Description

Definition at line 18 of file BinPrint.h.

Constructor & Destructor Documentation

◆ BinPrint()

dqm_algorithms::BinPrint::BinPrint ( )

Definition at line 96 of file BinPrint.cxx.

98 : m_name("BinPrint")
99 , m_NbinsX(-1)
100 , m_NbinsY(-1)
101 , m_UnMask_All(-1)
102 , m_UseValue(0)
103 , m_TypeValue(0)
104 , m_Value(0.)
105 , m_UseMaskValue(0)
106 , m_MaskValue(0.)
107
108 {
109 dqm_core::AlgorithmManager::instance().registerAlgorithm( m_name, this );
110 }
dqm_algorithms::BinPrint::m_NbinsX
int m_NbinsX
Definition BinPrint.h:35
dqm_algorithms::BinPrint::m_TypeValue
int m_TypeValue
Definition BinPrint.h:39
dqm_algorithms::BinPrint::m_UnMask_All
int m_UnMask_All
Definition BinPrint.h:37
dqm_algorithms::BinPrint::m_NbinsY
int m_NbinsY
Definition BinPrint.h:36
dqm_algorithms::BinPrint::m_Value
double m_Value
Definition BinPrint.h:40
dqm_algorithms::BinPrint::m_UseMaskValue
int m_UseMaskValue
Definition BinPrint.h:41
dqm_algorithms::BinPrint::m_UseValue
int m_UseValue
Definition BinPrint.h:38
dqm_algorithms::BinPrint::m_name
std::string m_name
Definition BinPrint.h:33
dqm_algorithms::BinPrint::m_MaskValue
double m_MaskValue
Definition BinPrint.h:42

◆ ~BinPrint()

dqm_algorithms::BinPrint::~BinPrint ( )
virtual

Definition at line 113 of file BinPrint.cxx.

115 {
116 }

Member Function Documentation

◆ clone()

dqm_core::Algorithm * dqm_algorithms::BinPrint::clone ( )
virtual

Definition at line 120 of file BinPrint.cxx.

122 {
123 return new BinPrint(*this);
124 }
dqm_algorithms::BinPrint::BinPrint
BinPrint()
Definition BinPrint.cxx:97

◆ execute()

dqm_core::Result * dqm_algorithms::BinPrint::execute ( const std::string & name,
const TObject & data,
const dqm_core::AlgorithmConfig & config )
virtual

Definition at line 128 of file BinPrint.cxx.

130 {
131 //No status flags are set
132 dqm_core::Result* result = new dqm_core::Result();
133 result->status_ = dqm_core::Result::Undefined;
134 //Histogram dimension default = no dimensions
135 m_NbinsX = -1;
136 m_NbinsY = -1;
137
138 if (!data.IsA()->InheritsFrom("TH1")) {
139 throw dqm_core::BadConfig(ERS_HERE, name, "does not inherit from TH1");
140 }
141 const TH1* h = static_cast<const TH1*>(&data); // h cannot be null
142 if (h->GetDimension() > 2) {
143 throw dqm_core::BadConfig(ERS_HERE, name, "dimension > 2 ");
144 }
145
146 //Get optional parameters
147 int Npublished = 0;
148 m_UseValue = UseValue_GetFromMap(config.getParameters());
149 m_TypeValue = TypeValue_GetFromMap(config.getParameters());
150 m_Value = Value_GetFromMap(config.getParameters());
151 m_UseMaskValue = UseMaskValue_GetFromMap(config.getParameters());
152 m_MaskValue = MaskValue_GetFromMap(config.getParameters());
153 const int Error = (int) dqm_algorithms::tools::GetFirstFromMap( "PrintError", config.getParameters(), 0);
154 //out<<Error<<"Error"<<std::endl;
155 //**********
156 // 1D Histogram case
157 //**********
158 if (h->GetDimension() == 1) {
159 m_NbinsX = h->GetNbinsX();
160
161 //Get bin mask
162 std::vector<bool> Mask;
163 Mask = Mask1D_GetFromMap(config.getParameters());
164
165 //Rescale m_Value if fractional definition is used
166 double h_entries = h->GetEntries();
167 if ( m_TypeValue > 0.5 ) m_Value = m_Value * h_entries;
168
169 //Check all bins
170 for (int bin = 0; bin < m_NbinsX; bin++) {
171 double bincon = h->GetBinContent(bin + 1);
172 double ebincon = h->GetBinError(bin + 1);
173 //out<<"here"<<Mask[bin]<<std::endl;
174 //if( !Mask[bin] ) {
175 if( Mask[bin] ) {
176 bool do_printbin = false;
177 if(m_UseValue == 0) do_printbin = true;
178 if( (m_UseValue == 1 && bincon >= m_Value) ||
179 (m_UseValue > 1 && bincon > m_Value) ||
180 (m_UseValue == -1 && bincon <= m_Value) ||
181 (m_UseValue < -1 && bincon < m_Value)
182 ) do_printbin = true;
183 if( (m_UseMaskValue == 1 && bincon >= m_MaskValue) ||
184 (m_UseMaskValue > 1 && bincon > m_MaskValue) ||
185 (m_UseMaskValue == -1 && bincon <= m_MaskValue) ||
186 (m_UseMaskValue < -1 && bincon < m_MaskValue)
187 ) do_printbin = ! do_printbin;
188 if(do_printbin) {
189 //out<<"bin with name " << bincon<<std::endl;
190 Npublished++;
191 if ( m_UnMask_All < 0 ||
192 Npublished <= m_UnMask_All ) {
193 double binvalX = h->GetXaxis()->GetBinCenter(bin + 1);
194 std::string binname = Form("%s_Bin(%u | %.*e)", name.c_str(), bin, 2, binvalX);
195 std::string sigbinname = Form("%s_EBin(%u | %.*e)", name.c_str(), bin, 2, binvalX);
196 //ERS_DEBUG(1, "bin with name " << binname <<" and value "<< bincon);
197 //out<<"bin with name " << binname <<" and value "<< bincon<<std::endl;
198 //out<<"bin with name " << sigbinname <<" and value "<< ebincon<<std::endl;
199 //From() ~ printf() (s ~ string, u ~ unsigned int, .*e ~ scientific)
200 if ( m_TypeValue > 0.5 ) {
201 result->tags_[binname.c_str()] = (bincon / h_entries);
202 if (Error ==1 ) result->tags_[sigbinname.c_str()] = ebincon ;
203 } else {
204 result->tags_[binname.c_str()] = bincon;
205 if (Error ==1 ) result->tags_[sigbinname.c_str()] = ebincon ;
206 }
207 }
208 }
209 }
210 }
211 }
212
213 //**********
214 // 2D Histogram case
215 //**********
216 if (h->GetDimension() == 2) {
217 m_NbinsX = h->GetNbinsX();
218 m_NbinsY = h->GetNbinsY();
219
220 //Get bin mask
221 std::vector< std::vector<bool> > Mask;
222 Mask = Mask2D_GetFromMap(config.getParameters());
223
224 //Rescale m_Value if fractional definition is used
225 double h_entries = h->GetEntries();
226 if ( m_TypeValue > 0.5 ) m_Value = m_Value * h_entries;
227
228 //Check all bins
229 for (int binX = 0; binX < m_NbinsX; binX++) {
230 for (int binY = 0; binY < m_NbinsY; binY++) {
231 double bincon = h->GetBinContent(binX + 1, binY + 1);
232 double ebincon = h->GetBinError(binX + 1, binY + 1);
233 if( !Mask[binX][binY] ) {
234 bool do_printbin = false;
235 if(m_UseValue == 0) do_printbin = true;
236 if( (m_UseValue == 1 && bincon >= m_Value) ||
237 (m_UseValue > 1 && bincon > m_Value) ||
238 (m_UseValue == -1 && bincon <= m_Value) ||
239 (m_UseValue < -1 && bincon < m_Value)
240 ) do_printbin = true;
241 if( (m_UseMaskValue == 1 && bincon >= m_MaskValue) ||
242 (m_UseMaskValue > 1 && bincon > m_MaskValue) ||
243 (m_UseMaskValue == -1 && bincon <= m_MaskValue) ||
244 (m_UseMaskValue < -1 && bincon < m_MaskValue)
245 ) do_printbin = ! do_printbin;
246 if(do_printbin) {
247 Npublished++;
248 if ( m_UnMask_All < 0 ||
249 Npublished <= m_UnMask_All ) {
250 double binvalX = h->GetXaxis()->GetBinCenter(binX + 1);
251 double binvalY = h->GetYaxis()->GetBinCenter(binY + 1);
252 std::string binname = Form("%s_Bin((%u,%u) | %.*e,%.*e)", name.c_str(), binX, binY, 2, binvalX, 2, binvalY);
253 std::string sigbinname = Form("%s_EBin((%u,%u) | %.*e,%.*e)", name.c_str(), binX, binY, 2, binvalX, 2, binvalY);
254 if ( m_TypeValue > 0.5 ) {
255 result->tags_[binname.c_str()] = (bincon / h_entries);
256 result->tags_[sigbinname.c_str()] = ebincon;
257 } else {
258 }
259 result->tags_[binname.c_str()] = bincon;
260 result->tags_[sigbinname.c_str()] = ebincon;
261 }
262 }
263 }
264 }
265 }
266 }
267
268 //Append statement if all warnings or errors were not printed
269 if ( m_UnMask_All >= 0 &&
270 Npublished > m_UnMask_All ) {
271 std::string pub_excess = Form("%s_PROBLEM_Publishable_UnPrinted",name.c_str());
272 result->tags_[pub_excess.c_str()] = Npublished - m_UnMask_All;
273 }
274
275 return result;
276 }
data
char data[hepevt_bytes_allocation_ATLAS]
Definition HepEvt.cxx:11
dqm_algorithms::BinPrint::UseMaskValue_GetFromMap
int UseMaskValue_GetFromMap(const std::map< std::string, double > &params)
Definition BinPrint.cxx:313
dqm_algorithms::BinPrint::Mask1D_GetFromMap
std::vector< bool > Mask1D_GetFromMap(const std::map< std::string, double > &params)
Definition BinPrint.cxx:333
dqm_algorithms::BinPrint::UseValue_GetFromMap
int UseValue_GetFromMap(const std::map< std::string, double > &params)
Definition BinPrint.cxx:283
dqm_algorithms::BinPrint::Value_GetFromMap
double Value_GetFromMap(const std::map< std::string, double > &params)
Definition BinPrint.cxx:303
dqm_algorithms::BinPrint::MaskValue_GetFromMap
double MaskValue_GetFromMap(const std::map< std::string, double > &params)
Definition BinPrint.cxx:323
dqm_algorithms::BinPrint::TypeValue_GetFromMap
int TypeValue_GetFromMap(const std::map< std::string, double > &params)
Definition BinPrint.cxx:293
dqm_algorithms::BinPrint::Mask2D_GetFromMap
std::vector< std::vector< bool > > Mask2D_GetFromMap(const std::map< std::string, double > &params)
Definition BinPrint.cxx:363
L1Topo::Error
Error
The different types of error that can be flagged in the L1TopoRDO.
Definition Error.h:16
Trk::binX
@ binX
Definition BinningType.h:47
Trk::binY
@ binY
Definition BinningType.h:48
dqm_algorithms::tools::GetFirstFromMap
double GetFirstFromMap(const std::string &paramName, const std::map< std::string, double > &params)
Definition AlgorithmHelper.cxx:339
get_generator_info.result
result
Definition get_generator_info.py:21
python.base_data.config
config
Definition base_data.py:20

◆ Mask1D_GetFromMap()

std::vector< bool > dqm_algorithms::BinPrint::Mask1D_GetFromMap ( const std::map< std::string, double > & params)
protected

Definition at line 333 of file BinPrint.cxx.

334 {
335 std::map<std::string, double>::const_iterator mask_map_bin;
336
337 //Make default mask
338 bool default_Mask = true;
339 m_UnMask_All = -1;
340 //Get m_UnMask_All configuration
341 mask_map_bin = params.find("UnMask_All");
342 if ( mask_map_bin != params.end() ) {
343 if(mask_map_bin->second > 0.5) {
344 m_UnMask_All = (int) mask_map_bin->second;
345 default_Mask = false;
346 }
347 }
348 std::vector<bool> Mask(m_NbinsX, default_Mask);
349
350 //Get specific mask settings
351 for ( int bin = 0; bin < m_NbinsX; bin++ ) {
352 std::string mask_bin = Form("Mask_%d", bin + 1);
353 mask_map_bin = params.find(mask_bin.c_str());
354 if ( mask_map_bin != params.end() ) {
355 if(mask_map_bin->second > 0.5) Mask[bin] = true;
356 else Mask[bin] = false;
357 }
358 }
359
360 return(Mask);
361 }
PowhegControl_ttFCNC_NLO.params
params
Definition PowhegControl_ttFCNC_NLO.py:226

◆ Mask2D_GetFromMap()

std::vector< std::vector< bool > > dqm_algorithms::BinPrint::Mask2D_GetFromMap ( const std::map< std::string, double > & params)
protected

Definition at line 363 of file BinPrint.cxx.

364 {
365 std::map<std::string, double>::const_iterator mask_map_bin;
366
367 //Make default mask
368 bool default_Mask = true;
369 m_UnMask_All = -1;
370 //Get m_UnMask_All configuration
371 mask_map_bin = params.find("UnMask_All");
372 if ( mask_map_bin != params.end() ) {
373 if(mask_map_bin->second > 0.5) {
374 m_UnMask_All = (int) mask_map_bin->second;
375 default_Mask = false;
376 }
377 }
378 std::vector< std::vector<bool> > Mask(m_NbinsX, std::vector<bool>(m_NbinsY, default_Mask));
379
380 //Get specific mask settings
381 for ( int binX = 0; binX < m_NbinsX; binX++ ) {
382 for ( int binY = 0; binY < m_NbinsY; binY++ ) {
383 std::string mask_bin = Form("Mask_%d_%d", binX + 1, binY + 1);
384 mask_map_bin = params.find(mask_bin.c_str());
385 if ( mask_map_bin != params.end() ) {
386 if(mask_map_bin->second > 0.5) Mask[binX][binY] = true;
387 else Mask[binX][binY] = false;
388 }
389 }
390 }
391
392 return(Mask);
393 }

◆ MaskValue_GetFromMap()

double dqm_algorithms::BinPrint::MaskValue_GetFromMap ( const std::map< std::string, double > & params)
protected

Definition at line 323 of file BinPrint.cxx.

324 {
325 std::map<std::string, double>::const_iterator it = params.find("MaskValue");
326 if ( it != params.end() ){
327 return(it->second);
328 } else {
329 return(0.0);
330 }
331 }

◆ printDescription()

void dqm_algorithms::BinPrint::printDescription ( std::ostream & out)
virtual

Definition at line 29 of file BinPrint.cxx.

31 {
32 std::string message;
33 message += "\n";
34 message += "Algorithm: \"" + m_name + "\"\n";
35 message += "Description: Extracts bin contents from a TProfile, TH1, TH2 object without performing\n";
36 message += " any assessment; the status is always \"Undefined\"\n";
37 message += "Optional Parameter: UnMask_All Default = -1\n";
38 message += " <0: Only unmask bins when Mask_## = 0\n";
39 message += " >=0: Unmask all bins and only mask bins when Mask_## = 1\n";
40 message += " # >= 0: Maximum number of bins printed is #\n";
41 message += " This setting is combined so that large bin lists do not occur accidentaly.\n";
42 message += "Optional Parameter: UseValue: Default = 0\n";
43 message += " 0: Print all unmasked bins\n";
44 message += " 1: Print bin contents >= Value\n";
45 message += " >1: Print bin contents > Value\n";
46 message += " -1: Print bin contents <= Value\n";
47 message += " <-1: Print bin contents < Value\n";
48 message += "Optional Parameter: Value:\n";
49 message += "Optional Parameter: UseMaskValue: Default = 0\n";
50 message += " 0: Mask no bins\n";
51 message += " 1: Change Mask for all >= MaskValue\n";
52 message += " >1: Change Mask for all > Mask Value\n";
53 message += " -1: Change Mask for all <= MaskValue\n";
54 message += " <-1: Change Mask for all < Mask Value\n";
55 message += " NOTE: The same boundaries apply to the mask\n";
56 message += "Optional Parameter: MaskValue:\n";
57 message += " Example of Printing values from 0. <= x <= 1.\n";
58 message += " UseValue = 1\n";
59 message += " Value = 0. ## x >= 0.\n";
60 message += " UseMaskValue = 2\n";
61 message += " MaskValue = 1. ## x <= 1.\n";
62 message += " Example of Printing values outside of the range above\n";
63 message += " UseValue = 2\n";
64 message += " Value = 1.\n";
65 message += " ## By Value Only: x > 1.0\n";
66 message += " UseMaskValue = -2\n";
67 message += " MaskValue = 0.\n";
68 message += " ## Including Mask: x < 0.0\n";
69 message += "Optional Parameter: TypeValue: Default = 0\n";
70 message += " 0: Value is compared to total entries in bin\n";
71 message += " 1: Value is compared to fraction of entries in histogram appearing in bin\n";
72 message += " This also determines how the bin contents will be listed if published.\n";
73 message += "1D Histogram Configuration:\n";
74 message += "Optional Parameters: Mask_#\n";
75 message += " 0: UnMask bin\n";
76 message += " 1: Mask bin\n";
77 message += " Example of Printing all but the first bin\n";
78 message += " ***In algorithm declaration\n";
79 message += " UnMask_All = 3\n";
80 message += " Mask_1 = 1\n";
81 message += "2D Histogram Configuration:\n";
82 message += "Optional Parameters: Mask_#_#\n";
83 message += " 0: UnMask bin\n";
84 message += " 1: Mask bin\n";
85 message += " Example of masking the X = 1, Y = 2 bin:\n";
86 message += " ***In algorithm declaration\n";
87 message += " UnMask_All = 3\n";
88 message += " Mask_1_2 = 1\n";
89 message += "\n";
90 message += "Optional Parameters: PrintError\n";
91 message += " 1: Print Corresponding Bin Error\n";
92
93 out << message;
94 }

◆ TypeValue_GetFromMap()

int dqm_algorithms::BinPrint::TypeValue_GetFromMap ( const std::map< std::string, double > & params)
protected

Definition at line 293 of file BinPrint.cxx.

294 {
295 std::map<std::string, double>::const_iterator it = params.find("TypeValue");
296 if ( it != params.end() ){
297 return((int) it->second);
298 } else {
299 return(0);
300 }
301 }

◆ UseMaskValue_GetFromMap()

int dqm_algorithms::BinPrint::UseMaskValue_GetFromMap ( const std::map< std::string, double > & params)
protected

Definition at line 313 of file BinPrint.cxx.

314 {
315 std::map<std::string, double>::const_iterator it = params.find("UseMaskValue");
316 if ( it != params.end() ){
317 return((int) it->second);
318 } else {
319 return(0);
320 }
321 }

◆ UseValue_GetFromMap()

int dqm_algorithms::BinPrint::UseValue_GetFromMap ( const std::map< std::string, double > & params)
protected

Definition at line 283 of file BinPrint.cxx.

284 {
285 std::map<std::string, double>::const_iterator it = params.find("UseValue");
286 if ( it != params.end() ){
287 return((int) it->second);
288 } else {
289 return(0);
290 }
291 }

◆ Value_GetFromMap()

double dqm_algorithms::BinPrint::Value_GetFromMap ( const std::map< std::string, double > & params)
protected

Definition at line 303 of file BinPrint.cxx.

304 {
305 std::map<std::string, double>::const_iterator it = params.find("Value");
306 if ( it != params.end() ){
307 return(it->second);
308 } else {
309 return(0.0);
310 }
311 }

Member Data Documentation

◆ m_MaskValue

double dqm_algorithms::BinPrint::m_MaskValue {}
protected

Definition at line 42 of file BinPrint.h.

42{};

◆ m_name

std::string dqm_algorithms::BinPrint::m_name
protected

Definition at line 33 of file BinPrint.h.

◆ m_NbinsX

int dqm_algorithms::BinPrint::m_NbinsX {}
protected

Definition at line 35 of file BinPrint.h.

35{};

◆ m_NbinsY

int dqm_algorithms::BinPrint::m_NbinsY {}
protected

Definition at line 36 of file BinPrint.h.

36{};

◆ m_TypeValue

int dqm_algorithms::BinPrint::m_TypeValue {}
protected

Definition at line 39 of file BinPrint.h.

39{};

◆ m_UnMask_All

int dqm_algorithms::BinPrint::m_UnMask_All {}
protected

Definition at line 37 of file BinPrint.h.

37{};

◆ m_UseMaskValue

int dqm_algorithms::BinPrint::m_UseMaskValue {}
protected

Definition at line 41 of file BinPrint.h.

41{};

◆ m_UseValue

int dqm_algorithms::BinPrint::m_UseValue {}
protected

Definition at line 38 of file BinPrint.h.

38{};

◆ m_Value

double dqm_algorithms::BinPrint::m_Value {}
protected

Definition at line 40 of file BinPrint.h.

40{};
The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.14.0