ATLAS Offline Software
Loading...
Searching...
No Matches
Classes | Typedefs | Functions | Variables
comparitor.cxx File Reference
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <sys/time.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <algorithm>
#include <regex>
#include "TrigInDetAnalysis/Efficiency1D.h"
#include "TrigInDetAnalysis/Efficiency2D.h"
#include "TrigInDetAnalysisExample/ChainString.h"
#include "ReadCards.h"
#include "Resplot.h"
#include "utils.h"
#include "label.h"
#include "DrawLabel.h"
#include "TFile.h"
#include "TTree.h"
#include "TString.h"
#include "TH2F.h"
#include "TH1D.h"
#include "TPad.h"
#include "TCanvas.h"
#include "TLegend.h"
#include "TStyle.h"
#include "TF1.h"
#include "TPave.h"
#include "TPaveStats.h"
#include "TColor.h"
#include "computils.h"
#include "AtlasStyle.h"
#include "AtlasLabels.h"
#include "default_panels.h"

Go to the source code of this file.

Classes

class  bands

Typedefs

typedef std::map< std::string, std::string > chainmap_t
 global typedef here is ok, since this is a standalone executable, including a main().

Functions

void SetZeros (TH2D *h)
void Scale (TH1 *h, double d=1)
TH1F * Rebin (TH1F *h, double f)
TH1F * rebin_log (TH1F *h, bool low=false)
template<typename T = TH1F>
T * Get (TFile &f, const std::string &n, const std::string &dir="", const chainmap_t *chainmap=0, std::vector< std::string > *saved=0)
 get a histogram given a path, and an optional initial directory if histogram is not found, then check for dir/name, allows optional remapping of the reference chain information
TH1F * d0rebin (TH1F *h)
int usage (const std::string &name, int status, const std::string &err_msg="")
void binwidth (TH1F *h)
void ascale (TH1F *h, double s_)
std::string fullreplace (std::string s, const std::string &s2, const std::string &s3)
void print_pad (const std::string &s)
void zero (TH2 *h)
 zero the contents of a 2d histogram
void normy (TH2 *h)
 zero the contents of a 2d histogram
void autox (TH2 *h)
 get the auto x range of a 2d histogram
void autoy (TH2 *h)
 get the auto y range of a 2d histogram
double chi2 (TH1 *h0, TH1 *h1)
int main (int argc, char **argv)

Variables

bool fulldbg = false
bool LINEF
bool LINES
int colours [6]
int markers [6]

Detailed Description

Author
mark sutton
Date
Fri 12 Oct 2012 13:39:05 BST

Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration

Definition in file comparitor.cxx.

Typedef Documentation

◆ chainmap_t

typedef std::map<std::string,std::string> chainmap_t

global typedef here is ok, since this is a standalone executable, including a main().

As such it does not need to be in a namespace at this point as it won't in any case be visible outside this translation unit

Definition at line 173 of file comparitor.cxx.

Function Documentation

◆ ascale()

void ascale ( TH1F * h,
double s_ )

Definition at line 413 of file comparitor.cxx.

413 {
414 for ( int i=1 ; i<=h->GetNbinsX() ; i++ ) {
415 h->SetBinContent( i, h->GetBinContent(i)*s_ );
416 h->SetBinError( i, h->GetBinError(i)*s_ );
417 }
418}
h
Header file for AthHistogramAlgorithm.

◆ autox()

void autox ( TH2 * h)

get the auto x range of a 2d histogram

Definition at line 465 of file comparitor.cxx.

465 {
466
467 int Nx = h->GetNbinsX();
468 int Ny = h->GetNbinsY();
469
470 double xhi = h->GetXaxis()->GetBinLowEdge(1);
471 double xlo = h->GetXaxis()->GetBinLowEdge( h->GetXaxis()->GetNbins() );
472
473 for ( int i=1 ; i<=Nx ; i++ ) {
474 double x = h->GetXaxis()->GetBinLowEdge(i);
475 for ( int j=1 ; j<=Ny ; j++ ) {
476 double n = h->GetBinContent(i,j);
477 if ( n!=0 ) {
478 if ( x<xlo ) {
479 if ( i>1 ) xlo = h->GetXaxis()->GetBinLowEdge(i-1);
480 else xlo = x;
481 }
482 if ( x>xhi ) {
483 if ( i<h->GetXaxis()->GetNbins() ) xhi = h->GetXaxis()->GetBinLowEdge(i+1);
484 else xhi = x;
485 }
486 }
487 }
488 }
489
490 h->GetXaxis()->SetRangeUser( xlo, xhi );
491}
x
#define x

◆ autoy()

void autoy ( TH2 * h)

get the auto y range of a 2d histogram

Definition at line 495 of file comparitor.cxx.

495 {
496
497 int Nx = h->GetNbinsX();
498 int Ny = h->GetNbinsY();
499
500 double yhi = h->GetYaxis()->GetBinLowEdge(1);
501 double ylo = h->GetYaxis()->GetBinLowEdge( h->GetYaxis()->GetNbins() );
502
503 for ( int i=1 ; i<=Ny ; i++ ) {
504 double y = h->GetYaxis()->GetBinLowEdge(i);
505 for ( int j=1 ; j<=Nx ; j++ ) {
506 double n = h->GetBinContent(j,i);
507 if ( n!=0 ) {
508 if ( y<ylo ) {
509 if ( i>1 ) ylo = h->GetYaxis()->GetBinLowEdge(i-1);
510 else ylo = y;
511 }
512 if ( y>yhi ) {
513 if ( i<h->GetYaxis()->GetNbins() ) yhi = h->GetYaxis()->GetBinLowEdge(i+1);
514 else yhi = y;
515 }
516 }
517 }
518 }
519
520 h->GetYaxis()->SetRangeUser( ylo, yhi );
521}
y
#define y

◆ binwidth()

void binwidth ( TH1F * h)

Definition at line 405 of file comparitor.cxx.

405 {
406 for ( int i=1 ; i<=h->GetNbinsX() ; i++ ) {
407 double w = h->GetBinLowEdge(i+1) - h->GetBinLowEdge(i);
408 h->SetBinContent( i, h->GetBinContent(i)/w );
409 h->SetBinError( i, h->GetBinError(i)/w );
410 }
411}

◆ chi2()

double chi2 ( TH1 * h0,
TH1 * h1 )

Definition at line 525 of file comparitor.cxx.

525 {
526 double c2 = 0;
527
528 for ( int i=0 ; i<h0->GetNbinsX() ; i++ ) {
529
530 double d0 = h0->GetBinContent(i+1);
531 double d1 = h1->GetBinContent(i+1);
532
533 double e0 = h0->GetBinError(i+1);
534 double e1 = h1->GetBinError(i+1);
535
536 double e2 = e0*e0+e1*e1;
537
538 if ( e2>0 ) c2 += (d0-d1)*(d0-d1)/e2;
539
540 }
541
542 return c2;
543}
dq_defect_virtual_defect_validation.d1
d1
Definition dq_defect_virtual_defect_validation.py:79
egammaEnergyPositionAllSamples::e2
double e2(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in 2nd sampling
egammaEnergyPositionAllSamples::e0
double e0(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in pre-sampler
egammaEnergyPositionAllSamples::e1
double e1(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in 1st sampling
read_hist_ntuple.h1
h1
Definition read_hist_ntuple.py:24

◆ d0rebin()

TH1F * d0rebin ( TH1F * h)

Definition at line 275 of file comparitor.cxx.

275 {
276
277 std::vector<double> limits;
278
279 for ( int i=1 ; i<h->GetNbinsX() ; i++ ) {
280 limits.push_back( h->GetBinLowEdge(i) );
281 }
282
283 std::vector<double> alimits;
284 std::vector<double> nlimits;
285
286 double x = 0;
287
288 for ( [[maybe_unused]] int i=0 ; x<20 ; i++ ) {
289
290 alimits.push_back(x);
291
292#if 0
293 if ( x<0.5 ) x+=0.2;
294 else if ( x<1.0 ) x+=0.2;
295 else if ( x<1.5 ) x+=0.3;
296 else if ( x<2.0 ) x+=0.4;
297 else if ( x<2.5 ) x+=0.5;
298 else x+=0.6;
299#else
300 if ( x<0.5 ) x+=0.1;
301 else if ( x<1.0 ) x+=0.2;
302 else if ( x<1.5 ) x+=0.2;
303 else if ( x<2.0 ) x+=0.2;
304 else if ( x<2.5 ) x+=0.2;
305 else if ( x<3.0 ) x+=0.3;
306 else x+=0.3;
307#endif
308
309 }
310
311 for ( size_t i=alimits.size() ; i-- ; ) {
312 if ( alimits[i]<=15 ) nlimits.push_back( -alimits[i] );
313 }
314
315 for ( size_t i=1 ; i<alimits.size() ; i++ ) {
316 if ( alimits[i]<=15 ) nlimits.push_back( alimits[i] );
317 }
318
319 std::cout << "limits: " << limits.size() << " " << nlimits.size() << std::endl;
320
321 TH1F* hnew = new TH1F( "h", h->GetTitle(), nlimits.size()-1, &nlimits[0] );
322
323 for ( int i=1 ; i<=h->GetNbinsX() ; i++ ) {
324 double d = h->GetBinCenter(i);
325 int j = hnew->FindBin( d );
326 hnew->SetBinContent( j, hnew->GetBinContent(j)+h->GetBinContent(i) );
327 }
328
329 return hnew;
330}
hist_file_dump.d
d
Definition hist_file_dump.py:142
python.TrigEgammaMonitorHelper.TH1F
TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition TrigEgammaMonitorHelper.py:24

◆ fullreplace()

std::string fullreplace ( std::string s,
const std::string & s2,
const std::string & s3 )

cowardly, don't replace string by itself

Definition at line 423 of file comparitor.cxx.

423 {
424 if ( s2=="" || s2==s3 ) return s;
425 std::string::size_type pos;
426 while ( (pos=s.find(s2)) != std::string::npos ) s.replace(pos, s2.size(), s3);
427 return s;
428}

◆ Get()

template<typename T = TH1F>
T * Get ( TFile & f,
const std::string & n,
const std::string & dir = "",
const chainmap_t * chainmap = 0,
std::vector< std::string > * saved = 0 )

get a histogram given a path, and an optional initial directory if histogram is not found, then check for dir/name, allows optional remapping of the reference chain information

Definition at line 181 of file comparitor.cxx.

182 {
183
184 std::string name;
185
186 size_t pos = n.find('+');
187 if ( pos!=std::string::npos ) name = n.substr( 0, pos );
188 else name = n;
189
190 T* h = (T*)f.Get( name.c_str() );
191 if ( h || dir.empty() || name.find(dir)!=std::string::npos ) {
192 std::cout << "Get() name 0 " << name << " :: " << h << std::endl;
193 }
194 else {
195 name = dir+'/'+name;
196 h = (T*)f.Get( name.c_str() );
197 std::cout << "Get() name 1 " << name << " :: " << h << std::endl;
198 }
199
200 if ( h == 0 ) {
201 if ( chainmap && chainmap->size()!=0 ) {
202 for ( chainmap_t::const_iterator itr=chainmap->begin() ; itr!=chainmap->end() ; ++itr ) {
203 if ( contains( name, itr->first ) ) {
204 std::cout << "\tmatch: " << itr->first << " -> " << itr->second << std::endl;
205 name.replace( name.find(itr->first), itr->first.size(), itr->second );
206 h = (T*)f.Get( name.c_str() );
207 break;
208 }
209 }
210 }
211 }
212
213 if ( saved ) saved->push_back( std::move(name) );
214
215 if ( h ) h->SetDirectory(0);
216
217 return h;
218}
contains
bool contains(const std::string &s, const std::string &regx)
does a string contain the substring
Definition hcg.cxx:114
hist_file_dump.f
f
Definition hist_file_dump.py:140

◆ main()

int main ( int argc,
char ** argv )

control stuff

control flags and labels

leave this commented here - now instead of bombing out if we don't specify the reference file, just carry on as if it was not specified at all, so as this changes the external behaviour of the code we want this retained

don't fail anymore if can't open the reference file, now continue without plotting the refereces, instead printing a warning on the plots

get release data

we divide the resolutions by these values if we have an "entries" histogram to tell us how many events there are overall

get from Chains?

set up the correct reference chain names ...

get the actual chain name and track collection from

the Chain histogram if present

reference chains

set up the plot panels

read config in from a file if requested ...

read the histos - 1 panel per histo

read in the panel descriptions

use the default values as single histogram panels

use the default panels

a better colour palette than the egregious root default

Fixme: add the 2D histogram processing here ??

words can not express the sheer unpleasantness in trying to do anything serious with subpanels

  • if any margins between pads are set to 0, root messes up the pad margins so they are 0 with seemingly no way to prevent it - have to use a very small (but non 0) value, but then the margins don't size properly.
  • Once you cd() to one of the child pads, if you ask for the child GetWh() or GetWw() you don't get the parameters of the child pad, but the main pad etc

How are you supposed to get the paremeters of the actual pad ? It is insane.

histos within the panel

leave this code commented here for the time being ... if ( histo.name()=="pT" || histo.name()=="pT_rec" ) ypos = 0.19;

calculate all the postions for the items in the legend

legends ....

leave these comments here for testing ...

get the actual chain name and track collection from the Chain histogram if present

refit the resplots - get the 2d histogram and refit

get the test histogram

Actually DO refit the references - if we are adding together many resplots, then the means etc may not even have been calculated

leave this code commented here since we want to know where to change this in the future it was added for a reason, so is useful to keep for now

useful test for debugging ...

everything else

leave this code commented here since we want to know where to change this in the future it was added for a reason, so useful to keep for now

debugging ...

rebin if requested ...

now recalculate reference

leave for documentation purposes ...

again, this changes the external behaviour so we want to leave this "continue" in place, but commented

only set the plot name once )

replace the "/" in the filename so we don't try to make plots in subdirectories by accident

calculate and set axis limits

resolutions

calculate power

try to localise all axis range setting, log, lin scales etc to this one place

sort out the range settings for the xaxis ...

calculate the log range

keep the original equation by way of documentation ...

leave this code commented here since we want to know where to change this in the future it was added for a reason, so it is useful to keep for now
std::exit(-1);

calculate the required range such that the histogram labels won't crowd the points

actually draw the plot here ...

loop over histograms in panel

NB: now, we no longer print the individual plots - only the "panels" individual plots can still be printed by creating a "panel" which contains only that plots - in fast the "histos" item that before provided details of the separate plots is now interpreted as a list of single plot panels so this is done for you

loop over panels

if deleting all non-used reference histograms

make sure we are not using the same reference as test file

clean up reference file

copy the release tree

debugging ...

close files

now actually overwrite the old reference file

Definition at line 546 of file comparitor.cxx.

546 {
547
548 std::cout << "\n---------------------------------\n";
549 std::cout << "\n comparitor is off ...\n";
550
551 if ( argc<4 ) return usage(argv[0], -1, "too few arguments");
552
554
555 std::string tag = "";
556 std::string key = "";
557
558 std::string dir = "";
559
560 std::string ftestname = "";
561 std::string frefname = "";
562
563 TFile* ftest_ = 0;
564 TFile* fref_ = 0;
565
566 bool effset = false;
567 double effmin = 90;
568 double effmax = 102;
569
570 std::string defreflabel = "";
571
573
574 std::vector<std::string> usrlabels;
575 bool uselabels = false;
576 bool addinglabels = false;
577
578 std::vector<std::string> taglabels;
579 bool addingtags = false;
580
581 bool make_ref_efficiencies = false;
582 bool refit_resplots = false;
583 bool refitref_resplots = false;
584 bool bayes = true;
585 bool nostats = false;
586 bool nomeans = false;
587 bool noref = false;
588 bool atlasstyle = false;
589 bool deleteref = false;
590 bool nowatermark = false;
591 bool noplots = false;
592 bool nopng = false;
593 bool nopdf = false;
594 bool Cfile = false;
595 bool notitle = true;
596 bool dochi2 = false;
597 bool normref = false;
598 bool scalepix = false;
599 bool oldrms = false;
600 bool addchains = false;
601 bool usechainref = false;
602 bool quiet = false;
603
604 bool RANGEMAP = false;
605 bool ALLRANGEMAP = false;
606
607 double xerror = 0;
608
609 std::string atlaslabel_tmp = "Internal";
610
611
612 double scale_eff = -1;
613 double scale_eff_ref = -1;
614
615 std::string configfile = "";
616
617 double xoffset = 0;
618
619
620 double ypos_arg = 0;
621
622 std::string pattern = "";
623 std::string regex = "";
624
625 std::string patternr = "";
626 std::string regexr = "";
627
628 std::string patternt = "";
629 std::string regext = "";
630
631 std::string basedir = "";
632
633 std::string xpattern = "";
634 std::string xregex = "";
635
636 std::vector<std::string> chains;
637 std::vector<std::string> refchains;
638
639 bool addingrefchains = false;
640
641 std::string mapfile = "";
642
643 std::vector<std::string> chainfiles;
644
645 int ncols = 2;
646
647 for(int i=1; i<argc; i++){
648 std::string arg = argv[i];
649
650
651 if ( arg.find('-')!=0 && addinglabels ) {
652 std::string label = arg;
653 fullreplace( label, "__", " " );
654 replace( label, '#', ' ' );
655 usrlabels.push_back( label );
656 continue;
657 }
658 else addinglabels = false;
659
660 if ( arg.find('-')!=0 && addingrefchains ) {
661 refchains.push_back( arg );
662 continue;
663 }
664 else addingrefchains = false;
665
666 if ( arg.find('-')!=0 && addingtags ) {
667 taglabels.push_back( fullreplace( arg, "__", " " ) );
668 std::cout << "\tadding tag label: " << taglabels.back() << std::endl;
669 continue;
670 }
671 else addingtags = false;
672
673 if ( arg=="-h" || arg=="--help" ) {
674 return usage(argv[0], 0);
675 }
676 else if ( arg=="-c" || arg=="--config" ) {
677 if ( ++i<argc ) configfile=argv[i];
678 else return usage(argv[0], -1, "no config file provided");
679 }
680 else if ( arg=="-t" || arg=="--tag" ) {
681 if ( ++i<argc ) tag=std::string("-")+argv[i];
682 else return usage(argv[0], -1, "no tag provided");
683 }
684 else if ( arg=="-l" || arg=="--labels" ) {
685 addinglabels = true;
686 }
687 else if ( arg=="-el" ) {
688 LINES = true;
689 }
690 else if ( arg=="-k" || arg=="--key" ) {
691 if ( ++i<argc ) key=argv[i];
692 else return usage(argv[0], -1, "no key provided");
693 }
694 else if ( arg=="-m" || arg=="--mapfile" ) {
695 if ( ++i<argc ) mapfile=argv[i];
696 else return usage(argv[0], -1, "no mapfile provided");
697 }
698 else if ( arg=="-d" || arg=="--dir" ) {
699 if ( ++i<argc ) dir=argv[i];
700 else return usage(argv[0], -1, "no directory provided");
701 }
702 else if ( arg=="-b" || arg=="--bdir" ) {
703 if ( ++i<argc ) basedir=argv[i];
704 else return usage(argv[0], -1, "no directory provided");
705 }
706 else if ( arg=="--taglabels" ) {
707 addingtags = true;
708 }
709 else if ( arg=="--unscalepix" ) {
710 scalepix = false;
711 }
712 else if ( arg=="--scalepix" ) {
713 scalepix = true;
714 }
715 else if ( arg=="-ac" || arg=="--addchains" ) {
716 addchains = true;
717 }
718 else if ( arg=="-yrange" ) {
719 effset = true;
720 if ( ++i<argc ) effmin=std::atof(argv[i]);
721 else return usage(argv[0], -1, "no range specified");
722 if ( ++i<argc ) effmax=std::atof(argv[i]);
723 else return usage(argv[0], -1, "no upper y limit specified");
724 }
725 else if ( arg=="-e" || arg=="--efficiencies" ) {
726 make_ref_efficiencies = true;
727 }
728 else if ( arg=="-r" || arg=="--refit" ) {
729 refit_resplots = true;
730 }
731 else if ( arg=="-rr" || arg=="--refitref" ) {
732 refitref_resplots = true;
733 }
734 else if ( arg=="--oldrms" ) {
735 oldrms = true;
736 }
737 else if ( arg=="-nw" || arg=="--nowatermark" ) {
738 nowatermark = true;
739 Plots::setwatermark(!nowatermark);
740 }
741 else if ( arg=="--chi2" ) {
742 dochi2 = true;
743 }
744 else if ( arg=="-ns" || arg=="--nostats" ) {
745 nostats = true;
746 }
747 else if ( arg=="-nm" || arg=="--nomeans" ) {
748 nomeans = true;
749 }
750 else if ( arg=="-nt" || arg=="--notitle" ) {
751 notitle = true;
752 }
753 else if ( arg=="-nr" || arg=="--noref" ) {
754 Plotter::setplotref(false);
755 noref = true;
756 }
757 else if ( arg=="--normref" ) {
758 normref = true;
759 }
760 else if ( arg=="-rc" || arg=="--refchains" ) {
761 addingrefchains = true;
762 }
763 else if ( arg=="-uc" || arg=="--usechainref" ) {
764 usechainref = true;
765 }
766 else if ( arg=="-nb" || arg=="--nobayes" ) {
767 bayes = false;
768 }
769 else if ( arg=="-es" || arg=="--effscale" ) {
770 if ( ++i<argc ) scale_eff=std::atof(argv[i]);
771 else return usage(argv[0], -1, "no efficiency scale provided");
772 }
773 else if ( arg=="-er" || arg=="--effscaleref" ) {
774 if ( ++i<argc ) scale_eff_ref=std::atof(argv[i]);
775 else return usage(argv[0], -1, "no efficiency scale for the reference histograms provided");
776 }
777 else if ( arg=="--ncols" ) {
778 if ( ++i<argc ) ncols=std::atoi(argv[i]);
779 else return usage(argv[0], -1, "no number of columns provided");
780 }
781 else if ( arg=="-np" || arg=="--noplots" ) {
782 noplots = true;
783 }
784 else if ( arg=="-C" || arg=="--Cfiles" ) {
785 Cfile = true;
786 }
787 else if ( arg=="--deleteref" ) {
788 deleteref = true;
789 }
790 else if ( arg=="--nopng" ) {
791 nopng = true;
792 }
793 else if ( arg=="--nopdf" ) {
794 nopdf = true;
795 }
796 else if ( arg=="-as" || arg=="--atlasstyle" ) {
797 atlasstyle = true;
798 }
799 else if ( arg=="-q" || arg=="--quiet" ) {
800 quiet = true;
801 }
802 else if ( arg=="-al" || arg=="--atlaslabel" ) {
803 if ( ++i<argc ) atlaslabel_tmp=argv[i];
804 else return usage(argv[0], -1, "no label provided");
805 }
806 else if ( arg=="-xo" || arg=="--xoffset" ) {
807 if ( ++i<argc ) xoffset=std::atof(argv[i]);
808 else return usage(argv[0], -1, "no xoffset provided");
809 }
810 else if ( arg=="-yp" || arg=="--ypos" ) {
811 if ( ++i<argc ) ypos_arg=std::atof(argv[i]);
812 else return usage(argv[0], -1, "no y position provided");
813 }
814 else if ( arg=="-xe" || arg=="--xerror" ) {
815 if ( ++i<argc ) xerror=std::atof(argv[i]);
816 else return usage(argv[0], -1, "no x error provided");
817 }
818 else if ( arg=="-s" || arg=="--swap" ) {
819 if ( ++i<argc ) pattern=argv[i];
820 else return usage(argv[0], -1, "no patterns provided");
821 if ( ++i<argc ) regex=argv[i];
822 else return usage(argv[0], -1, "no target pattern provided");
823 }
824 else if ( arg=="--swapt" ) {
825 if ( ++i<argc ) patternt=argv[i];
826 else return usage(argv[0], -1, "no patterns provided");
827 if ( ++i<argc ) regext=argv[i];
828 else return usage(argv[0], -1, "no target pattern provided");
829 }
830 else if ( arg=="--swapr" ) {
831 if ( ++i<argc ) patternr=argv[i];
832 else return usage(argv[0], -1, "no patterns provided");
833 if ( ++i<argc ) regexr=argv[i];
834 else return usage(argv[0], -1, "no target pattern provided");
835 }
836 else if ( arg=="-sx" || arg=="--swapaxtitles" ) {
837 if ( ++i<argc ) xregex=argv[i];
838 else return usage(argv[0], -1, "no target pattern provided");
839 if ( ++i<argc ) xpattern=argv[i];
840 else return usage(argv[0], -1, "no patterns provided");
841 }
842 else if ( arg.find('-')==0 ) {
843 std::cerr << "unknown option: " << arg << "\n" << std::endl;
844 return usage(argv[0], -4);
845 }
846 else {
847 if ( ftestname=="" ) ftestname = arg;
848 else if ( frefname=="" ) frefname = arg;
849 else {
850 std::string file = "";
851
852 if ( arg.find(":file:")!=std::string::npos ) {
853 file = arg.substr( 0, arg.find(":file:") );
854 chainfiles.push_back( file );
855 arg = arg.substr(arg.find(":file:")+6,arg.size());
856 }
857
858 std::string chain = arg;
859
860 if ( chain.find("=")!=std::string::npos ) chain = ChainString(arg);
861
862 replace ( chain, ':', '_' );
863 replace ( chain, ';', '_' );
864 chains.push_back(chain);
865
866 std::cout << "file: " << file << "\tchain: " << chain << std::endl;
867
868 }
869 }
870 }
871
872 if ( ftestname.empty() ) {
873 std::cerr << "main(): test file not specified " << std::endl;
874 return -1;
875 }
876
877 if ( !exists(ftestname) ) {
878 std::cerr << "main(): test file " << ftestname << " does not exist" << std::endl;
879 return -1;
880 }
881
882 std::vector<TFile*> chainTFiles;
883
884
885
886 if ( chainfiles.size()==0 ) ftest_ = TFile::Open( ftestname.c_str() );
887 else {
888 noref=true;
889 chainTFiles.resize(chainfiles.size());
890 for ( size_t i=0 ; i<chainfiles.size() ; i++ ) {
891 chainTFiles[i] = TFile::Open( chainfiles[i].c_str() );
892 if ( chainTFiles[i] == 0 ) {
893 std::cerr << "\tfile: " << chainfiles[i] << " could not be opened" << std::endl;
894 return -1;
895 }
896 else std::cout << "\tchainfiles: " << chainfiles[i] << " " << chainTFiles[i] << std::endl;
897 }
898 }
899
900
901 if ( noref==false ) {
902 if ( frefname.empty() ) {
903 std::cerr << "main(): ref file not specified " << std::endl;
904 Plotter::setplotref(false);
905 noref = true;
910 // return -1;
911 }
912
913 if ( frefname==ftestname ) fref_ = ftest_;
914 else if ( exists(frefname) ) fref_ = TFile::Open( frefname.c_str() );
915 else {
916 std::cerr << "main(): ref file " << frefname << " does not exist" << std::endl;
917 // return -1;
918 Plotter::setplotref(false);
919 noref=true;
920 }
921 }
922 else fref_ = ftest_;
923
924 if ( chainfiles.size()==0 ) {
925 if ( ftest_==0 ) {
926 std::cerr << "could not open test file " << ftestname << std::endl;
927 return -1;
928 }
929
930 if ( noref==false && fref_==0 ) {
931 std::cerr << "could not open files " << std::endl;
935 noref=true;
936 fref_=ftest_;
937 defreflabel = "failed to open reference file";
938 }
939
940 }
941
942 if ( scale_eff == -1 ) scale_eff = 100;
943 if ( scale_eff_ref == -1 ) scale_eff_ref = scale_eff;
944
945
946 bool noreftmp = noref;
947
948 if ( chains.size()==0 ) return usage(argv[0], -1, "no chains specified");
949
950
951 if ( basedir.size()>0 ) {
952 if ( basedir[basedir.size()-1]!='/' ) basedir += "/";
953 for ( size_t ic=chains.size() ; ic-- ; ) chains[ic] = basedir+chains[ic];
954 }
955
956 if ( refchains.size()>0 && refchains.size()!=chains.size() ) return usage(argv[0], -1, "not enough chains specified");
957
958 if ( refchains.size()==0 ) refchains = chains;
959
960 std::vector<std::string> chainref(chains.size(),"");
961 std::vector<std::string> chain_name(chains.size(),"");
962
963 std::vector<std::string> refchain(chainref.size(),"");
964
965
966
967 std::cout << argv[0] << " options:" << std::endl;
968 std::cout << "\tATLAS style: " << ( atlasstyle ? "true" : "false" ) << std::endl;
969 std::cout << "\tBayesian uncertainties: " << ( bayes ? "true" : "false" ) << std::endl;
970 std::cout << "\trefit resplot uncertainties: " << ( refit_resplots ? "true" : "false" ) << std::endl;
971 std::cout << "\tsuppress mean and rms stats: " << ( nostats ? "true" : "false" ) << std::endl;
972 if ( !nostats ) std::cout << "\tsuppress meanstats: " << ( nomeans ? "true" : "false" ) << std::endl;
973 std::cout << "\tsuppress png output: " << ( nopng ? "true" : "false" ) << std::endl;
974 std::cout << "\tsuppress pdf output: " << ( nopdf ? "true" : "false" ) << std::endl;
975 std::cout << "\tsuppress reference output: " << ( noref ? "true" : "false" ) << std::endl;
976 std::cout << "\tuse chain references: " << ( usechainref ? "true" : "false" ) << std::endl;
977 std::cout << "\tpanel ncols: " << ncols << std::endl;
978
979 if ( usrlabels.size()>0 ) std::cout << "\tlabels: " << usrlabels.size() << std::endl;
980 if ( taglabels.size()>0 ) std::cout << "\textra text: " << taglabels << std::endl;
981
982
983 for ( size_t il=0 ; il<usrlabels.size() ; il++ ) {
984 std::cout << "usr label[" << il << "] : " << usrlabels[il] << std::endl;
985 }
986
987 std::cout << "atlas style : " << atlasstyle << std::endl;
988
989 if ( atlasstyle ) {
990 SetAtlasStyle();
991 gStyle = AtlasStyle();
992 gStyle->cd();
993 }
994 else {
995 gROOT->SetStyle("Plain");
996 gStyle->cd();
997 gStyle->SetLineScalePS(1);
998 xoffset += 0.02;
999 }
1000
1001 gStyle->SetErrorX(xerror);
1002
1003 gStyle->SetPadLeftMargin(0.15);
1004 gStyle->SetPadBottomMargin(0.15);
1005
1006 gStyle->SetPadRightMargin(0.02);
1007 gStyle->SetPadTopMargin(0.05);
1008
1009 std::cout << "Chains: " << std::endl;
1010 for ( unsigned ic=0 ; ic<chains.size() ; ic++ ) std::cout << "\t" << chains[ic] << std::endl;
1011
1012 if ( usrlabels.size()>0 ) std::cout << "labels: " << usrlabels << std::endl;
1013
1014 if ( usrlabels.size()>0 && usrlabels.size()==chains.size() ) uselabels = true;
1015
1017
1018 TTree* dataTree = 0;
1019 TString* releaseData = new TString("");
1020 std::vector<std::string> release_data;
1021
1022 if ( !nowatermark && ftest_ ) {
1023
1024 dataTree = (TTree*)ftest_->Get("dataTree");
1025
1026 if ( dataTree ) {
1027 dataTree->SetBranchAddress( "ReleaseMetaData", &releaseData);
1028
1029 for (unsigned int i=0; i<dataTree->GetEntries() ; i++ ) {
1030 dataTree->GetEntry(i);
1031 release_data.push_back( releaseData->Data() );
1032 std::cout << "main() release data: " << release_data.back() << " : " << *releaseData << std::endl;
1033 }
1034 }
1035
1036
1037 if ( release_data.size()>0 ) {
1038 if ( release_data.size()>1 ) std::cerr << "main() more than one release - using only the first" << std::endl;
1039
1040 // std::cout << "release: " << chop(release_data[0], " " ) << std::endl;
1041
1042 std::string nightly = chop(release_data[0], " " );
1043
1044 if ( contains(nightly,"private" ) ) {
1045 for ( int ic=0 ; ic<4 ; ic++ ) chop(release_data[0], " " );
1046 release += " (" + release_data[0]+")";
1047 }
1048 else {
1049 release += " (" + nightly;
1050 chop( release_data[0], " " );
1051 release += " " + chop(release_data[0], " " ) + ")";
1052 }
1053 }
1054 }
1055
1056
1057 // Make output directory
1058 if (!dir.empty()) {
1059
1060 gDirectory->pwd();
1061
1062 std::cout << "trying to make directory" << std::endl;
1063 dir += '/';
1064 if ( !quiet && !noplots && !exists(dir) ) {
1065 if ( mkdir( dir.c_str(), 0777 ) ) std::cerr << "main() couldn't create directory " << dir << std::endl;
1066 else std::cout << "main() output will be sent to directory " << dir << std::endl;
1067 }
1068 }
1069
1070 if ( ftest_==0 && chainTFiles.size()>0 ) fref_ = ftest_ = chainTFiles[0];
1071
1072 TFile* ftest = ftest_;
1073 TFile* fref = fref_;
1074
1075 std::string testrun = findrun( ftest );
1076
1077 std::string rawrefrun = "";
1078 std::string refrun = "";
1079
1080 if ( fref_ ) refrun = rawrefrun = findrun( fref );
1081
1082 std::cout << "testrun: " << testrun << "\nrefrun: " << refrun << std::endl;
1083
1084 if ( !testrun.empty() && refrun != testrun ) {
1085 if ( pattern.empty() ) {
1086 pattern = testrun;
1087 regex = refrun;
1088 }
1089
1090 }
1091
1092 if ( !refrun.empty() ) {
1093
1094 std::string newtag = "Reference: ";
1095
1096 std::cout << "refrun: " << refrun << std::endl;
1097
1098 size_t pos;
1099 while ( (pos=refrun.find('_'))!=std::string::npos ) refrun.replace( pos, 1, " " );
1100 newtag += refrun;
1101
1102 std::string rawrun = refrun.erase( refrun.find("run"), 4 );
1103
1104 if ( contains(frefname, rawrun) ) {
1105
1106 std::string release = frefname;
1107
1108 release.erase( 0, release.find(rawrun) );
1109
1110 if ( contains(release,"HIST") ) release.erase( 0, release.find("HIST")+5 );
1111 while ( contains(release,".") ) release.erase( release.find('.'), release.size() );
1112 while ( contains(release,"-") ) release.erase( release.find('-'), release.size() );
1113 while ( contains(release,"_p") ) release.erase( release.find("_p"), release.size() );
1114 while ( contains(release,"_t") ) release.erase( release.find("_t"), release.size() );
1115
1116 newtag += " ";
1117 newtag += release;
1118
1119 }
1120
1121 taglabels.push_back( newtag );
1122
1123 std::cout << "tag labels: " << taglabels << std::endl;
1124
1125 }
1126
1131 int NeventTest = 1;
1132 int NeventRef = 1;
1133
1134
1135 std::vector<std::string> savedhistos;
1136
1137
1138 if ( !nowatermark ) {
1139
1140 TH1D* htestev = (TH1D*)ftest->Get("event") ;
1141 TH1D* hrefev = (TH1D*)fref->Get("event") ;
1142
1143 std::cout << "htestev " << htestev << " " << hrefev << std::endl;
1144
1145 if ( htestev ) NeventTest = htestev->GetEntries();
1146 if ( hrefev ) NeventRef = hrefev->GetEntries();
1147
1148 savedhistos.push_back("event");
1149 }
1150 else {
1151 NeventTest = 1;
1152 NeventRef = 1;
1153 }
1154
1155
1156 if ( NeventTest>1 ) std::cout << "Nevents Test: " << NeventTest << std::endl;
1157 if ( NeventRef>1 ) std::cout << "Nevents Ref: " << NeventRef << std::endl;
1158
1159 chainmap_t* chainmap = nullptr;
1160
1161 if ( mapfile.empty() ) mapfile = configfile;
1162
1163 if ( !mapfile.empty() ) {
1164
1165 ReadCards m( mapfile );
1166
1167 if ( m.isTagDefined( "ChainMap" ) ) {
1168 std::vector<std::string> chains = m.GetStringVector( "ChainMap" );
1169
1170 chainmap = new chainmap_t();
1171
1172 for ( size_t i=0 ; i<chains.size() ; i+=2 ) {
1173 chainmap->insert( chainmap_t::value_type( chains[i], chains[i+1] ) );
1174 }
1175
1176 std::cout << "\nusing chain map:" << std::endl;
1177
1178 for ( chainmap_t::iterator itr=chainmap->begin() ; itr!=chainmap->end() ; ++itr ) {
1179 std::cout << "\t" << itr->first << "\t" << itr->second << std::endl;
1180 }
1181 }
1182 }
1183
1185
1186 std::cout << "\ncreating chain and reference information ..." << std::endl;
1187
1188 for ( size_t j=0; j<chains.size(); j++) {
1189
1190 if ( !regex.empty() ) chains[j] = fullreplace( chains[j], pattern, regex );
1191 if ( !regext.empty() ) chains[j] = fullreplace( chains[j], patternt, regext );
1192
1194
1196 std::cout << "chain: " << chains[j] << "\taddchains: " << addchains << std::endl;
1197
1198 if ( addchains && ( contains(chains[j],"Shifter") || ( !contains(chains[j],"HLT_") && !contains(chains[j], "Fullscan" ) ) ) ) {
1199
1200 TFile* fftest = ftest;
1201
1202 if ( chainfiles.size()>0 && chainfiles.size()>j ) fftest = chainTFiles[j];
1203
1204 TH1F* hchain = Get( *fftest, chains[j]+"/Chain", testrun );
1205
1206 if ( hchain ) {
1207
1208 std::string name = hchain->GetTitle();
1209
1210 if ( usechainref && !contains(chains[j],"Purity") ) {
1211
1212 chainref[j] = name;
1213
1214 std::cout << "new chainref: " << chainref[j] << std::endl;
1215
1216 std::string::size_type pos = chainref[j].find(":for");
1217 if ( pos!=std::string::npos ) chainref[j].replace( pos, 4, "_for" );
1218 std::replace( chainref[j].begin(), chainref[j].end(), ':', '/');
1219 std::string newchain = dirname( dirname( chains[j]) ) + "/Expert/" + chainref[j];
1220 chainref[j] = newchain;
1221
1222 std::cout << "final chainref: " << chainref[j] << std::endl;
1223
1224 }
1225
1226 std::cout << "chainref: " << chainref[j] << std::endl;
1227
1228 while ( contains( name, "HLT_" ) ) name = name.erase( name.find("HLT_"), 4 );
1229
1230 std::cout << "name: " << name << std::endl;
1231
1232 if ( contains( name, ":" ) ) chain_name[j] = name.substr( 0, name.find(':') ) + " : ";
1233 else chain_name[j] = name;
1234
1235 if ( chain_name[j] == " : " ) chain_name[j] = "";
1236
1237 std::cout << "chain_name: " << chain_name[j] << std::endl;
1238 }
1239 }
1240 }
1241
1242 std::cout << "chainref size: " << chainref.size() << " " << refchains.size() << std::endl;
1243
1244 for ( size_t j=0 ; j<chainref.size() ; j++ ) {
1245 std::cout << "chainref: " << chainref[j] << " :: " << refchains[j] << std::endl;
1246
1248 if ( chainref[j]!="" ) refchain[j] = fullreplace( chainref[j], pattern, regex );
1249 else refchain[j] = fullreplace( refchains[j], pattern, regex );
1250
1251 if ( !patternr.empty() ) {
1252 if ( chainref[j]!="" ) refchain[j] = fullreplace( chainref[j], patternr, regexr );
1253 else refchain[j] = fullreplace( refchains[j], patternr, regexr );
1254 }
1255
1256 std::cout << "refchain: " << refchain[j] << std::endl;
1257 }
1258
1259 std::cout << "done chains" << std::endl;
1260
1262
1263 std::vector<Panel> panels;
1264
1266
1267 bands bnd;
1268
1269
1270 std::vector<int> ccolours;
1271 std::vector<int> cstyles;
1272
1273 std::vector<std::string> ctags;
1274 std::vector<std::string> ctaglabels;
1275
1276
1277 std::cout << "\n" << argv[0] << "\tconfigfile: " << configfile << std::endl;
1278
1279 bool use_file_config = false;
1280
1281 if ( configfile!="" ) {
1282
1283 if ( exists(configfile) ) {
1284
1285 std::cout << argv[0] << ":\treading configuration file " << configfile << std::endl;
1286
1287 ReadCards rc(configfile);
1288
1289
1291
1292 if ( rc.isTagDefined( "histos" ) ) {
1293
1294 std::cout << argv[0] << ":\treading histogram configuration from file " << configfile << std::endl;
1295
1296 use_file_config = true;
1297
1298 std::vector<std::string> raw_input = rc.GetStringVector( "histos" );
1299
1300 for ( size_t iraw=0 ; iraw<raw_input.size() ; iraw += 6) {
1301 HistDetails h( &(raw_input[iraw]) );
1302 Panel p( h.name(), 1 );
1303 p.push_back( h );
1304 panels.push_back( p );
1305 }
1306
1307 }
1308
1309 std::cout << "searching for panels" << std::endl;
1310
1312
1313 if ( rc.isTagDefined( "panels" ) ) {
1314
1315 std::cout << argv[0] << ":\treading histogram panel configuration from file " << configfile << std::endl;
1316
1317 use_file_config = true;
1318
1319 std::vector<std::string> panel_config = rc.GetStringVector( "panels" );
1320
1321 std::vector<string> panel_columns;
1322
1323 if ( rc.isTagDefined("panel_columns") ) {
1324 panel_columns = rc.GetStringVector( "panel_columns" );
1325 if ( panel_columns.size()%2 ) return usage( argv[0], -1, "incorrect panel settings" );
1326 }
1327
1328
1329 for ( size_t ipanel=panel_config.size() ; ipanel-- ; ) {
1330
1331 std::vector<std::string> raw_input = rc.GetStringVector( panel_config[ipanel] );
1332
1333 int tncols = ncols;
1334
1335 if ( panel_columns.size() ) {
1336 std::vector<string>::iterator itr = find( panel_columns.begin(), panel_columns.end(), panel_config[ipanel] );
1337 if ( itr!=panel_columns.end() ) tncols = std::atoi( (++itr)->c_str() );
1338 }
1339
1340 Panel p( panel_config[ipanel], tncols );
1341
1342 if ( raw_input.empty() ) {
1343 std::cerr << argv[0] << ":\t panel " << panel_config[ipanel] << " is empty";
1344 return -1;
1345 }
1346 for ( size_t iraw=0 ; iraw<raw_input.size() ; iraw += 6 ) p.push_back( HistDetails( &(raw_input[iraw]) ) );
1347
1348 panels.push_back( p );
1349
1350 }
1351
1352 }
1353
1354 if ( rc.isTagDefined( "Bands" ) && rc.isTagDefined( "Labels" ) ) {
1355 bnd = bands( rc.GetVector( "Bands"), rc.GetStringVector( "Labels" ) );
1356 }
1357
1358
1359 if ( rc.isTagDefined("Colours") ) ccolours = rc.GetIntVector("Colours");
1360 if ( rc.isTagDefined("Styles") ) cstyles = rc.GetIntVector("Styles");
1361 if ( rc.isTagDefined("Tags") ) ctags = rc.GetStringVector("Tags");
1362 if ( rc.isTagDefined("TagLabels") ) ctaglabels = rc.GetStringVector("TagLabels");
1363 if ( rc.isTagDefined("TagLabels") ) usrlabels = rc.GetStringVector("TagLabels");
1364
1365 if ( rc.isTagDefined("Styles") ) {
1366 for ( size_t is=0 ; is<cstyles.size() && is<6 ; is++ ) {
1367 markers[is] = cstyles[is];
1368 }
1369 }
1370
1371
1372 uselabels = true;
1373
1374
1375 std::cout << argv[0] << "\tuserlabels :" << usrlabels << ":" << std::endl;
1376
1377
1378
1379 if ( rc.isTagDefined("RANGEMAP") ) RANGEMAP = true;
1380 if ( rc.isTagDefined("ALLRANGEMAP") ) ALLRANGEMAP = true;
1381
1382 std::cout << "Extra: " << rc.isTagDefined("Extra") << std::endl;
1383
1384 if ( rc.isTagDefined("Extra") ) taglabels.push_back( fullreplace( rc.GetString("Extra"), "__", " " ) );
1385
1386
1387 }
1388 else {
1389 std::cerr << argv[0] << ":\t config file not found: " << configfile << std::endl;
1390 return -1;
1391 }
1392
1393 }
1394
1395 if ( !use_file_config ) {
1396
1397 std::cout << "using default panels" << std::endl;
1398
1400
1401 // for ( size_t iraw=0 ; iraw<Nhistos ; iraw++ ) {
1402 // Panel p( histos_default[iraw][0], 1 );
1403 // p.push_back( histos_default[iraw] );
1404 // panels.push_back( p );
1405 // }
1406
1407 // default panel efficiencies plotted from 0 to 100,
1408 // so scale efficiencies no matter what
1409
1410 scale_eff = 100;
1411 scale_eff_ref = 100;
1412
1414
1415 std::string (*inpanels[3])[6] = { eff_panel, res_panel, diff_panel };
1416
1417 size_t nphist[3] = { 4, 4, 10 };
1418
1419 std::string pnames[3] = { "eff", "res", "diff" };
1420
1421 for ( size_t ip=0 ; ip<3 ; ip++ ) {
1422 Panel p( pnames[ip]+"_panel", 2 );
1423 for ( size_t iraw=0 ; iraw<nphist[ip] ; iraw++ ) p.push_back( HistDetails( inpanels[ip][iraw] ) );
1424 panels.push_back( p );
1425 }
1426
1427 }
1428
1429
1430 std::cout << "taglabels" << std::endl;
1431
1432 for ( size_t it=0 ; it<taglabels.size() ; it++ ) std::cout << taglabels[it] << std::endl;
1433
1434
1435 std::cout << "\npanels: " << panels.size() << std::endl;
1436
1437 if ( panels.size()==0 ) return usage(argv[0], -1, "no panels to plot");
1438
1439 for ( size_t ip=0 ; ip<panels.size() ; ip++ ) std::cout << panels[ip] << std::endl;
1440
1441
1443 if ( true ) {
1444 gStyle->SetPadRightMargin(0.05);
1445 gStyle->SetPadTopMargin(0.05);
1446
1447 const Int_t Number = 3;
1448 Double_t Red[Number] = { 0.00, 0.00, 1.00};
1449 Double_t Green[Number] = { 0.00, 5.00, 1.00};
1450 Double_t Blue[Number] = { 0.00, 0.50, 0.00};
1451 Double_t Length[Number] = { 0.00, 0.50, 1.00 };
1452 Int_t nb=50;
1453 TColor::CreateGradientColorTable(Number,Length,Red,Green,Blue,nb);
1454 }
1455 else gStyle->SetPalette(1);
1456
1457 if ( fulldbg ) std::cout << __LINE__ << std::endl;
1458
1459 double rightmargin = gStyle->GetPadRightMargin();
1460 gStyle->SetPadRightMargin(0.1);
1461
1463
1464 gStyle->SetPadRightMargin(rightmargin);
1465
1466 // gStyle->SetLineScalePS(1);
1467
1468 for ( size_t ipanel=0 ; ipanel<panels.size() ; ipanel++ ) {
1469
1470 Panel& panel = panels[ipanel];
1471
1472 std::cout << "\n\n---------------------------------------------\n";
1473
1474 std::cout << panel << "\n" << std::endl;
1475
1476 int ncolsp = panel.ncols();
1477 int nrowsp = panel.nrows();
1478
1479 double extraw = 1;
1480
1481 std::cout << "\nncols: " << ncolsp << "\tnrows: " << nrowsp << std::endl;
1482
1483 bool multipanel = ( panel.size() > 1 );
1484
1485 if ( panel.size()==0 ) {
1486 std::cout << "panel empty: " << panel.name() << std::endl;
1487 continue;
1488 }
1489
1490 gStyle->cd();
1491
1492 if ( panel.size()>4 ) gStyle->SetLineScalePS(0.5);
1493
1494 if ( multipanel ) extraw = 1.05;
1495
1496 TCanvas* tc = new TCanvas( "tc", "", extraw*ncolsp*800, nrowsp*600 );
1497
1498 tc->cd();
1499
1500 const std::string& atlaslabel = atlaslabel_tmp;
1501
1502
1503 if ( multipanel ) {
1504
1505 gStyle->SetLineScalePS(1);
1506
1509
1517
1520
1521 tc->Divide( ncolsp, nrowsp, 0.0001, 0.0003 );
1522 // atlaslabel = " " + atlaslabel_tmp;
1523 }
1524
1526
1527 std::string plotname = "";
1528
1529 for ( size_t i=0 ; i<panel.size() ; i++ ) {
1530
1531 HistDetails histo = panel[i];
1532
1533 bool drawmeans = false;
1534 bool drawresiduals = true;
1535
1536 if ( contains(histo.detail(), "+mean" ) ) drawmeans = true;
1537 if ( contains(histo.detail(), "-residual") ) drawresiduals = false;
1538
1539 std::string xaxis = histo.xtitle();
1540 std::string yaxis = histo.ytitle();
1541
1542 if ( !xregex.empty() ) {
1543 size_t pos = xaxis.find(xregex);
1544 if ( pos!=std::string::npos ) xaxis.replace( pos, xregex.size(), xpattern );
1545 pos = yaxis.find(xregex);
1546 if ( pos!=std::string::npos ) yaxis.replace( pos, xregex.size(), xpattern );
1547 }
1548
1549 const AxisInfo& xinfo = histo.xaxis();
1550 const AxisInfo& yinfo = histo.yaxis();
1551
1552 std::string hname = histo.name();
1553 std::string detail = histo.detail();
1554
1555 double rebin = 1;
1556 bool d0rebin_flag = false;
1557
1558 if ( contains( detail, "+d0rebin" ) ) d0rebin_flag = true;
1559
1560 if ( contains( detail, "+Rebin" ) ) {
1561 rebin = std::atof( detail.substr( detail.find("+Rebin")+6, detail.size() ).c_str() );
1562 }
1563
1564 if ( contains( detail, "+rebin" ) ) {
1565 rebin = std::atof( detail.substr( detail.find("+rebin")+6, detail.size() ).c_str() );
1566 }
1567
1568
1569 int npanel = nrowsp*(i/nrowsp) + i%nrowsp + 1 ;
1570
1571 std::cout << "panel: panel: " << panel.name() << "\tsubpanel: " << npanel << std::endl;
1572
1573 if ( multipanel ) tc->cd( npanel );
1574
1575 SetAtlasStyle();
1576
1577 noreftmp = noref;
1578
1579 Plotter::setplotref(!noreftmp);
1580
1581 if ( fulldbg ) std::cout << __LINE__ << std::endl;
1582
1583 std::cout << "main() processing histo[" << i << "] " << (i<10 ? " " : "" ) << histo.name() << "\t" << histo.xaxis() << std::endl;
1584
1585 Plots plots_eff( "", yinfo.trim() );
1586 plots_eff.clear();
1587
1588 Plots plots( "", yinfo.trim() );
1589 plots.clear();
1590
1591 std::string noreflabel=defreflabel;
1592
1593 double xpos = 0.18;
1594 double ypos = 0.91;
1595
1596 if ( contains(histo.name(),"eff") || contains(histo.name(),"Eff_") ) ypos = 0.19;
1597
1598 // ypos = 0.19;
1599
1602
1603 if ( atlasstyle ) {
1604 xpos = 0.18;
1605 if ( ypos>0.5 ) ypos = 0.85;
1606 else ypos = 0.18;
1607 }
1608
1609 if ( ypos_arg!=0 ) ypos = ypos_arg;
1610
1611 double xpos_original = xpos;
1612
1613 xpos += xoffset;
1614
1615 if ( xinfo.offset() != 0 ) {
1616
1617 std::cout << "HA ! xinfo.offset: " << xinfo.offset() << std::endl;
1618
1619 xpos = xinfo.offset();
1620
1621 }
1622
1623
1624 if ( yinfo.offset() != 0 ) {
1625
1626 std::cout << "HA ! yinfo.offset: " << yinfo.offset() << std::endl;
1627
1628 ypos = yinfo.offset();
1629
1630 }
1631
1632
1633
1635
1636 size_t Nrows = chains.size();
1637
1638 if ( ALLRANGEMAP || (RANGEMAP && xaxis.find("p_{T}")!=std::string::npos && ccolours.size() ) )
1639 Nrows = ( Nrows < ccolours.size() ? Nrows : ccolours.size() );
1640
1641 int Nlines = Nrows + taglabels.size();
1642
1643 std::vector<double> ypositions;
1644
1645 double deltay = (Nrows*0.055-0.005)/Nrows;
1646
1647 double ylo = ypos;
1648 double yhi = ypos-0.01;
1649
1650 if ( ypos>0.5 ) ylo -= Nlines*deltay;
1651 else yhi += Nlines*deltay;
1652
1653 ypositions.reserve(Nlines);
1654 for ( int ilines=0 ; ilines<Nlines ; ilines++ ) {
1655 ypositions.push_back( yhi - deltay*(ilines+0.5) );
1656 }
1657
1658 // specify different legends for efficiencies or residuals?
1659
1661
1662
1663 if ( !contains(histo.name(),"eff") && !contains(histo.name(),"Eff_") ) ylo -= 0.02;
1664
1665 Legend legend( xpos, xpos+0.1, ylo, ylo+Nrows*0.06-0.005 );
1666 Legend legend_eff( xpos, xpos+0.1, ylo, ylo+Nrows*0.06-0.005 );
1667
1668
1669 std::vector<std::string> Mean;
1670 std::vector<std::string> RMS;
1671
1672 Mean.clear();
1673 RMS.clear();
1674
1675 std::vector<std::string> Chi2;
1676 std::vector<std::string> MeanRef;
1677 std::vector<std::string> RMSRef;
1678
1679 // int colours[6] = { 1, 2, 4, 6, 7, 8 };
1680
1681 Chi2.clear();
1682 MeanRef.clear();
1683 RMSRef.clear();
1684
1685 int mean_power = 0;
1686 int rms_power = 0;
1687 bool power_set = false;
1688
1689 LINEF = true;
1690
1692 // bool uselogx = xinfo.log();
1693 // bool uselogy = yinfo.log();
1694
1695 for ( unsigned int j=0; j<chains.size(); j++) {
1696
1697 TFile* fftest = ftest;
1698 TFile* ffref = fref;
1699
1700 if ( chainfiles.size()>0 && chainfiles.size()>j ) ffref = fftest = chainTFiles[j];
1701
1704
1705 std::cout << "chain: " << chains[j] << "\taddchains: " << addchains << std::endl;
1706 std::cout << "chainref: " << chainref[j] << std::endl;
1707
1708 noreftmp = noref;
1709 Plotter::setplotref(!noreftmp);
1710
1711 TH1F* htest = 0;
1712 TH1F* href = 0;
1713
1714 TH1F* htestnum = 0;
1715 TH1F* htestden = 0;
1716 TH1F* hrefnum = 0;
1717
1718 TGraphAsymmErrors* tgtest = 0;
1719
1720 std::cout << "refchain.size() " << refchain.size() << std::endl;
1721
1722 std::cout << "refchain: " << refchain[j] << std::endl;
1723
1725
1726 gPad->SetRightMargin(0.03);
1727
1728 if ( contains(histo.name(),"/2d") ) {
1729
1730 gPad->SetRightMargin(0.13);
1731
1732 TH2D* h2test = Get<TH2D>( *fftest, chains[j]+"/"+histo.name(), testrun, 0, &savedhistos );
1733
1734 DrawLabel( 0.5, 0.5, "a test" );
1735
1736 h2test->GetYaxis()->SetTitleOffset(1.55);
1737 h2test->GetXaxis()->SetTitleOffset(1.5);
1738 h2test->GetXaxis()->SetTitle(xaxis.c_str());
1739 h2test->GetYaxis()->SetTitle(yaxis.c_str());
1740
1741 const AxisInfo& xinfo = histo.xaxis();
1742 const AxisInfo& yinfo = histo.yaxis();
1743
1744
1745 std::cout << xinfo << std::endl;
1746 std::cout << yinfo << std::endl;
1747
1748 if ( yinfo.rangeset() ) {
1749 h2test->GetYaxis()->SetRangeUser( yinfo.lo(), yinfo.hi() );
1750 }
1751
1752 if ( yinfo.normset() ) normy( h2test );
1753
1754 if ( xinfo.rangeset() ) {
1755 h2test->GetXaxis()->SetRangeUser( xinfo.lo(), xinfo.hi() );
1756 }
1757
1758 if ( xinfo.autoset() ) autox( h2test );
1759 if ( yinfo.autoset() ) autoy( h2test );
1760
1761 SetZeros( h2test );
1762
1763 h2test->DrawCopy("colz");
1764
1765 if ( histo.detail().find("logz")!=std::string::npos ) gPad->SetLogz(true);
1766 else gPad->SetLogz(false);
1767
1768
1769 }
1770 else if ( refit_resplots && ( contains(histo.name(),"/sigma") || contains(histo.name(),"/mean") ) ) {
1771
1772 bool bsigma = false;
1773 if ( contains(histo.name(),"/sigma") ) bsigma = true;
1774
1775 bool bmean = false;
1776 if ( contains(histo.name(),"/mean") ) bmean = true;
1777
1778 std::cout << "\trefitting: " << histo.name() << std::endl;
1779
1780 Resplot::setoldrms95(oldrms);
1781 Resplot::setscalerms95(true);
1782
1783 std::string tmp_ = histo.name();
1784 std::string base;
1785
1786 if ( bsigma ) base = chop( tmp_, "/sigma" );
1787 if ( bmean ) base = chop( tmp_, "/mean" );
1788
1789 TH2D* htest2d_ = Get<TH2D>( *fftest, chains[j]+"/"+base+"/2d", testrun, 0, &savedhistos );
1790
1791 std::cout << "ffref " << ffref << std::endl;
1792 TH2D* href2d_ = 0;
1793
1794 if ( ffref ) href2d_ = Get<TH2D>( *ffref, chains[j]+"/"+base+"/2d", testrun );
1795
1796 if ( htest2d_==0 ) continue;
1797 if ( !noreftmp && href2d_==0 ) noreftmp = true;
1798 Plotter::setplotref(!noreftmp);
1799
1801
1802 Resplot rtest("tmp", htest2d_ );
1803
1804 if ( rtest.finalised() ) {
1805 if ( contains(histo.name(),"npix") || contains(histo.name(),"nsct") || contains(histo.name(),"nsi") || contains(histo.name(),"nbl") ) rtest.Refit(Resplot::FitNull);
1806 else rtest.Refit(Resplot::FitNull95);
1807 }
1808 else {
1809 if ( contains(histo.name(),"npix") || contains(histo.name(),"nsct") || contains(histo.name(),"nsi") || contains(histo.name(),"nbl") ) rtest.Finalise(Resplot::FitNull);
1810 else rtest.Finalise(Resplot::FitNull95);
1811 }
1812
1813 if ( bsigma ) { htest = (TH1F*)rtest.Sigma()->Clone("rtest_sigma"); htest->SetDirectory(0); }
1814 if ( bmean ) { htest = (TH1F*)rtest.Mean()->Clone("rtest_mean"); htest->SetDirectory(0); }
1815
1816 if ( htest==0 ) {
1817 std::cerr << "missing test histogram: " << (refchain[j]+" / "+histo.name()) << " " << htest << "(test)" << std::endl;
1818 continue;
1819 }
1820
1821
1824
1825 TH1F* hreft = 0;
1826
1827 if ( !noreftmp ) {
1828 if ( refitref_resplots ) {
1829
1830 Resplot rref("tmp", href2d_ );
1831
1832 if ( rref.finalised() ) {
1833 if ( contains(histo.name(),"npix") || contains(histo.name(),"nsct") ) rref.Refit(Resplot::FitNull);
1834 else rref.Refit(Resplot::FitNull95);
1835 }
1836 else {
1837 if ( contains(histo.name(),"npix") || contains(histo.name(),"nsct") ) rref.Finalise(Resplot::FitNull);
1838 else rref.Finalise(Resplot::FitNull95);
1839 }
1840
1841 if ( bsigma ) { hreft = (TH1F*)rref.Sigma()->Clone("rref_sigma"); hreft->SetDirectory(0); }
1842 if ( bmean ) { hreft = (TH1F*)rref.Mean()->Clone("rref_mean"); hreft->SetDirectory(0); }
1843
1844 }
1845 else {
1846 hreft = Get( *ffref, refchain[j]+"/"+histo.name(), rawrefrun, chainmap );
1847 if ( hreft==0 ) {
1848 std::cerr << "ERROR: could not find " << (refchain[j]+"/"+histo.name()) << std::endl;
1849 }
1850 }
1851 }
1852
1853 if ( !noreftmp && hreft==0 ) {
1854 std::cerr << "missing ref histogram: " << (refchain[j]+" / "+histo.name()) << " " << htest << "(ref)" << std::endl;
1855
1856 noreftmp = true;
1857 Plotter::setplotref(!noreftmp);
1858 noreflabel="reference not found";
1861 // std::exit(-1);
1862 }
1863
1864 if ( !noreftmp ) {
1865 href = (TH1F*)hreft->Clone();
1866 href->SetDirectory(0);
1867 }
1868
1870 // std::cout << "\tget " << (refchain[j]+"/"+histos[i]) << "\t" << href << std::endl;
1871
1872 savedhistos.push_back( refchain[j]+"/"+histo.name() );
1873
1874 }
1875 else {
1876
1877 if ( fulldbg ) std::cout << __LINE__ << std::endl;
1878
1880
1881 std::string reghist = histo.name();
1882
1883 std::cout << "hist: " << (chains[j]+"/"+reghist) << "\tftest " << ftest << std::endl;
1884
1885 htest = Get( *fftest, chains[j]+"/"+reghist, testrun, 0, &savedhistos );
1886
1887 std::cout << "hist: " << htest << std::endl;
1888
1889 std::cout << xaxis << std::endl;
1890
1891 if ( htest==0 ) {
1892 std::cerr << "missing test histogram: " << (chains[j]+" / "+reghist) << " " << htest<< std::endl;
1893 continue;
1894 }
1895
1896 TH1F* hreft = 0;
1897
1898 std::cout << "hreft: " << hreft << std::endl;
1899
1900 if ( ffref ) hreft = Get( *ffref, refchain[j]+"/"+reghist, rawrefrun, chainmap );
1901 else noreftmp = true;
1902
1903 std::cout << "hreft: " << hreft << std::endl;
1904
1905 if ( std::string(htest->ClassName()).find("TH2")!=std::string::npos ) {
1906 std::cout << "Class TH2: " << htest->GetName() << std::endl;
1907 continue;
1908 }
1909
1910 if ( std::string(htest->ClassName()).find("TH1")!=std::string::npos ) {
1911 std::cout << "Class TH1: " << htest->GetName() << std::endl;
1912 }
1913 else if ( std::string(htest->ClassName()).find("TProfile")!=std::string::npos ) {
1914 std::cout << "Class TProf: " << htest->GetName() << std::endl;
1915 }
1916
1917
1918
1919 if ( !noreftmp && hreft==0 ) {
1920 std::cerr << "missing ref histogram: " << (refchain[j]+" / "+reghist)
1921 << " " << hreft << std::endl;
1922 noreftmp = true;
1923 Plotter::setplotref(false);
1924 noreflabel="reference not found";
1927 // std::exit(-1);
1928
1929 }
1930
1931 if ( hreft!=0 ) {
1932 href = (TH1F*)hreft->Clone();
1933 href->SetDirectory(0);
1934 }
1935 else {
1936 noreftmp = true;
1937 href = 0;
1938 }
1939
1940 std::cout << " \tget " << (chains[j]+"/"+reghist) << "\thtest " << htest << std::endl;
1941 std::cout << " \tget " << (refchain[j]+"/"+reghist) << "\thref " << href << std::endl;
1942
1943 if ( htest==0 ) continue;
1944
1945 if ( !noreftmp && href==0 ) {
1946 noreftmp = true;
1947 Plotter::setplotref(!noreftmp);
1948 }
1949
1950 if ( fulldbg ) std::cout << __LINE__ << std::endl;
1951
1952
1953 if ( rebin!=1 ) {
1954 std::cout << "rebin: " << hname << "\t" << rebin << std::endl;
1955 if ( htest ) htest->Rebin(rebin);
1956 if ( href ) href->Rebin(rebin);
1957 for ( int ip=0 ; ip<10 ; ip++ ) std::cout << std::endl;
1958 }
1959
1960#if 0
1962 if ( !contains( histo.name(), "rdz_vs_zed" ) && contains( histo.name(), "1d") ) {
1963 std::cout << "Rebinning histogram: " << histo.name() << std::endl;
1964 if ( htest->GetNbinsX()>500 ) htest->Rebin(10);
1965 if ( href && href->GetNbinsX()>500 ) href->Rebin(10);
1966 }
1967#endif
1968
1969
1970 if ( histo.name().find("zed_eff")!=std::string::npos ) {
1971 if ( htest->GetNbinsX()>100 ) htest->Rebin(5);
1972 if ( href && href->GetNbinsX()>100 ) href->Rebin(5);
1973 }
1974
1975
1976 if ( fulldbg ) std::cout << __LINE__ << std::endl;
1977
1978 if ( scalepix && std::string(htest->GetName()).find("npix")!=std::string::npos ) Scale(htest,0.5);
1979 if ( scalepix && href && std::string(htest->GetName()).find("npix")!=std::string::npos ) Scale(href,0.5);
1980
1981 if ( fulldbg ) std::cout << __LINE__ << std::endl;
1982
1983 if ( notitle ) {
1984 htest->SetTitle("");
1985 if( href ) href->SetTitle("");
1986 }
1987
1988 if ( fulldbg ) std::cout << __LINE__ << std::endl;
1989
1990 }
1991
1992 if ( fulldbg ) std::cout << __LINE__ << std::endl;
1993
1994 if ( make_ref_efficiencies ) {
1995 if ( htest && href ) {
1996
1998 // std::cout << "contains _eff " << contains( std::string(htest->GetName()), "eff" ) << std::endl;
1999
2000 if ( contains( std::string(htest->GetName()), "eff" ) ) {
2001
2002 std::string effhist = histo.name();
2003
2004 htestnum = Get( *fftest, chains[j]+"/"+effhist+"_n", testrun, 0, &savedhistos );
2005
2006 TH1F* hrefnumt = Get( *ffref, refchain[j]+"/"+effhist+"_n", rawrefrun, chainmap, &savedhistos );
2007
2008 if ( !noreftmp && hrefnumt!=0 ) {
2009 hrefnum = (TH1F*)hrefnumt->Clone();
2010 hrefnum->SetDirectory(0);
2011 }
2012
2013 }
2014 }
2015 }
2016
2017
2018 if ( bayes ) {
2019
2020 if ( htest && contains( std::string(htest->GetName()), "eff" ) ) {
2021
2022 std::string effhist = histo.name();
2023
2025
2026 if ( rebin!=1 ) std::cout << effhist << "\trebin: " << rebin << std::endl;
2027
2028 htestnum = Get( *fftest, chains[j]+"/"+effhist+"_n", testrun, 0, &savedhistos ) ;
2029 htestden = Get( *fftest, chains[j]+"/"+effhist+"_d", testrun, 0, &savedhistos ) ;
2030
2031 std::cout << "1: Bayesian error calculation " << htestnum << " " << htestden << "\tscale " << scale_eff << std::endl;
2032
2033 if ( htestnum && htestden ) {
2034
2035 if ( d0rebin_flag ) {
2036 htestnum = d0rebin( htestnum );
2037 htestden = d0rebin( htestden );
2038 }
2039 else if ( rebin!=1 ) {
2040 htestnum = Rebin(htestnum, rebin );
2041 htestden = Rebin(htestden, rebin );
2042 }
2043
2044 std::cout << "test histogram name: : " << htestnum->GetName() << "\txaxis: " << xaxis << "\t" << std::endl;
2045
2046 // if ( xaxis.find("p_{T}")!=std::string::npos || xaxis.find("pt")!=std::string::npos ) {
2047 if ( std::string(htestnum->GetName()).find("ntrax_eff")!=std::string::npos ) {
2048
2049 bool low = true;
2050
2051 // if ( chains[j].find("j55")!=std::string::npos ) low = false;
2052
2053 htestnum = rebin_log( htestnum, low );
2054 htestden = rebin_log( htestden, low );
2055 }
2056
2057#if 0
2060 if ( contains( htest->GetName(), "_vs_lb" ) ) {
2061 std::cout << "rebin " << histo.name() << std::endl;
2062 htestnum->Rebin(3);
2063 htestden->Rebin(3);
2064 }
2065
2066 if ( contains( htest->GetName(), "eta_eff" ) ) {
2067 std::cout << "rebin " << histo.name() << std::endl;
2068 htestnum->Rebin(2);
2069 htestden->Rebin(2);
2070 }
2071#endif
2072
2073 // if ( RANGEMAP && (effhist.find("pT")!=std::string::npos || effhist.find("pt")!=std::string::npos ) ) {
2074 if ( RANGEMAP && (effhist.find("ET")!=std::string::npos ) ) {
2075 std::cout << "\trange: " << j << " " << htest << std::endl;
2076 bnd.range( chains[j], htestnum );
2077 bnd.range( chains[j], htestden );
2078 }
2079
2080
2081 Efficiency1D e( htestnum, htestden, "", scale_eff );
2082 tgtest = e.Bayes(scale_eff);
2083
2084 htest = e.Hist();
2085
2086 std::cout << "effhist: " << effhist << std::endl;
2087
2088 }
2089
2091
2092 std::cout << "recalculating reference efficiencies ..." << std::endl;
2093
2094 if ( href ) {
2095
2096 std::cout << "doin ..." << std::endl;
2097
2098 TH1F* hrefnum = Get( *ffref, refchain[j]+"/"+histo.name()+"_n", rawrefrun, chainmap );
2099
2100 TH1F* hrefden = Get( *ffref, refchain[j]+"/"+histo.name()+"_d", rawrefrun, chainmap );
2101
2102 std::cout << "2. Bayesian error calculation " << htestnum << " " << htestden << "\tscale " << scale_eff << std::endl;
2103 std::cout << "3. Bayesian error calculation " << hrefnum << " " << hrefden << "\tscale " << scale_eff_ref << std::endl;
2104
2105
2106 if ( hrefnum && hrefden ) {
2107
2108 if ( d0rebin_flag ) {
2109 hrefnum = d0rebin( hrefnum );
2110 hrefden = d0rebin( hrefden );
2111 }
2112 else if ( rebin!=1 ) {
2113 hrefnum = Rebin(hrefnum, rebin );
2114 hrefden = Rebin(hrefden, rebin );
2115 }
2116
2117 Efficiency1D e( hrefnum, hrefden, "", scale_eff_ref );
2119 // tgref = e.Bayes(scale_eff);
2120
2121 href = e.Hist();
2122
2123 }
2124 }
2125 }
2126
2127 }
2128
2129
2130 if ( htest==0 ) {
2131 std::cout << " no test histogram : " << (chains[j]+"/"+histo.name()) << std::endl;
2132 continue;
2133 }
2134
2135 if ( !noreftmp && href==0 ) {
2136 std::cout << " no ref histogram : " << (chains[j]+"/"+histo.name()) << std::endl;
2137 noreftmp = true;
2138 Plotter::setplotref(!noreftmp);
2139 noreflabel="reference not found";
2142 // continue;
2143 }
2144
2145
2146 htest->GetYaxis()->SetTitleOffset(1.55);
2147 htest->GetXaxis()->SetTitleOffset(1.5);
2148 htest->GetXaxis()->SetTitle(xaxis.c_str());
2149 htest->GetYaxis()->SetTitle(yaxis.c_str());
2150
2151 if ( !noreftmp ) {
2152 href->GetYaxis()->SetTitleOffset(1.5);
2153 href->GetXaxis()->SetTitleOffset(1.5);
2154 href->GetXaxis()->SetTitle(xaxis.c_str());
2155 if ( contains(yaxis,"Efficiency") && !contains(yaxis,"%") && scale_eff==100 ) href->GetYaxis()->SetTitle((yaxis+" [%]").c_str());
2156 else href->GetYaxis()->SetTitle(yaxis.c_str());
2157 }
2158
2159 if ( fulldbg ) std::cout << __LINE__ << std::endl;
2160
2161#if 1
2162 if ( contains(histo.name(),"ntracks") ) {
2163
2164 double xm = htest->GetMean();
2165
2166 if ( xm>=10 ) {
2167 double lxm = std::log10(xm);
2168 int newbins = int(0.5+xm/std::pow(10,int(lxm)))*pow(10,int(lxm));
2169 int nrebin = int( (newbins+5)/10 );
2170
2171 if ( nrebin>1 ) {
2172 std::cout << "rebin: " << htest->GetName() << "\tbins: " << nrebin << std::endl;
2173 htest->Rebin(nrebin);
2174 htest->Sumw2();
2175 if ( !noreftmp ) {
2176 href->Rebin(nrebin);
2177 href->Sumw2();
2178 }
2179 }
2180 }
2181 }
2182#endif
2183
2184 if ( fulldbg ) std::cout << __LINE__ << std::endl;
2185
2187 if ( plotname == "" ) {
2188
2189 if ( key!="" ) {
2190 htest->SetTitle("");
2191 if ( href ) href->SetTitle("");
2192 plotname = key+"_";
2193 }
2194 else if (fcontains(chains[j],"HLT_")) {
2195 htest->SetTitle("");
2196 if ( href ) href->SetTitle("");
2197 plotname = "HLT_";
2198 }
2199 else if (fcontains(chains[j],"EF_")) {
2200 htest->SetTitle("");
2201 if ( href ) href->SetTitle("");
2202 plotname = "EF_";
2203 }
2204 else if (fcontains(chains[j],"L2_")) {
2205 htest->SetTitle("");
2206 if ( href ) href->SetTitle("");
2207 plotname = "L2_";
2208 }
2209 else if (contains(chains[j],"FTK") && ! contains(chains[j],"HLT_") ) {
2210 htest->SetTitle(("FTK "+ histo.name()).c_str());
2211 if ( href ) href->SetTitle(("FTK "+ histo.name()).c_str());
2212 plotname = "FTK_";
2213 }
2214
2215 plotname += histo.name();
2216
2219 replace(plotname, '/', '_');
2220
2221 }
2222
2223
2224 if ( fulldbg ) std::cout << __LINE__ << std::endl;
2225
2226 bool residual = false;
2227
2228 if ( contains(histo.name(),"_res") || contains(histo.name(),"residual_") || contains(histo.name(),"1d") ) residual = true;
2229
2230
2231
2232
2233 std::string collection = basename( chains[j] );
2234
2235 std::string actual_chain = basename( dirname( chains[j] ) );
2236
2237 if ( collection.find("_InDet")!=std::string::npos ) collection.erase( 0, collection.find("_InDet")+1 );
2238 if ( actual_chain.find("_InDet")!=std::string::npos ) actual_chain.erase( actual_chain.find("_InDet") );
2239
2240
2241 std::cout << "raw: " << chains[j] << std::endl;
2242
2243 std::cout << "track collection: " << collection << std::endl;
2244 std::cout << "actual chain: " << actual_chain << std::endl;
2245
2246 std::regex rx("_HLT_[^_]*RoI.*");
2247 std::regex rx1("_HLT_[^_]*_RoI.*");
2248
2249 actual_chain = std::regex_replace( actual_chain, std::regex( "_HLT_IDTrack.*" ), "" );
2250
2251 collection = std::regex_replace( collection, std::regex(".*HLT_IDTrack_"), "IDTrack " );
2252 collection = std::regex_replace( collection, std::regex("IDTrack "), "" );
2253 collection = std::regex_replace( std::regex_replace( collection, rx, "" ), rx1, "" );
2254
2255 if ( actual_chain.find("HLT_IDTrack_")!=std::string::npos ) actual_chain.erase( actual_chain.find("HLT_IDTrack_"), 12 );
2256 if ( actual_chain.find("_IDTrack_")!=std::string::npos ) actual_chain.erase( actual_chain.find("_IDTrack_"), 9 );
2257 if ( actual_chain.find("IDTrack")!=std::string::npos ) actual_chain.erase( actual_chain.find("IDTrack"), 7 );
2258 if ( actual_chain.find("_idperf")!=std::string::npos ) actual_chain.erase( actual_chain.find("_idperf"), 7 );
2259 if ( actual_chain.find("_bperf")!=std::string::npos ) actual_chain.erase( actual_chain.find("_bperf"), 6 );
2260 if ( actual_chain.find("_boffperf")!=std::string::npos ) actual_chain.erase( actual_chain.find("_boffperf"), 9 );
2261 if ( actual_chain.find("_HLT_")!=std::string::npos ) actual_chain.replace( actual_chain.find("_HLT_"), 5, " " );
2262 if ( actual_chain.find("HLT_")!=std::string::npos ) actual_chain.erase( actual_chain.find("HLT_"), 4 );
2263
2264 if ( collection.find("_IDTrkNoCut")!=std::string::npos ) collection.erase( collection.find("_IDTrkNoCut"), 11 );
2265 if ( collection.find("xAODCnv")!=std::string::npos ) collection.erase( collection.find("xAODCnv"), 7 );
2266 if ( collection.find("HLT_IDTrack_")!=std::string::npos ) collection.erase( collection.find("HLT_IDTrack_"), 12 );
2267 if ( collection.find("HLT_IDTrack")!=std::string::npos ) collection.erase( collection.find("HLT_IDTrack"), 11 );
2268 if ( collection.find("Tracking")!=std::string::npos ) collection.replace( collection.find("Tracking"), 8, "Trk" );
2269 if ( collection.find("InDetTrigTrk_")!=std::string::npos ) collection.erase( collection.find("InDetTrigTrk_"), 13 );
2270 if ( collection.find("HLT_xAODTracks_")!=std::string::npos ) collection.erase( collection.find("HLT_xAODTracks_"), 15 );
2271 if ( collection.find("_HLT_")!=std::string::npos ) collection.replace( collection.find("_HLT_"), 5, " " );
2272 if ( collection.find("HLT_")!=std::string::npos ) collection.erase( collection.find("HLT_"), 4 );
2273
2274
2275 if ( actual_chain.size()>30 ) {
2276 size_t pos = actual_chain.find_last_of("_");
2277 while ( pos!=std::string::npos && actual_chain.size()>30 ) {
2278 actual_chain.erase( pos, actual_chain.size()-pos );
2279 actual_chain+="...";
2280 pos = actual_chain.find_last_of("_");
2281 }
2282 }
2283
2284 std::string c = actual_chain + " : " + collection;
2285
2286 std::cout << "track collection: " << collection << " <-" << std::endl;
2287 std::cout << "actual chain: " << actual_chain << " <-" << std::endl;
2288
2289 replace( c, "_In", " : " );
2290
2291 c = " " + c;
2292
2293 std::cout << "use label: " << c << "\tchains size " << chains.size() << "\t" << usrlabels.size() << std::endl;
2294
2295 std::cout << "chains.size() " << chains.size() << " " << j << std::endl;
2296 std::cout << "chains.size() " << chains.size() << " " << j << std::endl;
2297
2298 std::cout << "chains[j] : " << j << " " << chains[j] << std::endl;
2299
2300 std::cout << "userlabels.size() " << usrlabels.size() << std::endl;
2301
2302 if ( usrlabels.size() < j+1 ) {
2303 if ( usrlabels.size()!=0 ) std::cerr << "userlabels not large enough - not using userlabels" << std::endl;
2304 }
2305 else c = usrlabels[ j ];
2306
2307 std::cout << "use label: c: " << c << std::endl;
2308
2310
2311 // std::cout << "adding plot " << histos[i] << " " << htest->GetName() << std::endl;
2312
2313 if ( fulldbg ) std::cout << __LINE__ << std::endl;
2314
2315
2316
2317 std::cout << "\n\n\n\nxaxis: " << xaxis << std::endl;
2318
2319
2320
2321 if ( ALLRANGEMAP || xaxis.find("p_{T}")!=std::string::npos || xaxis.find("E_{T}")!=std::string::npos ) {
2322
2323 if ( RANGEMAP && xaxis.find("p_{T}")!=std::string::npos ) {
2324 bnd.range( chains[j], htest );
2325 if ( href ) bnd.range( chains[j], href );
2326 }
2327
2328 if ( RANGEMAP || ALLRANGEMAP ) {
2329
2330 LINEF = false;
2331
2332 std::cout << "\n\n\nctags " << ctags.size() << "\n\n" << std::endl;
2333
2334 for ( size_t ic=0 ; ic<ctags.size() ; ic++ ) {
2335
2336 // std::cout << "\tctags[" << ic << "] = " << ctags[ic] << std::endl;
2337
2338 std::cout << "\n\nic: " << ic << " " << ctags[ic] << " " << ccolours[ic] << "\n\n" << std::endl;
2339
2340 if ( chains[j].find(ctags[ic])!=std::string::npos ) {
2341 std::cout << "\ttag " << ctags[ic] << " \tcolour: " << ccolours[ic] << "\tstyle: " << cstyles[ic] << std::endl;
2342 htest->SetLineColor( ccolours[ic] );
2343 htest->SetMarkerColor( ccolours[ic] );
2344 htest->SetMarkerStyle( cstyles[ic] );
2345 c = ctaglabels[ic];
2346 if ( tgtest ) {
2347 tgtest->SetLineColor(htest->GetMarkerColor());
2348 tgtest->SetMarkerStyle(htest->GetMarkerStyle());
2349 tgtest->SetMarkerColor(htest->GetMarkerColor());
2350 }
2351 break;
2352 }
2353 }
2354
2355 }
2356
2357 std::cout << "test: " << chains[j] << "chains colour: " << htest->GetMarkerColor() << std::endl;
2358
2359 }
2360
2361
2362 std::cout << "movin' on ..." << std::endl;
2363
2364 std::cout << "chain: " << chains[j] << " \t marker colour: " << htest->GetMarkerColor() << std::endl;
2365
2366 // std::exit(0);
2367
2368 std::cout << "Plotter marker : " << htest->GetMarkerColor() << " " << htest->GetMarkerStyle() << std::endl;
2369
2370 // if ( uselabels ) plots.push_back( Plotter( htest, href, chain_name+usrlabels[j], tgtest ) );
2371 if ( uselabels ) plots.push_back( Plotter( htest, href, " " + chain_name[j] + c, tgtest ) );
2372 else {
2373 std::cout << "using label: " << c << std::endl;
2374 plots.push_back( Plotter( htest, href, c, tgtest ) );
2375 }
2376
2377 if ( ALLRANGEMAP || ( RANGEMAP && xaxis.find("p_{T}")!=std::string::npos ) ) plots.back().max_entries( ccolours.size() );
2378
2379 if ( fulldbg ) std::cout << __LINE__ << std::endl;
2380
2381 if ( make_ref_efficiencies ) {
2382
2383 if ( htestnum && hrefnum ) {
2384 Efficiency1D e( htestnum, hrefnum, "", scale_eff );
2385
2386 TH1* h = e.Hist();
2387
2388 double range = h->GetMaximum()-h->GetMinimum();
2389
2390 if ( range<0.2*scale_eff ) {
2391
2392 double max = int( (h->GetMaximum() + 20)*0.1 )*0.1*scale_eff;
2393 double min = int( (h->GetMinimum() - 10)*0.1 )*0.1*scale_eff;
2394
2395 if ( max>1*scale_eff ) max = 1.02*scale_eff;
2396 if ( min<0 ) min = 0;
2397
2398 h->SetMinimum(min);
2399 h->SetMaximum(max);
2400
2401 }
2402
2403 plots_eff.push_back( Plotter( e.Hist(), 0, c ) );
2404
2405 }
2406 }
2407
2408
2409 if ( href ) Chi2.push_back( label( "chi2 = %5.2lf / %2.0lf", chi2( htest, href ), double(htest->GetNbinsX()) ) );
2410
2411 if ( drawmeans ) {
2412
2413 double mean_95 = htest->GetMean();
2414 double dmean_95 = htest->GetMeanError();
2415 double rms_95 = htest->GetRMS();
2416 double drms_95 = htest->GetRMSError();
2417
2418 Mean.push_back(label(" mean = %4.2lf #pm %4.2lf", mean_95, dmean_95) );
2419 RMS.push_back(label( " rms = %4.2lf #pm %4.2lf", rms_95, drms_95 ) );
2420
2421 }
2422
2423 if ( residual && drawresiduals ) {
2424
2426
2427 xpos = xpos_original;
2428
2429 std::cout << "calculating resolutions : " << histo.name() << " " << htest->GetName() << std::endl;
2430 //dangerous cast, but FitNull95 takes a TH1D * argument
2431 TF1* d95 = Resplot::FitNull95( reinterpret_cast<TH1D*>(htest) );
2432
2433 double mean_95 = d95->GetParameter(1);
2434 double dmean_95 = d95->GetParError(1);
2435 double rms_95 = d95->GetParameter(2);
2436 double drms_95 = d95->GetParError(2);
2437
2438 std::cout << "\t\t" << histo.name()
2439 << "\tmean: " << mean_95 << " +- " << dmean_95
2440 << "\trms: " << rms_95 << " +- " << drms_95 << std::endl;
2441
2443
2444 if ( !power_set ) {
2445 for ( int ip=-2 ; ip<9 ; ip++ ) {
2446 if ( std::fabs(mean_95) >= std::pow( 10., double(-ip) ) ) {
2447 mean_power = ip;
2448 break;
2449 }
2450 }
2451
2452 for ( int ip=-2 ; ip<9 ; ip++ ) {
2453 if ( std::fabs(rms_95) >= std::pow( 10., double(-ip) ) ) {
2454 rms_power = ip;
2455 break;
2456 }
2457 }
2458 }
2459
2460 power_set = true;
2461
2462 std::cout << "\t\t" << histo.name()
2463 << "\tmean: " << mean_95 << " +- " << dmean_95 << " : pow " << mean_power
2464 << "\trms: " << rms_95 << " +- " << drms_95 << " : pow " << rms_power << std::endl;
2465
2466
2467 if ( mean_power == 0 ) {
2468 Mean.push_back(label("mean_{95} = %4.2lf #pm %4.2lf", mean_95, dmean_95) );
2469 }
2470 else {
2471 Mean.push_back(label("mean_{95} = ( %4.2lf #pm %4.2lf ) #times 10^{%d}",
2472 mean_95*std::pow(10.,double(mean_power)), dmean_95*std::pow(10,double(mean_power)), -mean_power ) );
2473
2474 }
2475
2476 if ( rms_power == 0 ) {
2477 RMS.push_back(label( "rms_{95} = %4.2lf #pm %4.2lf", rms_95, drms_95 ) );
2478 }
2479 else {
2480 RMS.push_back(label( "rms_{95} = ( %4.2lf #pm %4.2lf ) #times 10^{%d}",
2481 rms_95*std::pow(10.,double(rms_power)), drms_95*std::pow(10,double(rms_power)), -rms_power ) );
2482 }
2483
2484 if ( href ) {
2485 //dangerous cast, but FitNull95 takes a TH1D * argument
2486 TF1* d95ref = Resplot::FitNull95( reinterpret_cast<TH1D*>(href) );
2487
2488 double mean_95ref = d95ref->GetParameter(1);
2489 double dmean_95ref = d95ref->GetParError(1);
2490 double rms_95ref = d95ref->GetParameter(2);
2491 double drms_95ref = d95ref->GetParError(2);
2492
2493 std::cout << "\t\t" << histo.name()
2494 << "\tmean ref: " << mean_95ref << " +- " << dmean_95ref << " : pow " << mean_power
2495 << "\trms ref: " << rms_95ref << " +- " << drms_95ref << " : pow " << rms_power << std::endl;
2496
2497 if ( mean_power == 0 ) {
2498 MeanRef.push_back(label("mean_{95} ref = %4.2lf #pm %4.2lf", mean_95ref, dmean_95ref) );
2499 }
2500 else {
2501 MeanRef.push_back(label("mean_{95} ref = ( %4.2lf #pm %4.2lf ) #times 10^{%d}",
2502 mean_95ref*std::pow(10,double(mean_power)), dmean_95ref*std::pow(10,double(mean_power)), -mean_power ) );
2503
2504 }
2505
2506
2507 if ( rms_power == 0 ) {
2508 RMSRef.push_back(label( "rms_{95} ref = %4.2lf #pm %4.2lf", rms_95ref, drms_95ref ) );
2509 }
2510 else {
2511 RMSRef.push_back(label( "rms_{95} ref = ( %4.2lf #pm %4.2lf ) #times 10^{%d}",
2512 rms_95ref*std::pow(10,double(rms_power)), drms_95ref*std::pow(10,double(rms_power)), -rms_power ) );
2513 }
2514 }
2515
2516 htest->Sumw2();
2517 if ( href ) href->Sumw2();
2518 }
2519
2520 if ( yinfo.normset() ) {
2521 Norm( htest );
2522 if ( href ) Norm( href );
2523 }
2524 else if ( yinfo.refnormset() ) {
2525 if ( href ) Norm( href, Entries(htest) );
2526 }
2527
2528 if ( yinfo.binwidth() ) {
2529 binwidth( htest );
2530 if ( href ) binwidth( href );
2531 }
2532
2533
2534
2535 if ( !noreftmp && normref &&
2536 !contains( histo.name(), "mean") && !contains( histo.name(), "sigma" ) &&
2537 !contains( histo.name(), "Eff") && !contains( histo.name(), "eff") &&
2538 !contains( histo.name(), "Res") && !contains( histo.name(), "vs") && !contains( histo.name(), "_lb") ) {
2539 Norm( href, Entries( htest ) );
2540 }
2541
2542 }
2543
2544 if ( fulldbg ) std::cout << __LINE__ << std::endl;
2545
2546 if ( !noplots ) {
2547
2550
2551 if ( fulldbg ) std::cout << __LINE__ << std::endl;
2552
2554 plots.sortx( xinfo );
2555
2556 if ( fulldbg ) std::cout << __LINE__ << std::endl;
2557
2558 double yminset = 0;
2559 double ymaxset = 0;
2560
2561 double rmin = 0;
2562 double rmax = 0;
2563
2564 if ( xinfo.rangeset() ) {
2565 rmin = plots.realmin( plots.lo(), plots.hi() );
2566 rmax = plots.realmax( plots.lo(), plots.hi() );
2567 }
2568 else {
2569 rmin = plots.realmin();
2570 rmax = plots.realmax();
2571 }
2572
2573 if ( yinfo.autoset() ) {
2574
2575 int csize = chains.size() + taglabels.size() + ( atlasstyle ? 1 : 0 );
2576
2577 if ( yinfo.log() && rmin>0 && rmax>0 ) {
2578
2580 double delta = std::log10(rmax)-std::log10(rmin);
2581
2583 // ymaxset = rmax*std::pow(10,delta*0.15*csize);
2584
2585 yminset = rmin*std::pow(10,-delta*0.1);
2586
2587 double newdelta = std::log10(rmax) - std::log10(yminset) + 0.05*delta;
2588
2589 if ( csize<10 ) ymaxset = rmin*std::pow(10,newdelta/(1-0.07*csize));
2590 else ymaxset = rmin*std::pow(10,newdelta*2);
2591
2592 if ( yminset!=yminset ) {
2593 std::cerr << " range error " << delta << " " << yminset << " " << ymaxset << "\t(" << rmin << " " << rmax << ")" << std::endl;
2597 continue;
2598 }
2599
2600 }
2601 else {
2602
2605
2606 if ( ypos>0.5 ) {
2607 double delta = rmax-rmin;
2608
2609 yminset = rmin-0.1*delta;
2610
2611 if ( rmin>=0 && yminset<=0 ) yminset = 0;
2612
2613 double newdelta = rmax - yminset + 0.05*delta;
2614
2615 if ( csize<10 ) ymaxset = yminset + newdelta/(1-0.09*csize);
2616 else ymaxset = yminset + newdelta*2;
2617 }
2618 else {
2619 double delta = rmax-rmin;
2620
2621 ymaxset = rmax+0.1*delta;
2622
2623 double newdelta = ymaxset - rmin - 0.05*delta;
2624
2625 if ( csize<10 ) yminset = ymaxset - newdelta/(1-0.09*csize);
2626 else yminset = ymaxset - newdelta*2;
2627
2628 if ( rmin>=0 && yminset<=0 ) yminset = 0;
2629
2630 }
2631
2632 }
2633
2634 }
2635 else {
2636 if ( yinfo.rangeset() ) {
2637 yminset = yinfo.lo();
2638 ymaxset = yinfo.hi();
2639 }
2640 }
2641
2642 if ( fulldbg ) std::cout << __LINE__ << std::endl;
2643
2644 // more useful debugging ...
2645 // std::cout << "yauto: " << yinfo.autoset() << "\tyrange " << yinfo.rangeset() << std::endl;
2646
2647 // std::cout << "yminset " << yminset << "\tymaxset " << ymaxset << std::endl;
2648
2649 if ( yinfo.autoset() && yinfo.rangeset() ) {
2650
2651 if ( fulldbg ) std::cout << __LINE__ << std::endl;
2652
2653 if ( yminset>yinfo.lo() ) yminset = yinfo.lo();
2654 if ( ymaxset<yinfo.hi() ) ymaxset = yinfo.hi();
2655 }
2656
2657
2658 if ( contains(histo.name(),"_eff") ) {
2659
2660 if ( fulldbg ) std::cout << __LINE__ << std::endl;
2661
2662 if ( effset ) {
2663 ymaxset = effmax;
2664 yminset = effmin;
2665 }
2666 }
2667
2668 if ( ymaxset!=0 || yminset!=0 ) {
2669
2670 if ( fulldbg ) std::cout << __LINE__ << std::endl;
2671
2672 plots.Max( ymaxset );
2673 plots.Min( yminset );
2674 }
2675
2676 if ( fulldbg ) std::cout << __LINE__ << std::endl;
2677
2678 if ( yminset!=0 || ymaxset!=0 ) {
2679 if ( yminset>0 ) plots.SetLogy(yinfo.log());
2680 else plots.SetLogy(false);
2681 }
2682 else plots.SetLogy(yinfo.log());
2683
2684 // plots.SetLogy(false);
2685
2686 if ( fulldbg ) std::cout << __LINE__ << std::endl;
2687
2688 // plots.limits();
2689
2691
2692 if ( fulldbg ) std::cout << __LINE__ << std::endl;
2693
2694 plots.Draw( legend );
2695
2696 if ( fulldbg ) std::cout << __LINE__ << std::endl;
2697
2698 if ( atlasstyle ) ATLASLabel( xpos, ypositions[0]+deltay, atlaslabel, kBlack, ncolsp, nrowsp );
2699
2700 if ( fulldbg ) std::cout << __LINE__ << std::endl;
2701
2702 for ( unsigned it=0 ; it<taglabels.size() ; it++ ) {
2703 DrawLabel( xpos, ypositions[it], taglabels[it], kBlack, 0.04 );
2704 }
2705 }
2706
2707 if ( fulldbg ) std::cout << __LINE__ << std::endl;
2708
2709
2710 if ( ( !nostats || !nomeans ) && !noplots ) {
2711 if ( dochi2 ) for ( unsigned j=0 ; j<Chi2.size() ; j++ ) DrawLabel( 0.75, 0.85-j*0.035, Chi2[j], colours[j%6] );
2712 if ( ( (contains(histo.name(),"_res") ||
2713 contains(histo.name(),"1d") ||
2714 histo.name()=="pT" ||
2715 contains(histo.name(),"residual_") ||
2716 contains(histo.name(),"vs_pt") ) && !contains(histo.name(),"sigma") ) || drawmeans ) {
2717
2718 if ( contains(histo.name(),"_res") || contains(histo.name(),"residual_") || contains(histo.name(),"1d") || drawresiduals ){
2719 for ( unsigned j=0 ; j<chains.size() ; j++ ) {
2720 if ( !noreftmp ) {
2721 if ( j<MeanRef.size() ) {
2722 if ( !nomeans ) DrawLabel( xpos_original-0.02, (0.67-j*0.035), MeanRef[j], colours[j%6] );
2723 DrawLabel( xpos_original-0.01, (0.67-0.035*chains.size()-j*0.035)-0.01, RMSRef[j], colours[j%6] );
2724 }
2725 }
2726 if ( j<Mean.size() ) {
2727 if ( !nomeans ) DrawLabel( 0.62, (0.67-j*0.035), Mean[j], colours[j%6] );
2728 DrawLabel( 0.62, (0.67-0.035*chains.size()-j*0.035)-0.01, RMS[j], colours[j%6] );
2729 }
2730 }
2731 }
2732 }
2733
2734 }
2735
2736 if ( xinfo.log() ) gPad->SetLogx(true);
2737 else gPad->SetLogx(false);
2738
2739 if ( yinfo.log() ) gPad->SetLogy(true);
2740 else gPad->SetLogy(false);
2741
2742 if ( fulldbg ) std::cout << __LINE__ << std::endl;
2743
2744 if ( !noplots ) {
2745
2746 if ( make_ref_efficiencies ) {
2747
2748 plots_eff.SetXaxisTitle( plots.GetXaxisTitle() );
2749 plots_eff.SetYaxisTitle( plots.GetYaxisTitle() );
2750
2751 plots_eff.Draw( legend_eff );
2752 }
2753
2754 if ( !noreflabel.empty() ) DrawLabel(0.1, 0.06, noreflabel, kRed, 0.03 );
2755
2756 } // no plots
2757
2758 }
2759
2760
2766
2767 if ( !noplots ) {
2768
2769 if ( !quiet ) {
2770
2771 tc->cd();
2772
2773 std::string useplotname;
2774
2775 if ( panel.size()>1 ) {
2776 useplotname = panel.name();
2777 replace( useplotname, '/', '_' );
2778 }
2779 else {
2780 useplotname = plotname;
2781 }
2782
2783 useplotname.erase( std::remove( useplotname.begin(), useplotname.end(), '+' ), useplotname.end() );
2784
2785 // std::string printbase = dir+"HLT_"+ppanelname+tag;
2786 std::string printbase = dir + useplotname + tag;
2787
2788 tc->Update();
2789
2790 if ( !nopdf ) print_pad( printbase+".pdf" );
2791 if ( !nopng ) print_pad( printbase+".png" );
2792 if ( Cfile ) print_pad( printbase+".C" );
2793
2794 std::cout << std::endl;
2795 }
2796
2797 }
2798
2799 if ( tc ) delete tc;
2800
2801 }
2802
2803
2804 if ( fulldbg ) std::cout << __LINE__ << std::endl;
2805
2807
2808
2810 bool files_duplicated = ( fref_==ftest_ );
2811
2812 if ( deleteref && !files_duplicated ) {
2813
2814 if ( fref_ ) {
2815
2817
2818 std::cout << "main() cleaning up reference file" << std::endl;
2819
2820 TFile* newout = new TFile(".newout.root","recreate");
2821 newout->cd();
2822
2824 copyReleaseInfo( fref, newout );
2825
2826 TDirectory* base = gDirectory;
2827
2828 for ( unsigned i=0 ; i<savedhistos.size() ; i++ ) {
2829
2831 // std::cout << i << " " << savedhistos[i] << std::endl;
2832
2833 std::vector<std::string> dirs = AxisInfo::split( savedhistos[i], "/" );
2834
2835 for ( unsigned j=0 ; j<dirs.size()-1 ; j++ ) {
2836 std::cout << "\t" << dirs[j] << std::endl;
2837 TDirectory* renedir = gDirectory->GetDirectory( dirs[j].c_str() );
2838 if ( renedir==0 ) gDirectory->mkdir( dirs[j].c_str() );
2839 gDirectory->cd( dirs[j].c_str() );
2840 }
2841
2842
2843 TH1* href = (TH1*)fref->Get( savedhistos[i].c_str() );
2844 if ( !noreftmp && href ) {
2845 std::cout << i << " " << savedhistos[i] << " 0x" << href << std::endl;
2846 href->Write( dirs.back().c_str() );
2847 }
2848
2849
2850 base->cd();
2851 }
2852
2853 newout->Close();
2854
2855 }
2856 }
2857
2858
2859 if ( fulldbg ) std::cout << __LINE__ << std::endl;
2860
2862
2863 if ( fref_ && !files_duplicated ) fref_->Close();
2864 if ( ftest_ ) ftest_->Close();
2865
2867
2868 if ( deleteref && !noref ) {
2869 std::cout << "ref " << frefname << "\ttest " << ftestname << std::endl;
2870 if ( frefname != ftestname && !files_duplicated ) {
2871 std::string cmd = std::string("mv ") + frefname + " " + frefname + ".bak";
2872 std::system( cmd.c_str() );
2873
2874 cmd = std::string("mv .newout.root ") + std::string(frefname);
2875 std::system( cmd.c_str() );
2876 }
2877 else {
2878 std::cerr << "reference file and test file are the same - not replacing" << std::endl;
2879 }
2880 }
2881
2882 // std::cout << "deleting " << __LINE__ << std::endl;
2883
2884 if ( fref_ && !files_duplicated ) delete fref_;
2885 if ( ftest_ ) delete ftest_;
2886
2887 return 0;
2888}
DrawLabel
int DrawLabel(float xstart, float ystart, string label)
Definition GraphToolKit.h:13
AtlasStyle
TStyle * AtlasStyle()
Definition AtlasStyle.cxx:34
tc
static Double_t tc
Definition LArPhysWaveHECTool.cxx:38
rc
static Double_t rc
Definition LArPhysWaveHECTool.cxx:37
ATLASLabel
void ATLASLabel(Double_t x, Double_t y, char *text=NULL, Color_t color=1)
pow
constexpr int pow(int base, int exp) noexcept
Definition ap_fixedTest.cxx:15
min
#define min(a, b)
Definition cfImp.cxx:40
max
#define max(a, b)
Definition cfImp.cxx:41
AxisInfo
class to store information about axes, limits, whether it is log or linear scale etc
Definition computils.h:150
AxisInfo::autoset
bool autoset() const
Definition computils.h:252
AxisInfo::binwidth
double binwidth() const
Definition computils.h:271
AxisInfo::rangeset
bool rangeset() const
Definition computils.h:260
AxisInfo::refnormset
bool refnormset() const
Definition computils.h:256
AxisInfo::trim
bool trim() const
Definition computils.h:262
AxisInfo::hi
double hi() const
Definition computils.h:269
AxisInfo::log
bool log() const
Definition computils.h:250
AxisInfo::split
static std::vector< std::string > split(const std::string &s, const std::string &t=":")
Definition computils.h:278
AxisInfo::offset
double offset() const
Definition computils.h:265
AxisInfo::normset
bool normset() const
Definition computils.h:254
AxisInfo::lo
double lo() const
Definition computils.h:268
HistDetails
details of the histogram axes etc
Definition computils.h:1259
Legend
slightly more convenient legend class
Definition computils.h:337
Panel::ncols
int ncols() const
Definition computils.h:1356
Panel::size
size_t size() const
Definition computils.h:1347
Panel::name
const std::string & name() const
Definition computils.h:1345
Panel::nrows
int nrows() const
Definition computils.h:1355
Plots
set of generic plots
Definition computils.h:917
Plots::setwatermark
static void setwatermark(bool b)
Definition computils.h:1224
ReadCards
Get tag-value pairs from a file.
Definition ReadCards.h:50
Resplot::setscalerms95
static bool setscalerms95(bool b)
Definition Resplot.h:556
Resplot::FitNull
static TF1 * FitNull(TH1D *s, double a=-999, double b=-999)
Definition Resplot.cxx:1287
Resplot::FitNull95
static TF1 * FitNull95(TH1D *s, double a=0, double b=0)
Definition Resplot.cxx:1672
Resplot::setoldrms95
static bool setoldrms95(bool b)
Definition Resplot.h:555
bands::range
void range(const std::string &chain, TH1F *h)
Definition comparitor.cxx:235
tPlotter< TH1F >::setplotref
static void setplotref(bool b)
Definition computils.h:861
autoy
void autoy(TH2 *h)
get the auto y range of a 2d histogram
Definition comparitor.cxx:495
rebin_log
TH1F * rebin_log(TH1F *h, bool low=false)
Definition comparitor.cxx:127
fulldbg
bool fulldbg
Definition comparitor.cxx:59
LINES
bool LINES
Definition computils.cxx:41
normy
void normy(TH2 *h)
zero the contents of a 2d histogram
Definition comparitor.cxx:453
print_pad
void print_pad(const std::string &s)
Definition comparitor.cxx:430
markers
int markers[6]
Definition computils.cxx:47
fullreplace
std::string fullreplace(std::string s, const std::string &s2, const std::string &s3)
Definition comparitor.cxx:423
d0rebin
TH1F * d0rebin(TH1F *h)
Definition comparitor.cxx:275
LINEF
bool LINEF
Definition computils.cxx:40
chainmap_t
std::map< std::string, std::string > chainmap_t
global typedef here is ok, since this is a standalone executable, including a main().
Definition comparitor.cxx:173
chi2
double chi2(TH1 *h0, TH1 *h1)
Definition comparitor.cxx:525
Rebin
TH1F * Rebin(TH1F *h, double f)
Definition comparitor.cxx:88
autox
void autox(TH2 *h)
get the auto x range of a 2d histogram
Definition comparitor.cxx:465
Scale
void Scale(TH1 *h, double d=1)
Definition comparitor.cxx:79
SetZeros
void SetZeros(TH2D *h)
Definition comparitor.cxx:70
colours
int colours[6]
Definition computils.cxx:46
Get
T * Get(TFile &f, const std::string &n, const std::string &dir="", const chainmap_t *chainmap=0, std::vector< std::string > *saved=0)
get a histogram given a path, and an optional initial directory if histogram is not found,...
Definition comparitor.cxx:181
Norm
void Norm(TH1 *h, double scale)
Definition computils.cxx:67
copyReleaseInfo
void copyReleaseInfo(TFile *finput, TFile *foutdir)
copy the release info TTree
Definition computils.cxx:620
Entries
double Entries(TH1 *h)
Definition computils.cxx:52
findrun
std::string findrun(TFile *f)
Definition computils.cxx:575
exists
bool exists(const std::string &filename)
does a file exist
Definition computils.cxx:256
fcontains
bool fcontains(const std::string &s, const std::string &p)
contains a string at the beginning of the string
Definition computils.cxx:234
Plotter
tPlotter< TH1F > Plotter
Definition computils.h:886
release
static std::string release
Definition computils.h:50
diff_panel
std::string diff_panel[10][6]
Definition default_panels.h:118
res_panel
std::string res_panel[4][6]
Definition default_panels.h:108
eff_panel
std::string eff_panel[4][6]
Definition default_panels.h:98
usage
StatusCode usage()
Definition fbtTestToyMC.cxx:1168
savedhistos
std::vector< std::string > savedhistos
Definition hcg.cxx:53
replace
std::string replace(std::string s, const std::string &s2, const std::string &s3)
Definition hcg.cxx:310
find
std::string find(const std::string &s)
return a remapped string
Definition hcg.cxx:138
base
std::string base
Definition hcg.cxx:81
dirs
std::map< std::string, int > dirs
list of directories to be explicitly included, together with corresponding depths of subdirectories
Definition hcg.cxx:102
chop
std::string chop(std::string &s1, const std::string &s2)
Definition hcg.cxx:161
label
std::string label(const std::string &format, int i)
Definition label.h:19
binwidth
bool binwidth
Definition listroot.cxx:58
CaloCondBlobAlgs_fillNoiseFromASCII.tag
str tag
Definition CaloCondBlobAlgs_fillNoiseFromASCII.py:23
HLTNavDetails::rx1
const std::regex rx1(R"(_v[0-9]+$)")
create_dcsc_inputs_sqlite.arg
list arg
Definition create_dcsc_inputs_sqlite.py:48
dqt_zlumi_pandas.hname
str hname
Definition dqt_zlumi_pandas.py:280
find_tgc_unfilled_channelids.ip
ip
Definition find_tgc_unfilled_channelids.py:3
grepfile.ic
int ic
Definition grepfile.py:33
makeegammaturnon.rebin
rebin(binning, data)
Definition makeegammaturnon.py:15
plot_material.mkdir
mkdir(path, recursive=True)
Definition plot_material.py:15
rerun_display.cmd
str cmd
Definition rerun_display.py:67
std::remove
DataModel_detail::iterator< DVL > remove(typename DataModel_detail::iterator< DVL > beg, typename DataModel_detail::iterator< DVL > end, const T &value)
Specialization of remove for DataVector/List.
Definition DVL_algorithms.h:49
file
TFile * file
Definition tile_monitor.h:29
dirname
std::string dirname(std::string name)
Definition utils.cxx:200
basename
std::string basename(std::string name)
Definition utils.cxx:207

◆ normy()

void normy ( TH2 * h)

zero the contents of a 2d histogram

Definition at line 453 of file comparitor.cxx.

453 {
454 int Nx = h->GetNbinsX();
455 int Ny = h->GetNbinsY();
456 for ( int i=1 ; i<=Nx ; i++ ) {
457 double n = 0;
458 for ( int j=1 ; j<=Ny ; j++ ) n += h->GetBinContent(i,j);
459 if ( n>0 ) for ( int j=1 ; j<=Ny ; j++ ) h->SetBinContent( i, j, h->GetBinContent(i,j)/n );
460 }
461}

◆ print_pad()

void print_pad ( const std::string & s)

Definition at line 430 of file comparitor.cxx.

430 {
431 std::cout << "Printing " << s << std::endl;
432 gPad->Print( s.c_str() );
433}

◆ Rebin()

TH1F * Rebin ( TH1F * h,
double f )

Definition at line 88 of file comparitor.cxx.

88 {
89
90 std::cout << "\nREBIN: " << h->GetName() << " :: " << f << std::endl;
91
92 if ( int(f) == f ) {
93 TH1F* n = (TH1F*)h->Clone("foeda"); n->SetDirectory(0);
94 n->Rebin(int(f));
95 return n;
96 }
97
98 int fi=int(f);
99 double fb=(f-fi);
100
101 for ( int i=0 ; i<10 ; i++ ) {
102 fb *= 10;
103 if ( std::fabs(int(fb)-fb)<1e-6 ) break;
104 }
105
106 std::vector<double> limits;
107 std::vector<double> contents;
108
109 for ( int i=1 ; i<=h->GetNbinsX()+1 ; i++ ) {
110 limits.push_back( h->GetBinLowEdge(i) );
111 contents.push_back( h->GetBinContent(i) );
112 if ( i<fb ) {
113 for ( int ib=1 ; ib<fi ; ib++ ) contents.back() += h->GetBinContent(++i);
114 }
115 }
116
117 TH1F* n = new TH1F( "foeda", h->GetTitle(), limits.size()-1, &limits[0] ); n->SetDirectory(0);
118
119 for ( size_t i=0 ; i<contents.size() ; i++ ) n->SetBinContent( i+1, contents[i] );
120
121 return n;
122}
contents
void contents(std::vector< std::string > &keys, TDirectory *td, const std::string &directory, const std::string &pattern, const std::string &path)
Definition computils.cxx:321

◆ rebin_log()

TH1F * rebin_log ( TH1F * h,
bool low = false )

Definition at line 127 of file comparitor.cxx.

127 {
128
129 double limits[40] = {
130 0.5, 1.5, 2.5, 3.5, 4.5,
131 5.5, 6.5, 7.5, 8.5, 9.5,
132 10.5, 11.5, 12.5, 13.5, 14.5,
133 15.5, 16.5, 17.5, 18.5, 19.5,
134 20.5, 21.5, 22.5, 23.5, 24.5,
135 25.5, 26.5, 28.5, 30.5, 32.5,
136 35.5, 38.5, 42.5, 46.5, 50.5,
137 55.5, 60.5, 66.5, 72.5, 78.5
138 };
139
140 double lowlimits[24] = {
141 0.5, 1.5, 2.5, 3.5, 4.5,
142 5.5, 6.5, 7.5, 8.5, 9.5,
143 10.5, 11.5, 12.5, 14.5, 17.5,
144 20.5, 24.5, 29.5, 35.5, 42.5,
145 50.5, 60.5, 72.5, 86.5,
146 };
147
148 TH1F* n;
149
150 if ( low ) n = new TH1F( "foeda", h->GetTitle(), 39, limits );
151 else n = new TH1F( "foeda", h->GetTitle(), 23, lowlimits );
152
153 n->SetDirectory(0);
154
155 for ( int i=1 ; i<=h->GetNbinsX() ; i++ ) {
156 n->Fill( h->GetBinCenter(i), h->GetBinContent(i) );
157 }
158
159
160 for ( int i=1 ; i<=n->GetNbinsX() ; i++ ) {
161 n->SetBinError(i, std::sqrt( n->GetBinContent(i) ) );
162 }
163
164 return n;
165}

◆ Scale()

void Scale ( TH1 * h,
double d = 1 )

Definition at line 79 of file comparitor.cxx.

79 {
80 if ( d==1 ) return;
81 for ( int i=1 ; i<=h->GetNbinsX() ; i++ ) {
82 h->SetBinContent( i, h->GetBinContent(i)*d );
83 h->SetBinError( i, h->GetBinError(i)*d );
84 }
85}

◆ SetZeros()

void SetZeros ( TH2D * h)

Definition at line 70 of file comparitor.cxx.

70 {
71 for ( int i=1 ; i<=h->GetNbinsX() ; i++ ) {
72 for ( int j=1 ; j<=h->GetNbinsY() ; j++ ) {
73 int ibin = h->GetBin( i, j );
74 if ( h->GetBinContent(ibin)==0 ) h->SetBinContent(ibin, 0.1);
75 }
76 }
77}

◆ usage()

int usage ( const std::string & name,
int status,
const std::string & err_msg = "" )

Definition at line 335 of file comparitor.cxx.

335 {
336 if ( err_msg != "" ) std::cerr << err_msg << "\n" << std::endl;
337 std::ostream& s = std::cout;
338 s << "Usage: " << name << "\t [OPTIONS] test.root reference.root chain1 chain2 chain2 ...\n\n";
339 s << "\t" << " plots comparison histograms";
340 s << " - compiled on " << __DATE__ << " at " << __TIME__ << "\n\n";
341 s << "Options: \n";
342 s << " -c, --config value \t configure which histograms to plot from config file,\n\n";
343 s << " -t, --tag value \t appends tag 'value' to the end of output plot names, \n";
344 s << " -k, --key value \t prepends key 'value' to the front of output plots name, \n";
345 s << " -t, --tag value \t post pend tag 'value' to the end of output plots name, \n";
346 s << " -d, --dir value \t creates output files into directory, \"value\" \n\n";
347 s << " --ncols value \t creates panels with \"value\" columns\n\n";
348
349 s << " -e, --efficiencies \t make test efficiencies with respect to reference \n";
350 s << " -es, --effscale value \t scale efficiencies to value\n";
351 s << " -er, --effscaleref value \t scale reference efficiencies to value\n";
352 s << " -nb --nobayes \t do not calculate Basyesian efficiency uncertaintiesr\n\n";
353
354 s << " -r, --refit \t refit all test resplots\n";
355 s << " -rr, --refitref \t also refit all reference resplots\n";
356 s << " --oldrms \t use fast rms95 when refitting resplots\n\n";
357
358 s << " -as, --atlasstyle \t use ATLAS style\n";
359 s << " -l, --labels values\t use specified labels for key\n";
360 s << " --taglabels values\t use specified additional labels \n";
361 s << " -al, --atlaslable value \t set value for atlas label\n";
362 s << " -sx, --swapaxtitles exp pattern\t swap the expression \"exp \" in the axis titles with \"pattern\"\n";
363 s << " -ac, --addchains \t if possible, add chain names histogram labels \n\n";
364
365 s << " -m, --mapfile \t remap file for reference histograms \n\n";
366
367 s << " -rc, --refchains values ..\t allow different reference chains for comparison\n";
368 s << " -s, --swap pattern regex \t swap \"pattern\" in the chain names by \"regex\"\n";
369 s << " --swapr pattern regex \t swap \"pattern\" in the ref chain names by \"regex\"\n";
370 s << " --swapt pattern regex \t swap \"pattern\" in the test chain names by \"regex\"\n";
371 s << " -nr, --noref \t do not plot reference histograms\n";
372 s << " --normref \t normalise the reference counting histograms to test histograms\n";
373 s << " -us, --usechainref \t use the histograms from chain definied in the \"Chain\" histogram as reference\n\n";
374
375 s << " -ns, --nostats \t do not show stats for mean and rms\n";
376 s << " -nm, --nomeans \t do not show stats for the means\n";
377 s << " --chi2 \t show the chi2 with respect to the reference\n\n";
378
379 s << " -np, --noplots \t do not actually make any plot\n";
380 s << " -q, --quiet \t make the plots but do not print them out\n\n";
381
382 s << " --unscalepix \t do not scale the number of pixels by 0.5 (unscaled by default)\n";
383 s << " --scalepix \t do scale the number of pixels by 0.5 (unscaled by default)\n";
384 s << " --yrange min max \t use specified y axis range\n";
385 s << " -xo, --xoffset value \t relative x offset for the key\n";
386 s << " -yp, --ypos value \t relative yposition for the key\n";
387 s << " -xe, --xerror value \t size of the x error tick marks\n";
388 s << " -nw, --nowatermark \t do not plot the release watermark\n\n";
389
390 s << " -C, --Cfiles \t write C files also\n";
391 s << " --nopng \t do not print png files\n";
392 s << " --nopdf \t do not print pdf files\n";
393 s << " --deleteref \t delete unused reference histograms\n\n";
394
395 s << " --printconfig \t print the configuration being used in the form useable as an input file\n\n";
396
397 s << " -h, --help \t this help\n";
398 // s << "\nSee " << PACKAGE_URL << " for more details\n";
399 // s << "\nReport bugs to <" << PACKAGE_BUGREPORT << ">";
400 s << std::endl;
401 return status;
402}
merge.status
status
Definition merge.py:16

◆ zero()

void zero ( TH2 * h)

zero the contents of a 2d histogram

Definition at line 438 of file comparitor.cxx.

438 {
439 int Nx = h->GetNbinsX();
440 int Ny = h->GetNbinsY();
441 for ( int i=1 ; i<=Nx ; i++ ) {
442 for ( int j=1 ; j<=Ny ; j++ ) {
443 if ( h->GetBinContent( i, j )==0 ) {
444 h->SetBinContent( i, j, 1e-10 );
445 h->SetBinError( i, j, 1e-10 );
446 }
447 }
448 }
449}

Variable Documentation

◆ colours

int colours[6]
extern

Definition at line 46 of file computils.cxx.

46{ 1, 2, kBlue-4, 6, kCyan-2, kMagenta+2 };

◆ fulldbg

bool fulldbg = false

Definition at line 59 of file comparitor.cxx.

◆ LINEF

bool LINEF
extern

Definition at line 40 of file computils.cxx.

◆ LINES

bool LINES
extern

Definition at line 41 of file computils.cxx.

◆ markers

int markers[6]
extern

Definition at line 47 of file computils.cxx.

47{ 20, 24, 25, 26, 25, 22 };
Generated on for ATLAS Offline Software by doxygen 1.14.0