TList* extractObjectFromPad(TPad* pad, const char* name)
{
TList* objects = new TList();
TList* primitivesList = pad->GetListOfPrimitives();
assert(primitivesList);
for (int i = 0; i < primitivesList->GetSize(); ++i) {
TObject* object = primitivesList->At(i);
std::cout << object->ClassName() << ' ' << object->GetName() << std::endl;
if (object->InheritsFrom("TPad")) {
TList* objectsFromPad = extractObjectFromPad(static_cast<TPad*>(object), name);
for (int j = 0; j < objectsFromPad->GetSize(); ++j)
objects->Add(objectsFromPad->At(j));
} else if (object->InheritsFrom("THStack")) {
TList* hList = (static_cast<THStack*>(object))->GetHists();
for (int j = 0; j < hList->GetSize(); ++j)
if (!strcmp(hList->At(j)->GetName(), name)) {
objects->Add(hList->At(j));
}
} else if (!strcmp(object->GetName(), name)) {
std::cout << "--->" << name << std::endl;
objects->Add(object);
}
}
return objects;
}
TGraph* getContourFilledX(TH2D* inputHisto, TCanvas* goodCanvas, int Width, int Style, int FillStyle, double X){
TCanvas* c1 = new TCanvas("temp", "temp",600,600);
TH2D* histo = (TH2D*)inputHisto->Clone("temp");
double levels[] = {X};
histo->SetContour(1, levels);
histo->Draw("CONT LIST");
c1->Update();
TObjArray* contours = (TObjArray*)gROOT->GetListOfSpecials()->FindObject("contours");
Int_t ncontours = contours->GetSize();
TList *list = (TList*)contours->At(0);
delete c1;
goodCanvas->cd();
printf("list size = %i\n", (int)list->GetSize());
if(list->GetSize()<=0)return new TGraph(0);
for(unsigned int i=0;i<list->GetSize();i++){
TGraph* EXCLUSION = (TGraph*)(list->At(i)->Clone("copy"));
EXCLUSION->SetLineColor(1);
EXCLUSION->SetLineWidth(Width);
EXCLUSION->SetLineStyle(Style);
EXCLUSION->SetFillColor(kBlack);
EXCLUSION->SetFillStyle(FillStyle);
//EXCLUSION->Draw("CL F same");
}
return EXCLUSION;
}
TList* contourFromTH2(TH2 *h2in, double threshold) {
std::cout << "Getting contour at threshold " << threshold << " from " << h2in->GetName() << std::endl;
//http://root.cern.ch/root/html/tutorials/hist/ContourList.C.html
Double_t contours[1];
contours[0] = threshold;
TH2D *h2 = frameTH2D((TH2D*)h2in);
h2->SetContour(1, contours);
// Draw contours as filled regions, and Save points
h2->Draw("CONT Z LIST");
gPad->Update(); // Needed to force the plotting and retrieve the contours in TGraphs
// Get Contours
TObjArray *conts = (TObjArray*)gROOT->GetListOfSpecials()->FindObject("contours");
TList* contLevel = NULL;
if (conts == NULL || conts->GetSize() == 0){
printf("*** No Contours Were Extracted!\n");
return 0;
}
TList *ret = new TList();
for(int i = 0; i < conts->GetSize(); i++){
contLevel = (TList*)conts->At(i);
printf("Contour %d has %d Graphs\n", i, contLevel->GetSize());
for (int j = 0, n = contLevel->GetSize(); j < n; ++j) {
TGraph *gr1 = (TGraph*) contLevel->At(j)->Clone();
ret->Add(gr1);
}
}
return ret;
}
void collectContours(map<string,TGraph2D *>& m_graphs,
const vector<string>& keys,
map<string,double>& m_contourlevels,
map<string,TList *>& m_contours)
{
cout << "CollectContours" << endl;
TCanvas *canv = new TCanvas("dummy","dummy",100,100);
//canv->Divide(3,2);
std::cout << "keys.size() = " << keys.size() << std::endl;
//process TGraph2Ds into contours at levels m_contourlevels
for (size_t i=0; i<keys.size(); i++) {
double clev = m_contourlevels[keys[i]];
TGraph2D *gr2d = m_graphs[keys[i]];
std::cout << "gr2d = " << gr2d << std::endl;
std::cout << "gr2d->GetN() = " << gr2d->GetN() << std::endl;
if (gr2d && (gr2d->GetN() > 0)) {
gr2d->GetHistogram()->SetContour(1, &clev);
//canv->cd(i+1);
cout << "drawing... " << endl;
gr2d->Draw("CONT LIST"); // it's stupid, but only "CONT" will generate the list
gPad->Update();
TObjArray *contours = (TObjArray *)gROOT->GetListOfSpecials()->FindObject("contours");
assert(contours);
TList *newlist = 0;
for (int ci=0; ci<contours->GetEntriesFast(); ci++) {
TList *contLevel = (TList*)contours->At(ci);
printf("%s: Contour %d has %d Graphs\n", keys[i].c_str(), ci, contLevel->GetSize());
if (contLevel->GetSize()) {
assert(contLevel->First());
if (!newlist) newlist = new TList();
TGraph *curv = (TGraph*)(contLevel->First());
for (int j=0; j<contLevel->GetSize(); j++) {
newlist->Add((TGraph *)(curv->Clone()));
curv=(TGraph *)(contLevel->After(curv));
}
}
} // contour loop
cout << "Inserting contour list for "<< keys[i] << " newlist="<<newlist<<endl;
m_contours[keys[i]] = newlist;
} // if (gr2d)
} // key loop
//delete canv;
} // collectContours
TList* GetListOfBranches(const char* dataType, TFile* file) {
if (TString(dataType) == "HLT") {
file->cd("DQMData/Run 1/HLT/Run summary/Muon/MuonTrack");
}
else if (TString(dataType) == "RECO") {
file->cd("DQMData/Run 1/Muons/Run summary/RecoMuonV/MuonTrack");
}
else {
cout << "ERROR: Data type " << dataType << " not allowed: only RECO and HLT are considered" << endl;
cerr << "ERROR: Data type " << dataType << " not allowed: only RECO and HLT are considered" << endl;
return 0;
}
TDirectory * dir=gDirectory;
TList* sl = GetListOfDirectories(dir);
if (sl->GetSize() == 0) {
cout << "ERROR: No DQM muon reco histos found in NEW file " << endl;
cerr << "ERROR: No DQM muon reco histos found in NEW file " << endl;
delete sl;
return 0;
}
return sl;
}
void testContour()
{
TFile *file = new TFile("T2tt___sigma_UL_bestexpected.root");
TH2F *h = (TH2F*)file->Get("T2tt__expected_strength_UL");
TGraph2D *tg2d = new TGraph2D(h); //Crea TGraph2D da TH2
Double_t contours[1]; // Crea array con i valori dei contour che vuoi
contours[0] = 1.0;
tg2d->GetHistogram()->SetContour(1,contours); //SetContour(numero contour,array contour)
//tg2d->Draw("cont list"); //Dummy plotting, serve solo per creare la lista di contour
TList *contLevel = tg2d->GetContourList(1.); // Prendi quello che ti interessa
if(contLevel->GetSize()>0) doContour = true;
cout<< doContour << endl;
TCanvas *cSmoothed = new TCanvas("test","test",800,600); // Crea canvas
cSmoothed->cd();
//TH1F* hrl = cSmoothed->DrawFrame(0.1,0.,1.,0.5); // Commando fondamentale: ti setta il range del Pad, formato (x1,y1,x2,y2) dove (x1,y1) e (x2,y2) sono le coordinate estreme del tuo TH2
h->Draw("colz same"); //prima fa il Draw() del TH2 (o TGraph2D)
if (doContour){
TIter next(contLevel);
TObject *contour = 0;
while (contour = next()){
((TGraph2D*)contour)->SetLineWidth(3);
((TGraph2D*)contour)->SetLineStyle(2);
((TGraph2D*)contour)->Draw("L"); // poi fa del TGraph del contour, ma senza l'opzione "A"
}
}
//ROOT::gPad::RedrawAxis();
cSmoothed->Update();
cSmoothed->SaveAs(".root");
}
void NtupleChecker(){
TString path = "/uscms_data/d2/uplegger/CMSSW/CMSSW_3_8_0_pre7/src/RecoVertex/BeamSpotProducer/test/scripts/Ntuples/";
TSystemDirectory sourceDir("fileDir",path);
TList* fileList = sourceDir.GetListOfFiles();
TIter next(fileList);
TSystemFile* fileName;
int fileNumber = 1;
int maxFiles = 1000;
BeamSpotTreeData aData;
while ((fileName = (TSystemFile*)next()) && fileNumber <= maxFiles){
if(TString(fileName->GetName()) == "." || TString(fileName->GetName()) == ".." ){
continue;
}
TTree* aTree = 0;
TFile file(path+fileName->GetName(),"READ");//STARTUP
cout << "Opening file: " << path+fileName->GetName() << endl;
file.cd();
// aTree = (TTree*)file.Get("PrimaryVertices");
aTree = (TTree*)file.Get("BeamSpotTree");
cout << (100*fileNumber)/(fileList->GetSize()-2) << "% of files done." << endl;
++fileNumber;
if(aTree == 0){
cout << "Can't find the tree" << endl;
continue;
}
aData.setBranchAddress(aTree);
for(unsigned int entry=0; entry<aTree->GetEntries(); entry++){
aTree->GetEntry(entry);
cout << aData.getRun() << endl;
}
}
}
void dominik()
{
TH1* matHistogramRoman = static_cast<TH1*>(extractObjectFromFile("lyRoman.root", "lightYieldProjectionY")->At(0));
TList* objects = extractObjectFromFile("c.root", "chargeBins");
TH1* matHistogramDominik = new TH1D("matHistogramDominik", ";channel;light yield / pixels", 512, -0.5, 512-0.5);
int sipmIt = 0;
for (int i = 0; i < objects->GetSize(); ++i) {
TH1* h = static_cast<TH1*>(objects->At(i));
if (h->GetLineColor() == 8) {
for (int bin = 1; bin <= 128; ++bin) {
matHistogramDominik->SetBinContent(512 - (sipmIt * 128 + bin - 1), h->GetBinContent(bin));
if (h->GetBinError(bin) > 0)
matHistogramDominik->SetBinError(512 - (sipmIt * 128 + bin - 1), h->GetBinError(bin));
}
++sipmIt;
}
}
TCanvas* c = new TCanvas;
c->Divide(1, 2);
c->cd(1);
matHistogramDominik->Draw();
matHistogramRoman->Draw("SAME");
c->cd(2);
TH1* h = static_cast<TH1*>(matHistogramDominik->Clone());
h->Add(matHistogramRoman, -1);
h->Draw();
}
void make_histos_syst_rawyield(TString file_syst, TString file_default, TString out_tag){
TFile *f1 = new TFile(file_syst.Data(),"read");
TFile *f2 = new TFile(file_default.Data(),"read");
TDirectoryFile *dir1 = (TDirectoryFile*)(f1->Get("effunf"));
TDirectoryFile *dir2 = (TDirectoryFile*)(f2->Get("effunf"));
TList *list = dir1->GetListOfKeys();
TFile *f = new TFile(Form("plots/ratiosyst_%s.root",out_tag.Data()),"recreate");
for (int i=0; i<list->GetSize(); i++){
TString name = dir1->GetListOfKeys()->At(i)->GetName();
if (!(name.Contains("hreco_"))) continue;
TObject *obj1 = dir1->Get(name.Data());
assert(obj1);
TObject *obj2 = dir2->Get(name.Data());
assert(obj2);
TString newname = name;
newname.Append("_ratiosyst");
if (name.EndsWith("_0")) newname.ReplaceAll("_0_","_EBEB_");
if (name.EndsWith("_1")) newname.ReplaceAll("_1_","_EBEE_");
if (name.EndsWith("_2")) newname.ReplaceAll("_2_","_EEEE_");
TH1F *h = (TH1F*)(((TH1F*)obj1)->Clone(newname.Data()));
h->SetTitle(h->GetName());
h->Divide((TH1F*)obj2);
for (int j=0; j<h->GetNbinsX(); j++) h->SetBinError(j+1,0);
for (int j=0; j<h->GetNbinsX(); j++) h->SetBinContent(j+1,1+fabs(1-h->GetBinContent(j+1)));
f->cd();
h->Write();
}
}
UInt_t GetListOfJobs( TFile* file, TList& jobdirs)
{
// get a list of all jobs in all method directories
// based on ideas by Peter and Joerg found in macro deviations.C
TIter next(file->GetListOfKeys());
TKey *key(0);
while ((key = (TKey*)next())) {
if (TString(key->GetName()).BeginsWith("Method_")) {
if (gROOT->GetClass(key->GetClassName())->InheritsFrom("TDirectory")) {
TDirectory* mDir = (TDirectory*)key->ReadObj();
TIter keyIt(mDir->GetListOfKeys());
TKey *jobkey;
while ((jobkey = (TKey*)keyIt())) {
if (!gROOT->GetClass(jobkey->GetClassName())->InheritsFrom("TDirectory")) continue;
TDirectory *jobDir = (TDirectory *)jobkey->ReadObj();
cout << "jobdir name " << jobDir->GetName() << endl;
jobdirs.Add(jobDir);
}
}
}
}
return jobdirs.GetSize();
}
// Save to .root file
void SaveOutput(TString name,TList &list)
{
TFile *out = new TFile(name,"RECREATE");
TDirectory *pwd = gDirectory;
for(int i=0;i<list.GetSize();i++)
{
TDecayMode *dm = list.At(i);
TDirectory *subdir = out->mkdir(dm->GetName());
subdir->cd();
subdir->Append(dm);
subdir->Append(dm->histograms);
pwd->cd();
}
if(!genDesc) cout<<"WARNING! No Generator description in files!"<<endl;
else out->Append(genDesc);
if(userHisto)
{
TDecayMode *uh = (TDecayMode*) userHisto;
cout<<"INFO: Appending user histograms"<<endl;
TDirectoryFile *histos = out->mkdir("USER_HISTOGRAMS");
TIter nexthist(uh->histograms);
TKey *key_hist=0;
TH1D *h;
while(h=(TH1D*)nexthist()) histos->Append(h);
}
out->Write();
out->Close();
delete out;
}
void TTree_UnfriendAll(TTree *tree)
{
TList *friends = tree->GetListOfFriends();
while(friends->GetSize() != 0)
{
friends->RemoveLast();
}
}
Bool_t KVLVContainer::HandleButton(Event_t* event)
{
// Override TGContainer method in order to set fControlClick flag
fControlClick = kFALSE;
if (event->fCode == kButton1 && (event->fState & kKeyControlMask)) fControlClick = kTRUE;
if (event->fCode == kButton3) {
TList* list = GetSelectedItems();
if (list->GetSize() == 0) {
fContextMenu->Popup(event->fXRoot, event->fYRoot, this);
delete list;
return kTRUE;
} else if (list->GetSize() == 1) {
return TGLVContainer::HandleButton(event);
}
delete list;
}
return TGLVContainer::HandleButton(event);
}
TGraph* GetContour(TGraph2D *g, TString name){
TGraph *gnew;
//cout << g->GetName() << " " << g->GetN() << endl;
TH2D *temp = (TH2D*)g->GetHistogram();//need this for list to work?
//g->Draw("alp");//need this for list to work?
TList *glist = (TList*)g->GetContourList(1.0);
if(glist == nullptr) return gnew;
int max_points = -1;
int nn = glist->GetSize();
//cout << "number of entries in list " << nn << endl;
for(int i = 0; i<glist->GetSize(); ++i){
TGraph *gtemp = (TGraph*)glist->At(i);
int Npoints = gtemp->GetN();
if(Npoints>max_points){
gnew = (TGraph*)gtemp->Clone(name);
max_points = Npoints;
}
}
return gnew;
}
TPaveStats* GetStatPad(TH1* hst)
{
TList *lst = hst->GetListOfFunctions();
if (!lst) return 0;
int nf = lst->GetSize();
for (int i=0;i<nf;i++) {
TPaveStats *fnc = (TPaveStats*) lst->At(i);
if (fnc->InheritsFrom("TPaveStats")) return fnc;
}
return 0;
//
}
TList* extractObjectFromFile(const char* fileName, const char* name)
{
TList* objects = new TList();
TFile file(fileName);
gROOT->cd();
TList* keyList = file.GetListOfKeys();
for (int i = 0; i < keyList->GetSize(); ++i) {
TKey* key = static_cast<TKey*>(keyList->At(i));
std::cout<< key->GetName()<< std::endl;
if (!strcmp(key->GetName(), name)) {
objects->Add(key->ReadObj()->Clone());
} else if (!strcmp(key->GetClassName(), "TCanvas")) {
TCanvas* canvas = static_cast<TCanvas*>(key->ReadObj());
if (!strcmp(canvas->GetName(), name))
objects->Add(canvas->Clone());
TList* objectsFromPad = extractObjectFromPad(canvas, name);
for (int j = 0; j < objectsFromPad->GetSize(); ++j)
objects->Add(objectsFromPad->At(j));
}
}
file.Close();
return objects;
}
TFrame* GetFrame(TPad* pad)
{
if (!pad) pad = (TPad*)gPad;
if (!pad) return 0;
TList* lst = pad->GetListOfPrimitives();
int size = lst->GetSize();
TFrame* frm=0;
for (int i=0;i<size;i++) {
TObject* obj = lst->At(i);
if (!obj) continue;
if (obj->InheritsFrom("TFrame")) {frm = (TFrame*)obj; break;}
}
return frm;
}
TH1* GetBaseHisto(TPad* pad)
{
if (!pad) pad = (TPad*)gPad;
if (!pad) return 0;
TList* lst = pad->GetListOfPrimitives();
int size = lst->GetSize();
TH1* hst=0;
for (int i=0;i<size;i++) {
TObject* obj = lst->At(i);
if (!obj) continue;
if (obj->InheritsFrom("TH1")) {hst = (TH1*)obj; break;}
}
return hst;
}
std::vector<TGraph *> SetupHist(TH2D *hist, TGraph2D *graph) {
for (int i = 1; i <= hist->GetXaxis()->GetNbins(); ++i) {
for (int j = 1; j <= hist->GetYaxis()->GetNbins(); ++j) {
hist->SetBinContent(
i, j, graph->Interpolate(hist->GetXaxis()->GetBinCenter(i),
hist->GetYaxis()->GetBinCenter(j)));
if (hist->GetBinContent(i, j) == 0.) hist->SetBinContent(i, j, 1E-6);
}
}
TList *conts = contourFromTH2(hist, 0.05);
std::vector<TGraph *> cgraphs;
for (int i = 0; i < conts->GetSize(); ++i) {
cgraphs.push_back((TGraph *)conts->At(i));
}
return cgraphs;
}
TGraph*
ContourGraph( TH2F* hist)
{
TGraph* gr0 = new TGraph();
TH2F* h = (TH2F*)hist->Clone();
gr = (TGraph*)gr0->Clone(h->GetName());
// cout << "==> Will dumb histogram: " << h->GetName() << " into a graph" <<endl;
h->SetContour( 1 );
double pval = CombinationGlob::cl_percent[1];
double signif = TMath::NormQuantile(1-pval);
h->SetContourLevel( 0, signif );
h->Draw("CONT LIST");
h->SetDirectory(0);
gPad->Update();
TObjArray *contours = gROOT->GetListOfSpecials()->FindObject("contours");
Int_t ncontours = contours->GetSize();
TList *list = (TList*)contours->At(0);
Int_t number_of_lists = list->GetSize();
gr = (TGraph*)list->At(0);
TGraph* grTmp = new TGraph();
for (int k = 0 ; k<number_of_lists ; k++){
grTmp = (TGraph*)list->At(k);
Int_t N = gr->GetN();
Int_t N_tmp = grTmp->GetN();
if(N < N_tmp) gr = grTmp;
// mg->Add((TGraph*)list->At(k));
}
gr->SetName(hist->GetName());
int N = gr->GetN();
double x0, y0;
// for(int j=0; j<N; j++) {
// gr->GetPoint(j,x0,y0);
// cout << j << " : " << x0 << " : "<<y0 << endl;
// }
// // gr->SetMarkerSize(2.0);
// gr->SetMarkerSize(2.0);
// gr->SetMarkerStyle(21);
// gr->Draw("LP");
// cout << "Generated graph " << gr << " with name " << gr->GetName() << endl;
return gr;
}
void SetGStyle(TGraph* hst,int col,int mark,float mrsize)
{
hst->SetLineColor(col);
hst->SetMarkerColor(col);
hst->SetFillColor(col);
hst->SetMarkerStyle(mark);
hst->SetMarkerSize(mrsize);
TList *lst = hst->GetListOfFunctions();
if (lst) {
int nf = lst->GetSize();
for (int i=0;i<nf;i++) {
TObject *fnc = lst->At(i);
if (fnc->InheritsFrom("TF1")) {
((TF1*)fnc)->SetLineColor(col);
((TF1*)fnc)->SetLineWidth(1);
((TF1*)fnc)->ResetBit(TF1::kNotDraw);
}
else if (fnc->InheritsFrom("TPaveStats")) {
((TPaveStats*)fnc)->SetTextColor(col);
}
}
}
}
TList* getContours(const TH2* hist,double contourLevel,const TString filename)
{
TH2* h = (TH2*)hist->Clone("_clone");
double limitValue[1] = {contourLevel};
h->SetContour(1,limitValue);
TCanvas* c = new TCanvas("contour_canvas","Contour List",0,0,600,600);
h->Draw("CONT LIST");
c->Update();
TList* contours = (TList*)((TObjArray*)gROOT->GetListOfSpecials()->FindObject("contours"))->At(0);
TGraph* contour = (TGraph*)contours->First();
if(filename!="")
{
for(unsigned int j = 0; j < contours->GetSize(); j++)
{
TString newFilename = filename+"_";
newFilename+=j;
contour->SaveAs(newFilename+".C");
contour = (TGraph*)contours->After(contour); // Get Next graph
}
}
delete h;
delete c;
return contours;
}
////////////////////////////////////////////////////////////
//
// This function goes to the right branch inside the file
// looking for branches having branchContent.
// It returns a list with all those branches,
//
TList* getListOfBranches(const char* dataType, TFile* file, const char* branchContent) {
if (TString(dataType) == "RECO") {
if(! file->cd("DQMData/Run 1/Muons/Run summary")) {
cout << "ERROR: Muon Histos for " << dataType << " not found" << endl;
return 0;
}
}
else {
cout << "ERROR: Data type " << dataType << " not allowed: only RECO is considered" << endl;
return 0;
}
TDirectory * dir=gDirectory;
TList* sl = GetListOfDirectories(dir, branchContent);
if (sl->GetSize() == 0) {
cout << "ERROR: No DQM muon reco histos found in NEW file " << endl;
delete sl;
return 0;
}
return sl;
}
void plottingmacro_IVF()
{
double fa = 0.46502;
double fb = 0.53498;
bool debug_ = true;
// std::string path("Nov10thFall11Plots/");
// std::string path("Nov10Fall1160MTopSlimPlots/");
std::string path("Nov10Fall1160MTopIVFPlots_b/");
if(debug_)
std::cout << "Init the style form setTDRStyle" << std::endl;
setTDRStyle();
gStyle->SetErrorX(0.5);
gROOT->ForceStyle();
initOptions();
if(debug_)
std::cout << "Init the sample" << std::endl;
// std::vector<Sample> s = Nov10thDiJetPtUpdatedSlimHistos();
//std::vector<Sample> s = Nov10Fall1160MTopSlimHistos();
std::vector<Sample> s = Nov10Fall1160MTopIVFHistos();
Sample data(1,"fake data","S1.root",0,true,1000);
if(debug_)
std::cout << "Init the data sample" << std::endl;
for(size_t i=0;i< s.size();i++) if(s[i].data) {data=s[i];break;}
if(debug_)
std::cout << "Ls data sample" << std::endl;
data.file()->ls();
if(debug_)
std::cout << "Init the mc sample" << std::endl;
for(size_t i=0;i< s.size();i++) s[i].dump(1,fa,fb);
std::vector<std::string> names;
if(debug_)
std::cout << "Get List of Keys" << std::endl;
TList * subs = data.file()->GetListOfKeys();
for(size_t i=0;i< subs->GetSize();i++)
{
TString nn = subs->At(i)->GetName();
if( nn.Contains(TRegexp("Count*")) )
continue;
if(debug_)
std::cout << "Get List of Keys in subdirs" << std::endl;
TList * objs = ((TDirectoryFile *)data.file()->Get(subs->At(i)->GetName()))->GetListOfKeys();
for(size_t j=0;j< objs->GetSize();j++)
{
if(debug_)
std::cout << "Name = " << subs->At(i)->GetName()+std::string("/") + objs->At(j)->GetName() << std::endl;
names.push_back(subs->At(i)->GetName()+std::string("/") + objs->At(j)->GetName());
// std::cout << subs->At(i)->GetName() << "/" << objs->At(j)->GetName() << std::endl;
//TODO: select plots via regexp
}
}
if(debug_)
std::cout << "Starting plotting" << std::endl;
std::string process;
for(size_t i = 0 ; i < names.size() ; i++)
{
std::map<std::string,TH1F *> grouped;
TString n=names[i];
// if(!n.Contains(TRegexp("VlightRegionHZee/HiggsPtVlightRegionHZee"))) continue;
// if(!n.Contains(TRegexp("VlightRegionHZee/ZPtVlightRegionHZee"))) continue;
// if(!n.Contains(TRegexp("VlightRegionHZee"))) continue;
// if(!n.Contains(TRegexp("ZSVRegionZmmSV"))) continue;
// if(!n.Contains(TRegexp("ZSVRegionZeeSV"))) continue;
// if(!n.Contains(TRegexp("ZSVRegionZcombSV"))) continue;
// if(!n.Contains(TRegexp("ZSVPureRegionZcombSV"))) continue;
// if(!n.Contains(TRegexp("ZSVTTbarPureRegionZcombSV"))) continue;
if(!n.Contains(TRegexp("TTbarRegionZeeSVJets"))) continue;
if(n.Contains(TRegexp("RegionHZcomb")))
process = "Z(l^{+}l^{-})H(b#bar{b})";
if(n.Contains(TRegexp("RegionHZmm")))
process = "Z(#mu^{+}#mu^{-})H(b#bar{b})";
if(n.Contains(TRegexp("RegionHZee")))
process = "Z(e^{+}e^{-})H(b#bar{b})";
if(debug_)
std::cout << "Creating the Canvas" << std::endl;
TCanvas *c = new TCanvas();
c->SetLogy(false);
c->SetTitle(names[i].c_str());
if(debug_)
std::cout << "Creating histograms" << std::endl;
TH1F *hd = ((TH1F*)data.file()->Get(names[i].c_str()));
hd->Sumw2();
Options o=options[names[i]];
// hd->Rebin(o.rebin);
hd->SetMarkerStyle(20);
hd->GetXaxis()->SetLabelOffset(99);
hd->SetYTitle(o.yaxis.c_str());
double nbin = hd->GetNbinsX();
double min_bin = hd->GetXaxis()->GetXmin();
double max_bin = hd->GetXaxis()->GetXmax();
TH1F *hmc = new TH1F("hmc","hmc", nbin, min_bin, max_bin);
hmc->SetFillColor(kWhite);
hmc->Sumw2();
// hmc->Rebin(o.rebin);
if(debug_)
std::cout << "Creating the THStack and Legend" << std::endl;
THStack * sta = new THStack("sta",hd->GetTitle());
TLegend * l = new TLegend(o.legendx1,o.legendy1,o.legendx2,o.legendy2); //0.7,0.1,0.9,0.6);
l->SetFillColor(kWhite);
l->SetBorderSize(0);
l->SetTextFont(62);
l->SetTextSize(0.03);
if(debug_)
std::cout << "Adding data to the legend" << std::endl;
l->AddEntry(hd, "Data","P");
if(debug_)
std::cout << "Adding MC to the THStack" << std::endl;
//with the proper trigger eff
// double SF[] = {1.01,1.03,1.00};
// double SF[] = {1.03,1.054,1.032};
double SF[] = {1.0,1.0,1.0};
if(debug_){
for(int i = 0; i< 3; ++i)
std::cout << "SF [" << i << "] = " << SF[i] << std::endl;
}
double mcIntegral=0;
for(size_t j=0;j< s.size() ;j++)
{
if(!s[j].data)
{
if(debug_)
std::cout << "Creating TH1F from file " << s[j].name << std::endl;
TH1F * h = ((TH1F*)s[j].file()->Get(names[i].c_str()));
h->Sumw2();
if(debug_){
std::cout << "TH1F created from file " << s[j].name << std::endl;
std::cout << "Scaling : " << s[j].scale(data.lumi(),fa,fb) << std::endl;
std::cout << "Scaling with SF : " << s[j].scale(data.lumi(),fa,fb,SF) << std::endl;
std::cout << "Histo integral before scaling = " << h->Integral() << std::endl;
}
h->Scale(s[j].scale(data.lumi(),fa,fb,SF));
if(debug_){
std::cout << "Histo integral after scaling = " << h->Integral() << std::endl;
std::cout << "Managing style... " << std::endl;
}
h->SetLineWidth(1.);
h->SetFillColor(s[j].color);
h->SetLineColor(s[j].color);
// h->Rebin(options[names[i]].rebin);
if(debug_)
std::cout << "Cloning and update legend " << std::endl;
if(grouped.find(s[j].name) == grouped.end()){
l->AddEntry(h,s[j].name.c_str(),"F");
}
std::cout << "Sample : " << s[j].name << " - Integral for plot " << names[i] << " = " << h->Integral(-10000,10000) << std::endl;
mcIntegral += h->Integral();
sta->Add(h);
hmc->Add(h);
//TO FIX grouped map
// sovrascrive histo con lo stesso nome tipo VV o ST etc...
grouped[s[j].name]=(TH1F *)h->Clone(("_"+names[i]).c_str());
}
}
if(debug_){
std::cout << "Data total = " << hd->Integral() << std::endl;
std::cout << "MC = " << mcIntegral << std::endl;
std::cout << "Data/MC = " << hd->Integral()/mcIntegral << std::endl;
}
TPad * TopPad = new TPad("TopPad","Top Pad",0.,0.3,1.,1. ) ;
TPad * BtmPad = new TPad("BtmPad","Bottom Pad",0.,0.,1.,0.313 ) ;
TopPad->SetBottomMargin(0.02);
BtmPad->SetTopMargin(0.0);
BtmPad->SetFillStyle(4000);
TopPad->SetFillStyle(4000);
BtmPad->SetFillColor(0);
BtmPad->SetBottomMargin(0.35);
TopPad->Draw() ;
BtmPad->Draw() ;
std::cout << "hd maximum = " << hd->GetMaximum() << " sta maximum = " << sta->GetMaximum() << std::endl;
double maxY;
if(hd->GetMaximum() > sta->GetMaximum()) maxY = (hd->GetMaximum())*1.5;
else maxY = (sta->GetMaximum())*1.5;
TopPad->cd();
hd->Draw("E1X0");
sta->Draw("sameHIST");
hmc->Draw("sameE2");
hmc->SetFillColor(2);
hmc->SetMarkerSize(0);
hmc->SetFillStyle(3013);
hd->Draw("E1X0same");
l->Draw("same");
std::cout << "Set Maximum to = " << maxY << std::endl;
hd->GetYaxis()->SetRangeUser(0.,maxY);
hd->GetXaxis()->SetRangeUser(options[names[i]].min,options[names[i]].max);
BtmPad->cd();
std::cout << "Division" << std::endl;
TH1D * divisionErrorBand = (TH1D*)(hmc)->Clone("divisionErrorBand");
divisionErrorBand->Sumw2();
divisionErrorBand->Divide(hmc);
divisionErrorBand->Draw("E2");
divisionErrorBand->SetMaximum(2.49);
divisionErrorBand->SetMinimum(0);
divisionErrorBand->SetMarkerStyle(20);
divisionErrorBand->SetMarkerSize(0.55);
divisionErrorBand->GetXaxis()->SetTitleOffset(1.12);
divisionErrorBand->GetXaxis()->SetLabelSize(0.12);
divisionErrorBand->GetXaxis()->SetTitleSize(0.5);
divisionErrorBand->GetYaxis()->SetTitle("Data/MC");
divisionErrorBand->GetYaxis()->SetLabelSize(0.12);
divisionErrorBand->GetYaxis()->SetTitleSize(0.12);
divisionErrorBand->GetYaxis()->SetTitleOffset(0.40);
divisionErrorBand->GetYaxis()->SetNdivisions(505);
//divisionErrorBand->UseCurrentStyle();
divisionErrorBand->SetFillColor(2);
divisionErrorBand->SetFillStyle(3001);
divisionErrorBand->SetMarkerSize(0.);
TH1D * division = (TH1D*)(hd)->Clone("division");
division->Sumw2();
division->Divide(hmc);
// division->SetMaximum(2.5);
// division->SetMinimum(0);
// division->SetMarkerStyle(20);
// division->SetMarkerSize(0.55);
// division->GetXaxis()->SetLabelSize(0.12);
// division->GetXaxis()->SetTitleSize(0.14);
// division->GetYaxis()->SetLabelSize(0.10);
// division->GetYaxis()->SetTitleSize(0.10);
// division->GetYaxis()->SetTitle("Data/MC");
Double_t min = division->GetXaxis()->GetXmin();
Double_t max = division->GetXaxis()->GetXmax();
division->Draw("E1X0same");
TLine *line = new TLine(min, 1.0, max, 1.0);
line->SetLineColor(kRed);
line->Draw("same");
TLegend * leg3 =new TLegend(0.50,0.86,0.69,0.96);
leg3->AddEntry(divisionErrorBand,"MC uncert. (stat.)","f");
leg3->SetFillColor(0);
leg3->SetLineColor(0);
leg3->SetShadowColor(0);
leg3->SetTextFont(62);
leg3->SetTextSize(0.06);
leg3->Draw();
TPaveText *pave = new TPaveText(0.15,0.85,0.32,0.96,"brNDC");
pave->SetTextAlign(12);
pave->SetLineColor(0);
pave->SetFillColor(0);
pave->SetShadowColor(0);
//TText *text = pave->AddText(Form("#chi_{#nu}^{2} = %.3f, K_{s} = %.3f",histDt->Chi2Test(histCopyMC5,"UWCHI2/NDF"),histDt->KolmogorovTest(histCopyMC5))); // stat + sys
TText *text = pave->AddText(Form("#chi_{#nu}^{2} = %.3f, K_{s} = %.3f",hd->Chi2Test(hmc,"UWCHI2/NDF"),hd->KolmogorovTest(hmc))); // stat only
text->SetTextFont(62);
text->SetTextSize(0.08);
pave->Draw();
TopPad->cd();
TLatex latex;
latex.SetNDC();
latex.SetTextAlign(12);
latex.SetTextSize(0.052);
latex.DrawLatex(0.17,0.89,"CMS Preliminary");
latex.SetTextSize(0.04);
latex.DrawLatex(0.17,0.84,"#sqrt{s} = 7 TeV, L = 4.7 fb^{-1}");
// latex.DrawLatex(0.17,0.79,"Z(e^{+}e^{-})H(b#bar{b})");
latex.DrawLatex(0.17,0.79,process.c_str());
c->Update();
std::string cName= hd->GetName();
cName += "_bare.pdf";
cName = path+cName;
c->Print(cName.c_str(),"pdf");
// std::cout << names[i] << " d: " << hd->Integral() << " ";
// THStack * sta2 = new THStack("sta2",hd->GetTitle());
// float tot=0;
// float toterr2=0;
// if(debug_)
// std::cout << "Putting the iterator in the for loop" << std::endl;
// for(std::map<std::string,TH1F *>::reverse_iterator it=grouped.rbegin(); it!=grouped.rend();++it)
// {
// if(debug_)
// std::cout << "Using the iterator" << std::endl;
// std::cout << (*it).first << " " << (*it).second->Integral() << " | " << std::endl ;
// if((*it).second->GetEntries() > 0) {
// float er=1.*sqrt((*it).second->GetEntries())/(*it).second->GetEntries()*(*it).second->Integral();
// toterr2+=er*er;
// }
// tot+=(*it).second->Integral();
// sta2->Add(it->second);
// }
// std::cout << " Tot: " << tot << "+-" << sqrt(toterr2) << " SF: " << hd->Integral()/tot << std::endl;
// TCanvas *c2 = new TCanvas();
// c2->SetTitle(names[i].c_str());
// std::cout << "hd maximum = " << hd->GetMaximum() << " sta2 maximum = " << sta2->GetMaximum() << std::endl;
// if(hd->GetMaximum() > sta2->GetMaximum()) maxY = hd->GetBinContent(hd->GetMaximumBin()) * 1.5;
// else maxY = ( sta2->GetMaximum())*1.5;
// // hd->Draw("E1");
// sta2->Draw("PADSHIST");
// // hd->Draw("E1same");
// // l->Draw("same");
// std::cout << "Set Maximum to = " << maxY << std::endl;
// hd->GetYaxis()->SetRangeUser(0.,maxY);
// hd->GetXaxis()->SetRangeUser(options[names[i]].min,options[names[i]].max);
// c2->Update();
// std::string c2Name = hd->GetName();
// c2Name = path+c2Name;
// c2Name += "_norm.pdf";
// c2->Print(c2Name.c_str(),"pdf");
}
}
void long_Ay_nu_05() {
gROOT->SetStyle("HALLA");
TCanvas *cn = new TCanvas("cn","cn",540,360);
cn->Draw();
cn->UseCurrentStyle();
TH1F *frm = new TH1F("frm","",100,0.,10.);
frm->GetXaxis()->SetTitle("#nu (GeV)");
frm->GetYaxis()->SetTitle("Ay for Q2=0.456 (GeV/c)2");
frm->SetMinimum(0);
// frm->SetMinimum(0);
// frm->SetMaximum(1.0);
frm->SetMaximum(0.35);
frm->UseCurrentStyle();
frm->Draw();
frm->SetAxisRange(0.120,0.350,"X");
// frm->SetAxisRange(0.5,1.1,"X");
// TF1* galster = new TF1("galster","x/(4.*0.938*.938)*1.91/(1.+x/.71)^2/(1.+5.6*x/(4.*.938*.938))",0.,4.);
// galster->SetLineColor(6);
// galster->SetLineStyle(3);
// galster->SetLineWidth(2);
TF1 *genf = new TF1("genf",genff,1.,10.,1);
genf->SetLineColor(2);
genf->SetLineStyle(2);
genf->SetParameter(0,1.);
// match to Madey point just below 1.5
// genf->SetParameter(0,.0411/genf->Eval(1.45));
genf->SetParameter(0,-0.558645);
// TF1 *bbba05 = new TF1("BBBA05",gen_bbba05,0.,10.,0);
// bbba05->SetLineColor(7);
// bbba05->SetLineStyle(3);
TMultiGraph* mgrDta = new TMultiGraph("Data","G_{E}^{n}");
TLegend *legDta = new TLegend(.54,.6,.875,.90,"","brNDC");
TMultiGraph* wgr = mgrDta;
TLegend *wlg = legDta;
// the data
legDta->SetBorderSize(0); // turn off border
legDta->SetFillStyle(0);
datafile_t *f = datafiles;
TGraph* gr=0;
while ( f && f->filename ) {
gr=OneGraph(f);
if (gr) {
if (f->lnpt) {
mgrDta->Add(gr,f->lnpt);
legDta->AddEntry(gr,f->label,f->lnpt);
}
else if (gr->GetMarkerStyle()>=20) {
mgrDta->Add(gr,"p");
legDta->AddEntry(gr,f->label,"p");
}
else {
mgrDta->Add(gr,"l");
legDta->AddEntry(gr,f->label,"l");
}
}
f++;
}
mgrDta->Draw("p");
// legDta->Draw();
TF1 *theFit = new TF1("theFit","pol0");
gr->Fit(theFit);
theFit->Draw("same");
TMultiGraph* mgrThry = new TMultiGraph("Theory","G_{E}^{n}");
TLegend *legThry = new TLegend(.54,.3,.875,.6,"","brNDC");
wgr = mgrThry;
wlg = legThry;
// the theory
wlg->SetBorderSize(0); // turn off border
wlg->SetFillStyle(0);
f = theoryfiles1;
gr=0;
while ( f && f->filename ) {
gr=OneGraph(f);
if (gr) {
TGraphAsymmErrors *egr = dynamic_cast<TGraphAsymmErrors*>(gr);
if (egr && egr->GetN()>1 && egr->GetEYhigh() && egr->GetEYhigh()[1]>0) {
gr = toerror_band(egr);
gr->SetFillStyle(3000+f->style);
}
if (f->lnpt) {
wgr->Add(gr,f->lnpt);
wlg->AddEntry(gr,f->label,f->lnpt);
}
else if (gr->GetMarkerStyle()>=20) {
wgr->Add(gr,"p");
wlg->AddEntry(gr,f->label,"p");
}
else {
wgr->Add(gr,"l");
wlg->AddEntry(gr,f->label,"l");
}
}
f++;
}
// genf->Draw("same");
mgrThry->Draw("c");
// galster->Draw("same");
// bbba05->Draw("same");
// legThry->AddEntry(genf,"F_{2}/F_{1} #propto ln^{2}(Q^{2}/#Lambda^{2})/Q^{2}","l");
// legThry->AddEntry(galster,"Galster fit","l");
// legThry->AddEntry(bbba05,"BBBA05","l");
// legThry->Draw();
// legDta->Draw();
// draw a line at 1
cn->Modified();
cn->Update();
cn->SaveAs(Form("%s.eps",psfile));
cn->SaveAs(Form("%s.root",psfile));
gSystem->Exec(Form("./replace_symbols.pl %s.eps",psfile));
return; // LEAVING HERE
// now an overlay, hopefully matching dimensions
// remove everything but the graph
cn->Update();
TList *clist = cn->GetListOfPrimitives();
TFrame* frame = cn->GetFrame();
for (int i=0; i<clist->GetSize(); ) {
if (clist->At(i) != frame) {
clist->RemoveAt(i);
} else i++;
}
// draw markers in the corners
TMarker *mkr = new TMarker(frame->GetX1(),frame->GetY1(),2);
mkr->Draw();
mkr = new TMarker(frame->GetX2(),frame->GetY1(),2);
mkr->Draw();
mkr = new TMarker(frame->GetX1(),frame->GetY2(),2);
mkr->Draw();
mkr = new TMarker(frame->GetX2(),frame->GetY2(),2);
mkr->Draw();
frame->SetLineColor(10);
cn->Update();
datafile_t miller = { "figure_input/Miller/lattice.GEn.rtf","Miller",
"[0]","[1]","[1]-[3]","[2]-[1]",0,0,1,3,"F" };
gr = OneGraph(&miller);
TGraphAsymmErrors* egr = dynamic_cast<TGraphAsymmErrors*>(gr);
if (egr && egr->GetEYhigh() && egr->GetEYhigh()[egr->GetN()/2]>0) {
gr = toerror_band(egr);
gr->SetLineStyle(1);
gr->SetFillColor(gr->GetLineColor());
gr->SetFillStyle(3000+miller.style);
}
gr->Draw("F");
cn->Update();
cn->SaveAs("gen_Miller_Overlay.eps");
cn->SaveAs("gen_Miller_Overlay.root");
}
void StandardProfileInspectorDemo(const char* infile = "",
const char* workspaceName = "combined",
const char* modelConfigName = "ModelConfig",
const char* dataName = "obsData"){
/////////////////////////////////////////////////////////////
// First part is just to access a user-defined file
// or create the standard example file if it doesn't exist
////////////////////////////////////////////////////////////
const char* filename = "";
if (!strcmp(infile,""))
filename = "results/example_combined_GaussExample_model.root";
else
filename = infile;
// Check if example input file exists
TFile *file = TFile::Open(filename);
// if input file was specified byt not found, quit
if(!file && strcmp(infile,"")){
cout <<"file not found" << endl;
return;
}
// if default file not found, try to create it
if(!file ){
// Normally this would be run on the command line
cout <<"will run standard hist2workspace example"<<endl;
gROOT->ProcessLine(".! prepareHistFactory .");
gROOT->ProcessLine(".! hist2workspace config/example.xml");
cout <<"\n\n---------------------"<<endl;
cout <<"Done creating example input"<<endl;
cout <<"---------------------\n\n"<<endl;
}
// now try to access the file again
file = TFile::Open(filename);
if(!file){
// if it is still not there, then we can't continue
cout << "Not able to run hist2workspace to create example input" <<endl;
return;
}
/////////////////////////////////////////////////////////////
// Tutorial starts here
////////////////////////////////////////////////////////////
// get the workspace out of the file
RooWorkspace* w = (RooWorkspace*) file->Get(workspaceName);
if(!w){
cout <<"workspace not found" << endl;
return;
}
// get the modelConfig out of the file
ModelConfig* mc = (ModelConfig*) w->obj(modelConfigName);
// get the modelConfig out of the file
RooAbsData* data = w->data(dataName);
// make sure ingredients are found
if(!data || !mc){
w->Print();
cout << "data or ModelConfig was not found" <<endl;
return;
}
//////////////////////////////////////////////
// now use the profile inspector
ProfileInspector p;
TList* list = p.GetListOfProfilePlots(*data,mc);
// now make plots
TCanvas* c1 = new TCanvas("c1","ProfileInspectorDemo"); //,800,200);
c1->Divide(4,4);
// const RooArgSet* nuis_params = mc->GetNuisanceParameters();
for(int i=0; i<list->GetSize(); ++i){
c1->cd(i+1);
//RooRealVar* nuis = (RooRealVar*) nuis_params->At(i);
TGraph* graph = (TGraph*) list->At(i);
std::string y_title = graph->GetYaxis()->GetTitle();
y_title = "Profiled value of: " + y_title;
graph->GetYaxis()->SetTitle(y_title.c_str());
graph->GetYaxis()->SetTitleSize(0.05);
graph->GetYaxis()->SetTitleOffset(0.8);
//std::string poi_name = graph->GetXaxis()->GetTitle();
//graph->GetYaxis()->SetTitle(var->GetName());
graph->GetXaxis()->SetTitleSize(0.05);
graph->GetXaxis()->SetTitleOffset(0.8);
graph->Draw("al");
//list->At(i)->Draw("al");
}
c1->Print("ProfileInspector.eps");
c1->Print("ProfileInspector.pdf");
cout << endl;
}
int main (int argc, char* argv[] )
{
cout << endl << "Really, REALLY stupid plotter for producing comparative plots between Edinburgh fit outputs." << endl;
cout << endl << "USAGE: merge_plot Output_1.root Output_2.root \"Title 1\" \"Title 2\" " << endl;
gStyle->SetCanvasColor(0);
gStyle->SetFillColor(0);
gROOT->SetStyle("Plain");
if( argc != 5) exit(-1);
TCanvas* c3 = new TCanvas("throw2","throw");
TFile* input_1 = new TFile( argv[1], "READ" );
gDirectory->ls();
TH2D* hist_1 = (TH2D*)gDirectory->Get("pllhist");//"Graph2D");//pllhist");//Graph2D_from_nllhist");
TGraph2D* graph_1 = (TGraph2D*)gDirectory->Get("pllhist");//"Graph2D");//pllhist");//Graph2D_from_nllhist");
graph_1->Draw();
c3->Update();
TFile* input_2 = new TFile( argv[2], "READ" );
gDirectory->ls();
TH2D* hist_2 = (TH2D*)gDirectory->Get("pllhist");//"fcnew");//pllhist");//lr_data");
TGraph2D* graph_2 = (TGraph2D*)gDirectory->Get("pllhist");//"fcnew");//pllhist");//lr_data");
graph_2->Draw();
hist_2->Draw();
c3->Update();
TString Plot_Title_1( argv[3] );
TString Plot_Title_2( argv[4] );
TCanvas* c1 = new TCanvas("Output_Plot","Output_Plot",1680,1050);
double pllconts[3] = {1.15,2.305,3.0};//,4.61};
//double pll2[3] = {2.3,4.61,6};//,9.62};
//double pll2[3] = {0.68,0.9,0.95};
double confs[3] = {68.0,90.0,95.0};//,99.0};
TList* contLevel = NULL;
TGraph* curv = NULL;
TGraph* gc = NULL;
//gStyle->SetCanvasColor(0);
//gStyle->SetPalette(1);
//gROOT->SetStyle("Plain");
//gROOT->ForceStyle();
// gStyle->SetFrameBorderMode(0);
// gStyle->SetCanvasBorderMode(0);
// gStyle->SetPadBorderMode(0);
// gStyle->SetPadColor(0);
// gStyle->SetCanvasColor(0);
// gStyle->SetStatColor(0);
// gStyle->SetTitleFillColor(0);
// gStyle->SetFillColor(0);
// gStyle->SetFrameFillColor(0);
//gStyle->SetFillStyle(0);
//gROOT->ForceStyle();
hist_1->SetContour(3,pllconts);
hist_1->SetLineWidth(1);
c1->cd();
hist_1->Draw("cont2");
// hist_1->GetXaxis()->SetRangeUser(-3.1,2);
hist_1->SetContour(3,pllconts);
// c1->cd();
hist_1->Draw("cont2");
// StyleTH2D(hist_2);
// c3->cd();
hist_2->Draw();
// hist_2->GetXaxis()->SetRangeUser(-3.1,2);
// hist_2->Draw();
hist_1->Draw("cont2");
// hist_2->Draw("SAME");//cont2");
hist_2->SetContour(3,pllconts);//pll2);//pllconts);//pll2);
hist_2->SetLineColor(2);
hist_2->SetLineWidth(1);
// c3->cd();
c1->Update();
// hist_2->Draw("SAMEcont2");
// hist_2->GetXaxis()->SetRangeUser(-3.1,1);
// hist_2->SetContour(3,pll2);//pllconts);//pll2);
// c1->cd();
// hist_2->Draw("SAMEcont2");
// c1->Update();
TCanvas* c2 = new TCanvas( "Throw","Throw" );
hist_1->Draw("CONT LIST");
c2->Update();
//addLHCbLabel("NLL Scan")->Draw();
TObjArray *contObjArr = (TObjArray*)gROOT->GetListOfSpecials()->FindObject("contours");
int TotalConts = contObjArr->GetSize();
c1->cd();
TLegend *leg = new TLegend(0.65,0.7,1.1,0.9);
leg->SetHeader( Plot_Title_1 );
leg->SetBorderSize(0);
leg->SetFillStyle(0);
for(int i = 0; i < TotalConts; i++){
TString confname = "";
double cl = confs[i];
confname +=cl;
confname += "% C.L.";
contLevel = (TList*)contObjArr->At(i);
for(int j =0; j<contLevel->GetSize(); j++){
curv = (TGraph*)contLevel->At(j);
gc = (TGraph*)curv->Clone();
if( i!=3 ) gc->SetLineColor(Color_t(i+2));
else gc->SetLineColor(Color_t(i+3));
gc->Draw("L");
}
leg->AddEntry(gc,confname, "L");
}
c1->cd();
TLegend *leg2 = new TLegend(0.13,0.7,0.5,0.9);
leg2->SetHeader( Plot_Title_2 );
leg2->SetBorderSize(0);
leg2->SetFillStyle(0);
c2->cd();
hist_2->Draw("CONT LIST");
c2->Update();
contObjArr = (TObjArray*)gROOT->GetListOfSpecials()->FindObject("contours");
TotalConts = contObjArr->GetSize();
for(int i = 0; i < TotalConts; i++){
TString confname = "";
double cl = confs[i];
confname +=cl;
confname += "% C.L.";
contLevel = (TList*)contObjArr->At(i);
for(int j =0; j<contLevel->GetSize(); j++){
curv = (TGraph*)contLevel->At(j);
gc = (TGraph*)curv->Clone();
if( i!=3 ) gc->SetLineColor(Color_t(i+2));
else gc->SetLineColor(Color_t(i+3));
gc->SetLineStyle(Style_t(i+2));
c1->cd();
gc->Draw("L");
c2->cd();
}
leg2->AddEntry(gc,confname, "L");
}
// c1->cd();
// Double_t X_min_1 = strtod( argv[3], NULL );
// Double_t Y_min_1 = strtod( argv[4], NULL );
// Double_t X_min_2 = strtod( argv[5], NULL );
// Double_t Y_min_2 = strtod( argv[6], NULL );
// c1->cd();
// TMarker* new_mark = new TMarker( X_min_1, Y_min_1, 20 );
// new_mark->SetMarkerSize(1);
// new_mark->SetMarkerColor(8);
//new_mark->Draw("SAME");
// TMarker* new_mark2 = new TMarker( X_min_2, Y_min_2, 20 );
// new_mark2->SetMarkerSize(1);
// new_mark2->SetMarkerColor(9);
//new_mark2->Draw("SAME");
// c1->Update();
c1->cd();
leg->Draw();
leg2->Draw();
addLHCbLabel("NLL Contours")->Draw();
c1->Update();
c1->Print("Output.png");
c1->Print("Output.pdf");
input_1->Close();
input_2->Close();
return 0;
}
void plot_efficiencies( TFile* file, Int_t type = 2, TDirectory* BinDir)
{
// input: - Input file (result from TMVA),
// - type = 1 --> plot efficiency(B) versus eff(S)
// = 2 --> plot rejection (B) versus efficiency (S)
Bool_t __PLOT_LOGO__ = kTRUE;
Bool_t __SAVE_IMAGE__ = kTRUE;
// the coordinates
Float_t x1 = 0;
Float_t x2 = 1;
Float_t y1 = 0;
Float_t y2 = 0.8;
// reverse order if "rejection"
if (type == 2) {
Float_t z = y1;
y1 = 1 - y2;
y2 = 1 - z;
// cout << "--- type==2: plot background rejection versus signal efficiency" << endl;
}
else {
// cout << "--- type==1: plot background efficiency versus signal efficiency" << endl;
}
// create canvas
TCanvas* c = new TCanvas( "c", "the canvas", 200, 0, 650, 500 );
// global style settings
c->SetGrid();
c->SetTicks();
// legend
Float_t x0L = 0.107, y0H = 0.899;
Float_t dxL = 0.457-x0L, dyH = 0.22;
if (type == 2) {
x0L = 0.15;
y0H = 1 - y0H + dyH + 0.07;
}
TLegend *legend = new TLegend( x0L, y0H-dyH, x0L+dxL, y0H );
legend->SetTextSize( 0.05 );
legend->SetHeader( "MVA Method:" );
legend->SetMargin( 0.4 );
TString xtit = "Signal efficiency";
TString ytit = "Background efficiency";
if (type == 2) ytit = "Background rejection";
TString ftit = ytit + " versus " + xtit;
if (TString(BinDir->GetName()).Contains("multicut")){
ftit += " Bin: ";
ftit += (BinDir->GetTitle());
}
// draw empty frame
if(gROOT->FindObject("frame")!=0) gROOT->FindObject("frame")->Delete();
TH2F* frame = new TH2F( "frame", ftit, 500, x1, x2, 500, y1, y2 );
frame->GetXaxis()->SetTitle( xtit );
frame->GetYaxis()->SetTitle( ytit );
TMVAGlob::SetFrameStyle( frame, 1.0 );
frame->Draw();
Int_t color = 1;
Int_t nmva = 0;
TKey *key, *hkey;
TString hNameRef = "effBvsS";
if (type == 2) hNameRef = "rejBvsS";
TList hists;
TList methods;
UInt_t nm = TMVAGlob::GetListOfMethods( methods );
// TIter next(file->GetListOfKeys());
TIter next(&methods);
// loop over all methods
while (key = (TKey*)next()) {
TDirectory * mDir = (TDirectory*)key->ReadObj();
TList titles;
UInt_t ninst = TMVAGlob::GetListOfTitles(mDir,titles);
TIter nextTitle(&titles);
TKey *titkey;
TDirectory *titDir;
while ((titkey = TMVAGlob::NextKey(nextTitle,"TDirectory"))) {
titDir = (TDirectory *)titkey->ReadObj();
TString methodTitle;
TMVAGlob::GetMethodTitle(methodTitle,titDir);
TIter nextKey( titDir->GetListOfKeys() );
while ((hkey = TMVAGlob::NextKey(nextKey,"TH1"))) {
TH1 *h = (TH1*)hkey->ReadObj();
TString hname = h->GetName();
if (hname.Contains( hNameRef ) && hname.BeginsWith( "MVA_" )) {
h->SetLineWidth(3);
h->SetLineColor(color);
color++; if (color == 5 || color == 10 || color == 11) color++;
h->Draw("csame");
hists.Add(h);
nmva++;
}
}
}
}
while (hists.GetSize()) {
TListIter hIt(&hists);
TH1* hist(0);
Double_t largestInt=-1;
TH1* histWithLargestInt(0);
while ((hist = (TH1*)hIt())!=0) {
Double_t integral = hist->Integral(1,hist->FindBin(0.9999));
if (integral>largestInt) {
largestInt = integral;
histWithLargestInt = hist;
}
}
if (histWithLargestInt == 0) {
cout << "ERROR - unknown hist \"histWithLargestInt\" --> serious problem in ROOT file" << endl;
break;
}
legend->AddEntry(histWithLargestInt,TString(histWithLargestInt->GetTitle()).ReplaceAll("MVA_",""),"l");
hists.Remove(histWithLargestInt);
}
// rescale legend box size
// current box size has been tuned for 3 MVAs + 1 title
if (type == 1) {
dyH *= (1.0 + Float_t(nmva - 3.0)/4.0);
legend->SetY1( y0H - dyH );
}
else {
dyH *= (Float_t(nmva - 3.0)/4.0);
legend->SetY2( y0H + dyH);
}
// redraw axes
frame->Draw("sameaxis");
legend->Draw("same");
// ============================================================
if (__PLOT_LOGO__) TMVAGlob::plot_logo();
// ============================================================
c->Update();
TString fname = "plots/" + hNameRef;
if (TString(BinDir->GetName()).Contains("multicut")){
TString fprepend(BinDir->GetName());
fprepend.ReplaceAll("multicutMVA_","");
fname = "plots/" + fprepend + "_" + hNameRef;
}
if (__SAVE_IMAGE__) TMVAGlob::imgconv( c, fname );
return;
}
void plotMSSM(const TString& what="(ggA+bbA)*BRAZh*BRhbb"){
const double BRZll=0.06726;
const double fb2pb=1000;
//TString scale(Form("*%f*%f",BRZll,fb2pb));
TString scale("");
TString cname(what);
cname.ReplaceAll("*","x");
cname.ReplaceAll("(","U");
cname.ReplaceAll(")","U");
cname+="_MSSM_mhmax";
//
TString goodName(what);
goodName.ReplaceAll("mh","m_{h}");
goodName.ReplaceAll("ggA","#sigma_{gg#rightarrowA}");
goodName.ReplaceAll("bbA","#sigma_{bb#rightarrowA}");
goodName.ReplaceAll("BRAZh","B(A#rightarrowZh)");
goodName.ReplaceAll("BRhbb","B(h#rightarrowbb)");
//goodName+=("*B(Z#rightarrowll)");
//goodName+=("[pb] ");
goodName+=("[GeV] ");
TString goodType("MSSM m_{h}^{max}");
//goodName=("#sigma*B(pp#rightarrowA#rightarrowZh#rightarrowllbb) [fb]");
//goodName=("#sigma*B(pp#rightarrowA) [fb]");
//goodName=("BR(A#rightarrowZh)");
//goodName=("BR(h#rightarrowbb)");
//if (m>0) mass=(Form(" * (mA==%d)",m));
//TString ok(" * validity * stability * perturbativity * unitarity ");
//TString ok(" * unitarity");
TString ok("");
TChain* ch=new TChain("TreeMSSM");
ch->Add("lsf_working_dir_M225_20636539/parameter_MSSM.root");
ch->Add("lsf_working_dir_M250_20636540/parameter_MSSM.root");
ch->Add("lsf_working_dir_M275_20636541/parameter_MSSM.root");
ch->Add("lsf_working_dir_M300_20636542/parameter_MSSM.root");
ch->Add("lsf_working_dir_M325_20636543/parameter_MSSM.root");
ch->Add("lsf_working_dir_M350_20636544/parameter_MSSM.root");
ch->Add("lsf_working_dir_M400_20636545/parameter_MSSM.root");
ch->Add("lsf_working_dir_M500_20636546/parameter_MSSM.root");
ch->Add("lsf_working_dir_M600_20636547/parameter_MSSM.root");
//double tanbeta[30]={1,10,20,30,40,50,60,70,80,90,100,120,140,160,180,200,220,240,260,280,300,400,500,600,700,800,900,1000,1100,10000};
//double tanbeta[51]={0,10,20,30,40,50,60,70,80,90,100,120,140,160,180,200,220,240,260,280,300,320,340,360,380,400,420,440,460,480,500,550,600,650,700,750,800,850,900,950,1000,1100,1200,1300,1400,1500,2000,3000,4000,5000,6000};
double tanbeta[51]={0,10,20,30,40,50,60,70,80,90,100,120,140,160,180,200,220,240,260,280,300,320,340,360,380,400,420,440,460,500,550,580,600,650,700,750,800,850,900,950,1000,1100,1200,1300,1400,1500,2000,3000,4000,5000,6000};
Double_t bin_tb[50];
for (unsigned int i=0; i<50; i++) {
bin_tb[i]=0.005*(tanbeta[i]+tanbeta[i+1]);
//cout << "bin_tb[" << i << "]=" << bin_tb[i] << " " << tanbeta[i+1]/100. << endl;
}
double mA[11]={200,225,250,275,300,325,350,400,500,600,700};
Double_t bin_mA[10];
for (unsigned int i=0; i<=10; ++i) {
bin_mA[i]=0.5*(mA[i]+mA[i+1]);
//cout << "bin_mA["<<i<<"]=" << bin_mA[i] << endl;
}
bin_mA[10]=650;
TH2F* hggA=new TH2F("hggA","ggA cross section vs tan#beta,m_{A}; m_{A} GeV; tan#beta",9,bin_mA,49,bin_tb);
hggA->Sumw2();
//hggA->Draw();
TString cut=what+scale+ok;
cout << "CUT: " << cut << endl;
ch->Project("hggA","tb:mA",cut);
TStyle *tdrStyle = gROOT->GetStyle("tdrStyle");
// Double_t level[15]={.01,.02,.05,.1,.2,.5,1.,2.,5.,10.,20.,50.,100.,200.,500.};
// hggA->SetContour(14,level);
// hggA->SetMinimum(level[0]);
//
//Double_t level[10]={1.,5.,10.,20.,50.,100.,200.,500.,800.,1000.}; // for x-section
//Double_t level[10]={100,105,110.,115.,120.,123,125.7,127,130.,135.}; // for mh
Double_t level[10]={1,2,3.,4.,120.,123,125.7,127,130.,135.}; // for mh
//Double_t level[10]={.01,.1,.2,0.5,0.6,0.65,0.7,0.75,0.8,0.9}; // for BR
//Double_t level[10]={.01,.02,.05,.07,.1,.15,0.2,0.5,0.75,1.}; // for BR
hggA->SetContour(9,level);
hggA->SetMinimum(level[0]);
Double_t level[7]={122.7.,123.7,125.4,126.0,127.7,128.7.,150}; // for mh
hggA->SetContour(6,level);
hggA->SetMinimum(90);
Int_t colors[7] = {kWhite,kGreen,kGreen+2,kBlack,kGreen+2,kGreen,kWhite};
tdrStyle->SetPalette((sizeof(colors)/sizeof(Int_t)), colors);
// DRAW
tdrStyle->SetOptStat(0);
// tdrStyle->SetPadGridX(true);
// tdrStyle->SetPadGridY(true);
// tdrStyle->SetPadTopMargin(0.05);
// tdrStyle->SetPadBottomMargin(0.13);
tdrStyle->SetTitleYOffset(1.3);
tdrStyle->SetTitleXOffset(1.6);
tdrStyle->SetTitleOffset(1.3,"Z");
// tdrStyle->SetOptLogz(1);
// tdrStyle->SetOptLogy(1);
tdrStyle->SetPadRightMargin(0.14);
//tdrStyle->SetPalette(1);
tdrStyle->cd();
gROOT->ForceStyle();
cout << "Creating canvas " << cname << endl;
TCanvas* c1=new TCanvas(cname,goodName,1200,600);
cout << " done " << c1->GetName() << endl;
c1->Divide(2);
c1->cd(1);
hggA->DrawCopy("lego2");
gPad->SetLogz();
gPad->SetLogy();
//gPad->SetPhi(120);
gPad->SetPhi(-150);
//gPad->SetTheta(30);
gPad->UseCurrentStyle();
gPad->Update();
TLatex tl;
tl.SetTextSize(0.04);
tl.SetNDC();
tl.DrawLatex(0.1,0.95,goodName);
tl.SetTextAlign(11);
tl.DrawLatex(0.1,0.89,goodType);
c1->cd(2);
// tdrStyle->SetPadLeftMargin(0.25);
gPad->UseCurrentStyle();
gPad->Update();
hggA->GetXaxis()->SetTitleOffset(1.1);
hggA->GetYaxis()->SetTitleOffset(1.1);
hggA->GetZaxis()->SetTitleOffset(100);
//hggA->Smooth();
gPad->SetLogy(kFALSE);
hggA->DrawCopy("zcont1");
tl.DrawLatex(0.15,0.97,goodName);
tl.SetTextAlign(11);
tl.DrawLatex(0.2,0.9,goodType);
TCanvas* ctmp=new TCanvas(cname,goodName,600,600);
hggA->GetYaxis()->SetRangeUser(0.1,10.);
hggA->DrawCopy("zcont1");
tl.DrawLatex(0.83,0.97,goodName);
tl.SetTextAlign(11);
tl.DrawLatex(0.2,0.9,goodType);
pCan(ctmp,cname+"_Lin");
// TH1F* test=new TH1F("test","ggA cross section vs tan#beta; tan#beta",27,bin_tb);
// ch->Project("test","tb",what);
// test->Draw();
TCanvas* c2=new TCanvas(cname+"Obs",goodName,800,800);
gPad->UseCurrentStyle();
gPad->Update();
hggA->GetXaxis()->SetTitleOffset(1.1);
hggA->GetYaxis()->SetTitleOffset(1.1);
hggA->DrawCopy("cont list");
gPad->Update();
//return;
// Get Contours
TObjArray *conts = (TObjArray*)gROOT->GetListOfSpecials()->FindObject("contours");
TList* contLevel = NULL;
TGraph* curv = NULL;
TGraph* gc = NULL;
Int_t nGraphs = 0;
Int_t TotalConts = 0;
if (conts == NULL){
printf("*** No Contours Were Extracted!\n");
TotalConts = 0;
return;
} else {
TotalConts = conts->GetSize();
}
printf("TotalConts = %d\n", TotalConts);
for(i = 0; i < TotalConts; i++){
contLevel = (TList*)conts->At(i);
printf("Contour %d has %d Graphs\n", i, contLevel->GetSize());
nGraphs += contLevel->GetSize();
}
nGraphs = 0;
TH2F *hr = new TH2F("hr", ";m_{A};tan#beta", 2, 225, 600, 2, 0.1, 100);
hr->GetXaxis()->SetTitleOffset(1.1);
hr->GetXaxis()->SetRangeUser(200,650);
hr->GetYaxis()->SetTitleOffset(1.2);
hr->GetYaxis()->SetNdivisions(110,kFALSE);
hr->GetXaxis()->SetNdivisions(20205,kFALSE);
hr->Draw();
Double_t x0, y0, z0;
TLatex l;
l.SetTextSize(0.03);
l.SetTextAlign(32);
char val[20];
for(i = 0; i < TotalConts; i++){
contLevel = (TList*)conts->At(i);
z0 = level[i];
printf("Z-Level Passed in as: Z = %f\n", z0);
// Get first graph from list on curves on this level
curv = (TGraph*)contLevel->First();
for(j = 0; j < contLevel->GetSize(); j++){
// last point
//curv->GetPoint(curv->GetN()-1, x0, y0);
// first point
curv->GetPoint(2, x0, y0);
// if (z0<0) curv->SetLineColor(kRed);
// if (z0>0) curv->SetLineColor(kBlue);
nGraphs ++;
printf("\tGraph: %d -- %d Elements\n", nGraphs,curv->GetN());
// Draw clones of the graphs to avoid deletions in case the 1st
// pad is redrawn.
gc = (TGraph*)curv->Clone();
gc->Draw("C");
if (z0>=.01) sprintf(val,"%0.2f",z0);
if (z0>=.1) sprintf(val,"%0.2f",z0);
if (z0>=1) sprintf(val,"%0.0f",z0);
l.DrawLatex(x0*0.99,y0,val);
curv = (TGraph*)contLevel->After(curv); // Get Next graph
}
}
gPad->SetLogy();
gPad->SetGridx();
gPad->SetGridy();
gPad->SetRightMargin(0.05);
gPad->SetTopMargin(0.10);
c2->Update();
printf("\n\n\tExtracted %d Contours and %d Graphs \n", TotalConts, nGraphs );
tl.SetTextAlign(31);
tl.DrawLatex(0.8,0.85,goodName);
tl.SetTextAlign(31);
tl.DrawLatex(0.8,0.77,goodType);
pCan(c2,cname+"_BW");
c1->cd(1);
gPad->SetLogy();
gPad->SetLogz();
c1->cd(2);
gPad->SetLogy();
c1->Update();
pCan(c1,cname);
}
void advancedNoiseAnalysis( unsigned int runNumber, unsigned int loop = 1) {
string inputFileName = "./histo/run00" + toString( runNumber ) + "-ped-histo.root";
string outputFileName = "./histo/run00" + toString( runNumber ) + "-adv-noise.root";
// before opening the input and the output files, try to see if they
// are not opened yet and in case close them before continue
TList * listOfOpenedFile = (TList*) gROOT->GetListOfFiles();
for ( int i = 0; i < listOfOpenedFile->GetSize() ; ++i ) {
TFile * file = (TFile*) listOfOpenedFile->At( i ) ;
TString fileName(file->GetName());
TString inputFileName1( inputFileName.c_str() );
TString outputFileName1( outputFileName.c_str() );
if ( ( fileName.Contains( inputFileName1 ) ) ||
( inputFileName1.Contains( fileName ) ) ||
( fileName.Contains( outputFileName1 ) ) ||
( outputFileName1.Contains( fileName ) ) ) {
cout << "Closing " << fileName << " before reopen " << endl;
file->Close();
}
}
// close also all the previously opened canvas
TList * listOfOpenedCanvas = (TList*) gROOT->GetListOfCanvases();
for ( int i = 0 ; i < listOfOpenedCanvas->GetSize() ; ++i ) {
TCanvas * canvas = (TCanvas*) listOfOpenedCanvas->At( i );
TString canvasName2 = canvas->GetName();
if ( canvasName2.Contains( "det" ) ) {
canvas->Close();
}
}
// now safely open the file
TFile * inputFile = TFile::Open( inputFileName.c_str() ) ;
TFile * outputFile = TFile::Open( outputFileName.c_str(), "RECREATE") ;
TList * outputHistoList = new TList;
// look into the inputFile for a folder named
string pedeProcessorFolderName = "PedestalAndNoiseCalculator";
TDirectoryFile * pedeProcessorFolder = (TDirectoryFile*) inputFile->Get( pedeProcessorFolderName.c_str() );
if ( pedeProcessorFolder == 0 ) {
cerr << "No pedestal processor folder found in file " << inputFileName << endl;
return ;
}
// this folder should contain one folder for each loop.
string loopFolderName = "loop-" + toString( loop );
TDirectoryFile * loopFolder = (TDirectoryFile *) pedeProcessorFolder->Get( loopFolderName.c_str() );
if ( loopFolder == 0 ) {
cerr << "No " << loopFolderName << " found in file " << inputFileName << endl;
return ;
}
// guess the number of sensors from the number of subfolder in the loopfolder
size_t nDetector = loopFolder->GetListOfKeys()->GetSize();
cout << "This file contains " << nDetector << " detectors" << endl;
// prepare arrays to store the mean and the rms of the noise distribution
if ( noiseMean == NULL ) {
delete [] noiseMean;
noiseMean = NULL;
}
if ( noiseRMS == NULL ) {
delete [] noiseRMS;
noiseRMS = NULL;
}
if ( channel == NULL ) {
delete [] channel;
channel = NULL;
}
noiseMean = new double[ nDetector * kNChan ];
noiseRMS = new double[ nDetector * kNChan ];
channel = new double[ kNChan ];
string canvasName = "comparison";
string canvasTitle = "Noise comparison";
TCanvas * comparisonCanvas = new TCanvas( canvasName.c_str(), canvasTitle.c_str(), 1000, 500 );
comparisonCanvas->Divide(1,2);
TPad * topPad = (TPad*) comparisonCanvas->cd(1);
topPad->Divide( nDetector );
TPad * middlePad = (TPad *) comparisonCanvas->cd(2);
middlePad->Divide( kNChan );
// for each detector we have to get the noise map and to prepare 4
// separe histos and maps
for ( unsigned int iDetector = 0; iDetector < nDetector; iDetector++ ) {
// get the noise map.
string noiseMapName = "detector-" + toString( iDetector ) ;
noiseMapName += "/NoiseMap-d" + toString( iDetector ) ;
noiseMapName += "-l" + toString( loop ) ;
TH2D * noiseMap = ( TH2D* ) loopFolder->Get( noiseMapName.c_str() );
// create a folder in the output file
TDirectory * subfolder = outputFile->mkdir( string( "detector_" + toString( iDetector ) ).c_str(),
string( "detector_" + toString( iDetector ) ).c_str()
);
subfolder->cd();
string canvasName = "det" + toString( iDetector );
string canvasTitle = "Detector " + toString( iDetector );
TCanvas * canvas = new TCanvas( canvasName.c_str(), canvasTitle.c_str(), 1000, 500 );
canvas->Divide( kNChan, 2 );
// ok now start the loop on channels
for ( size_t iChan = 0 ; iChan < kNChan ; ++iChan ) {
if ( iDetector == 0 ) channel[iChan] = iChan - 0.5;
string tempName = "NoiseMap_d" + toString( iDetector ) + "_l" + toString( loop ) + "_ch" + toString( iChan ) ;
string tempTitle = "NoiseMap Det. " + toString( iDetector ) + " - Ch. " + toString( iChan ) ;
TH2D * noiseMapCh = new TH2D ( tempName.c_str() , tempTitle.c_str(),
kXPixel / kNChan , -0.5 + xLimit[ iChan ] , -0.5 + xLimit[ iChan + 1 ],
kYPixel, -0.5, -0.5 + kYPixel );
noiseMapCh->SetXTitle("X [pixel]");
noiseMapCh->SetYTitle("Y [pixel]");
noiseMapCh->SetZTitle("Noise [ADC]");
noiseMapCh->SetStats( false );
outputHistoList->Add( noiseMapCh ) ;
tempName = "NoiseDist_d" + toString( iDetector ) + "_l" + toString( loop ) + "_ch" + toString( iChan ) ;
tempTitle = "NoiseDist Det. " + toString( iDetector ) + " - Ch. " + toString( iChan ) ;
TH1D * noiseDistCh = new TH1D( tempName.c_str(), tempTitle.c_str(), 50, 0., 10. );
noiseDistCh->SetXTitle("Noise [ADC]");
noiseDistCh->SetLineColor( kColor[iDetector] );
noiseDistCh->SetLineStyle( iChan + 2 );
noiseDistCh->SetLineWidth( 2 );
outputHistoList->Add( noiseDistCh );
// let's start looping on pixels now
for ( size_t yPixel = 1 ; yPixel <= kYPixel ; ++yPixel ) {
for ( size_t xPixel = xLimit[ iChan ] + 1; xPixel <= xLimit[ iChan +1 ] ; ++xPixel ) {
double noise = noiseMap->GetBinContent( xPixel , yPixel );
noiseMapCh->Fill( xPixel - 1 , yPixel - 1, noise );
noiseDistCh->Fill( noise );
}
}
canvas->cd( iChan + 1 ) ;
noiseMapCh->Draw("colz");
canvas->cd( iChan + kNChan + 1 );
noiseDistCh->Draw();
topPad->cd( iDetector + 1 );
if ( iChan == 0 ) {
noiseDistCh->Draw();
} else {
noiseDistCh->Draw("same");
}
middlePad->cd( iChan + 1 );
if ( iDetector == 0 ) {
noiseDistCh->Draw();
} else {
noiseDistCh->Draw("same");
}
noiseMean[ kNChan * iDetector + iChan ] = noiseDistCh->GetMean();
noiseRMS[ kNChan * iDetector + iChan ] = noiseDistCh->GetRMS();
}
canvas->Write();
}
canvasName = "summary";
canvasTitle = "Noise summary";
TCanvas * summaryCanvas = new TCanvas( canvasName.c_str(), canvasTitle.c_str(), 1000, 500 );
summaryCanvas->SetGridx(1);
TLegend * legend = new TLegend(0.5, 4.8, 1.5, 4.3,"","br");;
for ( size_t iDetector = 0 ; iDetector < nDetector ; ++iDetector ) {
TGraphErrors * gr = new TGraphErrors( kNChan, channel, &noiseMean[ iDetector * kNChan ], NULL, &noiseRMS[ iDetector * kNChan ] );
gr->SetName( string( "NoisePerChannel_d" + toString( iDetector )).c_str());
gr->SetTitle(string("Detector " + toString( iDetector )).c_str());
gr->GetXaxis()->SetTitle("Channel #");
gr->GetYaxis()->SetTitle("Noise [ADC]");
gr->GetXaxis()->SetNdivisions( 5 );
gr->GetXaxis()->SetLabelSize( 0 );
gr->SetMarkerStyle( iDetector + 1 );
gr->SetMarkerColor( kColor[iDetector] );
gr->SetLineColor( kColor[iDetector] );
gr->SetLineWidth( 2 );
legend->AddEntry( gr, string("Detector " + toString( iDetector )).c_str(), "LP");
if ( iDetector == 0 ) {
gr->Draw("ALP");
} else {
gr->Draw("LP");
}
}
legend->Draw();
for ( size_t iChan = 0 ; iChan < kNChan ; ++iChan ) {
TPaveLabel * label = new TPaveLabel( iChan - 0.75 , 3.2 , iChan -0.25 , 3, string("Ch " + toString( iChan ) ).c_str());
label->Draw();
}
summaryCanvas->Write();
comparisonCanvas->Write();
outputHistoList->Write();
}
