TGraph *MarcosExclusionLine(TH2F *exclusionshape, int scantype) {
// write_warning(__FUNCTION__,"USING MARIAS ALGORITHM...");
// return get_exclusion_line(exclusionshape);
TH2F *fakehisto = flipth2f(exclusionshape);
TGraph *fakegraph = get_mSUGRA_exclusion_line(fakehisto, scantype);
TGraph *realgraph = new TGraph(fakegraph->GetN());
double x,y;
float last_x=0;
float last_y=0;
int counter=0;
for(int i=0;i<fakegraph->GetN();i++) {
fakegraph->GetPoint(i,x,y);
if(scantype==PlottingSetup::SMS) {
if(y-x<75) {
realgraph->SetPoint(counter,last_x,last_y);
counter++;
continue;
}
}
realgraph->SetPoint(counter,y,x);
last_x=y;
last_y=x;
counter++;
}
realgraph->SetLineColor(TColor::GetColor("#151515")); //nice black
realgraph->SetLineWidth(2);
//realgraph->SetLineWidth(4);//paper style
delete fakegraph;
return realgraph;
}
void
plotSignificance(const char* filename, const char* channel, double min_=0., double max_=7., bool log_=false, std::string dataset_="CMS Preliminary, H#rightarrow#tau#tau, 4.9 fb^{-1} at 7 TeV, 19.4 fb^{-1} at 8 TeV", std::string xaxis_="m_{H} [GeV]", std::string yaxis_="Significance", bool mssm_=false)
{
TFile* file = TFile::Open(filename);
// retrieve TGraphs from file
TGraph* expected = (TGraph*)file->Get(std::string(channel).append("/expected").c_str());
TGraph* observed = (TGraph*)file->Get(std::string(channel).append("/observed").c_str());
TGraphAsymmErrors* innerBand = (TGraphAsymmErrors*)file->Get(std::string(channel).append("/innerBand").c_str());
TGraphAsymmErrors* outerBand = (TGraphAsymmErrors*)file->Get(std::string(channel).append("/outerBand").c_str());
// set up styles
SetStyle();
// create the unit lines
TGraph* unit3 = new TGraph();
TGraph* unit5 = new TGraph();
for(int imass=0, ipoint=0; imass<expected->GetN(); ++imass){
unit3->SetPoint(ipoint, expected->GetX()[imass], 3.);
unit5->SetPoint(ipoint, expected->GetX()[imass], 5.);
++ipoint;
}
// set proper maximum
float max = maximum(expected, max_);
// do the plotting
TCanvas canv = TCanvas("canv", "Limits", 600, 600);
// do the plotting
plottingSignificance(canv, innerBand, outerBand, expected, observed, unit3, unit5, xaxis_, yaxis_, min_, max, log_, mssm_);
/// setup the CMS Preliminary
CMSPrelim(dataset_.c_str(), "", 0.145, 0.835);
// write results to files
canv.Print(std::string(channel).append("_significance").append(".png").c_str());
canv.Print(std::string(channel).append("_significance").append(".pdf").c_str());
canv.Print(std::string(channel).append("_significance").append(".eps").c_str());
return;
}
void ButkevichDrawer::adjust_graph(TGraph& graph) {
for (int iPoint=0;iPoint<graph.GetN();iPoint++) {
double x,y;
graph.GetPoint(iPoint,x,y);
graph.SetPoint(iPoint,x,y*1.0e-38);
}
}
void getStartFinFrom(const TGraph& gr,
Double_t& start, Double_t& fin,
const Bool_t filterZero=kTRUE) {
// get a nice time axis for the domain of the graph
start = fin = 0;
const Int_t n = gr.GetN();
Bool_t first = kTRUE;
const Double_t* y = gr.GetX();
for (Int_t i=0; i<n; ++i, ++y) {
if (filterZero && ((*y)==0)) {
continue;
} else {
if (first) {
start = fin = *y;
first = kFALSE;
} else {
if ( (*y) < start ) {
start = *y;
}
if ( (*y) > fin ) {
fin = *y;
}
}
}
}
}
void
plotMaxLikelihood(const char* filename, const char* channel, double min_=0., double max_=-1., bool log_=false, std::string dataset_="CMS Preliminary, H#rightarrow#tau#tau, 4.9 fb^{-1} at 7 TeV, 19.4 fb^{-1} at 8 TeV", std::string xaxis_="m_{H} [GeV]", std::string yaxis_="best fit for #sigma/#sigma_{SM}", bool mssm_=false)
{
TFile* file = TFile::Open(filename);
// retrieve TGraphs from file
TGraph* expected = (TGraph*)file->Get(std::string(channel).append("/expected").c_str());
TGraphAsymmErrors* innerBand = (TGraphAsymmErrors*)file->Get(std::string(channel).append("/innerBand").c_str());
// set up styles
SetStyle();
// create the unit line
TGraph* unit = 0;
if(!mssm_){
unit = new TGraph();
for(int imass=0, ipoint=0; imass<expected->GetN(); ++imass){
unit->SetPoint(ipoint, expected->GetX()[imass], 1.); ++ipoint;
}
}
// set proper maximum
float max = maximum(expected, max_);
// do the plotting
TCanvas canv = TCanvas("canv", "Limits", 600, 600);
plottingLimit(canv, innerBand, 0, expected, 0, unit, xaxis_, yaxis_, min_, max, log_, "BESTFIT", "", mssm_);
// setup CMS Preliminary
CMSPrelim(dataset_.c_str(), "", 0.145, 0.835);
// write results to files
canv.Print(std::string(channel).append("_").append("bestfit").append(".png").c_str());
canv.Print(std::string(channel).append("_").append("bestfit").append(".pdf").c_str());
canv.Print(std::string(channel).append("_").append("bestfit").append(".eps").c_str());
return;
}
TGraph* autogain152(TH1 *hist) {
hist->GetXaxis()->SetRangeUser(200.,16000.);
TSpectrum *s = new TSpectrum();
Int_t nfound = s->Search(hist,6,"",0.08); //This will be dependent on the source used.
printf("Found %d candidate peaks to fit\n",nfound);
if(nfound > 6)
nfound = 6;
std::vector<float> vec;
for(int x=0;x<nfound;x++)
vec.push_back(s->GetPositionX()[x]);
std::sort(vec.begin(),vec.end());
Float_t energies[] = {121.7830, 244.6920, 344.276, 778.903, 964.131, 1408.011};
TGraph* slopefit = new TGraph(nfound, &(vec[0]), energies);
printf("Now fitting: Be patient\n");
slopefit->Fit("pol1");
if(slopefit->GetFunction("pol1")->GetChisquare() > 10.) {
slopefit->RemovePoint(slopefit->GetN()-1);
slopefit->Fit("pol1");
}
TChannel *chan = 0;
slopefit->Draw("AC*");
return slopefit;
}
void readValues(){
TFile *f = new TFile("L1L2Eff_final.root");
// TDirectory *d = (TDirectory*)f->Get("tpTree/BMuQualSoft_pt_eta_Mu5_Track2/fit_eff_plots");
// if(!d) std::cout << "directory not available" << std::endl;
int N = 0;
//string name;
//name.Format("gEff_DATA_PT_AETA%i",N);
TGraph *g = (TGraph*)f->Get("gEff_DATA_PT_AETA0");
if(!g)std::cout << "TGraph is sunbathing." << std::endl;
int n = g->GetN();
std::cout << n << " points in graph" << std::endl;
const char title = g->GetTitle();
//const char savename = "Effplots/"+title+".C";
//std::cout<<savename<<std::endl;
g->SaveAs("grph");
// put loop over points here
// for(int i = 0; i < n; i++){
// check which bin the pt is in
// } //iPT
f->Close();
}
void Calculation(){
gStyle->SetOptStat("neRMI");
Int_t CalibrationNumber = 0;
TFile* tf = new TFile(Form("CalibrationData/Calibration_4231_%d.root",CalibrationNumber));
const int nCSI = 2716;
TH1D* hisCalFactor[nCSI];
int nCal[nCSI];
double CalFactor[nCSI];
double CalRMS[nCSI];
TH1D* hisCalDistrib = new TH1D("hisCalDistrib","",200,0,2);
TH1D* hisRMSDistrib = new TH1D("hisRMSDistrib","",100,0,0.1);
TH1D* hisHitDistrib = new TH1D("hisHitDistrib","",100,0,100);
TGraph* grChannel = new TGraph();
std::ofstream ofs(Form("Data/CalibrationFactor%d.txt",CalibrationNumber+1));
for( int i = 0; i< nCSI; i++){
hisCalFactor[i] = (TH1D*)tf->Get(Form("his_Calibration_%04d",i));
nCal[i] = hisCalFactor[i]->Integral();
if( hisCalFactor[i]->Integral() < 20 ){
continue;
}
hisCalFactor[i]->Fit("gaus","Q","");
TF1* calFunction= hisCalFactor[i]->GetFunction("gaus");
CalFactor[i] = hisCalFactor[i]->GetMean();
CalRMS[i] = hisCalFactor[i]->GetRMS();
//CalFactor[i] = calFunction->GetParameter(1);
//CalRMS[i] = calFunction->GetParameter(2);
hisCalDistrib->Fill(CalFactor[i]);
hisHitDistrib->Fill(nCal[i]);
grChannel->SetPoint(grChannel->GetN(),i,nCal[i]);
if( nCal[i] != 0){
hisRMSDistrib->Fill(CalRMS[i]/CalFactor[i]);
}
ofs << i << "\t" << CalFactor[i] << std::endl;
}
ofs.close();
TCanvas* can = new TCanvas("can","",1200,1200);
can->Divide(2,2);
can->cd(1);
hisCalDistrib->Draw();
can->cd(2);
hisRMSDistrib->Draw();
can->cd(3);
hisHitDistrib->Draw();
can->cd(4);
grChannel->SetMarkerStyle(4);
grChannel->Draw("AP");
}
void KVIDentifier::CopyGraph(const TGraph& graph)
{
// Copy coordinates of points from the TGraph
Double_t x, y;
//change number of points
Set(graph.GetN());
for (int i = 0; i < GetN(); i++) {
graph.GetPoint(i, x, y);
SetPoint(i, x, y);
}
}
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;
}
TGraph *PeakFit::GetComponentVsAngle(unsigned int state, double scale, const Float_t barAngles[][2]) {
std::vector< int > barMap = GetBarMap(barAngles);
TGraph *gr = new TGraph();
for (unsigned int barIndex = 0; barIndex < GetNumBars(); barIndex++) {
int bar = barMap[barIndex];
gr->SetPoint(gr->GetN(), barAngles[bar][0], components_[bar][state] * scale);
}
gr->SetLineColor(kRed);
gr->SetLineWidth(2);
return gr;
}
void
plotTanb(const char* filename, const char* channel, bool draw_injected_=false, double min_=0., double max_=60., bool log_=false, std::string dataset_="CMS Preliminary, H#rightarrow#tau#tau, 4.9 fb^{-1} at 7 TeV, 19.8 fb^{-1} at 8 TeV", std::string xaxis_="m_{A} [GeV]", std::string yaxis_="#bf{tan#beta}")
{
TFile* file = TFile::Open(filename);
// retrieve TGraphs from file
TGraph* expected = (TGraph*)file->Get(std::string(channel).append("/expected").c_str());
TGraph* expected_low = (TGraph*)file->Get(std::string(channel).append("/expected_low").c_str());
TGraph* observed = (TGraph*)file->Get(std::string(channel).append("/observed").c_str());
TGraph* observed_low = (TGraph*)file->Get(std::string(channel).append("/observed_low").c_str());
TGraph* upperLEP = (TGraph*)file->Get(std::string(channel).append("/upperLEP").c_str());
TGraph* lowerLEP = (TGraph*)file->Get(std::string(channel).append("/lowerLEP").c_str());
TGraphAsymmErrors* innerBand = (TGraphAsymmErrors*)file->Get(std::string(channel).append("/innerBand").c_str());
TGraphAsymmErrors* innerBand_low = (TGraphAsymmErrors*)file->Get(std::string(channel).append("/innerBand_low").c_str());
TGraphAsymmErrors* outerBand = (TGraphAsymmErrors*)file->Get(std::string(channel).append("/outerBand").c_str());
TGraphAsymmErrors* outerBand_low = (TGraphAsymmErrors*)file->Get(std::string(channel).append("/outerBand_low").c_str());
TGraphAsymmErrors* plain = (TGraphAsymmErrors*)file->Get(std::string(channel).append("/plain").c_str());
TGraphAsymmErrors* plain_low = (TGraphAsymmErrors*)file->Get(std::string(channel).append("/plain_low").c_str());
// this is new for injected plot
TGraph* injected = 0;;
if(draw_injected_) {injected = (TGraph*)file->Get("injected/observed");}
if(draw_injected_){
for( int i=0; i<expected->GetN(); i++){
double shift = injected->GetY()[i]-expected->GetY()[i];
innerBand->SetPoint(i, innerBand->GetX()[i], innerBand->GetY()[i]+shift);
outerBand->SetPoint(i, outerBand->GetX()[i], outerBand->GetY()[i]+shift);
}
}
// this functionality is not yet supported
std::map<double, TGraphAsymmErrors*> higgsBands;
// this functionality is not yet supported
std::map<std::string, TGraph*> comparisons;
// set up styles
SetStyle();
// do the plotting
TCanvas canv = TCanvas("canv", "Limits", 600, 600);
// do the plotting
plottingTanb(canv, plain, plain_low, innerBand, innerBand_low, outerBand, outerBand_low, expected, expected_low, observed, observed_low, lowerLEP, upperLEP, higgsBands, comparisons, xaxis_, yaxis_, injected, min_, max_, log_);
/// setup the CMS Preliminary
CMSPrelim(dataset_.c_str(), "", 0.145, 0.835);
// write results to files
canv.Print(std::string(channel).append("_tanb").append(".png").c_str());
canv.Print(std::string(channel).append("_tanb").append(".pdf").c_str());
canv.Print(std::string(channel).append("_tanb").append(".eps").c_str());
return;
}
void BoundaryFinder::StoreDataFromGraph(const TGraph &gr)
{
Double_t *x = gr.GetX();
Double_t *y = gr.GetY();
ComputeCenter(gr);
Double_t xr=0, yr=0;
for (UInt_t i=0; i<gr.GetN(); i++)
{
xr = x[i]-fCenter.first;
yr = y[i]-fCenter.second;
point_t p = {::sqrt(xr*xr + yr*yr), i};
fSortedVals.insert(std::make_pair(::atan2(yr,xr),p));
}
}
void BoundaryFinder::ComputeCenter(const TGraph& gr)
{
Double_t *x = gr.GetX();
Double_t *y = gr.GetY();
UInt_t n = gr.GetN();
Double_t sum_x = 0;
Double_t sum_y = 0;
for (UInt_t i=0; i<n; i++)
{
sum_x += x[i];
sum_y += y[i];
}
fCenter.first = sum_x/n;
fCenter.second = sum_y/n;
}
void drawtext()
{
Int_t i,n;
Double_t x,y;
TLatex *l;
TGraph *g = (TGraph*)gPad->GetListOfPrimitives()->FindObject("Graph");
n = g->GetN();
for (i=1; i<n; i++) {
g->GetPoint(i,x,y);
l = new TLatex(x,y+0.2,Form("%4.2f",y));
l->SetTextSize(0.025);
l->SetTextFont(42);
l->SetTextAlign(21);
l->Paint();
}
}
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;
}
TGraph *PeakFit::GetFitVsAngle(double *scales, const Float_t barAngles[][2]) {
std::vector< int > barMap = GetBarMap(barAngles);
TGraph *gr = new TGraph();
for (unsigned int barIndex = 0; barIndex < GetNumBars(); barIndex++) {
int bar = barMap[barIndex];
double value = 0;
for (unsigned int state = 0; state < GetNumStates(bar); state++) {
value += components_[bar][state] * scales[state];
}
std::cout << "Bar Index: " << barIndex << " Bar " << bar << " value " << value << "\n";
gr->SetPoint(gr->GetN(), barAngles[bar][0], value);
}
gr->SetLineColor(kBlue);
gr->SetLineWidth(2);
return gr;
}
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;
}
std::vector<double> GetCrossings(TGraph const& g, double cross) {
std::vector<double> result;
unsigned n = g.GetN();
double x1 = 0;
double y1 = 0;
double x2 = 0;
double y2 = 0;
for (unsigned i = 0; i < (n-1); ++i) {
g.GetPoint(i, x1, y1);
g.GetPoint(i+1, x2, y2);
if ( (y2-cross)*(y1-cross) < 0.0 ) {
double m = (y2-y1)/(x2-x1);
double c = (y1 - m * x1);
double xc = (cross - c) / m;
result.push_back(xc);
std::cout << "Crossing at " << xc << std::endl;
}
}
return result;
}
//______________________________________________________________________________
void Draw(TFile* f, const char* gname, TLegend* l, Bool_t normalized)
{
if (!f) return;
TGraph* g = static_cast<TGraph*>(f->Get(gname));
if (!g) return;
if ( normalized )
{
g = static_cast<TGraph*>(g->Clone());
for ( Int_t i = 0; i < g->GetN(); ++i )
{
Double_t y = g->GetY()[i];
g->SetPoint(i,g->GetX()[i],y/NTOTALNUMBEROFPADS);
}
}
g->Draw("lp");
g->GetXaxis()->SetNdivisions(505);
g->GetXaxis()->SetNoExponent();
if (l) l->AddEntry(g,gname,"LP");
}
void drawCMSresponse() {
// New style settings
// #include "tdrstyle_mod14.C"
setTDRStyle();
// call cmsPrel(iPeriod, iPos);
// int iPeriod = 2; // 1=7TeV, 2=8TeV, 3=7+8TeV, 7=7+8+13TeV
// second parameter in example_plot is iPos, which drives the position of the CMS logo in the plot
// iPos=11 : top-left, left-aligned
// iPos=33 : top-right, right-aligned
// iPos=22 : center, centered
// mode generally :
// iPos = 10*(alignement 1/2/3) + position (1/2/3 = left/center/right)
if (!_jec) {
const char *sd = "CondFormats/JetMETObjects/data";
//const char *st = "Winter14_V5_MC";
//const char *st = "Winter14_V8_MC"; // 2012
//const char *st = "Winter14_V8_DATA";
//const char *st = "Summer15_25nsV3_DATA";
//const char *st = "Summer15_25nsV6_DATA";
//const char *st = "Summer15_25nsV7_DATA";
//const char *st = "Fall15_25nsV1_DATA";
//const char *st = "Spring16_25nsV3_MC";
//const char *st = "Summer16_23Sep2016GV3_DATA"; // 2017
//const char *st = "Summer16_03Feb2017G_V3_DATA"; // 2017 03FebV3
const char *st = "Summer16_03Feb2017BCD_V7_DATA"; // 2017 03FebV7
const char *s;
//s = Form("%s/%s_L1FastJet_AK5PFchs.txt",sd,st); cout << s << endl;
//JetCorrectorParameters *l1 = new JetCorrectorParameters(s);
s = Form("%s/%s_L1FastJet_AK4PFchs.txt",sd,st); cout << s << endl;
JetCorrectorParameters *l1 = new JetCorrectorParameters(s);
//s = Form("%s/%s_L2Relative_AK5PFchs.txt",sd,st); cout << s << endl;
s = Form("%s/%s_L2Relative_AK4PFchs.txt",sd,st); cout << s << endl;
JetCorrectorParameters *l2 = new JetCorrectorParameters(s);
//s = Form("%s/%s_L3Absolute_AK5PFchs.txt",sd,st); cout << s << endl;
s = Form("%s/%s_L3Absolute_AK4PFchs.txt",sd,st); cout << s << endl;
JetCorrectorParameters *l3 = new JetCorrectorParameters(s);
s = Form("%s/%s_L2L3Residual_AK4PFchs.txt",sd,st); cout << s << endl;
JetCorrectorParameters *l2l3 = new JetCorrectorParameters(s);
vector<JetCorrectorParameters> v;
v.push_back(l1);
v.push_back(*l2);
v.push_back(*l3);
v.push_back(*l2l3);
_jec = new FactorizedJetCorrector(v);
}
if (!_jecpt) {
_jecpt = new TF1("jecpt",fJECPt,0,6500,3);
}
//double ergs[] = {30, 60, 110, 400, 2000};
//const int ne = sizeof(ergs)/sizeof(ergs[0]);
double pts[] = {10, 30, 100, 400, 2000};
const int npt = sizeof(pts)/sizeof(pts[0]);
const int neta = 48;//52;
const int jeta = TMath::Pi()*0.4*0.4;
const int mu = 0;
TGraph *gs[npt];
//for (int ie = 0; ie != ne; ++ie) {
for (int ipt = 0; ipt != npt; ++ipt) {
//double energy = ergs[ie];
double pt = pts[ipt];
TGraph *g = new TGraph(0); gs[ipt] = g;
for (int ieta = 0; ieta != neta; ++ieta) {
double eta = (ieta+0.5)*0.1;
//double pt = energy / cosh(eta);
double energy = pt * cosh(eta);
if (pt >= 10. && energy < 6500.) { // 13 TeV
double jes = getResp(pt, eta, jeta, mu);
int n = g->GetN();
g->SetPoint(n, eta, jes);
}
} // for ie
} // for ieta
// Draw results
//TH1D *h = new TH1D("h",";Jet |#eta|;Simulated jet response",40,0,4.8);
//TH1D *h = new TH1D("h",";Jet |#eta|;Data jet response",40,0,4.8);
TH1D *h = new TH1D("h",";Jet |#eta|;Data response+offset",40,0,4.8);
h->SetMaximum(1.25);
h->SetMinimum(0.5);
extraText = "Simulation";
//extraText = "Simulation Preliminary";
//extraText = "Preliminary";
lumi_8TeV = "";
lumi_13TeV = "";
//lumi_13TeV = "2.1 fb^{-1}";
//TCanvas *c1 = tdrCanvas("c1",h,2,0,kSquare);
TCanvas *c1 = tdrCanvas("c1",h,4,0,kSquare);
TLegend *leg1 = tdrLeg(0.25,0.25,0.55,0.30);
TLegend *leg2 = tdrLeg(0.25,0.20,0.55,0.25);
TLegend *leg3 = tdrLeg(0.25,0.15,0.55,0.20);
TLegend *leg4 = tdrLeg(0.55,0.25,0.85,0.30);
TLegend *leg5 = tdrLeg(0.55,0.20,0.85,0.25);
TLegend *legs[npt] = {leg1, leg2, leg3, leg4, leg5};
int colors[] = {kGreen+2, kBlack, kOrange+1, kBlue, kRed+1};
int markers[] = {kFullCircle, kOpenCircle, kFullSquare, kOpenSquare,
kFullTriangleUp};
for (int ipt = 0; ipt != npt; ++ipt) {
TGraph *g = gs[ipt];
g->SetMarkerColor(colors[ipt]);
g->SetMarkerStyle(markers[ipt]);
g->Draw("SAMEP");
//TLegend *leg = (ie<3 ? leg1 : leg2);
TLegend *leg = legs[ipt];
leg->SetTextColor(colors[ipt]);
//leg->AddEntry(g, Form("E = %1.0f GeV",ergs[ie]), "P");
leg->AddEntry(g, Form("p_{T} = %1.0f GeV",pts[ipt]), "P");
}
TLatex *tex = new TLatex();
tex->SetNDC();
tex->SetTextSize(0.045);
TLine *l = new TLine();
l->DrawLine(1.3,0.7,1.3,1.1);
l->DrawLine(2.5,0.7,2.5,1.1);
l->DrawLine(3.0,0.7,3.0,1.1);
l->DrawLine(4.5,0.7,4.5,1.1);
l->SetLineStyle(kDashed);
l->DrawLine(3.2,0.7,3.2,1.1);
//tex->DrawLatex(0.23,0.86,"2012 JES: Anti-k_{t} R = 0.5, PF+CHS");
//tex->DrawLatex(0.30,0.86,"53X JES: Anti-k_{t} R = 0.5, PF+CHS");
//tex->DrawLatex(0.30,0.86,"74X JES: Anti-k_{t} R = 0.4, PF+CHS");
//tex->DrawLatex(0.30,0.86,"76X JES: Anti-k_{t} R = 0.4, PF+CHS");
//tex->DrawLatex(0.23,0.86,"2016 JES: Anti-k_{T} R=0.4, PF+CHS");
tex->DrawLatex(0.23,0.86,"2017 JES: Anti-k_{t} R = 0.4, PF+CHS");
//tex->DrawLatex(0.23,0.86,"2017 03FebV3: Anti-k_{t} R = 0.4, PF+CHS");
tex->DrawLatex(0.19,0.78,"Barrel");
tex->DrawLatex(0.47,0.78,"Endcap"); //0.42
tex->DrawLatex(0.73,0.78,"Forward");
tex->DrawLatex(0.21,0.73,"BB");
tex->DrawLatex(0.43,0.73,"EC1");
tex->DrawLatex(0.57,0.73,"EC2");
tex->DrawLatex(0.77,0.73,"HF");
c1->SaveAs("pdf/drawCMSresponse.pdf");
} // drawCMSresponse
void integrated_lumi(Bool_t goodOnly=0){
nGoodRuns+= nGoodRuns15f;
nGoodRuns+= nGoodRuns15h;
nGoodRuns+= nGoodRuns15i;
nGoodRuns+= nGoodRuns15j;
nGoodRuns+= nGoodRuns15l;
Int_t j=0;
for (Int_t i=0;i<nGoodRuns15f;i++) goodRuns[j++]=goodRuns15f[i];
for (Int_t i=0;i<nGoodRuns15h;i++) goodRuns[j++]=goodRuns15h[i];
// for (Int_t i=0;i<nGoodRuns15i_badIR;i++) goodRuns[j++]=goodRuns15i_badIR[i];
// for (Int_t i=0;i<nGoodRuns15i_badSPD;i++) goodRuns[j++]=goodRuns15i_badSPD[i];
for (Int_t i=0;i<nGoodRuns15i;i++) goodRuns[j++]=goodRuns15i[i];
for (Int_t i=0;i<nGoodRuns15j;i++) goodRuns[j++]=goodRuns15j[i];
for (Int_t i=0;i<nGoodRuns15l;i++) goodRuns[j++]=goodRuns15l[i];
gStyle->SetPadTopMargin(0.01);
gStyle->SetPadRightMargin(0.01);
gStyle->SetPadBottomMargin(0.06);
gStyle->SetPadLeftMargin(0.13);
TGaxis::SetMaxDigits(3);
gStyle->SetOptTitle(1);
gStyle->SetTitleOffset(1.6,"Y");
gStyle->SetOptStat(0);
TLatex* latex = new TLatex();
latex->SetTextSize(0.05);
latex->SetTextFont(42);
latex->SetTextAlign(11);
latex->SetNDC();
t = new TChain("trending");
t->AddFile("trending.root");
classes = new TObjArray();
partition = new TObjString();
lhcState = new TObjString();
lhcPeriod = new TObjString();
activeDetectors = new TObjString();
t->SetBranchAddress("run",&run);
t->SetBranchAddress("fill",&fill);
t->SetBranchAddress("classes",&classes);
t->SetBranchAddress("class_l2a",&class_l2a);
t->SetBranchAddress("class_lumi",&class_lumi);
t->SetBranchAddress("timeStart",&timeStart);
t->SetBranchAddress("timeEnd",&timeEnd);
t->SetBranchAddress("partition",&partition);
t->SetBranchAddress("lhcState",&lhcState);
t->SetBranchAddress("lhcPeriod",&lhcPeriod);
t->SetBranchAddress("activeDetectors",&activeDetectors);
TGraph* gINT = GetStat("CINT7-B-NOPF-CENT",1,goodOnly);
TGraph* gMUL = GetStat("CMUL7-B-NOPF-MUFAST",1,goodOnly);
TGraph* gV0M = GetStat("CVHMV0M-B-NOPF-CENTNOTRD",1,goodOnly);
TGraph* gSH2 = GetStat("CVHMSH2-B-NOPF-CENTNOTRD",1,goodOnly);
TGraph* gStatINT = GetStat("CINT7-B-NOPF-CENT",0,goodOnly);
TGraph* gStatV0M = GetStat("CVHMV0M-B-NOPF-CENTNOTRD",0,goodOnly);
TGraph* gStatSH2 = GetStat("CVHMSH2-B-NOPF-CENTNOTRD",0,goodOnly);
TGraph* gStatEMC = GetStat("CEMC7-B-NOPF-CENTNOTRD",0,goodOnly,"PHYSICS_2");
TGraph* gStatDMC = GetStat("CDMC7-B-NOPF-CENTNOTRD",0,goodOnly,"PHYSICS_2");
gMUL->SetLineColor(kBlack);
gINT->SetLineColor(kBlue);
gV0M->SetLineColor(kMagenta);
gSH2->SetLineColor(kRed);
gStatV0M->SetLineColor(kMagenta);
gStatSH2->SetLineColor(kRed);
gStatEMC->SetLineColor(kGray);
gStatDMC->SetLineColor(kGreen-2);
TCanvas* c1 = new TCanvas("c1","",800,700);
Double_t xminLumi = gMUL->GetXaxis()->GetXmin();
Double_t xmaxLumi = gMUL->GetXaxis()->GetXmax();
Double_t ymaxLumi = gMUL->GetYaxis()->GetXmax()*1.1;
TH1F* f1 = gPad->DrawFrame(xminLumi,0,xmaxLumi,ymaxLumi);
SetFrame(f1);
f1->GetYaxis()->SetTitle("Integrated luminosity, pb^{-1}");
f1->GetXaxis()->SetTimeDisplay(1);
f1->GetXaxis()->SetTimeFormat("%d %b");
Double_t y = 0.94;
latex->DrawLatex(0.18,0.94,"ALICE Performance, pp #sqrt{s} = 13 TeV");
latex->SetTextColor(gINT->GetLineColor());
latex->DrawLatex(0.18,y-=0.07,Form("MB triggers: L = %.3f pb^{-1}",gINT->GetY()[gINT->GetN()-1]));
latex->SetTextColor(gV0M->GetLineColor());
latex->DrawLatex(0.18,y-=0.07,Form("V0 HM triggers: L = %.3f pb^{-1}",gV0M->GetY()[gV0M->GetN()-1]));
latex->SetTextColor(gSH2->GetLineColor());
latex->DrawLatex(0.18,y-=0.07,Form("SPD HM triggers: L = %.3f pb^{-1}",gSH2->GetY()[gSH2->GetN()-1]));
latex->SetTextColor(gMUL->GetLineColor());
latex->DrawLatex(0.18,y-=0.07,Form("Dimuon triggers: L = %.3f pb^{-1}",gMUL->GetY()[gMUL->GetN()-1]));
gMUL->Draw();
gINT->Draw();
gV0M->Draw();
gSH2->Draw();
gPad->Print("lumi_dimuon_triggers.png");
TCanvas* c2 = new TCanvas("c2","",800,700);
Double_t xminEvents = gStatINT->GetXaxis()->GetXmin();
Double_t xmaxEvents = gStatINT->GetXaxis()->GetXmax();
Double_t ymaxEvents = gStatINT->GetYaxis()->GetXmax()*1.1;
TH1F* f2 = gPad->DrawFrame(xminEvents,0,xmaxEvents,ymaxEvents);
SetFrame(f2);
f2->GetYaxis()->SetTitle("Recorded triggers, 10^{6}");
f2->GetXaxis()->SetTimeDisplay(1);
f2->GetXaxis()->SetTimeFormat("%d %b");
gStatINT->Draw();
gStatV0M->Draw();
gStatSH2->Draw();
// gStatDMC->Draw();
// gStatEMC->Draw();
latex->SetTextColor(1);
latex->DrawLatex(0.18,0.94,"ALICE Performance, pp #sqrt{s} = 13 TeV");
y = 0.94;
latex->SetTextColor(gStatINT->GetLineColor());
latex->DrawLatex(0.18,y-=0.07,Form("MB triggers: %.0fM",gStatINT->GetY()[gStatINT->GetN()-1]));
latex->SetTextColor(gStatV0M->GetLineColor());
latex->DrawLatex(0.18,y-=0.07,Form("V0 HM triggers: %.0fM",gStatV0M->GetY()[gStatV0M->GetN()-1]));
latex->SetTextColor(gStatSH2->GetLineColor());
latex->DrawLatex(0.18,y-=0.07,Form("SPD HM triggers: %.0fM",gStatSH2->GetY()[gStatSH2->GetN()-1]));
// latex->SetTextColor(gStatEMC->GetLineColor());
// latex->DrawLatex(0.18,y-=0.07,Form("EMCAL triggers: %.0fM",gStatEMC->GetY()[gStatDMC->GetN()-1]));
// latex->SetTextColor(gStatDMC->GetLineColor());
// latex->DrawLatex(0.18,y-=0.07,Form("DCAL triggers: %.0fM",gStatDMC->GetY()[gStatDMC->GetN()-1]));
gPad->Print("stat_mb_triggers.png");
}
int main(int argc, char** argv)
{
setTDRStyle();
gStyle -> SetOptFit(0000);
int nFib = 64;
int nCryst = 9;
std::string inFileName(argv[1]);
//----------
// open file
TFile* inFile = TFile::Open(Form("ntuples/tot_capture_%s.root",inFileName.c_str()));
TTree* tree = (TTree*)( inFile->Get("tree") );
//---------------------
// set branch addresses
std::map<int,std::vector<int>*> t_waveform;
std::map<int,std::vector<int>*> t_crystWaveform;
for(int fibIt = 0; fibIt < nFib; ++fibIt)
{
t_waveform[fibIt] = new std::vector<int>;
tree -> SetBranchAddress(Form("fib%02d_waveform",fibIt),&t_waveform[fibIt]);
}
for(int crystIt = 0; crystIt < nCryst; ++crystIt)
{
t_crystWaveform[crystIt] = new std::vector<int>;
tree -> SetBranchAddress(Form("cryst%01d_waveform",crystIt),&t_crystWaveform[crystIt]);
}
//-------------
// define plots
std::map<int,int> n_waveform_fib;
TGraph** g_waveform_fib = new TGraph*[nFib];
std::map<int,int> n_waveform_cut_fib;
TGraph** g_waveform_cut_fib = new TGraph*[nFib];
TH1F** h_ped_fib = new TH1F*[nFib];
TH1F* h_ped_fib_all = new TH1F("h_ped_fib_all","",100,80.,120.);
TH1F** h_maximum_fib = new TH1F*[nFib];
TH1F* h_maximum_fib_all = new TH1F("h_maximum_fib_all","",1000,0.,2500.);
for(int fibIt = 0; fibIt < nFib; ++fibIt)
{
g_waveform_fib[fibIt] = new TGraph();
g_waveform_cut_fib[fibIt] = new TGraph();
h_ped_fib[fibIt] = new TH1F(Form("h_ped_fib%02d",fibIt),"",100,80.,120.);
h_maximum_fib[fibIt] = new TH1F(Form("h_maximum_fib%02d",fibIt),"",1000,0.,2500.);
}
TProfile2D* p_fibAveInt = new TProfile2D("p_fibAveInt","",17,-0.5,16.5,18,-0.5,17.5);
TProfile2D* p_fibAveMax = new TProfile2D("p_fibAveMax","",17,-0.5,16.5,18,-0.5,17.5);
TProfile2D* p_crystAveMax = new TProfile2D("p_crystAveMax","",3,-0.5,2.5,3,-0.5,2.5);
TH1F* h_tot_integral = new TH1F("h_tot_integral","",1000,0.,100000.);
TH1F* h_tot_maximum = new TH1F("h_tot_maximum", "",1000,0.,1000.);
//------------------
// loop over entries
for(int entry = 0; entry < tree->GetEntries(); ++entry)
{
std::cout << ">>> reading entry " << entry << " / " << tree->GetEntries() << "\r" << std::flush;
tree -> GetEntry(entry);
float tot_integral = 0.;
float tot_maximum = 0.;
for(int fibIt = 0; fibIt < nFib; ++fibIt)
{
++n_waveform_fib[fibIt];
AddWaveform(g_waveform_fib[fibIt],t_waveform[fibIt]);
float ped, integral, maximum;
CalculateAmplitude(t_waveform[fibIt],ped,integral,maximum);
h_ped_fib[fibIt] -> Fill(ped);
h_ped_fib_all -> Fill(ped);
h_maximum_fib[fibIt] -> Fill(maximum);
h_maximum_fib_all -> Fill(maximum);
int x = 16-2*int(fibIt/8);
int y = (x/2)%2 == 0 ? 16-2*(fibIt%8) : 16-2*(fibIt%8)-1;
p_fibAveInt -> Fill(x,y,integral);
p_fibAveMax -> Fill(x,y,maximum);
if( maximum+ped > 120. )
{
tot_integral += integral;
tot_maximum += maximum;
++n_waveform_cut_fib[fibIt];
AddWaveform(g_waveform_cut_fib[fibIt],t_waveform[fibIt]);
}
}
for(int crystIt = 0; crystIt < nCryst; ++crystIt)
{
float ped, integral, maximum;
CalculateAmplitude(t_waveform[crystIt],ped,integral,maximum);
p_crystAveMax -> Fill(crystIt%3,2-crystIt/3,maximum);
}
h_tot_integral -> Fill(tot_integral);
h_tot_maximum -> Fill(tot_maximum);
}
TCanvas* c_waveform_fib_all = new TCanvas();
int plotIt = 0;
float min = +999999.;
float max = -999999.;
for(int fibIt = 0; fibIt < nFib; ++fibIt)
{
TGraph* g = g_waveform_fib[fibIt];
if( g->GetN() == 0 ) continue;
NormalizeGraph(g,n_waveform_fib[fibIt]);
if( GetMinimum(g) < min ) min = GetMinimum(g);
if( GetMaximum(g) > max ) max = GetMaximum(g);
}
for(int fibIt = 0; fibIt < nFib; ++fibIt)
{
TGraph* g = g_waveform_fib[fibIt];
if( g->GetN() == 0 ) continue;
TCanvas* c_waveform_fib = new TCanvas();
g -> SetMinimum(min-0.05*fabs(max-min));
g -> SetMaximum(max+0.05*fabs(max-min));
g -> SetLineWidth(2);
g -> SetLineColor(fibIt+1);
g -> SetMarkerSize(0.2);
g -> GetXaxis() -> SetTitle("sample time (ns)");
g -> Draw("APL");
c_waveform_fib -> Print(Form("/afs/cern.ch/user/a/abenagli/www/TBatFNAL/%s/plotsPerFib/waveform_fib%02d.png",inFileName.c_str(),fibIt),"png");
c_waveform_fib_all -> cd();
if( plotIt == 0 ) g -> Draw("APL");
else g -> Draw("PL,same");
++plotIt;
}
c_waveform_fib_all -> Print(Form("/afs/cern.ch/user/a/abenagli/www/TBatFNAL/%s/waveform_fib_all.png",inFileName.c_str()),"png");
TCanvas* c_waveform_cut_fib_all = new TCanvas();
plotIt = 0;
min = +999999.;
max = -999999.;
for(int fibIt = 0; fibIt < nFib; ++fibIt)
{
TGraph* g = g_waveform_cut_fib[fibIt];
if( g->GetN() == 0 ) continue;
NormalizeGraph(g,n_waveform_cut_fib[fibIt]);
if( GetMinimum(g) < min ) min = GetMinimum(g);
if( GetMaximum(g) > max ) max = GetMaximum(g);
}
for(int fibIt = 0; fibIt < nFib; ++fibIt)
{
TGraph* g = g_waveform_cut_fib[fibIt];
if( g->GetN() == 0 ) continue;
//g -> SetMinimum(min-0.05*fabs(max-min));
//g -> SetMaximum(max+0.05*fabs(max-min));
g -> SetLineWidth(2);
g -> SetLineColor(fibIt+1);
g -> SetMarkerSize(0.2);
g -> GetXaxis() -> SetTitle("sample time (ns)");
g -> Draw("APL");
c_waveform_cut_fib_all -> cd();
if( plotIt == 0 ) g -> Draw("APL");
else g -> Draw("PL,same");
++plotIt;
}
c_waveform_cut_fib_all -> Print(Form("/afs/cern.ch/user/a/abenagli/www/TBatFNAL/%s/waveform_cut_fib_all.png",inFileName.c_str()),"png");
for(int fibIt = 0; fibIt < nFib; ++fibIt)
{
TH1F* h = h_ped_fib[fibIt];
TCanvas* c_ped_fib = new TCanvas();
c_ped_fib -> SetLogy();
h -> SetLineWidth(2);
h -> GetXaxis() -> SetTitle("max sample");
h -> Draw();
h -> Fit("gaus","Q");
TLatex* latex1 = new TLatex(0.60,0.90,Form("RMS = %.1f",h->GetRMS()));
latex1 -> SetNDC();
latex1 -> SetTextFont(42);
latex1 -> SetTextSize(0.04);
latex1 -> Draw("same");
TLatex* latex2 = new TLatex(0.60,0.85,Form("#sigma = %.1f",h->GetFunction("gaus")->GetParameter(2)));
latex2 -> SetNDC();
latex2 -> SetTextFont(42);
latex2 -> SetTextSize(0.04);
latex2 -> Draw("same");
c_ped_fib -> Print(Form("/afs/cern.ch/user/a/abenagli/www/TBatFNAL/%s/plotsPerFib/ped_fib%02d.png",inFileName.c_str(),fibIt),"png");
h = h_maximum_fib[fibIt];
TCanvas* c_maximum_fib = new TCanvas();
c_maximum_fib -> SetLogy();
h -> SetLineWidth(2);
h -> GetXaxis() -> SetTitle("max sample");
h -> Draw();
c_maximum_fib -> Print(Form("/afs/cern.ch/user/a/abenagli/www/TBatFNAL/%s/plotsPerFib/maximum_fib%02d.png",inFileName.c_str(),fibIt),"png");
}
TCanvas* c_ped_fib_all = new TCanvas();
c_ped_fib_all -> SetLogy();
h_ped_fib_all -> SetLineWidth(2);
h_ped_fib_all -> GetXaxis() -> SetTitle("pedestal");
h_ped_fib_all -> Draw();
h_ped_fib_all -> Fit("gaus","Q");
TLatex* latex1 = new TLatex(0.60,0.90,Form("RMS = %.1f",h_ped_fib_all->GetRMS()));
latex1 -> SetNDC();
latex1 -> SetTextFont(42);
latex1 -> SetTextSize(0.04);
latex1 -> Draw("same");
TLatex* latex2 = new TLatex(0.60,0.85,Form("#sigma = %.1f",h_ped_fib_all->GetFunction("gaus")->GetParameter(2)));
latex2 -> SetNDC();
latex2 -> SetTextFont(42);
latex2 -> SetTextSize(0.04);
latex2 -> Draw("same");
c_ped_fib_all -> Print(Form("/afs/cern.ch/user/a/abenagli/www/TBatFNAL/%s/ped_fib_all.png",inFileName.c_str()),"png");
TCanvas* c_maximum_fib_all = new TCanvas();
c_maximum_fib_all -> SetLogy();
h_maximum_fib_all -> SetLineWidth(2);
h_maximum_fib_all -> GetXaxis() -> SetTitle("max sample");
h_maximum_fib_all -> Draw();
c_maximum_fib_all -> Print(Form("/afs/cern.ch/user/a/abenagli/www/TBatFNAL/%s/maximum_fib_all.png",inFileName.c_str()),"png");
TCanvas* c_fibAveInt = new TCanvas();
p_fibAveInt -> Draw("COLZ");
c_fibAveInt -> Print(Form("/afs/cern.ch/user/a/abenagli/www/TBatFNAL/%s/fibAveInt.png",inFileName.c_str()),"png");
TCanvas* c_fibAveMax = new TCanvas();
p_fibAveMax -> Draw("COLZ");
c_fibAveMax -> Print(Form("/afs/cern.ch/user/a/abenagli/www/TBatFNAL/%s/fibAveMax.png",inFileName.c_str()),"png");
TCanvas* c_crystAveMax = new TCanvas();
p_crystAveMax -> Draw("COLZ");
c_crystAveMax -> Print(Form("/afs/cern.ch/user/a/abenagli/www/TBatFNAL/%s/crystAveMax.png",inFileName.c_str()),"png");
TCanvas* c_tot_integral = new TCanvas();
c_tot_integral -> SetLogy();
h_tot_integral -> Draw();
c_tot_integral -> Print(Form("/afs/cern.ch/user/a/abenagli/www/TBatFNAL/%s/tot_integral.png",inFileName.c_str()),"png");
TCanvas* c_tot_maximum = new TCanvas();
c_tot_maximum -> SetLogy();
h_tot_maximum -> Draw();
c_tot_maximum -> Print(Form("/afs/cern.ch/user/a/abenagli/www/TBatFNAL/%s/tot_maximum.png",inFileName.c_str()),"png");
}
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 laserCalibration(
char* filename = "frascatirun", //input file
int filenum = 1081, //file number
int channel = 3, //trace channel
int flagChannel = 5, //laser flag channel
Double_t entriesN = 10, //number of entries for prcessing
int sleep = 10, //sleep time between 2 processed entries, helpful for viewing traces
bool gui = true //enable or disable trace visualization
)
{
caen_5742 caen;
Int_t nbins = 1024;
Double_t entries = entriesN;
Int_t bin;
TCanvas *c1 = new TCanvas("c1","frascatirun",900,700);
c1->Divide(1,2);
c1->cd(1);
TGraph* g = new TGraph();
TH1F* lmPeaks = new TH1F("lm","Peaks Ratio", 1000, 0, 5000);
TH1F* d = new TH1F("d","",nbins,0,nbins);
TH1F* back = new TH1F("Back","",nbins,0,nbins);
// input file
char fname[100]=0;
sprintf(fname,"%s_0%i.root",filename,filenum);
TFile* infile = new TFile(fname);
TTree *t = (TTree*) infile->Get("t");
t->SetBranchAddress("caen_5742", &caen.system_clock);
t->Print();
if(entriesN<=0)
entries = t->GetEntries();
//out file
char foutname[100]=0;
int lm=0;
if (channel ==3)lm=1;
if (channel ==4)lm=2;
sprintf(foutname,"./calibration/LM%i_out_0%i.root",lm,filenum);
outfile = new TFile(foutname,"RECREATE");
outTree = new TTree("LM","frascatirun output");
calibTree = new TTree("LM_cal","frascatirun output");
outTree->Branch("LM_PX1",&fPositionX1,"PX1/D");
outTree->Branch("LM_PX2",&fPositionX2,"PX2/D");
outTree->Branch("LM_PY1",&fPositionY1,"PY1/D");
outTree->Branch("LM_PY2",&fPositionY2,"PY2/D");
//outTree->Branch("baseline",baseline,"baseline[1024]/F");
outTree->Branch("time",&timeline,"time/D");
outTree->Branch("LM_P2_Integral",&integralP2,"IP2/D");
calibTree->Branch("LM_P2_Integral_mean",&integralP2_mean,"IP2_mean/D");
calibTree->Branch("LM_P2_Integral_mean_error",&integralP2_mean_error,"IP2_mean_error/D");
calibTree->Branch("LM_P2_Integral_sigma",&integralP2_sigma,"IP2_sigma/D");
calibTree->Branch("LM_P2_Integral_sigma_error",&integralP2_sigma_error,"IP2_sigma_error/D");
/**************************************
* read entries
**************************************
*/
for (int j = 0; j < entries; ++j){
gSystem->Sleep (sleep);
t->GetEntry(j);
//TRIGGER SELECTION
if(caen.trace[flagChannel][400]>1000 && caen.trace[flagChannel][800]<3000){
timeline = caen.system_clock;
/**************************************
* Peaks estimation
**************************************
*/
for (int i = 0; i < nbins; ++i){
g->SetPoint(i, i, caen.trace[channel][i]);
}
Double_t y_max = TMath::MaxElement(g->GetN(),g->GetY());
Float_t * source = new Float_t[nbins];
Float_t * dest = new Float_t[nbins];
for (int i = 0; i < nbins; ++i){
source[i]=y_max-caen.trace[channel][i];
g->SetPoint(i, i, source[i]);
}
//Use TSpectrum to find the peak candidates
TSpectrum *s = new TSpectrum();
Int_t nfound = s->SearchHighRes(source, dest, nbins, 3, 2, kTRUE, 2, kFALSE, 5);
/**************************************
* Background estimation
**************************************
*/
Int_t ssize = nbins;
Int_t numberIterations = 20;
Int_t direction = s->kBackIncreasingWindow;
Int_t filterOrder = s->kBackOrder2;
bool smoothing = kFALSE;
Int_t smoothWindow = s->kBackSmoothing3;
bool compton = kFALSE;
for (int i = 0; i < nbins; ++i) baseline[i] = source[i];
s->Background(baseline, ssize, numberIterations, direction, filterOrder, smoothing, smoothWindow, compton);
/**************************************
* Peaks and integral estimation
**************************************
*/
Double_t px[2], py[2];
for (int i = 0; i < nbins; ++i) dest[i] = source[i]-baseline[i];
if(nfound==2){
bin = s->GetPositionX()[0];
fPositionX1 = bin;
fPositionY1 = dest[bin];
px[0] = bin;
py[0] = dest[bin];
bin = s->GetPositionX()[1];
fPositionX2 = bin;
fPositionY2 = dest[bin];
px[1] = bin;
py[1] = dest[bin];
}
int posxa=6;
int posxb=9;
switch (filenum){
case 1081:
posxa=6;
posxb=9;
break;
case 1082:
posxa=5;
posxb=7;
break;
case 1083:
posxa=5;
posxb=8;
break;
case 1084:
posxa=5;
posxb=7;
break;
case 1085:
posxa=5;
posxb=7;
break;
case 1086:
posxa=5;
posxb=5;
break;
case 1087:
posxa=4;
posxb=4;
break;
case 1088:
posxa=3;
posxb=4;
break;
case 1089:
posxa=3;
posxb=3;
break;
default:
posxa=6;
posxb=9;
}
integralP2 = g->Integral (fPositionX2-posxa,fPositionX2+posxb);
/**************************************
* print and update the canvas
**************************************
*/
if(gui==true){
TH1F* gh = g->GetHistogram();
gh->FillN(nbins,g->GetX(),g->GetY());
g->Draw();
TPolyMarker* pm = (TPolyMarker*)gh->GetListOfFunctions()->FindObject("TPolyMarker");
if (pm) {
gh->GetListOfFunctions()->Remove(pm);
delete pm;
}
pm = new TPolyMarker(nfound, px, py);
gh->GetListOfFunctions()->Add(pm);
pm->SetMarkerStyle(23);
pm->SetMarkerColor(kBlue);
pm->SetMarkerSize(1.3);
for (i = 0; i < nbins; i++) d->SetBinContent(i,dest[i]);
d->SetLineColor(kRed);
d->Draw("SAME");
for (i = 0; i < nbins; i++) back->SetBinContent(i,baseline[i]);
back->SetLineColor(kGreen);
back->Draw("SAME");
c1->Update();
}
/**************************************
* Fill tree and peaks data Histogram
**************************************
*/
if(nfound==2)
{
lmPeaks->Fill(integralP2);
outTree->Fill();
}
//printf("time= %d, posx1= %d, posy1= %d\n",time, fPositionX1, fPositionY1);
//printf("time= %d, posx2= %d, posy2= %d\n",time, fPositionX2, fPositionY2);
//for (int i=0;i<nbins;i++) printf("time = %d\n",baseline[i]);
}
}
/**************************************
* switch to the bottom pan and Draw Histogram
**************************************
*/
c1->cd(2);
//lmPeaks->SetAxisRange(TMath::MinElement(entries,binmin),TMath::MaxElement(entries,binmax)+100);
//lmPeaks->SetAxisRange(0,3000);
lmPeaks->Fit("gaus");
integralP2_mean = lmPeaks->GetFunction("gaus")->GetParameter(1);
integralP2_sigma = lmPeaks->GetFunction("gaus")->GetParameter(2);
integralP2_mean_error = lmPeaks->GetFunction("gaus")->GetParError(1);
integralP2_sigma_error = lmPeaks->GetFunction("gaus")->GetParError(2);
//printf("mean = %f\n",integralP2_mean);
//printf("sigma = %f\n",integralP2_sigma);
calibTree->Fill();
lmPeaks->Draw();
c1->Update();
outfile->cd();
gROOT->GetList()->Write();
outTree->Write();
calibTree->Write();
outfile->Close();
}
void draw_mSUGRA_exclusion(TH2F *ocrosssection, TH2F *oFilterEfficiency, TH2F *oabsXS, TH2F *limitmap, TH2F *expmap, TH2F *expplusmap, TH2F *expminusmap, TH2F *exp2plusmap, TH2F *exp2minusmap, bool isobserved) {
TH2F *crosssection = (TH2F*)ocrosssection->Clone("crosssection");
// TH2F *limitmap = (TH2F*)olimitmap->Clone(((string)olimitmap->GetName()+"clone").c_str());
TH2F *cleanhisto = (TH2F*)limitmap->Clone("clean");
for(int ix=1;ix<=cleanhisto->GetNbinsX();ix++) {
for(int iy=1;iy<=cleanhisto->GetNbinsY();iy++) {
cleanhisto->SetBinContent(ix,iy,0);
}
}
TH2F *FilterEfficiency;
TH2F *absXS;
write_warning(__FUNCTION__,"You'll want to switch off 'wrongwaytodothis')");
if(wrongwaytodothis) {
//this part is the one you want to remove.
TFile *Efficiencies = new TFile("FilterEfficiencyv3.root");
FilterEfficiency = cast_into_shape((TH2F*) Efficiencies->Get("FilterEfficiency"),limitmap);
assert(FilterEfficiency);
assert(crosssection);
absXS=(TH2F*)crosssection->Clone("absXS");
crosssection->Multiply(FilterEfficiency);
} else {
//this part is the one you want to keep!
FilterEfficiency=(TH2F*)oFilterEfficiency->Clone("FilterEfficiency");
absXS=(TH2F*)oabsXS->Clone("absXS");
}
TH2F *limits = (TH2F*)limitmap->Clone("limits");
set_range(limits,true,false);
limitmap->Divide(crosssection);
expminusmap->Divide(crosssection);
expplusmap->Divide(crosssection);
exp2minusmap->Divide(crosssection);
exp2plusmap->Divide(crosssection);
expmap->Divide(crosssection);
TGraph *observed = get_mSUGRA_exclusion_line(limitmap, PlottingSetup::mSUGRA);
observed->SetLineColor(kRed);
TGraph *expminus = get_mSUGRA_exclusion_line(expminusmap, PlottingSetup::mSUGRA);
TGraph *expplus = get_mSUGRA_exclusion_line(expplusmap, PlottingSetup::mSUGRA);
TGraph *exp2minus;
if(draw2sigma) exp2minus = get_mSUGRA_exclusion_line(exp2minusmap, PlottingSetup::mSUGRA);
TGraph *exp2plus;
if(draw2sigma) exp2plus = get_mSUGRA_exclusion_line(exp2plusmap, PlottingSetup::mSUGRA);
TGraph *expected = new TGraph(expminus->GetN()+expplus->GetN());
TGraph *expected2;
if(draw2sigma) expected2 = new TGraph(exp2minus->GetN()+exp2plus->GetN());
for(int i=0;i<=expminus->GetN();i++) {
Double_t x,y;
expminus->GetPoint(i,x,y);
expected->SetPoint(i,x,y);
}
for(int i=0;i<=exp2minus->GetN();i++) {
Double_t x,y;
exp2minus->GetPoint(i,x,y);
expected2->SetPoint(i,x,y);
}
for(int i=exp2plus->GetN()-1;i>=0;i--) {
Double_t x,y;
exp2plus->GetPoint(i,x,y);
expected2->SetPoint(exp2minus->GetN()+(exp2plus->GetN()-i),x,y);
}
for(int i=expplus->GetN()-1;i>=0;i--) {
Double_t x,y;
expplus->GetPoint(i,x,y);
expected->SetPoint(expminus->GetN()+(expplus->GetN()-i),x,y);
}
expected->SetFillColor(TColor::GetColor("#9FF781"));
if(draw2sigma) expected2->SetFillColor(TColor::GetColor("#F3F781"));
smooth_line(observed);
smooth_line(expected);
if(draw2sigma) smooth_line(expected2);
TCanvas *te = new TCanvas("te","te");
te->SetRightMargin(standardmargin);
// decorate_mSUGRA(cleanhisto,te,expected,expected2,observed);
TH2F *noh = new TH2F("noh","noh",1,1,2,1,1,2);
SugarCoatThis(te,10,noh,observed);
// expected->Draw("c");
// observed->Draw("c");
stringstream saveas;
if((int)((string)limitmap->GetName()).find("limitmap")>0) {
saveas << "Limits/";
if(!isobserved) saveas << "expected/expected_";
saveas << "final_exclusion_for_JZB_geq_" << ((string)limitmap->GetName()).substr(((string)limitmap->GetName()).find("limitmap")+8,10);
} else {
saveas << "Limits/";
if(!isobserved) saveas << "expected/expected";
saveas << "final_exclusion_for_bestlimits";
}
CompleteSave(te,saveas.str());
delete te;
TCanvas *overview = new TCanvas("overview","overview",1500,1000);
set_range(crosssection,true,false);
set_range(limits,true,false);
set_range(limitmap,true,false);
overview->Divide(3,2);
overview->cd(1);
overview->cd(1)->SetLogz(1);
absXS->GetZaxis()->SetRangeUser(0.0001,100);
absXS->Draw("COLZ");
TText *title0 = write_title("Cross Section");
title0->Draw("same");
overview->cd(2);
FilterEfficiency->GetZaxis()->SetRangeUser(0.01,0.7);
FilterEfficiency->Draw("COLZ");
TText *title0aa = write_title("Filter #epsilon");
title0aa->Draw("same");
overview->cd(3);
overview->cd(3)->SetLogz(1);
crosssection->GetZaxis()->SetRangeUser(0.0001,100);
crosssection->Draw("COLZ");
TText *title0a = write_title("Filter #epsilon x Cross Section");
title0a->Draw("same");
overview->cd(4);
overview->cd(4)->SetLogz(1);
limits->GetZaxis()->SetRangeUser(0.01,100);
limits->Draw("COLZ");
TText *title1 = write_title("Cross Section Upper Limit");
title1->Draw("same");
overview->cd(5);
limitmap->Draw("COLZ");
TText *title2 = write_title("UL/XS");
title2->Draw("same");
observed->Draw("c");
overview->cd(6);
overview->cd(6)->SetRightMargin(standardmargin);
// decorate_mSUGRA(cleanhisto,overview->cd(4),expected,expected2,observed);
SugarCoatThis(overview->cd(6),10,noh,observed);
// observed->Draw("c");
stringstream saveas2;
if((int)((string)limitmap->GetName()).find("limitmap")>0) {
saveas2 << "Limits/";
if(!isobserved) saveas << "expected/expected_";
saveas2 << "exclusion_overview_for_JZB_geq_" << ((string)limitmap->GetName()).substr(((string)limitmap->GetName()).find("limitmap")+8,10);
} else {
saveas2 << "Limits/";
if(!isobserved) saveas << "expected/expected_";
saveas2 << "exclusion_overview_for_bestlimits";
}
CompleteSave(overview,saveas2.str());
delete overview;
delete noh;
delete crosssection;
delete absXS;
delete FilterEfficiency;
}
void buildFakeAngTree(const Char_t* outtag,
const Float_t timereso, // ns
const UInt_t simevts=1,
const Float_t thetaOpt=400, // deg
const Float_t phiOpt=400, // deg
const Float_t coneOpt=400, // deg
const UInt_t rseed=23192,
const Float_t norm=100.0, // mV
const Float_t noise=20.0, // mV
const Char_t* outdir="/data/users/cjreed/work/simEvts",
const Char_t* infn="/w2/arianna/jtatar/nt.sigtemps.root",
const Char_t* geofn="/data/users/cjreed/work/"
"BounceStudy/Stn10/"
"CampSiteGeometry.root") {
// if any of the angles (thetaOpt, phiOpt, coneOpt) > 360, a random
// value will be used instead
//
// expect angles in the Templates tree to be in degrees
//
// expect the waveforms in the Templates tree to have amplitude 1
TRandom3 rnd(rseed);
geof = TFile::Open(geofn);
gg = dynamic_cast<TGeoManager*>(geof->Get("CampSite2013"));
site = dynamic_cast<const TSnGeoStnSite*>(gg->GetTopVolume());
TVector3 pos[NSnConstants::kNchans], nvec[NSnConstants::kNchans];
for (UChar_t ch=0; ch<NSnConstants::kNchans; ++ch) {
site->SetLPDAPosition(ch, pos[ch]);
site->SetLPDANormalVec(ch, nvec[ch]);
Printf("pos ch%d:",ch);
pos[ch].Print();
Printf("normal ch%d:",ch);
nvec[ch].Print();
}
TArrayD zeros(6);
inf = TFile::Open(infn);
nnt = dynamic_cast<TTree*>(inf->Get("Templates"));
TString infns(infn);
TString indir;
Int_t fl(0);
if (infns.Contains('/')) {
fl = infns.Last('/') + 1;
indir = infns(0, fl-1);
}
TString plaininfn = infns(fl, infns.Length()-fl);
TString outfn = Form("%s/FakeEvts.%s.%s", outdir, outtag,
plaininfn.Data());
outf = TFile::Open(outfn.Data(),"recreate");
outf->cd();
TParameter<Float_t> trp("TimeResolution", timereso);
trp.Write();
TParameter<Float_t> nmp("Normalization", norm);
nmp.Write();
TParameter<Float_t> nop("NoiseRMS", noise);
nop.Write();
TParameter<UInt_t> rsp("RandomSeed", rseed);
rsp.Write();
TSnCalWvData* wave = new TSnCalWvData;
Float_t eang(0), hang(0), hpf(0), limiter(0), coneang(0);
Bool_t bice(kFALSE);
nnt->SetBranchAddress("wave.",&wave);
nnt->SetBranchAddress("EAng",&eang);
nnt->SetBranchAddress("HAng",&hang);
nnt->SetBranchAddress("hpf",&hpf);
nnt->SetBranchAddress("limiter",&limiter);
nnt->SetBranchAddress("coneAng",&coneang);
nnt->SetBranchAddress("bIce",&bice);
// to look up waveform for EAng, HAng
nnt->BuildIndex("EAng + (1000*HAng)","coneAng");
// find the max angles
Printf("finding allowed angles...");
std::set<Float_t> Eangs, Hangs, Cangs;
const Long64_t nnents = nnt->GetEntries();
for (Long64_t i=0; i<nnents; ++i) {
nnt->GetEntry(i);
Eangs.insert(eang);
Hangs.insert(hang);
Cangs.insert(coneang);
}
#ifdef DEBUG
std::set<Float_t>::const_iterator ang, end = Eangs.end();
Printf("EAngs:");
for (ang=Eangs.begin(); ang!=end; ++ang) {
Printf("%g",*ang);
}
Printf("HAngs:");
for (ang=Hangs.begin(), end=Hangs.end(); ang!=end; ++ang) {
Printf("%g",*ang);
}
Printf("ConeAngs:");
for (ang=Cangs.begin(), end=Cangs.end(); ang!=end; ++ang) {
Printf("%g",*ang);
}
#endif
Float_t theta(0), phi(0), cone(0);
Float_t EAng[NSnConstants::kNchans],
HAng[NSnConstants::kNchans];
Float_t CAng(0);
TSnCalWvData* evdat = new TSnCalWvData;
TSnEventMetadata* meta = new TSnEventMetadata;
TSnEventHeader* hdr = new TSnEventHeader;
//ot = nnt->CloneTree(0);
//ot->SetName("SimTemplEvts");
ot = new TTree("SimTemplEvts","simulated events from templates",1);
ot->SetDirectory(outf);
ot->Branch("EventMetadata.",&meta);
ot->Branch("EventHeader.",&hdr);
ot->Branch("EAng",&(EAng[0]),Form("EAng[%hhu]/F",NSnConstants::kNchans));
ot->Branch("HAng",&(HAng[0]),Form("HAng[%hhu]/F",NSnConstants::kNchans));
ot->Branch("CAng",&CAng,"CAng/F");
ot->Branch("theta",&theta,"theta/F");
ot->Branch("phi",&phi,"phi/F");
ot->Branch("NuData.",&evdat);
// some useful aliases
TString an;
for (UChar_t ch=0; ch<NSnConstants::kNchans; ++ch) {
// to use as a cut for a particular channel:
an = Form("Ch%d",ch);
ot->SetAlias(an.Data(),
Form("(Iteration$>=(%hhu*%hhu)) && (Iteration$<(%hhu*%hhu))",
NSnConstants::kNsamps, ch,
NSnConstants::kNsamps,
static_cast<UChar_t>(ch+1)));
// to use as a variable showing the sample number [0,127] for any chan
an = Form("SmpCh%d",ch);
ot->SetAlias(an.Data(),
Form("Iteration$-%u", static_cast<UInt_t>(ch)
*static_cast<UInt_t>(NSnConstants::kNsamps)));
// e.g. Draw("RawData.fData:SmpCh2","EventHeader.fNum==21 && Ch2","l")
}
Printf("generating events...");
TStopwatch timer;
timer.Start();
for (UInt_t i=0; i<simevts; ++i) {
if ( (i%1000)==0 ) {
fprintf(stderr,"Processing %u/%u ... \r",i,simevts);
}
// choose angles
theta = (thetaOpt>360.) ? TMath::ACos( rnd.Uniform(-1.0, 0.0) )
: thetaOpt * TMath::DegToRad();
phi = (phiOpt>360.) ? rnd.Uniform(0.0, TMath::TwoPi())
: phiOpt * TMath::DegToRad();
cone = (coneOpt>360.)
? rnd.Uniform(*(Cangs.begin()), *(Cangs.rbegin()))
: coneOpt; // leave this one in degrees (as in the tree)
CAng = findNearestAllowedAngle(Cangs, cone);
#ifdef DEBUG
Printf("--- theta=%g, phi=%g, cone=%g",
theta*TMath::RadToDeg(), phi*TMath::RadToDeg(), cone);
#endif
// calculate channel shifts
TArrayD pwdt = NSnChanCorl::GetPlaneWaveOffsets(theta,
phi,
zeros,
pos,
kNgTopFirn);
TVector3 dir;
dir.SetMagThetaPhi(1.0, theta, phi);
#ifdef DEBUG
TObjArray graphs;
graphs.SetOwner(kTRUE);
TCanvas* c1 = new TCanvas("c1","c1",800,700);
c1->Divide(2,2);
#endif
for (UChar_t ch=0; ch<NSnConstants::kNchans; ++ch) {
// look up the EAng, fhang for this antenna
Float_t feang(0), fhang(0);
findEangHang(nvec[ch], dir, feang, fhang);
feang = TMath::Abs(TVector2::Phi_mpi_pi(feang));
fhang = TMath::Abs(TVector2::Phi_mpi_pi(fhang));
feang *= TMath::RadToDeg();
fhang *= TMath::RadToDeg();
// find closest allowed angle
EAng[ch] = findNearestAllowedAngle(Eangs, feang);
HAng[ch] = findNearestAllowedAngle(Hangs, fhang);
const Long64_t ni =
nnt->GetEntryNumberWithIndex(EAng[ch] + (1000*HAng[ch]), CAng);
#ifdef DEBUG
Printf("EAng=%g (%g), HAng=%g (%g), CAng=%g, ni=%lld",
EAng[ch],feang,HAng[ch],fhang,CAng,ni);
#endif
if (ni>-1) {
nnt->GetEntry(ni);
#ifdef DEBUG
c1->cd(ch+1);
TGraph* och = wave->NewGraphForChan(0, kTRUE);
const Int_t ochnp = och->GetN();
Double_t* ochy = och->GetY();
for (Int_t k=0; k<ochnp; ++k, ++ochy) {
*ochy *= norm;
}
graphs.Add(och);
och->SetLineColor(kBlack);
och->SetMarkerColor(kBlack);
och->SetMarkerStyle(7);
och->Draw("apl");
#endif
// first calculate the shift between chans due to the angle
// ch0 is always unshifted; other chans shifted w.r.t. ch0
// jitter the shift by the specified timing resolution
const Double_t shift =
rnd.Gaus( (ch==0) ? 0.0
: -pwdt.At( TSnRecoChanOffsets::IndexFor(ch, 0) ),
timereso);
// get a graph of the waveform
// data only in channel 0 of the template
TGraph* gch = wave->NewGraphForChan(0, kTRUE);
// "fit" the graph with an spline interpolation
TSpline3* gsp = new TSpline3("stmp", gch);
// evaluate the spline at the new sample positions
// (shifted, but NOT wrapped)
// and save that into the event data waveform
Float_t* d = evdat->GetData(ch);
const Float_t tstep = 1.0 / NSnConstants::kSampRate;
const Float_t tlast = static_cast<Float_t>(NSnConstants::kNsamps-1)
/ NSnConstants::kSampRate;
Float_t xloc = shift;
for (UChar_t s=0; s<NSnConstants::kNsamps; ++s, ++d, xloc+=tstep) {
if ( (xloc<0.0) || (xloc>=tlast) ) {
*d = 0.0;
} else {
*d = gsp->Eval( xloc );
}
}
#ifdef DEBUG
Printf("ch%hhu: shift=%g, dt=%g", ch, shift,
(ch==0) ? 0.0
: pwdt.At( TSnRecoChanOffsets::IndexFor(ch, 0) ));
TGraph* fch = evdat->NewGraphForChan(ch, kTRUE);
Double_t* y = gch->GetY();
Double_t* fy = fch->GetY();
for (UChar_t s=0; s<NSnConstants::kNsamps; ++s, ++y, ++fy) {
*y *= norm;
*fy *= norm;
}
gch->SetLineColor(kRed+1);
gch->SetMarkerColor(kRed+1);
gch->SetMarkerStyle(7);
gch->Draw("pl");
delete gsp;
gsp = new TSpline3("stmp",gch);
gsp->SetLineColor(kAzure-6);
gsp->SetMarkerColor(kAzure-6);
gsp->SetMarkerStyle(7);
gsp->Draw("pl same");
graphs.Add(fch);
fch->SetLineColor(kOrange+7);
fch->SetMarkerColor(kOrange+7);
fch->SetMarkerStyle(7);
fch->Draw("pl");
#endif
d = evdat->GetData(ch);
// finally add noise to the waveform
for (UChar_t s=0; s<NSnConstants::kNsamps; ++s, ++d) {
*d = rnd.Gaus( (*d) * norm, noise );
}
#ifdef DEBUG
TGraph* nch = evdat->NewGraphForChan(ch, kTRUE);
graphs.Add(nch);
nch->SetLineColor(kGreen+2);
nch->SetMarkerColor(kGreen+2);
nch->SetMarkerStyle(7);
nch->Draw("pl");
#endif
// cleanup
#ifdef DEBUG
graphs.Add(gch);
graphs.Add(gsp);
#else
delete gch;
delete gsp;
#endif
}
} // end channel loop
#ifdef DEBUG
TObject* o(0);
while ( (o=c1->WaitPrimitive())!=0 ) {
gSystem->ProcessEvents();
}
delete c1;
#endif
// save this event
ot->Fill();
} // end event loop
fprintf(stderr,"\n");
timer.Stop();
Printf("Finished generating events in:");
timer.Print();
outf->Write();
Printf("Wrote [%s]",outf->GetName());
delete outf; outf=0; // close file
}
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");
}
bool check(int n = 2) {
TFile *file = TFile::Open(TString::Format("merged%d.root",n));
bool result = true;
TH1F *h; file->GetObject("h1",h);
if (!h) {
Error("execFileMerger","h1 is missing\n");
result = false;
}
if (h->GetBinContent(2) != n || h->GetBinContent(3) != n) {
Error("execFileMerger","h1 not added properly");
result = false;
}
THnSparseF *sparse; file->GetObject("sparse",sparse);
if (!sparse) {
Error("execFileMerger","sparse is missing\n");
result = false;
} else {
Int_t coordIdx[5] = {1, 2, 3, 4, 5};
Double_t cont = sparse->GetBinContent(coordIdx);
if (cont > n + 0.4 || cont < n - 0.4) {
Error("execFileMerger","sparse merge failed: expected bin content %g, read %g\n",
(Double_t)n, cont);
result = false;
}
Double_t entries = sparse->GetEntries();
if (entries > n + 0.4 || entries < n - 0.4) {
Error("execFileMerger","sparse merge failed: expected %g entries, read %g\n",
(Double_t)n, entries);
result = false;
}
}
THStack *stack; file->GetObject("stack",stack);
if (!stack) {
Error("execFileMerger","stack is missing\n");
result = false;
}
h = (TH1F*)stack->GetHists()->FindObject("hs_1");
if (!h) {
Error("execFileMerger","hs_1 is missing\n");
result = false;
}
if (h->GetBinContent(2) != n || h->GetBinContent(3) != n) {
Error("execFileMerger","hs_1 not added properly");
result = false;
}
h = (TH1F*)stack->GetHists()->FindObject("hs_2");
if (!h) {
Error("execFileMerger","hs_2 is missing\n");
result = false;
}
if (h->GetBinContent(4) != n || h->GetBinContent(5) != n) {
Error("execFileMerger","hs_2 not added properly");
result = false;
}
TGraph *gr; file->GetObject("exgraph",gr);
if (!gr) {
Error("execFileMerger","exgraph is missing\n");
result = false;
}
if (gr->GetN() != ( n * 3)) {
Error("execFileMerger","exgraph not added properly n=%d rather than %d",gr->GetN(),n*3);
result = false;
} else {
for(Int_t k = 0; k < gr->GetN(); ++k) {
double x,y;
gr->GetPoint(k,x,y);
if ( x != ( (k%3)+1 ) || y != ( (k%3)+1 ) ) {
Error("execFileMerger","exgraph not added properly");
result = false;
}
}
}
TTree *tree; file->GetObject("tree",tree);
if (!tree) {
Error("execFileMerger","tree is missing\n");
result = false;
}
if (tree->GetEntries() != n*2) {
Error("execFileMerger","tree does not have the expected number of entries: %lld rather than %d",tree->GetEntries(),n*2);
result = false;
} else {
if ( tree->GetEntries("data==1") != n ) {
Error("execFileMerger","tree does not have the expected data. We got %lld entries with 'data==1' rather than %d",tree->GetEntries("data==1"),n);
tree->Scan();
result = false;
}
}
return result;
}
vector< pair <double,double> > getMinMaxOfGraphs (vector<GraphInfo> inputGraphs) {
cout << "-----------------Inside minMax -------------------" << endl;
pair<double,double> yValMinMax;
pair<double,double> xValMinMax;
yValMinMax.first = 1000.0; //min
yValMinMax.second = -1000.0; //max
xValMinMax.first = 1000.0; //min
xValMinMax.second = -1000.0; //max
for (unsigned iGraph =0; iGraph < inputGraphs.size(); iGraph++){
TGraph * thisGraph = inputGraphs[iGraph].theGraph;
double iMinY = 1000.0;
double iMaxY = -1000.0;
double iMinX = 1000.0;
double iMaxX = -1000.0;
for (int iPoint =0; iPoint < thisGraph->GetN(); iPoint++){
double xVal, yVal;
thisGraph->GetPoint(iPoint, xVal, yVal);
cout <<"n = " << iPoint << "x= " << xVal << "y = " << yVal << endl;
if (yVal < iMinY )
iMinY = yVal;
if (yVal > iMaxY)
iMaxY = yVal;
if (xVal < iMinX )
iMinX = xVal;
if (xVal > iMaxX)
iMaxX = xVal;
}
cout << "New plot minY = " << iMinY << ", maxY = " << iMaxY << endl
<< " minX = " << iMinX << ", maxX = " << iMaxX << endl ;
if (iMinY < yValMinMax.first)
yValMinMax.first = iMinY;
if (iMaxY > yValMinMax.second)
yValMinMax.second = iMaxY;
if (iMinX < xValMinMax.first)
xValMinMax.first = iMinX;
if (iMaxX > xValMinMax.second)
xValMinMax.second = iMaxX;
}
//------------------------
cout << "found min = " << yValMinMax.first
<< " found max = " << yValMinMax.second
<< endl;
if (yValMinMax.first > 0 )
yValMinMax.first = 0;
vector<pair<double,double> > returnValMinMax;
returnValMinMax.push_back(xValMinMax);
returnValMinMax.push_back(yValMinMax);
return returnValMinMax;
}