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

#include <BinwiseSummary.h>

Inheritance diagram for dqm_algorithms::summary::BinwiseSummary:
Collaboration diagram for dqm_algorithms::summary::BinwiseSummary:

Public Member Functions

 BinwiseSummary ()
 
 ~BinwiseSummary ()
 
BinwiseSummaryclone ()
 
dqm_core::Resultexecute (const std::string &name, const dqm_core::Result &, const dqm_core::ParametersMap &)
 

Detailed Description

Definition at line 21 of file BinwiseSummary.h.

Constructor & Destructor Documentation

◆ BinwiseSummary()

dqm_algorithms::summary::BinwiseSummary::BinwiseSummary ( )

Definition at line 35 of file BinwiseSummary.cxx.

36 {
37  dqm_core::AlgorithmManager::instance().registerSummaryMaker("BinwiseSummary",this);
38 }

◆ ~BinwiseSummary()

dqm_algorithms::summary::BinwiseSummary::~BinwiseSummary ( )

Definition at line 40 of file BinwiseSummary.cxx.

41 {
42 }

Member Function Documentation

◆ clone()

dqm_algorithms::summary::BinwiseSummary * dqm_algorithms::summary::BinwiseSummary::clone ( )

Definition at line 45 of file BinwiseSummary.cxx.

46 {
47  return new BinwiseSummary();
48 }

◆ execute()

dqm_core::Result * dqm_algorithms::summary::BinwiseSummary::execute ( const std::string &  name,
const dqm_core::Result ,
const dqm_core::ParametersMap &  map 
)

Definition at line 51 of file BinwiseSummary.cxx.

54 {
55 
56  //General summary maker infrastructure: (This can be resused)
57  dqm_core::Result *newresult = new dqm_core::Result();
58 
59  //Retrieve axis information for the first histogram:
60  int nBinsX = 0;
61  int nBinsY = 0;
62  TH1* firstBinwiseHist = 0;
63 
64  //Loop over elements of parameter map to find an example binwise status histogram, if any,
65  //Extract nbins x and y now so can check against these:
66  for (dqm_core::ParametersMap::const_iterator paramIter=map.begin();paramIter!=map.end();++paramIter){
67  if ( paramIter->second->getWeight() == 0 ) {
68  continue;
69  }
70  dqm_core::Result * inputResult = paramIter->second->getResult().get();
71  TObject* inputobject = inputResult->getObject();
72  if (inputobject == 0) {
73  continue;
74  }
75  for (std::map<std::string,double>::const_iterator tagIter=inputResult->tags_.begin();
76  tagIter != inputResult->tags_.end(); ++tagIter ) {
77  if( tagIter->first.find("Algorithm--BinsDiffByStrips") != std::string::npos) {
78  if( inputobject->IsA()->InheritsFrom("TObjArray") ) {
79  firstBinwiseHist = static_cast<TH1*> (static_cast<TObjArray*>(inputobject)->First());
80  nBinsX = firstBinwiseHist->GetNbinsX();
81  nBinsY = firstBinwiseHist->GetNbinsY();
82  break;
83  }
84  }
85  }
86  if( (nBinsX != 0) || (nBinsY != 0) ) {
87  break;
88  }
89  }
90  TH1 * mask = 0;
91  std::vector<std::pair<TH1*,float> > binwiseStatHists;
93 
94  std::map<double,std::vector<std::pair<int,float> > > standardAndGroup;
95  std::map<double,std::vector<std::pair<TH1*,float> > > binwiseAndGroup;
96  std::set<double> setOfAndGroups;
97 
98 
99  //Loop over elements of the parameter map to extract histograms and there roles, if any:
100  for (dqm_core::ParametersMap::const_iterator paramIter=map.begin();paramIter!=map.end();++paramIter){
101  //If weight is 0 skip this result. Allow to "turn off"
102  // results in summary makers
103  float weight = paramIter->second->getWeight();
104  if ( weight == 0 ) {
105  ERS_DEBUG(2,"Skip result (weight 0): "<<paramIter->first);
106  continue;
107  }
108  dqm_core::Result * inputResult = paramIter->second->getResult().get();
109  TObject* inputobject = inputResult->getObject();
110  if (inputobject == 0) {
111  ERS_DEBUG(2,"Empty input object, "<<paramIter->first);
112  status = tools::WorstCaseAddStatus(status,inputResult->status_,weight);
113  continue;
114  }
115 
116  //This seems to be a good object, use it according to it's tags:
117  bool isSpecialParameter = false;
118  double andGroup = -99999.;
119  TH1* binwiseStatHist = 0;
120  for (std::map<std::string,double>::const_iterator tagIter=inputResult->tags_.begin();
121  tagIter != inputResult->tags_.end(); ++tagIter ) {
122 
123  std::string tag = tagIter->first;
124  size_t stringPos;
125  std::string tagType = "ConfParameter--Role--Mask";
126  if ( (stringPos = tag.find(tagType)) != std::string::npos) {
127  if ( inputobject->IsA()->InheritsFrom("TH1") ) {
128  if( (static_cast<TH1*>(inputobject)->GetNbinsX() == nBinsX) &&
129  (static_cast<TH1*>(inputobject)->GetNbinsY() == nBinsY)) {
130  mask = static_cast<TH1*>(inputobject);
131  }
132  }
133  isSpecialParameter = true;
134  break;
135  }
136 
137  tagType = "Algorithm--BinsDiffByStrips"; //<-The only algorithm so far which produces a binwise status.
138  if ( (stringPos = tag.find(tagType)) != std::string::npos) {
139  if( inputobject->IsA()->InheritsFrom("TObjArray") ) {
140  binwiseStatHist = static_cast<TH1*> (static_cast<TObjArray*> (inputobject)->First());
141  if( (binwiseStatHist->GetNbinsX() != nBinsX) || (binwiseStatHist->GetNbinsY() != nBinsY) ) {
142  binwiseStatHist = 0;
143  }
144  else {
145  isSpecialParameter = true;
146  }
147  }
148  }
149  tagType = "AndGroup";
150  if ( (stringPos = tag.find(tagType)) != std::string::npos) {
151  andGroup = tagIter->second;
152  }
153  }
154  if( !isSpecialParameter ){
155  status = tools::WorstCaseAddStatus(status,inputResult->status_,weight);
156  }
157  else {
158  if( andGroup == -99999. ) {
159  if( binwiseStatHist != 0 ) {
160  std::pair<TH1*,float> binStatsPair ( binwiseStatHist, weight );
161  binwiseStatHists.push_back(binStatsPair);
162  }
163  }
164  else {
165  if( binwiseStatHist != 0 ) {
166  std::map<double,std::vector<std::pair<TH1*,float> > >::iterator fitr = binwiseAndGroup.find(andGroup);
167  if( fitr == binwiseAndGroup.end() ) {
168  //New and group, make it:
169  std::vector<std::pair<TH1*,float> > newAndGroup;
170  newAndGroup.push_back( std::make_pair( binwiseStatHist, weight ) );
171  binwiseAndGroup.insert(std::make_pair(andGroup,newAndGroup));
172  setOfAndGroups.insert(andGroup);
173  }
174  else {
175  fitr->second.push_back( std::make_pair( binwiseStatHist, weight ) );
176  }
177  }
178  else {
179  std::map<double,std::vector<std::pair<int,float> > >::iterator fitr = standardAndGroup.find(andGroup);
180  if( fitr == standardAndGroup.end() ) {
181  //New and group, make it:
182  std::vector<std::pair<int,float> > newAndGroup;
183  newAndGroup.push_back( std::make_pair( inputResult->status_, weight ) );
184  standardAndGroup.insert( std::make_pair(andGroup, newAndGroup) );
185  setOfAndGroups.insert(andGroup);
186  }
187  else {
188  fitr->second.push_back( std::make_pair( inputResult->status_, weight ) );
189  }
190  }
191  }
192  }
193  }
194 
195  //Loop over set of and groups, for those found with no binwise component do status calculation
196  // here and remove from set.
197  std::set<double>::iterator setItr = setOfAndGroups.begin();
198  while (setItr != setOfAndGroups.end()) { // we cannot use a normal for-loop because we may erase the current element
199  std::map<double, std::vector<std::pair<TH1*,float> > >::iterator findIter = binwiseAndGroup.find(*setItr);
200  if( findIter == binwiseAndGroup.end() ) {
201  std::map<double, std::vector<std::pair<int,float> > >::iterator fsIter = standardAndGroup.find(*setItr);
202  if( fsIter != standardAndGroup.end() ) {
203  if( !fsIter->second.empty() ) {
205  float groupWeight = 0;
206  for( std::vector<std::pair<int,float> >::const_iterator sandItr = fsIter->second.begin();
207  sandItr != fsIter->second.end(); ++sandItr ) {
208  groupStatus = tools::BestCaseAddStatus( groupStatus, (dqm_core::Result::Status) sandItr->first, sandItr->second );
209  groupWeight += sandItr->second;
210  }
211  status = tools::WorstCaseAddStatus(status,groupStatus,groupWeight);
212  }
213  standardAndGroup.erase(fsIter);
214  }
215  setOfAndGroups.erase(setItr++); // the erased iterator will become invalid, but post-incrementing is safe
216  } else {
217  ++setItr;
218  }
219  }
220  if( (binwiseStatHists.size() == 0) && (setOfAndGroups.size() == 0) ) {
221  newresult->status_ = status;
222  return newresult;
223  }
224 
225  std::vector<std::pair<TH1*,float> >::const_iterator itr;
226  std::vector<std::pair<TH1*,float> >::const_iterator iBegin = binwiseStatHists.begin();
227  std::vector<std::pair<TH1*,float> >::const_iterator iEnd = binwiseStatHists.end();
228 
229  if( mask != 0 ){
230  for(int ix = 1; ix <= nBinsX; ix++) {
231  for(int iy = 1; iy <= nBinsY; iy++) {
232  int bin = firstBinwiseHist->GetBin(ix,iy);
233  //If there is an entry in the mask histogram, we will downweight this bin:
234  double downWeight = 0;
235  if(mask->GetBinContent(bin) != 0) {
236  downWeight = 1;
237  }
238  for( itr = iBegin; itr != iEnd; ++itr ) {
239  status = tools::WorstCaseAddStatus( status,(dqm_core::Result::Status) floor(itr->first->GetBinContent(bin)),
240  (itr->second - downWeight) );
241  }
242  //Iterate over addGroups:
243  for( std::map<double, std::vector<std::pair<TH1*,float> > >::iterator bItr = binwiseAndGroup.begin();
244  bItr != binwiseAndGroup.end(); ++ bItr ) {
246  float groupWeight = 0;
247  for( std::vector<std::pair<TH1*,float> >::const_iterator bandItr = bItr->second.begin();
248  bandItr != bItr->second.end(); ++bandItr ) {
249  groupStatus = tools::BestCaseAddStatus( groupStatus,(dqm_core::Result::Status) floor(bandItr->first->GetBinContent(bin)),
250  (bandItr->second - downWeight) );
251  groupWeight += bandItr->second - downWeight;
252  }
253  std::map<double, std::vector<std::pair<int,float> > >::iterator fsIter = standardAndGroup.find(bItr->first);
254  if( fsIter != standardAndGroup.end() ) {
255  for( std::vector<std::pair<int,float> >::const_iterator sandItr = fsIter->second.begin();
256  sandItr != fsIter->second.end(); ++sandItr ) {
257  groupStatus = tools::BestCaseAddStatus( groupStatus, (dqm_core::Result::Status) sandItr->first, sandItr->second );
258  groupWeight += sandItr->second;
259  }
260  }
261  status = tools::WorstCaseAddStatus( status, groupStatus, groupWeight );
262 
263  }
264  }
265  }
266  }
267  else {
268  for(int ix = 1; ix <= nBinsX; ix++) {
269  for(int iy = 1; iy <= nBinsY; iy++) {
270  int bin = 0;
271  if( ! binwiseStatHists.empty() ) {
272  bin = binwiseStatHists.front().first->GetBin(ix,iy);
273  }
274  else {
275  bin = binwiseAndGroup.begin()->second.front().first->GetBin(ix,iy);
276  }
277 
278  for( itr = iBegin; itr != iEnd; ++itr ) {
279  status = tools::WorstCaseAddStatus( status,(dqm_core::Result::Status) floor(itr->first->GetBinContent(bin)),
280  itr->second );
281  }
282 
283  //Iterate over addGroups:
284  for( std::map<double, std::vector<std::pair<TH1*,float> > >::iterator bItr = binwiseAndGroup.begin();
285  bItr != binwiseAndGroup.end(); ++ bItr ) {
286 
288  float groupWeight = 0;
289  for( std::vector<std::pair<TH1*,float> >::const_iterator bandItr = bItr->second.begin();
290  bandItr != bItr->second.end(); ++bandItr ) {
291  groupStatus = tools::BestCaseAddStatus( groupStatus,(dqm_core::Result::Status) floor(bandItr->first->GetBinContent(bin)),
292  bandItr->second );
293  groupWeight += bandItr->second;
294  }
295  std::map<double, std::vector<std::pair<int,float> > >::iterator fsIter = standardAndGroup.find(bItr->first);
296  if( fsIter != standardAndGroup.end() ) {
297  for( std::vector<std::pair<int,float> >::const_iterator sandItr = fsIter->second.begin();
298  sandItr != fsIter->second.end(); ++sandItr ) {
299  groupStatus = tools::BestCaseAddStatus( groupStatus, (dqm_core::Result::Status) sandItr->first,sandItr->second );
300  groupWeight += sandItr->second;
301  }
302  }
303  status = tools::WorstCaseAddStatus( status, groupStatus, groupWeight );
304  }
305  }
306  }
307  }
308  newresult->status_ = status;
309  return newresult;
310 }

The documentation for this struct was generated from the following files:
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
Undefined
@ Undefined
Definition: MaterialTypes.h:8
bin
Definition: BinsDiffFromStripMedian.h:43
dqm_algorithms::tools::BestCaseAddStatus
dqm_core::Result::Status BestCaseAddStatus(dqm_core::Result::Status baseStatus, dqm_core::Result::Status addedStatus, float weight=1.0)
Definition: AlgorithmHelper.cxx:1347
dqm_algorithms::tools::WorstCaseAddStatus
dqm_core::Result::Status WorstCaseAddStatus(dqm_core::Result::Status baseStatus, dqm_core::Result::Status addedStatus, float weight=1.0)
Definition: AlgorithmHelper.cxx:1300
python.utils.AtlRunQueryLookup.mask
string mask
Definition: AtlRunQueryLookup.py:459
dqt_zlumi_pandas.weight
int weight
Definition: dqt_zlumi_pandas.py:190
instance
std::map< std::string, double > instance
Definition: Run_To_Get_Tags.h:8
Result
ICscStripFitter::Result Result
Definition: CalibCscStripFitter.cxx:13
python.handimod.Red
Red
Definition: handimod.py:550
TrackCorrType::First
@ First
Athena::Status
Status
Athena specific StatusCode values.
Definition: AthStatusCode.h:22
dqm_algorithms::summary::BinwiseSummary::BinwiseSummary
BinwiseSummary()
Definition: BinwiseSummary.cxx:35
merge.status
status
Definition: merge.py:16
CaloCondBlobAlgs_fillNoiseFromASCII.tag
string tag
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:23