/// Open new data file
bool DDG4EventHandler::Open(const std::string&, const std::string& name) {
if ( m_file.first ) m_file.first->Close();
m_hasFile = false;
m_hasEvent = false;
TFile* f = TFile::Open(name.c_str());
if ( f && !f->IsZombie() ) {
m_file.first = f;
TTree* t = (TTree*)f->Get("EVENT");
if ( t ) {
TObjArray* br = t->GetListOfBranches();
m_file.second = t;
m_entry = -1;
m_branches.clear();
for(Int_t i=0; i<br->GetSize(); ++i) {
TBranch* b = (TBranch*)br->At(i);
if ( !b ) continue;
m_branches[b->GetName()] = make_pair(b,(void*)0);
printout(INFO,"DDG4EventHandler::open","+++ Branch %s has %ld entries.",b->GetName(),b->GetEntries());
}
for(Int_t i=0; i<br->GetSize(); ++i) {
TBranch* b = (TBranch*)br->At(i);
if ( !b ) continue;
b->SetAddress(&m_branches[b->GetName()].second);
}
m_hasFile = true;
return true;
}
throw runtime_error("+++ Failed to access tree EVENT in ROOT file:"+name);
}
throw runtime_error("+++ Failed to open ROOT file:"+name);
}
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 scanDiffRecoTracks(std::string eName, std::string eoName,
std::string branchReg = "recoTracks_*"){
gSystem->Load("libFWCoreFWLite");
gROOT->ProcessLine("AutoLibraryLoader::enable();");
TChain* e = new TChain("Events");
e->SetScanField(0);
e->Add(eName.c_str());
TChain* eo = new TChain("Events");
eo->SetScanField(0);
eo->Add(eoName.c_str());
e->AddFriend(eo, "eo");
TRegexp regg(branchReg.c_str(), kTRUE);
TChain* tc = e ;
TObjArray* tl = tc->GetListOfBranches();
Int_t nBr = tl->GetSize();
for (int iB=0;iB<nBr;++iB){
TBranch* br = (TBranch*)(tl->At(iB));
TString ts(br->GetName());
if(ts.Index(regg)>=0){
std::cout<<ts.Data()<<std::endl;
tc->Scan(Form("Sum$(%s.obj.pt()>0):Sum$(eo.%s.obj.pt()>0):Sum$(%s.obj.pt()):Sum$(%s.obj.pt())-Sum$(eo.%s.obj.pt())",
ts.Data(), ts.Data(), ts.Data(), ts.Data(), ts.Data()),"", "");
}
} //> e.tecoTracks.recoT0.txt
}
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;
}
///
/// Copied from TColor::GetColorDark(Int_t n), but customized
/// the 'darkness'.
///
int ColorBuilder::darklightcolor(int n, float scale)
{
if (n < 0) return -1;
// Get list of all defined colors
TObjArray *colors = (TObjArray*) gROOT->GetListOfColors();
Int_t ncolors = colors->GetSize();
// Get existing color at index n
TColor *color = 0;
if (n < ncolors) color = (TColor*)colors->At(n);
if (!color) return -1;
// Get the rgb of the the new dark color corresponding to color n
Float_t r,g,b;
TColor::HLStoRGB(color->GetHue(), scale*color->GetLight(), color->GetSaturation(), r, g, b);
// Build the dark color (unless the slot nd is already used)
Int_t nd = scale<1. ? n+100 : n+150;
TColor *colord = 0;
if (nd < ncolors) colord = (TColor*)colors->At(nd);
if (colord) return nd;
colord = new TColor(nd,r,g,b);
colord->SetName(scale<1. ? Form("%s_dark",color->GetName()) : Form("%s_light",color->GetName()));
colors->AddAtAndExpand(colord,nd);
return nd;
}
void bright_colors(Float_t value=1)
{
// Notes:
// you can store the original colors by creating a clone of
// (TObjArray*)gROOT->GetListOfColors() and restore the colors by
// assigning the vector with original values to the list of colors
// that gROOT handles.
if (value > 5)
{
printf("Value %f too high - maximum is 5.\n", value);
return;
}
value *= 0.1f;
TObjArray *colors = (TObjArray*) gROOT->GetListOfColors();
TColor *color = 0;
Float_t r, g, b;
for (int i = 0; i < colors->GetSize(); ++i)
{
if ((color = dynamic_cast<TColor*>(colors->At(i))) != 0)
{
color->GetRGB(r, g, b);
if (r < 0.01 && g < 0.01 && b < 0.01) continue; // skip black
if (r > 0.95 && g > 0.95 && b > 0.95) continue; // skip white
r = TMath::Min(r + value, 1.0f);
g = TMath::Min(g + value, 1.0f);
b = TMath::Min(b + value, 1.0f);
color->SetRGB(r, g, b);
}
}
if (gEve)
gEve->FullRedraw3D();
}
//________________________________________________________
TLegend* GFHistManager::GetLegendOf(Int_t layer, Int_t histoNum)
{
// if it already exists!
if(!this->CheckHistNum("AddLegend", layer, histoNum)) return NULL;
TObjArray* legendsOfLayer = this->MakeLegends(layer);
TLegend* legend = (legendsOfLayer->GetSize() < histoNum ?
NULL : static_cast<TLegend*>(legendsOfLayer->At(histoNum)));
return legend;
}
void VariablePrint1() {
TFile *f = new TFile("/home/francji/data/subsets/small_training_sample/p17_CC_diboson_EqOneTag_EqThreeJet_zero_Topo_small_training_sample.root");
TTree *t = (TTree *) f->Get("TopologicalVariables");
TObjArray *arr = t->GetListOfBranches();
for (int i = 0; i < arr->GetSize(); i++) {
char s[1000];
strcpy(s, arr->At(i)->GetTitle());
char c = s[strlen(s)-1];
s[strlen(s)-2] = '\0';
printf("%i %s \n", i, s);
}
}
void D3PDSelector::loadBranch(std::string key )
{
//std::cout << "Getting List Of Leaves" << std::endl;
TObjArray* leaves = fChain->GetListOfLeaves();
//std::cout << "Got List Of Leaves" << std::endl;
//std::cout << "key " << key << std::endl;
for (int c=0; c<leaves->GetSize(); c++)
{
TLeaf* leaf = (TLeaf*)leaves->UncheckedAt(c);
TLeafObject* leafobj = (TLeafObject*)leaf;
const char* curbraname = leafobj->GetName();
//std::cout << "Got Leave " << curbraname << std::endl;
if (strcmp(curbraname, key.c_str()) == 0)
{
const char* curtitle = leafobj->GetTypeName();
std::string classtype(leafobj->ClassName());
m_types[key] = std::string(curtitle);
void* address;
//if (m_types[key].find("<") == std::string::npos) //vector type? //old check
//TLeafElement means it's a pointer to an obect
//Else its a more primitve type (int, float etc)
if (classtype.find("TLeafElement") == std::string::npos)
{
void* tmpfl = (void* )(new double(0.)); //make sure enough space, so make doube
address = tmpfl;
}
else
{
void** tmp = new void*; //works 1
*tmp = 0;
address=tmp;
}
m_data[key] = (void**)address;
TBranch* cur_branch = 0;
m_branches[key] = cur_branch;
fChain->SetBranchAddress(key.c_str(), m_data[key] , &m_branches[key] );
//m_branches[key]->GetEntry(m_curentry); //Entry is loaded in loadData method
return;
}
}
//std::cout << "Got All List Of Leaves" << std::endl;
//std::cout << "key " << key << std::endl;
std::cout << "WARNING: Requested variable " << key << " not found. The program might crash now." << std::endl;
}
TGraph* ContourGraph( TH2F* hist,double xmin=16, double xmax=90) {
//temporary canvas
TCanvas* MOO = new TCanvas( TString::Format("dummy_canvas_%s", hist->GetName()), "A scan of m_{0} versus m_{12}", 0, 0, 650,640);
MOO->cd();
TGraph* gr0 = new TGraph();
TH2F* h = (TH2F*)hist->Clone();
TGraph* gr = (TGraph*)gr0->Clone(TString::Format("gr_%s", h->GetName()));
cout << "==> Will dumb histogram: " << h->GetName() << " into a graph" <<endl;
h->SetContour( 1 );
//h->GetXaxis()->SetRangeUser(250,1200);
h->GetXaxis()->SetRangeUser(xmin, xmax);
//h->GetYaxis()->SetRangeUser(2,50);
double pval = CombinationGlob::cl_percent[1];
std::cout << pval << std::endl;
double signif = TMath::NormQuantile(1-pval);
h->SetContourLevel( 0, signif );
h->Draw("CONT LIST");
h->SetDirectory(0);
gPad->Update();
TObjArray *contours = (TObjArray*) gROOT->GetListOfSpecials()->FindObject("contours");
Int_t ncontours = contours->GetSize();
cout << "Found " << ncontours << " contours " << endl;
TList *list = (TList*)contours->At(0);
contours->Print("v");
if(!list) return NULL;
gr = (TGraph*)list->First();
if(!gr) return NULL;
gr->SetName(TString::Format("gr_%s", hist->GetName()));
//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->Draw("ALP");
delete MOO;
cout << "Generated graph " << gr << " with name " << gr->GetName() << endl;
return gr;
}
void D3PDSelector::Init(TTree *tree)
{
// The Init() function is called when the selector needs to initialize
// a new tree or chain. Typically here the branch addresses and branch
// pointers of the tree will be set.
// It is normally not necessary to make changes to the generated
// code, but the routine can be extended by the user if needed.
// Init() will be called many times when running on PROOF
// (once per file to be processed).
// Set object pointer
// Set branch addresses and branch pointers
std::cout << "INIT" << std::endl;
SetElectronContainerPrefix("el");
SetMuonContainerPrefix("mu_staco");
SetJetContainerPrefix("jet_AntiKt4TopoNewEM");
// SetJetContainerPrefix("jet_AntiKt4TopoEM");
//SetPhotonContainerPrefix("ph");
//Reset intenral data structure to Branch Addresses
m_data.clear();
m_branches.clear();
m_types.clear();
if (!tree) return;
fChain = tree;
fChain->SetMakeClass(1);
TObjArray* leaves = tree->GetListOfLeaves();
for (int c=0; c<leaves->GetSize(); c++)
{
TLeaf* leaf = (TLeaf*)leaves->UncheckedAt(c);
TLeafObject* leafobj = (TLeafObject*)leaf;
//TLeafObject* curbra = (TLeafObject*)tor->At(c);
const char* curbraname = leafobj->GetName();
const char* curtitle = leafobj->GetTypeName();
//const char* classn = leafobj->ClassName();
if (m_verbose)
std::cout << curbraname << " " << /*curbraclassName <<" " << */curtitle << std::endl;
}
}
// Helper function to avoid code mess with TString's Tokenize
inline vector<TString> tokenize(TString line, const char* delim=" ") {
vector<TString> retvec;
line = line.Strip();
// Tokenize the string, use blank as delimiter
TObjArray* tokens = line.Tokenize(delim);
for (int i=0; i<tokens->GetSize(); i++) {
// For some reasons Tokenize produces an awfull lot of Null-pointers
if (tokens->At(i)!=0) {
// We need to explicitly cast the array contents to TObjString
TString t = dynamic_cast<TObjString *>(tokens->At(i))->GetString();
retvec.push_back(t);
}
}
return retvec;
}
void VariablesPrint() {
TFile *f = new TFile("/work/budvar-clued0/francji/subsets/small_training_sample/p17_CC_diboson_EqOneTag_EqThreeJet_zero_Topo_small_training_sample.root");
TTree *t = (TTree *) f->Get("TopologicalVariables");
TObjArray *arr = t->GetListOfBranches();
int j = 1;
for (int i = 0; i < arr->GetSize(); i++) {
char s[1000];
strcpy(s, arr->At(i)->GetTitle());
char c = s[strlen(s)-1];
s[strlen(s)-2] = '\0';
if (c == 'D') {
printf("%5i D %s \n", j, s);
j++;
} else if (c == 'I') {
printf("%5i I %s \n", j, s);
j++;
} else {};
}
}
//_____________________________________________________
void GFHistManager::AddLegend(TLegend* leg, Int_t layer, Int_t histoNum)
{
// hist and layer must already exist
if(!this->CheckHistNum("AddLegend", layer, histoNum)) return;
TObjArray* legendsOfLayer = this->MakeLegends(layer);
TLegend* legend = (legendsOfLayer->GetSize() < histoNum ?
NULL : static_cast<TLegend*>(legendsOfLayer->At(histoNum)));
if(legend) {
this->Error("AddLegend", "legend exists, replacing it");
delete legend;
}
legend = leg;
legendsOfLayer->AddAtAndExpand(legend, histoNum);
if(layer < fCanArrays->GetEntriesFast()) {
this->Update(layer); // if canvas already drawn
}
}
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;
}
//_____________________________________________________
TLegend* GFHistManager::AddLegend(Int_t layer, Int_t histoNum,
const char* header, Bool_t referAll)
{
// adds a legend referencing all hists in same pad 'histoNum' of layer
//
// FIXME: use help of other AddLegend method?
if(!this->CheckHistNum("AddLegend", layer, histoNum)) return NULL;
TObjArray* legendsOfLayer = this->MakeLegends(layer);
TLegend* legend = (legendsOfLayer->GetSize() <= histoNum ?
NULL : static_cast<TLegend*>(legendsOfLayer->At(histoNum)));
if(!legend) {
legend = new TLegend(fLegendX1, fLegendY1, fLegendX2, fLegendY2);
#if ROOT_VERSION_CODE < ROOT_VERSION(5,6,0)
if (TString(gStyle->GetName()) == "Plain") legend->SetBorderSize(1);
#endif
legendsOfLayer->AddAtAndExpand(legend, histoNum);
}
if(header) legend->SetHeader(header);
GFHistArray* hists = this->GetHistsOf(layer, histoNum);
TList* legendEntries = legend->GetListOfPrimitives();
if(referAll){
TIter histsIter(hists);
while(TObject* hist = histsIter.Next()){
Bool_t addNew = kTRUE;
TIter legEntrIter(legendEntries);
while(TLegendEntry* entry = static_cast<TLegendEntry*>(legEntrIter())){
if(hist == entry->GetObject()) {addNew = kFALSE; break;}
}
if(addNew) legend->AddEntry(hist, hist->GetName(), fgLegendEntryOption);
}
}
if(layer < fCanArrays->GetEntriesFast()) {
this->Update(layer); // if canvas already drawn
}
return legend;
}
void myAna::SlaveBegin(TTree * /*tree*/)
{
// The SlaveBegin() function is called after the Begin() function.
// When running with PROOF SlaveBegin() is called on each slave server.
// The tree argument is deprecated (on PROOF 0 is passed).
TString option = GetOption();
string JSONPATH = "";
cout<<"option = "<<option.Data()<<endl;
TObjArray *args = (TObjArray*)option.Tokenize(" ");
if (args->GetSize()>1)
JSONPATH = (string)((TObjString*)args->At(0))->GetString();
// Will count events passing by each pad separately.
// Now, set them all to zero:
for (size_t n=0; n<nC; n++){
nEvents[static_cast<UInt_t>(PadsEnum::SiPad1)][n]=0;
nEvents[static_cast<UInt_t>(PadsEnum::SiPad2)][n]=0;
nEvents[static_cast<UInt_t>(PadsEnum::SiPad3)][n]=0;
nEvents[static_cast<UInt_t>(PadsEnum::SiPad4)][n]=0;
nEvents[static_cast<UInt_t>(PadsEnum::SiPad5)][n]=0;
nEvents[static_cast<UInt_t>(PadsEnum::SiPad6)][n]=0;
nEvents[0][n]=0;
}
pt::read_json(JSONPATH, TB_RUNS_DATA);
fProofFile = new TProofOutputFile("TB_2016_myHistograms.root");
fOutput->Add(fProofFile);
// Open the file
histoFile = fProofFile->OpenFile("RECREATE");
TH1::SetDefaultSumw2(kTRUE);
hists = new HistManager(histoFile);
}
void paracoor( TString fin = "TMVA.root", Bool_t useTMVAStyle = kTRUE )
{
// set style and remove existing canvas'
TMVAGlob::Initialize( useTMVAStyle );
// checks if file with name "fin" is already open, and if not opens one
TFile* file = TMVAGlob::OpenFile( fin );
TTree* tree = (TTree*)file->Get("TestTree");
if(!tree) {
cout << "--- No TestTree saved in ROOT file. Parallel coordinates will not be plotted" << endl;
return;
}
// first get list of leaves in tree
TObjArray* leafList = tree->GetListOfLeaves();
vector<TString> vars;
vector<TString> mvas;
for (Int_t iar=0; iar<leafList->GetSize(); iar++) {
TLeaf* leaf = (TLeaf*)leafList->At(iar);
if (leaf != 0) {
TString leafName = leaf->GetName();
if (leafName != "type" && leafName != "weight" && leafName != "boostweight" &&
leafName != "class" && leafName != "className" && leafName != "classID" &&
!leafName.Contains("prob_")) {
// is MVA ?
if (TMVAGlob::ExistMethodName( leafName )) {
mvas.push_back( leafName );
}
else {
vars.push_back( leafName );
}
}
}
}
cout << "--- Found: " << vars.size() << " variables" << endl;
cout << "--- Found: " << mvas.size() << " MVA(s)" << endl;
TString type[2] = { "Signal", "Background" };
const Int_t nmva = mvas.size();
TCanvas* csig[nmva];
TCanvas* cbkg[nmva];
for (Int_t imva=0; imva<mvas.size(); imva++) {
cout << "--- Plotting parallel coordinates for : " << mvas[imva] << " & input variables" << endl;
for (Int_t itype=0; itype<2; itype++) {
// create draw option
TString varstr = mvas[imva] + ":";
for (Int_t ivar=0; ivar<vars.size(); ivar++) varstr += vars[ivar] + ":";
varstr.Resize( varstr.Last( ':' ) );
// create canvas
TString mvashort = mvas[imva]; mvashort.ReplaceAll("MVA_","");
TCanvas* c1 = (itype == 0) ? csig[imva] : cbkg[imva];
c1 = new TCanvas( Form( "c1_%i",itype ),
Form( "Parallel coordinate representation for %s and input variables (%s events)",
mvashort.Data(), type[itype].Data() ),
50*(itype), 50*(itype), 750, 500 );
tree->Draw( varstr.Data(), Form("classID==%i",1-itype) , "para" );
c1->ToggleEditor();
gStyle->SetOptTitle(0);
TParallelCoord* para = (TParallelCoord*)gPad->GetListOfPrimitives()->FindObject( "ParaCoord" );
TParallelCoordVar* mvavar = (TParallelCoordVar*)para->GetVarList()->FindObject( mvas[imva] );
Double_t minrange = tree->GetMinimum( mvavar->GetName() );
Double_t maxrange = tree->GetMaximum( mvavar->GetName() );
Double_t width = 0.2*(maxrange - minrange);
Double_t x1 = minrange, x2 = x1 + width;
TParallelCoordRange* parrange = new TParallelCoordRange( mvavar, x1, x2 );
parrange->SetLineColor(4);
mvavar->AddRange( parrange );
para->AddSelection("-1");
for (Int_t ivar=1; ivar<TMath::Min(Int_t(vars.size()) + 1,3); ivar++) {
TParallelCoordVar* var = (TParallelCoordVar*)para->GetVarList()->FindObject( vars[ivar] );
minrange = tree->GetMinimum( var->GetName() );
maxrange = tree->GetMaximum( var->GetName() );
width = 0.2*(maxrange - minrange);
switch (ivar) {
case 0: { x1 = minrange; x2 = x1 + width; break; }
case 1: { x1 = 0.5*(maxrange + minrange - width)*0.02; x2 = x1 + width*0.02; break; }
case 2: { x1 = maxrange - width; x2 = x1 + width; break; }
}
parrange = new TParallelCoordRange( var, x1, x2 );
parrange->SetLineColor( ivar == 0 ? 2 : ivar == 1 ? 5 : 6 );
var->AddRange( parrange );
para->AddSelection( Form("%i",ivar) );
}
c1->Update();
TString fname = Form( "plots/paracoor_c%i_%s", imva, itype == 0 ? "S" : "B" );
TMVAGlob::imgconv( c1, fname );
}
}
}
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 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 makeMuVMassPlot(bool iUseWWType = false) {
SetStyle();
TCanvas *lCan = new TCanvas("A","A",600,600);
// lCan->SetGridx(1);
//lCan->SetGridy(1);
lCan->SetRightMargin(0.14);
double *lTX1 = new double[2];
double *lTX2 = new double[2];
double lMinNLL = 1000;
double lVMin = 0;
double *lMin = new double[36];
if(!iUseWWType) for(int i0 = 0; i0 < 36; i0++) { lMin[i0] = getMinNLL(110+i0*1.); if(lMin[i0] < lVMin) {lVMin = lMin[i0]; lTX1[0] = 110+i0*1.;}}
//lMin[17] = (lMin[16]+lMin[18])/2.;
//lMin[21] = (lMin[20]+lMin[22])/2.;
//lMin[29] = (lMin[28]+lMin[30])/2.;
//lMin[34] = (lMin[33]+lMin[35])/2.;
TFile *lFile = new TFile("/afs/cern.ch/user/p/pharris/public/massscan/cmb+.root");
TTree *lTree = lFile->FindObjectAny("limit");
TH2F *lH = new TH2F("2D","2D",36,109.5,145.5,50,-2.,3.);
float lNLL = 0; lTree->SetBranchAddress("nll" ,&lNLL);
float lMNLL = 0; lTree->SetBranchAddress("deltaNLL",&lMNLL);
double lMH = 0; lTree->SetBranchAddress("mh" ,&lMH);
float lR = 0; lTree->SetBranchAddress("r" ,&lR);
if(iUseWWType) {
for(int i0 = 0; i0 < lTree->GetEntries(); i0++) {
lTree->GetEntry(i0);
if(lR < 0.1 && lR > 0) lMin[int(lMH-110)] = -lMNLL;
}
lVMin = 10000;
for(int i0 = 0; i0 < lTree->GetEntries(); i0++) {
lTree->GetEntry(i0);
double pMin = lMin[int(lMH-110)] + lMNLL;
if(pMin < lVMin) lVMin = pMin;
}
}
for(int i0 = 0; i0 < lTree->GetEntries(); i0++) {
lTree->GetEntry(i0);
//if(lMH == 125) continue;
lNLL = 0.; //lMin = 0.;
lH->SetBinContent(lH->GetXaxis()->FindBin(lMH),lH->GetYaxis()->FindBin(lR),(lMNLL+lMin[lH->GetXaxis()->FindBin(lMH)-1]-lVMin));
if(lMH == lTX1[0] && lMNLL < lMinNLL) {lMinNLL = lMNLL; lTX2[0] = lR;}
}
TH2F* lHC = lH->Clone("2D_v2");
double lCont[3];
lCont[0] = 1.17;
lCont[1] = 3.0;
lCont[2] = 9.0;
lHC->SetContour(2,lCont);
//lCan->SetLogz();
lHC->Draw("cont z list");
lCan->Update();
lHC->Draw("colz");
TObjArray *lContours = (TObjArray*)gROOT->GetListOfSpecials()->FindObject("contours");
int lTotalConts = lContours->GetSize();
double *lTX = new double[2]; lTX[0] = 110; lTX[1] = 145;
double *lTY = new double[2]; lTY[0] = -0.5; lTY[1] = 2.5;
TGraph *lFirst = new TGraph(2,lTX,lTY); lFirst->SetLineColor(kWhite);
lFirst->GetXaxis()->SetRangeUser(110,148);
lFirst->Draw("al"); lFirst->SetTitle("");
lH->GetYaxis()->SetRangeUser(-0.5,2.5);
lFirst->GetXaxis()->SetTitle("m_{H}[GeV]");
lFirst->GetXaxis()->SetTitleOffset(1.0);
lFirst->GetYaxis()->SetTitle("#mu_{best-fit}");
lFirst->GetYaxis()->SetTitleOffset(1.2);
lH->GetXaxis()->SetTitle("m_{H}[GeV]");
lH->GetXaxis()->SetTitleOffset(1.0);
lH->GetYaxis()->SetTitle("#mu_{best-fit}");
lH->GetYaxis()->SetTitleOffset(1.2);
lTX1[1] = lTX1[0]; lTX2[1] = lTX2[1]+0.001;
TGraph *lSecond = new TGraph(1,lTX1,lTX2); lSecond->SetMarkerStyle(34); lSecond->SetMarkerSize(3.5);
//lSecond->Draw("p");
TLegend *lL = new TLegend(0.65,0.15,0.85,0.35); lL->SetBorderSize(0); lL->SetFillColor(0); lL->SetFillStyle(0);
for(i0 = 0; i0 < lTotalConts; i0++){
pContLevel = (TList*)lContours->At(lTotalConts-1.-i0);
// Get first graph from list on curves on this level
std::vector<double> lX;
std::vector<double> lY;
pCurv = (TGraph*)pContLevel->First();
for(int i1 = 0; i1 < pContLevel->GetSize(); i1++){
for(int i2 = 0; i2 < pCurv->GetN(); i2++) {lX.push_back(pCurv->GetX()[i2]); lY.push_back(pCurv->GetY()[i2]);}
//pCurv->GetPoint(0, x0, y0);
pCurv->SetLineColor(kBlack);//kGreen+i0);
pCCurv = (TGraph*)pCurv->Clone();
if(i0 == 0) pCCurv->SetFillColor(0);
if(i0 == 1) pCCurv->SetFillColor(0);
//if(i0 == 1) pCCurv->SetLineStyle(kDashed);
pCCurv->SetLineWidth(3);
pCCurv->GetXaxis()->SetRangeUser(0,3.0);
//if(i0 == 0) pCCurv->Draw("AL");
//if(i0 != -10) pCCurv->Draw("LC");
//l.DrawLatex(x0,y0,val);
pCurv = (TGraph*)pContLevel->After(pCurv); // Get Next graph
}
TGraph *lTotal = new TGraph(lX.size(),&lX[0],&lY[0]);
lTotal->SetLineWidth(3);
lTotal->SetFillColor(kGreen+i0*2);
lTotal->SetFillStyle(3001);
//lTotal->Draw("lf");
//if(i0 == 0) lTotal->Draw("alf");
//if(i0 == 0) lTotal->Draw("alf");
//for(int iX = 0; iX < lTotal->GetN(); iX++) cout << "===> " << lTotal->GetX()[iX] << " -- " << lTotal->GetY()[iX] << endl;
//if(i0 != -10) lTotal->Draw("lfC");
bool pSwitch = false;
int pSign = -1.; if(lTotal->GetX()[0] > lTotal->GetX()[1]) pSign = 1;
double pXOld = lTotal->GetX()[lTotal->GetN()-1];
std::vector<double> pXLeft;
std::vector<double> pXRight;
std::vector<double> pYLeft;
std::vector<double> pYRight;
for(int iX = 0; iX < lTotal->GetN(); iX++) {
double pX = lTotal->GetX()[iX];
if(pSign*pX > pSign*pXOld ) {pSwitch = !pSwitch; pSign *= -1;}
if(!pSwitch) {pXLeft.push_back(lTotal->GetX()[iX]); pYLeft.push_back(lTotal->GetY()[iX]); }
if(pSwitch) {pXRight.push_back(lTotal->GetX()[iX]); pYRight.push_back(lTotal->GetY()[iX]); }
pXOld = pX;
}
TGraph *lLeftTotal = new TGraph(pXLeft.size() ,&pXLeft[0],&pYLeft[0]);
TGraph *lRightTotal = new TGraph(pXRight.size(),&pXRight[0],&pYRight[0]);
lLeftTotal->SetLineColor(kRed);
lRightTotal->SetLineColor(kBlue);
lLeftTotal->SetLineStyle(kDashed);
lRightTotal->SetLineStyle(kDashed);
//lLeftTotal->Draw("l");
//lRightTotal->Draw("l");
TGraphSmooth *lGS0 = new TGraphSmooth("normal");
TGraphSmooth *lGS1 = new TGraphSmooth("normal");
TGraph *lSmooth0 = lGS0->SmoothSuper(lRightTotal,"",0.,0.);
TGraph *lSmooth1 = lGS1->SmoothSuper(lLeftTotal,"",0.,0.) ;
lSmooth0->Draw("l");
lSmooth1->Draw("l");
std::vector<double> pXSmooth;
std::vector<double> pYSmooth;
std::vector<double> pXSmooth1;
std::vector<double> pYSmooth1;
cout << "==" << lSmooth0->GetN() << " -- " <<lSmooth1->GetN() << endl;
for(int iX = 0; iX < lSmooth0->GetN(); iX++) {pXSmooth.push_back(lSmooth0->GetX()[iX]); pYSmooth.push_back(lSmooth0->GetY()[iX]);}
for(int iX = 0; iX < lSmooth1->GetN(); iX++) {pXSmooth.push_back(lSmooth1->GetX()[lSmooth1->GetN()-iX-1]); pYSmooth.push_back(lSmooth1->GetY()[lSmooth1->GetN()-iX-1]);}
for(int iX = 0; iX < lSmooth0->GetN(); iX++) {pXSmooth1.push_back(lSmooth0->GetX()[iX]); pYSmooth1.push_back(lSmooth0->GetY()[iX]);}
for(int iX = 0; iX < lSmooth1->GetN(); iX++) {pXSmooth1.push_back(lSmooth1->GetX()[lSmooth1->GetN()-iX-1]); pYSmooth1.push_back(lSmooth1->GetY()[lSmooth1->GetN()-iX-1]);}
//if(i0 == 1) {pXSmooth1.push_back(lSmooth1->GetX()[0]); pYSmooth1.push_back(lSmooth1->GetY()[0]);}
TGraph *pSmoothShape = new TGraph(pXSmooth.size() ,&pXSmooth [0],&pYSmooth [0]);
TGraph *pSmoothShape1 = new TGraph(pXSmooth1.size(),&pXSmooth1[0],&pYSmooth1[0]);
if(i0 == 1) {TLine *lLine = new TLine(pXSmooth1[0],pYSmooth1[0],pXSmooth1[pXSmooth1.size()-1],pYSmooth1[pYSmooth1.size()-1]); lLine->Draw();}
pSmoothShape1->SetLineColor(kBlack);
pSmoothShape1->SetLineWidth(2);
pSmoothShape->SetFillColor(kGreen+i0*2);
pSmoothShape->SetFillStyle(3001);
pSmoothShape->Draw("lf");
pSmoothShape1->Draw("l");
if(i0 == 0) lL->AddEntry(lTotal,"95% CL","lf");
if(i0 == 1) lL->AddEntry(lTotal,"68% CL","lf");
}
lL->AddEntry(lSecond,"BestFit","p");
lSecond->Draw("lp");
lL->Draw();
std::string masslabel = "m_{H}"; double mass = 125;
TString label = TString::Format("%s = 135 GeV", masslabel.c_str());//, 125.);
TPaveText* textlabel = new TPaveText(0.18, 0.81, 0.50, 0.90, "NDC");
textlabel->SetBorderSize( 0 );
textlabel->SetFillStyle ( 0 );
textlabel->SetTextAlign ( 12 );
textlabel->SetTextSize (0.04 );
textlabel->SetTextColor ( 1 );
textlabel->SetTextFont ( 62 );
textlabel->AddText(label);
//textlabel->Draw();
CMSPrelim("Preliminary, H#rightarrow#tau#tau,L = 24.3 fb^{-1}", "", 0.145, 0.835);
gPad->RedrawAxis();
lCan->Update();
lCan->SaveAs("cmb+_muvmass.png");
lCan->SaveAs("cmb+_muvmass.pdf");
lCan->SaveAs("cmb+_muvmass.eps");
}
TList *KVAvailableRunsFile::GetListOfAvailableSystems(const KVDBSystem *
systol)
{
//Create and fill a sorted list of available systems based on the runs in the available runs file.
//If systol!=0 then create and fill a list of available runs for the given system
//USER MUST DELETE THE LIST AFTER USE.
//
//For each system in the list we set the number of available runs : this number
//can be retrieved with KVDBSystem::GetNumberRuns()
//
//If available runs file does not exist, Update() is called to create it.
ReadFile(); // this will sanitize the file if necessary (remove duplicates)
//does runlist exist ?
if (!OpenAvailableRunsFile()) {
Error("GetListOfAvailableSystems",
"Error opening available runs file");
return 0;
}
TString fLine;
TList *sys_list = 0;
Int_t good_lines = 0;
fLine.ReadLine(fRunlist);
Int_t fRunNumber;
TDatime fDatime;
TString kvversion, username;
KVDBTable *runs_table = 0;
if (!fDataSet->GetDataBase()){
runs_table = new KVDBTable("Runs");
}
else{
runs_table = fDataSet->GetDataBase()->GetTable("Runs");
}
while (fRunlist.good()) {
TObjArray *toks = fLine.Tokenize('|'); // split into fields
if(toks->GetSize()){
KVString kvs(((TObjString *) toks->At(0))->GetString());
if(kvs.IsDigit()){
good_lines++;
fRunNumber = kvs.Atoi();
kvversion= username="";
TString tmp = ((TObjString *) toks->At(1))->GetString();
fDatime = TDatime(tmp.Data());
if(toks->GetEntries()>3){
kvversion = ((TObjString *) toks->At(3))->GetString();
username = ((TObjString *) toks->At(4))->GetString();
}
KVDBRun *a_run = (KVDBRun *) runs_table->GetRecord(fRunNumber);
KVDBSystem *sys = 0;
if (a_run){
sys = a_run->GetSystem();
}
if (!systol) {
//making a systems list
if (!sys_list)
sys_list = new TList;
if (sys) {
/* Block Modified() signal being emitted by KVDBRun object
when we set its 'datime'. This is to avoid seg fault with
KVDataAnalysisGUI, when we are changing system/display,
and the KVLVEntry to which this signal was previously connected
no longer exists */
a_run->BlockSignals(kTRUE);
a_run->SetDatime(fDatime);
a_run->SetKVVersion(kvversion);
a_run->SetUserName(username);
a_run->BlockSignals(kFALSE);
if (!sys_list->Contains(sys)) {
//new system
sys_list->Add(sys);
sys->SetNumberRuns(1); //set run count to 1
} else {
//another run for this system
sys->SetNumberRuns(sys->GetNumberRuns() + 1);
}
}
} else {
//making a runlist
if (systol == sys) { //run belongs to same system
if (!sys_list)
sys_list = new TList;
//if(noSystems && a_run){
/* Block Modified() signal being emitted by KVDBRun object
when we set its 'datime'. This is to avoid seg fault with
KVDataAnalysisGUI, when we are changing system/display,
and the KVLVEntry to which this signal was previously connected
no longer exists */
a_run->BlockSignals(kTRUE);
a_run->SetDatime(fDatime);
a_run->SetKVVersion(kvversion);
a_run->SetUserName(username);
a_run->BlockSignals(kFALSE);
//}
sys_list->Add(a_run);
}
}
}
}
delete toks;
fLine.ReadLine(fRunlist);
}
//sort list of systems in order of increasing run number
//sort list of runs in order of increasing run number
if (sys_list && sys_list->GetSize()>1)
sys_list->Sort();
if(!good_lines){
Error("GetListOfAvailableSystems",
"Available runs file is empty or absent");
}
CloseAvailableRunsFile();
return sys_list;
}
TCanvas *ContourList(){
const Double_t PI = TMath::Pi();
TCanvas* c = new TCanvas("c","Contour List",0,0,600,600);
c->SetRightMargin(0.15);
c->SetTopMargin(0.15);
Int_t i, j, TotalConts;
Int_t nZsamples = 80;
Int_t nPhiSamples = 80;
Double_t HofZwavelength = 4.0; // 4 meters
Double_t dZ = HofZwavelength/(Double_t)(nZsamples - 1);
Double_t dPhi = 2*PI/(Double_t)(nPhiSamples - 1);
TArrayD z(nZsamples);
TArrayD HofZ(nZsamples);
TArrayD phi(nPhiSamples);
TArrayD FofPhi(nPhiSamples);
// Discretized Z and Phi Values
for ( i = 0; i < nZsamples; i++) {
z[i] = (i)*dZ - HofZwavelength/2.0;
HofZ[i] = SawTooth(z[i], HofZwavelength);
}
for(Int_t i=0; i < nPhiSamples; i++){
phi[i] = (i)*dPhi;
FofPhi[i] = sin(phi[i]);
}
// Create Histogram
TH2D *HistStreamFn = new TH2D("HstreamFn",
"#splitline{Histogram with negative and positive contents. Six contours are defined.}{It is plotted with options CONT LIST to retrieve the contours points in TGraphs}",
nZsamples, z[0], z[nZsamples-1], nPhiSamples, phi[0], phi[nPhiSamples-1]);
// Load Histogram Data
for (Int_t i = 0; i < nZsamples; i++) {
for(Int_t j = 0; j < nPhiSamples; j++){
HistStreamFn->SetBinContent(i,j, HofZ[i]*FofPhi[j]);
}
}
gStyle->SetPalette(1);
gStyle->SetOptStat(0);
gStyle->SetTitleW(0.99);
gStyle->SetTitleH(0.08);
Double_t contours[6];
contours[0] = -0.7;
contours[1] = -0.5;
contours[2] = -0.1;
contours[3] = 0.1;
contours[4] = 0.4;
contours[5] = 0.8;
HistStreamFn->SetContour(6, contours);
// Draw contours as filled regions, and Save points
HistStreamFn->Draw("CONT Z LIST");
c->Update(); // Needed to force the plotting and retrieve the contours in TGraphs
// 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;
TCanvas* c1 = new TCanvas("c1","Contour List",610,0,600,600);
c1->SetTopMargin(0.15);
TH2F *hr = new TH2F("hr",
"#splitline{Negative contours are returned first (highest to lowest). Positive contours are returned from}{lowest to highest. On this plot Negative contours are drawn in red and positive contours in blue.}",
2, -2, 2, 2, 0, 6.5);
hr->Draw();
Double_t x0, y0, z0;
TLatex l;
l.SetTextSize(0.03);
char val[20];
for(i = 0; i < TotalConts; i++){
contLevel = (TList*)conts->At(i);
if (i<3) z0 = contours[2-i];
else z0 = contours[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++){
curv->GetPoint(0, 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");
sprintf(val,"%g",z0);
l.DrawLatex(x0,y0,val);
curv = (TGraph*)contLevel->After(curv); // Get Next graph
}
}
c1->Update();
printf("\n\n\tExtracted %d Contours and %d Graphs \n", TotalConts, nGraphs );
gStyle->SetTitleW(0.);
gStyle->SetTitleH(0.);
return c1;
}
