//________________________________________________________________
void KVCanvas::DynamicZoomTH1(Int_t Sign, Int_t px, Int_t)
{
// Zoom in or out of histogram with mouse wheel
if (!fSelected) return;
TH1* TheHisto = (TH1*) FindHisto();//fSelected;
Double_t percent = 0.15 - Sign * 0.05;
Int_t dX = 0;
px = AbsPixeltoX(px);
TAxis* ax = TheHisto->GetXaxis();
Int_t NbinsXtmp = ax->GetNbins();
Int_t X0tmp = ax->GetFirst();
Int_t X1tmp = ax->GetLast();
Int_t step = TMath::Min(TMath::Max(1, (Int_t)(percent * (X1tmp - X0tmp))), NbinsXtmp / 2);
step *= Sign;
X0tmp = TMath::Min(TMath::Max(X0tmp + step, 1), X1tmp - step);
X1tmp = TMath::Max(TMath::Min(X1tmp - step, NbinsXtmp), X0tmp);
if (X0tmp >= X1tmp) X0tmp = X1tmp - 1;
if (Sign > 0) dX = (Int_t)(X0tmp + (X1tmp - X0tmp) * 0.5 - ax->FindBin(px));
if ((X0tmp - dX) < 0) ax->SetRange(0, X1tmp - X0tmp);
else if ((X1tmp - dX) > ax->GetNbins()) ax->SetRange(ax->GetNbins() - (X1tmp - X0tmp), ax->GetNbins());
else ax->SetRange(X0tmp - dX, X1tmp - dX);
Modified();
Update();
return;
}
TH1* linearizeHistogram(TH1* histogram)
{
if ( !histogram ) return 0;
TH1* histogram2d = dynamic_cast<TH2*>(histogram);
if ( !histogram2d ) return histogram;
TAxis* xAxis = histogram2d->GetXaxis();
int numBinsX = xAxis->GetNbins();
TAxis* yAxis = histogram2d->GetYaxis();
int numBinsY = yAxis->GetNbins();
std::string histogramName1d = Form("%s_1d", histogram->GetName());
int numBins1d = numBinsX*numBinsY;
TH1* histogram1d = new TH1D(histogramName1d.data(),histogramName1d.data(), numBins1d, -0.5, numBins1d - 0.5);
int iBin1d = 1;
for ( int iBinX = 1; iBinX <= numBinsX; ++iBinX ) {
for ( int iBinY = 1; iBinY <= numBinsY; ++iBinY ) {
double binContent = histogram2d->GetBinContent(iBinX, iBinY);
double binError = histogram2d->GetBinError(iBinX, iBinY);
histogram1d->SetBinContent(iBin1d, binContent);
histogram1d->SetBinError(iBin1d, binError);
++iBin1d;
}
}
return histogram1d;
}
//______________________________________________________________________________
TEveCaloDataVec* MakeVecData(Int_t ncells=0)
{
// Example how to fill data when bins can be iregular.
// If ncells = 0 (default) whole histogram is taken,
// otherwise just ncells cells around the maximum.
TFile::SetCacheFileDir(".");
TFile* hf = TFile::Open(histFile, "CACHEREAD");
TH2F* h1 = (TH2F*)hf->Get("ecalLego");
TH2F* h2 = (TH2F*)hf->Get("hcalLego");
TEveCaloDataVec* data = new TEveCaloDataVec(2);
data->RefSliceInfo(0).Setup("ECAL", 0.3, kRed);
data->RefSliceInfo(1).Setup("HCAL", 0.1, kBlue);
TAxis *ax = h1->GetXaxis();
TAxis *ay = h1->GetYaxis();
Int_t xm = 1, xM = ax->GetNbins();
Int_t ym = 1, yM = ay->GetNbins();
if (ncells != 0)
{
Int_t cx, cy, cz;
h1->GetMaximumBin(cx, cy, cz);
xm = TMath::Max(xm, cx-ncells);
xM = TMath::Min(xM, cx+ncells);
ym = TMath::Max(ym, cy-ncells);
yM = TMath::Min(yM, cy+ncells);
}
// Take every second cell and set a random size.
for(Int_t i=xm; i<=xM; i+=2)
{
for(Int_t j=ym; j<=yM; j+=2)
{
if ( (i+j) % 3)
{
data->AddTower(ax->GetBinLowEdge(i), ax->GetBinUpEdge(i),
ay->GetBinLowEdge(j), ay->GetBinUpEdge(j));
data->FillSlice(0, h1->GetBinContent(i, j));
data->FillSlice(1, h2->GetBinContent(i, j));
}
else
{
data->AddTower(ax->GetBinLowEdge(i),
2 * ax->GetBinWidth(i) + ax->GetBinLowEdge(i),
ay->GetBinLowEdge(j),
2 * ay->GetBinWidth(j) + ay->GetBinLowEdge(j));
data->FillSlice(0, h2->GetBinContent(i, j));
data->FillSlice(1, h2->GetBinContent(i, j));
}
}
}
data->SetEtaBins(ax);
data->SetPhiBins(ay);
data->DataChanged();
return data;
}
static bool CheckAxisCompatibility(const TAxis& a, const TAxis& b)
{
static const double delta_max = 0.001;
static const double rel_delta_max = 0.01;
if(a.GetNbins() != b.GetNbins()) return false;
for(Int_t n = 1; n <= a.GetNbins(); ++n) {
const double c_a = a.GetBinCenter(n);
const double c_b = b.GetBinCenter(n);
const double delta = c_a - c_b;
if( ( c_a && std::abs(delta/c_a) > rel_delta_max ) || ( !c_a && std::abs(delta) > delta_max ) )
return false;
}
return true;
}
//______________________________________________________________________________
void drawsparse_draw(THnSparse* h)
{
// Draw a THnSparse using TParallelCoord, creating a temporary TTree.
TTree* tree = toTree(h);
TString whatToDraw;
TIter iLeaf(tree->GetListOfLeaves());
const TLeaf* leaf = 0;
while ((leaf = (const TLeaf*)iLeaf())) {
if (whatToDraw.Length())
whatToDraw += ":";
whatToDraw += leaf->GetName();
}
tree->Draw(whatToDraw, "", "para");
TParallelCoord* parallelCoord = (TParallelCoord*)gPad->GetListOfPrimitives()->FindObject("ParaCoord");
TIter iVar(parallelCoord->GetVarList());
TParallelCoordVar* var = 0;
for (Int_t d = 0;(var = (TParallelCoordVar*) iVar()) && d < h->GetNdimensions(); ++d) {
TAxis* axis = h->GetAxis(d);
var->SetHistogramBinning(axis->GetNbins());
var->SetCurrentLimits(axis->GetXmin(), axis->GetXmax());
var->SetTitle(axis->GetTitle());
}
var->SetTitle("bin content");
}
/** comapre axis for equalitiy
*
* check whether the cass histogram axis and the root histogram axis are the
* same. Test for number of bins, low and high ends and the title of the axis.
*
* @return true when both axis are the same
* @param ca the axis of the cass histogram
* @param ra the axis of the root histogram
*
* @author Lutz Foucar
*/
bool operator== (const cass::Result<float>::axe_t &ca, const TAxis &ra)
{
return (static_cast<int>(ca.nBins) == ra.GetNbins() &&
fabs(ca.low - ra.GetXmin()) < sqrt(numeric_limits<double>::epsilon()) &&
fabs(ca.up - ra.GetXmax()) < sqrt(numeric_limits<double>::epsilon()) &&
ca.title == ra.GetTitle());
}
void BinLog(TH2F *h)
{
TAxis *axis = h->GetXaxis();
int bins = axis->GetNbins();
Axis_t from = axis->GetXmin();
Axis_t to = axis->GetXmax();
Axis_t width = (to - from) / bins;
Axis_t *new_bins = new Axis_t[bins + 1];
for (int i = 0; i <= bins; i++) {
new_bins[i] = TMath::Power(10, from + i * width);
}
axis->Set(bins, new_bins);
TAxis *axis2 = h->GetYaxis();
int bins2 = axis2->GetNbins();
Axis_t from2 = axis2->GetXmin();
Axis_t to2 = axis2->GetXmax();
Axis_t width2 = (to2 - from2) / bins2;
Axis_t *new_bins2 = new Axis_t[bins2 + 1];
for (int i = 0; i <= bins2; i++) {
new_bins2[i] = TMath::Power(10, from2 + i * width2);
}
axis2->Set(bins2, new_bins2);
delete new_bins;
delete new_bins2;
}
void
getLimits (TH1D *cutFlow, TDirectoryFile *dir)
{
string histName = cutFlow->GetName ();
TH1D *lowerLimit = (TH1D *) cutFlow->Clone ((histName + "LowerLimit").c_str ()),
*upperLimit = (TH1D *) cutFlow->Clone ((histName + "UpperLimit").c_str ());
TAxis *x = cutFlow->GetXaxis ();
for (int i = 1; i <= x->GetNbins (); i++)
{
double events = cutFlow->GetBinContent (i), eventsLowerLimit, eventsUpperLimit;
// The calculation of upper and lower limits is taken from the PDG Statistics chapter.
// "Poisson or binomal data", section 37.4.2.3 in 2013 version; Eqns. 37.71a, 37.71b.
// Here ALPHA is the confidence level, so ALPHA = 0.68 corresponds to a 68% C.L.
// The PDG uses a different convention: the C.L is 1 - \alpha.
// For example, the 68% CL upper limit on an observation of 0 events is:
// 0.5 * TMath::ChisquareQuantile (0.68, 2) = 1.139
eventsLowerLimit = 0.5 * TMath::ChisquareQuantile (1 - ALPHA, 2 * events);
eventsUpperLimit = 0.5 * TMath::ChisquareQuantile (ALPHA, 2 * (events + 1));
lowerLimit->SetBinContent (i, eventsLowerLimit);
upperLimit->SetBinContent (i, eventsUpperLimit);
}
dir->cd ();
lowerLimit->Write ((histName + "LowerLimit").c_str ());
upperLimit->Write ((histName + "UpperLimit").c_str ());
}
TH2F * histo_rebin(TH2F *h, const int nx, const Double_t *xbins, const int ny, const Double_t *ybins){
// NB: the errors of the rebinned histogram are wrong!
TH2F * h_new = new TH2F("h_new",h->GetTitle(),nx,xbins,ny,ybins);
h_new->Sumw2();
TAxis *xaxis = h->GetXaxis();
TAxis *yaxis = h->GetYaxis();
for (int jbin=1; jbin<=yaxis->GetNbins(); ++jbin){
for (int ibin=1; ibin<=xaxis->GetNbins(); ++ibin){
h_new->Fill(xaxis->GetBinCenter(ibin),yaxis->GetBinCenter(jbin),h->GetBinContent(ibin,jbin));
}
}
return (TH2F*) h_new->Clone();
}
void divideByBinWidth(TH1* histogram)
{
if ( !histogram ) return;
TAxis* xAxis = histogram->GetXaxis();
int numBins = xAxis->GetNbins();
for ( int iBin = 1; iBin <= numBins; ++iBin ) {
double binContent = histogram->GetBinContent(iBin);
double binError = histogram->GetBinError(iBin);
double binWidth = xAxis->GetBinWidth(iBin);
histogram->SetBinContent(iBin, binContent/binWidth);
histogram->SetBinError(iBin, binError/binWidth);
}
}
void dumpHistogram(TH1* histogram)
{
std::cout << "<dumpHistogram>:" << std::endl;
std::cout << " histogram: name = " << histogram->GetName() << ", title = " << histogram->GetTitle() << std::endl;
std::cout << " fillColor = " << histogram->GetFillColor() << ", fillStyle = " << histogram->GetFillStyle() << ","
<< " lineColor = " << histogram->GetLineColor() << ", lineStyle = " << histogram->GetLineStyle() << ", lineWidth = " << histogram->GetLineWidth() << ","
<< " markerColor = " << histogram->GetMarkerColor() << ", markerStyle = " << histogram->GetMarkerStyle() << ", markerSize = " << histogram->GetMarkerSize() << std::endl;
TAxis* xAxis = histogram->GetXaxis();
int numBins = xAxis->GetNbins();
for ( int iBin = 1; iBin <= numBins; ++iBin ) {
std::cout << "bin #" << iBin << " (x = " << xAxis->GetBinCenter(iBin) << "): " << histogram->GetBinContent(iBin) << " +/- " << histogram->GetBinError(iBin) << std::endl;
}
std::cout << "integral = " << compIntegral(histogram, true, true) << std::endl;
}
TH1* divideHistogramByBinWidth(TH1* histogram)
{
std::string histogramDensityName = Form("%s_density", histogram->GetName());
TH1* histogramDensity = (TH1*)histogram->Clone(histogramDensityName.data());
TAxis* xAxis = histogram->GetXaxis();
int numBins = xAxis->GetNbins();
for ( int iBin = 1; iBin <= numBins; ++iBin ) {
double binContent = histogram->GetBinContent(iBin);
double binError = histogram->GetBinError(iBin);
double binWidth = xAxis->GetBinWidth(iBin);
histogramDensity->SetBinContent(iBin, binContent/binWidth);
histogramDensity->SetBinError(iBin, binError/binWidth);
}
return histogramDensity;
}
void findFilterEnergyLoss::BinLogY(TH2 *h) {
TAxis *axis = h->GetYaxis();
int bins = axis->GetNbins();
Axis_t from = axis->GetXmin();
Axis_t to = axis->GetXmax();
Axis_t width = (to - from) / bins;
Axis_t *new_bins = new Axis_t[bins+1];
for (int i=0; i <= bins; i++) {
new_bins[i] = TMath::Power(10, from + i * width);
}
axis->Set(bins, new_bins);
delete new_bins;
}
void printStat(const char* fl)
{
printf("Stat for %s\n",fl);
TFile* ff = TFile::Open(fl);
TList* lst = (TList*)ff->Get("clist");
if (!lst) {printf("no clist\n");return;}
TH1* hstat = (TH1*)lst->FindObject("stat");
if (!hstat) {printf("no hstat\n");return;}
//
TAxis* ax = hstat->GetXaxis();
for (int ib=1;ib<ax->GetNbins();ib++) {
double val = hstat->GetBinContent(ib);
if (val) printf("%-20s\t%9d\n",ax->GetBinLabel(ib),int(val));
}
ff->Close();
delete ff;
return;
}
//________________________________________________________________
void KVCanvas::DynamicZoom(Int_t Sign, Int_t px, Int_t py)
{
// Zoom in or out of histogram with mouse wheel
// Info("DynamicZoom","px=%d py=%d",px,py);
if (!fSelected) return;
TH2* TheHisto = (TH2*) FindHisto();//fSelected;
Double_t percent = 0.15 - Sign * 0.05;
Int_t dX = 0;
Int_t dY = 0;
Double_t ppx = AbsPixeltoX(px);
Double_t ppy = AbsPixeltoY(py);
TAxis* ax = TheHisto->GetXaxis();
Int_t NbinsXtmp = ax->GetNbins();
Int_t X0tmp = ax->GetFirst();
Int_t X1tmp = ax->GetLast();
Int_t step = TMath::Min(TMath::Max(1, (Int_t)(percent * (X1tmp - X0tmp))), NbinsXtmp / 2);
step *= Sign;
X0tmp = TMath::Min(TMath::Max(X0tmp + step, 1), X1tmp - step);
X1tmp = TMath::Max(TMath::Min(X1tmp - step, NbinsXtmp), X0tmp);
if (X0tmp >= X1tmp) X0tmp = X1tmp - 1;
if (Sign > 0) dX = (Int_t)(X0tmp + (X1tmp - X0tmp) * 0.5 - ax->FindBin(ppx));
if ((X0tmp - dX) < 0) ax->SetRange(0, X1tmp - X0tmp);
else if ((X1tmp - dX) > ax->GetNbins()) ax->SetRange(ax->GetNbins() - (X1tmp - X0tmp), ax->GetNbins());
else ax->SetRange(X0tmp - dX, X1tmp - dX);
ax = TheHisto->GetYaxis();
Int_t NbinsYtmp = ax->GetNbins();
Int_t Y0tmp = ax->GetFirst();
Int_t Y1tmp = ax->GetLast();
step = TMath::Min(TMath::Max(1, (Int_t)(percent * (Y1tmp - Y0tmp))), NbinsYtmp / 2);
step *= Sign;
Y0tmp = TMath::Min(TMath::Max(Y0tmp + step, 1), Y1tmp - step);
Y1tmp = TMath::Max(TMath::Min(Y1tmp - step, NbinsYtmp), Y0tmp);
if (Y0tmp >= Y1tmp) Y0tmp = Y1tmp - 1;
if (Sign > 0) dY = (Int_t)(Y0tmp + (Y1tmp - Y0tmp) * 0.5 - ax->FindBin(ppy));
if ((Y0tmp - dY) < 0) ax->SetRange(0, Y1tmp - Y0tmp);
else if ((Y1tmp - dY) > ax->GetNbins()) ax->SetRange(ax->GetNbins() - (Y1tmp - Y0tmp), ax->GetNbins());
else ax->SetRange(Y0tmp - dY, Y1tmp - dY);
Modified();
Update();
return;
}
void th22mama(TH2* m, const char* filename, const char* comment="none")
{
char tmp[128];
time_t now = time(0);
strftime(tmp, sizeof(tmp), "%Y-%m-%d %T", localtime(&now)); // not the 23-Mar-07 16:02:34 format
TAxis *xax = m->GetXaxis(), *yax = m->GetYaxis();
const int nx = std::min(xax->GetNbins(), 2048);
const int ny = yax->GetNbins();
std::cout << "matrix is " << nx << 'x' << ny << "; comment='" << comment << "'" << std::endl;
std::ofstream mama(filename);
mama << "!FILE=Disk \n"
"!KIND=Matrix \n"
"!LABORATORY=Oslo Cyclotron Laboratory (OCL) \n"
"!EXPERIMENT=siri2root \n"
"!COMMENT=" << comment << "\n"
"!TIME=" << tmp << "\n"
"!CALIBRATION EkeV=6";
const float cal[6] = { xax->GetBinLowEdge(1), xax->GetBinWidth(1), 0,
yax->GetBinLowEdge(1), yax->GetBinWidth(1), 0 };
for(int i=0; i<6; ++i) {
snprintf(tmp, sizeof(tmp), ",%13.6E", cal[i]);
mama << tmp;
}
mama << "\n!PRECISION=16\n";
snprintf(tmp, sizeof(tmp), "!DIMENSION=2,0:%4d,0:%4d\n", nx-1, ny-1);
mama << tmp;
snprintf(tmp, sizeof(tmp), "!CHANNEL=(0:%4d,0:%4d)\n", nx-1, ny-1);
mama << tmp;
for(int iy=1; iy<=ny; ++iy) {
for(int ix=1; ix<=nx; ++ix)
mama << m->GetBinContent(ix, iy) << ' ';
mama << "\n";
}
mama << "!IDEND=" << endl << endl;
mama.close();
}
void BinLogAxis(const TH1 *h)
{
//
// Method for the correct logarithmic binning of histograms
//
TAxis *axis = const_cast<TAxis*>(h->GetXaxis());
const Int_t bins = axis->GetNbins();
const Double_t from = axis->GetXmin();
const Double_t to = axis->GetXmax();
Double_t *newBins = new Double_t[bins + 1];
newBins[0] = from;
Double_t factor = pow(to / from, 1. / bins);
for (Int_t i = 1; i <= bins; i++) {
newBins[i] = factor * newBins[i - 1];
}
axis->Set(bins, newBins);
delete [] newBins;
}
void fillHistograms(double mvaOutput, double pt, double eta, double Nvtx, double evtWeight)
{
histogramPt_denominator_->Fill(pt, evtWeight);
histogramEta_denominator_->Fill(eta, evtWeight);
histogramNvtx_denominator_->Fill(Nvtx, evtWeight);
bool passesCuts = (mvaOutput > mvaCut_);
//std::cout << "passesCuts = " << passesCuts << std::endl;
if ( passesCuts ) {
histogramPt_numerator_->Fill(pt, evtWeight);
histogramEta_numerator_->Fill(eta, evtWeight);
histogramNvtx_numerator_->Fill(Nvtx, evtWeight);
}
double y = mvaOutput;
TAxis* yAxis = histogramMVAoutput_vs_Pt_->GetYaxis();
int binY = yAxis->FindBin(y);
int numBinsY = yAxis->GetNbins();
if ( binY < 1 ) binY = 1;
if ( binY > numBinsY ) binY = numBinsY;
double yWithinRange = yAxis->GetBinCenter(binY);
histogramMVAoutput_vs_Pt_->Fill(pt, y, evtWeight);
histogramPt_->Fill(pt, evtWeight);
}
TH1* VariableSizeRebin(TH1* inhisto, unsigned int nbinsx,
double *xbins, TString axisname="x",
TString newhistoname="newhist")
{
if ( nbinsx == 0 ) {
cout << "Error! nbinsx must be non-zero." << endl; return 0; }
if ( inhisto == 0 ) {
cout << "Error! Input histogram pointer is null." << endl; return 0; }
if ( axisname == "y" && !inhisto->InheritsFrom("TH2") ) {
cout << "No y-axis defined for " << inhisto->GetName() << endl; return 0; }
if ( newhistoname == "" ) {
cout << "Error! Output histogram name is null."<< endl; return 0; }
double *edgeArr = new double[nbinsx+2]; // an extra bin for safety
TAxis *axis = (axisname=="y" ? inhisto->GetYaxis() : inhisto->GetXaxis());
unsigned int nbins = 0; // number of bins for the new histogram
unsigned int j = 0; // dummy bin index (to be used as a pointer)
for ( unsigned int i=0; i<=axis->GetNbins()+1; ++i ) {
if ( j > nbinsx ) break;
double ble = axis->GetBinLowEdge(i);
if ( xbins[j] > ble ) continue;
edgeArr[nbins] = ble; j++; nbins++;
if ( xbins[j-1] < ble ) {
cout << "Warning! Bin edge at " << xbins[j-1] << " does not align with"
<< " input histo. Realigning at " << ble << ".\n";
// check if the upcoming bin edges become obsolete after realigning.
while ( j<=nbinsx && xbins[j] <= ble ) j++;
}
}
// if we finished the loop normally, ie. not 'break'ing out, it must be
// that the input histogram xrange is shorter than what the new binning
// tried to get. So handle that.
if ( j <= nbinsx ) {
double xmax = axis->GetBinLowEdge(axis->GetNbins()+1);
if ( xmax>edgeArr[nbins-1] ) {
edgeArr[nbins]=xmax;
cout << "Warning! Input histo reached max value of its x-range. "
<< "Last bin to be closed at " << edgeArr[nbins] << "." << endl;
nbins++; }
}
// we go out of the loop when index j overshoots. So our nbins is
// always one more than actual number of bins. Fix that.
nbins--;
if ( nbinsx != nbins )
cout << "Warning! nbinsx set to " << nbins
<< " instead of " << nbinsx << "." << endl;
//for ( unsigned int i=0; i<=nbins; i++ )
// cout << "For bin " << i+1 << "\tlowedge= " << edgeArr[i] << endl;
// Now generate the new histogram
TH1 *newhist = 0;
if ( !inhisto->InheritsFrom("TH2") )
newhist = inhisto->Rebin(nbins,newhistoname.Data(),edgeArr);
else {
// Copy the perpendicular axis as it is.
TAxis *axisp = (axisname=="y" ? inhisto->GetXaxis() : inhisto->GetYaxis());
unsigned int nbinsp = axisp->GetNbins();
double *edgeArrp = new double[nbinsp+1];
for ( unsigned int i=1; i<=nbinsp+1; ++i )
edgeArrp[i] = axisp->GetBinLowEdge(i);
if ( axisname == "y" ) {
if ( axisp->IsVariableBinSize() )
newhist = new TH2D(newhistoname, inhisto->GetTitle(),
nbinsp, edgeArrp, nbins, edgeArr);
else
newhist = new TH2D(newhistoname, inhisto->GetTitle(),
nbinsp, edgeArrp[0], edgeArrp[nbinsp+1],
nbins, edgeArr);
if ( axisp->GetLabels() )
for ( unsigned int i=1; i<=nbinsp; ++i )
newhist->GetXaxis()->SetBinLabel(i, axisp->GetBinLabel(i));
}
else
// ToDo: Have not yet implemented the above nice stuff for axisname=="x"
newhist = new TH2D(newhistoname, inhisto->GetTitle(),
nbins, edgeArr, nbinsp, edgeArrp);
newhist->GetYaxis()->SetTitle(inhisto->GetYaxis()->GetTitle());
newhist->GetXaxis()->SetTitle(inhisto->GetXaxis()->GetTitle());
bool sw2 = ( inhisto->GetSumw2N() != 0 );
// Fill the new histogram from the input histogram
j=0; // reset the dummy bin index
for ( unsigned int i=0; i<=axis->GetNbins()+1; ++i ) {
double ble = axis->GetBinLowEdge(i);
if ( edgeArr[j] == ble ) j++;
for ( unsigned int k=0; k<=nbinsp+1; ++k ) {
int newbin(0), oldbin(0);
// Equivalent 1D bin number = binx + (fXaxis.GetNbins()+2)*biny
if ( axisname == "y" ) {
newbin = k+j*(nbinsp+2); oldbin = k+i*(nbinsp+2); }
else {
newbin = j+k*(nbins+2); oldbin = i+k*(axis->GetNbins()+2); }
newhist->SetBinContent( newbin, newhist->GetBinContent(newbin)
+ inhisto->GetBinContent(oldbin) );
if ( sw2 )
newhist->SetBinError( newbin,
sqrt(pow(newhist->GetBinError(newbin),2) +
pow(inhisto->GetBinError(oldbin),2)) );
}
}
newhist->SetEntries(inhisto->GetEntries());
}
//newhist->Draw();
delete [] edgeArr;
return newhist;
}
//______________________________________________________________________________
void KVCanvas::HandleInput(EEventType event, Int_t px, Int_t py)
{
// Handle Input Events.
//
// Handle input events, like button up/down in current canvas.
if (fFreezed) return;
TPad* pad;
TPad* prevSelPad = (TPad*) fSelectedPad;
TObject* prevSelObj = fSelected;
fPadSave = (TPad*)gPad;
cd(); // make sure this canvas is the current canvas
fEvent = event;
fEventX = px;
fEventY = py;
Int_t sign = 0;
Bool_t sendOrder = true;
if (fHasDisabledClasses && fSelected) {
if (fDisabledClasses.Contains(fSelected->ClassName())) sendOrder = false;
}
if (fHasDisabledObject && fSelected) {
if (fDisabledObjects.Contains(fSelected)) sendOrder = false;
}
switch (event) {
case kMouseMotion:
// highlight object tracked over
pad = Pick(px, py, prevSelObj);
if (!pad) return;
EnterLeave(prevSelPad, prevSelObj);
gPad = pad; // don't use cd() we will use the current
// canvas via the GetCanvas member and not via
// gPad->GetCanvas
if (sendOrder) fSelected->ExecuteEvent(event, px, py);
RunAutoExec();
if (fAgeOfEmpire && (fSelected->InheritsFrom("TH2"))) {
TH2* TheHisto = (TH2*) FindHisto();//fSelected;
Double_t size = 0.4 - 0.35 * fVenerMode;
Int_t dX = 0;
Int_t dY = 0;
Double_t ppx = AbsPixeltoX(px);
Double_t ppy = AbsPixeltoY(py);
TAxis* ax = TheHisto->GetXaxis();
Int_t X0 = ax->GetFirst();
Int_t X1 = ax->GetLast();
Int_t NbinsX = ax->GetNbins();
px = ax->FindBin(ppx);
Double_t ddX = (X1 + X0) * 0.5 - px;
Double_t distX = TMath::Abs(ddX) / (X1 - X0);
if (distX >= 0.5) return;
TAxis* ay = TheHisto->GetYaxis();
Int_t Y0 = ay->GetFirst();
Int_t Y1 = ay->GetLast();
Int_t NbinsY = ay->GetNbins();
py = ay->FindBin(ppy);
Double_t ddY = (Y1 + Y0) * 0.5 - py;
Double_t distY = TMath::Abs(ddY) / (Y1 - Y0);
if (distY >= 0.5) return;
if ((distX <= size) && (distY <= size)) return;
dX = TMath::Nint(ddX * (0.05 + 0.05 * fVenerMode));
dY = TMath::Nint(ddY * (0.05 + 0.05 * fVenerMode));
if (TMath::Abs(dX) < 1) dX = TMath::Sign(1., ddX);
if (TMath::Abs(dY) < 1) dY = TMath::Sign(1., ddY);
Bool_t up = false;
if ((X0 - dX > 0) && (X1 - dX < NbinsX)) {
ax->SetRange(X0 - dX, X1 - dX);
up = true;
}
if ((Y0 - dY > 0) && (Y1 - dY < NbinsY)) {
ay->SetRange(Y0 - dY, Y1 - dY);
up = true;
}
if (up) {
Modified();
Update();
}
}
break;
case kMouseEnter:
// mouse enters canvas
if (!fDoubleBuffer) FeedbackMode(kTRUE);
break;
case kMouseLeave:
// mouse leaves canvas
{
// force popdown of tooltips
TObject* sobj = fSelected;
TPad* spad = fSelectedPad;
fSelected = 0;
fSelectedPad = 0;
EnterLeave(prevSelPad, prevSelObj);
fSelected = sobj;
fSelectedPad = spad;
if (!fDoubleBuffer) FeedbackMode(kFALSE);
}
break;
case kButton1Double:
// triggered on the second button down within 350ms and within
// 3x3 pixels of the first button down, button up finishes action
case kButton1Down:
// find pad in which input occured
pad = Pick(px, py, prevSelObj);
if (!pad) return;
gPad = pad; // don't use cd() because we won't draw in pad
// we will only use its coordinate system
if (fSelected) {
FeedbackMode(kTRUE); // to draw in rubberband mode
fSelected->ExecuteEvent(event, px, py);
RunAutoExec();
if (fSelected->InheritsFrom("TH2")) {
oldx = GetEventX();
oldy = GetEventY();
xmin = AbsPixeltoX(oldx);
ymin = AbsPixeltoY(oldy);
gVirtualX->DrawBox(XtoAbsPixel(xmin), YtoAbsPixel(ymin), oldx, oldy, TVirtualX::kHollow);
}
}
break;
case kButton1Motion:
if (fSelected) {
if (fSelected->InheritsFrom("TH2")) {
gVirtualX->DrawBox(XtoAbsPixel(xmin), YtoAbsPixel(ymin), oldx, oldy, TVirtualX::kHollow);
oldx = GetEventX();
oldy = GetEventY();
gVirtualX->DrawBox(XtoAbsPixel(xmin), YtoAbsPixel(ymin), oldx, oldy, TVirtualX::kHollow);
moved = true;
}
}
case kButton1ShiftMotion: //8 == kButton1Motion + shift modifier
if (fSelected) {
gPad = fSelectedPad;
if (sendOrder) fSelected->ExecuteEvent(event, px, py);
gVirtualX->Update();
if (!fSelected->InheritsFrom(TAxis::Class())) {
Bool_t resize = kFALSE;
if (fSelected->InheritsFrom(TBox::Class()))
resize = ((TBox*)fSelected)->IsBeingResized();
if (fSelected->InheritsFrom(TVirtualPad::Class()))
resize = ((TVirtualPad*)fSelected)->IsBeingResized();
if ((!resize && TestBit(kMoveOpaque)) || (resize && TestBit(kResizeOpaque))) {
gPad = fPadSave;
Update();
FeedbackMode(kTRUE);
}
}
RunAutoExec();
}
break;
case kButton1Up:
if (fSelected) {
gPad = fSelectedPad;
if (sendOrder) fSelected->ExecuteEvent(event, px, py);
RunAutoExec();
if (fPadSave)
gPad = fPadSave;
else {
gPad = this;
fPadSave = this;
}
if (fSelected->InheritsFrom("TH2") && moved && !fSelected->InheritsFrom("TH3")) {
xmax = AbsPixeltoX(GetEventX());
ymax = AbsPixeltoY(GetEventY());
Double_t toto = 0;
if (xmax < xmin) {
toto = xmax;
xmax = xmin;
xmin = toto;
}
if (ymax < ymin) {
toto = ymax;
ymax = ymin;
ymin = toto;
}
ZoomSelected((TH2*)FindHisto());
// ZoomSelected((TH2*)fSelected);
moved = false;
}
Update(); // before calling update make sure gPad is reset
}
break;
//*-*----------------------------------------------------------------------
case kButton2Down:
// find pad in which input occured
pad = Pick(px, py, prevSelObj);
if (!pad) return;
gPad = pad; // don't use cd() because we won't draw in pad
// we will only use its coordinate system
FeedbackMode(kTRUE);
if (!fSelected->InheritsFrom("TH1")) fSelected->Pop(); // pop object to foreground
pad->cd(); // and make its pad the current pad
if (fSelected->InheritsFrom("TH2") && !fSelected->InheritsFrom("TH3")) {
// implement pan & scan
X0 = px;
Y0 = py; // u clikd here
theXaxis = ((TH2*)FindHisto())->GetXaxis();
theYaxis = ((TH2*)FindHisto())->GetYaxis();
NXbins = theXaxis->GetNbins(); // maximum bin number in X
NYbins = theYaxis->GetNbins(); // maximum bin number in Y
Xf1 = Xfirst0 = theXaxis->GetFirst(); // initial displayed bin range in X
Xl1 = Xlast0 = theXaxis->GetLast();
Yf1 = Yfirst0 = theYaxis->GetFirst(); // initial displayed bin range in Y
Yl1 = Ylast0 = theYaxis->GetLast();
// size of axes in pixels
Int_t pixelWidthX = gPad->XtoAbsPixel(gPad->GetUxmax()) - gPad->XtoAbsPixel(gPad->GetUxmin());
Int_t pixelWidthY = gPad->YtoAbsPixel(gPad->GetUymax()) - gPad->YtoAbsPixel(gPad->GetUymin());
// sizes of bins in pixels
NdisXbins = Xlast0 - Xfirst0 + 1;
NdisYbins = Ylast0 - Yfirst0 + 1;
XbinPixel = pixelWidthX / (1.0 * NdisXbins);
YbinPixel = pixelWidthY / (1.0 * NdisYbins);
}
if (gDebug)
printf("Current Pad: %s / %s\n", pad->GetName(), pad->GetTitle());
// loop over all canvases to make sure that only one pad is highlighted
{
TIter next(gROOT->GetListOfCanvases());
TCanvas* tc;
while ((tc = (TCanvas*)next()))
tc->Update();
}
/*if (pad->GetGLDevice() != -1 && fSelected)
fSelected->ExecuteEvent(event, px, py);*/
break; // don't want fPadSave->cd() to be executed at the end
case kButton2Motion:
//was empty!
if (fSelected && fSelected->InheritsFrom("TH2") && !fSelected->InheritsFrom("TH3")) {
// implement pan & scan
Int_t dX = px - X0; // how far have i moved ?
Int_t dY = py - Y0;
Int_t dXbins = dX / XbinPixel;
Int_t dYbins = dY / YbinPixel;
Bool_t changed = kFALSE;
Int_t newXfirst = Xfirst0 - dXbins;
Int_t newXlast;
if (newXfirst < 1) {
newXfirst = 1;
newXlast = NdisXbins;
} else {
newXlast = Xlast0 - dXbins;
if (newXlast > NXbins) {
newXlast = NXbins;
newXfirst = newXlast - NdisXbins + 1;
}
}
if (newXfirst != Xf1) {
Xf1 = newXfirst;
Xl1 = newXlast;
theXaxis->SetRange(Xf1, Xl1);
changed = kTRUE;
}
Int_t newYfirst = Yfirst0 - dYbins;
Int_t newYlast;
if (newYfirst < 1) {
newYfirst = 1;
newYlast = NdisYbins;
} else {
newYlast = Ylast0 - dYbins;
if (newYlast > NYbins) {
newYlast = NYbins;
newYfirst = newYlast - NdisYbins + 1;
}
}
if (newYfirst != Yf1) {
Yf1 = newYfirst;
Yl1 = newYlast;
theYaxis->SetRange(Yf1, Yl1);
changed = kTRUE;
}
if (changed) {
Modified();
Update();
}
}
case kButton2Up:
if (fSelected) {
gPad = fSelectedPad;
if (sendOrder) fSelected->ExecuteEvent(event, px, py);
RunAutoExec();
}
break;
case kButton2Double:
break;
//*-*----------------------------------------------------------------------
case kButton3Down:
// popup context menu
pad = Pick(px, py, prevSelObj);
if (!pad) return;
if (!fDoubleBuffer) FeedbackMode(kFALSE);
if (fContextMenu && !fSelected->TestBit(kNoContextMenu) && !pad->TestBit(kNoContextMenu) && !TestBit(kNoContextMenu)) {
if (sendOrder) fContextMenu->Popup(px, py, fSelected, this, pad);
else fSelected->ExecuteEvent(event, px, py);
}
break;
case kButton3Motion:
break;
case kButton3Up:
if (!fDoubleBuffer) FeedbackMode(kTRUE);
break;
case kButton3Double:
break;
case kKeyDown:
// Info("HandleInput","Key down: %d %d",px,py);
break;
case kKeyUp:
// Info("HandleInput","Key up: %d %d",px,py);
break;
case kKeyPress:
if (!fSelectedPad || !fSelected) return;
gPad = fSelectedPad; // don't use cd() because we won't draw in pad
// we will only use its coordinate system
fSelected->ExecuteEvent(event, px, py);
HandleKey(px, py);
RunAutoExec();
break;
case kButton1Shift:
// Try to select
pad = Pick(px, py, prevSelObj);
if (!pad) return;
EnterLeave(prevSelPad, prevSelObj);
gPad = pad; // don't use cd() we will use the current
// canvas via the GetCanvas member and not via
// gPad->GetCanvas
fSelected->ExecuteEvent(event, px, py);
RunAutoExec();
break;
case kWheelUp:
case kWheelDown:
pad = Pick(px, py, prevSelObj);
if (!pad) return;
sign = (event == kWheelUp ? 1 : -1);
gPad = pad;
if (fSelected->InheritsFrom("TAxis")) fSelected->ExecuteEvent(event, px, py);
else if (fSelected->InheritsFrom("TH2")) DynamicZoom(sign, px, py);
RunAutoExec();
break;
default:
break;
}
if (fPadSave && event != kButton2Down)
fPadSave->cd();
if (event != kMouseLeave) { // signal was already emitted for this event
ProcessedEvent(event, px, py, fSelected); // emit signal
DrawEventStatus(event, px, py, fSelected);
}
}
void RebinProfile(){
f = new TFile("../../../rootfiles/MC/EPOS_PbPb_Ntrk_0.root");
TH2D* h2;
h2 = (TH2D*)f->Get("demo/scatterHist_effcorr");
TCanvas* C = new TCanvas("fitscatterplot","EPOS Hydjet Scatterplot",1800,1200);
C->Divide(3,2);
C->cd(1);
double newbins[8] = {-0.3,-0.075,-0.045,-0.015,0.015,0.045,0.075,0.3};
//double newbins[6] = {-0.3,-0.045,-0.015,0.015,0.045,0.3};
TH2D* hnew = new TH2D("rebin","rebin",7,newbins,1000,-0.3,0.3);
TAxis *xaxis = h2->GetXaxis();
TAxis *yaxis = h2->GetYaxis();
for (int k=1; k<=yaxis->GetNbins();k++) {
for (int l=1; l<=xaxis->GetNbins();l++) {
hnew->Fill(xaxis->GetBinCenter(l),yaxis->GetBinCenter(k),h2->GetBinContent(l,k));
}
}
TProfile *prof = hnew->ProfileX();
TF1* fit1 = new TF1("Linear fitting case 1", "[0]+x*[1]", -0.2, 0.2);
fit1->SetLineColor(kBlue);
fit1->SetLineStyle(1);
fit1->SetLineWidth(3);
prof->Fit(fit1,"RN0");
TLatex* text2 = makeLatex(Form("slope : %.3f #pm %.3f",fit1->GetParameter(1),fit1->GetParError(1)),0.55,0.25) ;
prof->Draw();
text2->Draw("same");
fit1->Draw("same");
/*
for (Int_t i=0;i<2;i++) {
for (Int_t j=0;j<3;j++) {
h = (TH2D*)f->Get("demo/scatterHist_noeffcorr");
h -> new TH2D(" ");
corrTable[oc]->SetBinContent(eta+1, pt+1, c);
double c1 = testload.getWeight(ptbins[pt], etabins[eta], ocbin[oc], "eff");
double c2 = testload.getWeight(ptbins[pt], etabins[eta], ocbin[oc], "fak");
double c = c1/(1-c2);
if( oc == 0 && eta == 15 && pt == 20 ) cout << "1: " << c << endl;
if( oc == 4 && eta == 15 && pt == 20 ) cout << "4: " << c << endl;
//cout << "corr factor: " << c << endl;
corrTable[oc]->SetBinContent(eta+1, pt+1, c);
c = c1/(1-c2);
c2 = c3/(1-c1);
c4 = c2/(1-c3);
c5 = c6/(1-c7);
*/
}
TGraphAsymmErrors* getEfficiency(const TH1* histogram_numerator, const TH1* histogram_denominator)
{
Int_t error = 0;
if ( !(histogram_numerator->GetNbinsX() == histogram_denominator->GetNbinsX()) ) error = 1;
if ( !(histogram_numerator->GetXaxis()->GetXmin() == histogram_denominator->GetXaxis()->GetXmin()) ) error = 1;
if ( !(histogram_numerator->GetXaxis()->GetXmax() == histogram_denominator->GetXaxis()->GetXmax()) ) error = 1;
if ( error ){
std::cerr << "Error in <getEfficiency>: Dimensionality of histograms does not match !!" << std::endl;
return 0;
}
TAxis* xAxis = histogram_numerator->GetXaxis();
Int_t nBins = xAxis->GetNbins();
TArrayF x(nBins);
TArrayF dxUp(nBins);
TArrayF dxDown(nBins);
TArrayF y(nBins);
TArrayF dyUp(nBins);
TArrayF dyDown(nBins);
for ( Int_t ibin = 1; ibin <= nBins; ibin++ ){
Int_t nObs = TMath::Nint(histogram_denominator->GetBinContent(ibin));
Int_t rObs = TMath::Nint(histogram_numerator->GetBinContent(ibin));
Float_t xCenter = histogram_denominator->GetBinCenter(ibin);
Float_t xWidth = histogram_denominator->GetBinWidth(ibin);
x[ibin - 1] = xCenter;
dxUp[ibin - 1] = 0.5*xWidth;
dxDown[ibin - 1] = 0.5*xWidth;
if ( nObs > 0 ){
Float_t rMin = 0.;
Float_t rMax = 0.;
getBinomialBounds(nObs, rObs, rMin, rMax);
y[ibin - 1] = rObs/((Float_t)nObs);
dyUp[ibin - 1] = (rMax - rObs)/((Float_t)nObs);
dyDown[ibin - 1] = (rObs - rMin)/((Float_t)nObs);
} else{
y[ibin - 1] = 0.;
dyUp[ibin - 1] = 0.;
dyDown[ibin - 1] = 0.;
}
}
TString name = TString(histogram_numerator->GetName()).Append("Graph");
TString title = histogram_numerator->GetTitle();
TGraphAsymmErrors* graph =
new TGraphAsymmErrors(nBins, x.GetArray(), y.GetArray(),
dxDown.GetArray(), dxUp.GetArray(), dyDown.GetArray(), dyUp.GetArray());
graph->SetName(name);
graph->SetTitle(title);
return graph;
}
//void pi0_mfitpeak(char *FileName, char *HistName, Int_t etapi0flag)
void pi0_mfitpeak(TH1F *mh1, Int_t etapi0flag, float xmin, float xmax, int npol,float res[],int posFlag, const char *dirName, const char *histName, float text_x, float text_y, const char *texName)
{
TGaxis::SetMaxDigits(3);
// TVirtualFitter::SetDefaultFitter("Minuit");
// This script attempts to fit any pi0 peak so that the freaking fit function would converge
// currently background is fitted to a pol4 function and the peak by a gaussian;
// results are not very nice
// usage .x pi0_mfitpeak.C++ ("pi0calib.root","minv_spb")
// or eg. .x pi0_mfitpeak.C ("../pi0anal/pi0ana_punorm.root","minv_spb",0)
gROOT->Reset();
// gStyle->SetOptFit();
// gStyle->SetOptFit(0);
// gStyle->SetOptStat(0);
// gStyle->SetOptTitle(0);
Bool_t NOTE=1;
if(NOTE) gStyle->SetCanvasBorderMode(0);
gStyle->SetPadTopMargin(0.08);
gStyle->SetPadBottomMargin(0.12);
gStyle->SetPadLeftMargin(0.15);
gStyle->SetPadRightMargin(0.08);
mh1->GetXaxis()->SetRangeUser(xmin,xmax);
Int_t highx=500;
TCanvas *c2 = new TCanvas("c2","",200,10,highx,500);
// cout<<FileName<<" "<<HistName<<endl;
// TFile f(FileName);
// TH1F *mh1 = (TH1F*) f.Get(HistName);
mh1->SetMarkerStyle(20);
mh1->SetMarkerSize(1.);
mh1->SetStats(0); // 1/0 to set the stat box
mh1->GetXaxis()->SetTitle("Invariant Mass of Photon Pairs (GeV/c^{2})");
float binwidth = mh1->GetBinWidth(1);
char *ytitle = new char[100];
sprintf(ytitle,"Photon Pairs / %4.3f GeV/c^{2}",binwidth);
mh1->GetYaxis()->SetTitle(ytitle);
mh1->GetXaxis()->SetTitleSize(0.055);
mh1->GetYaxis()->SetTitleSize(0.055);
mh1->GetXaxis()->SetLabelSize(0.045);
mh1->GetYaxis()->SetLabelSize(0.045);
mh1->GetXaxis()->SetTitleOffset(0.90);
mh1->GetXaxis()->CenterTitle();
mh1->GetYaxis()->SetTitleOffset(1.32);
// First work with the histogram and find the peak and fit ranges
TAxis *xaxis = mh1->GetXaxis();
Float_t binsiz= xaxis->GetBinCenter(3) - xaxis->GetBinCenter(2);
Int_t nbins = xaxis->GetNbins();
Float_t nevtperbin0[10000];
Float_t errorbin0[10000];
Float_t nevttot;
Float_t maxbin=0; Int_t nmaxbin=0, nminbord=0, nmaxbord=nbins;
for (Int_t nn=1; nn <= nbins; nn++)
{
nevtperbin0[nn] = mh1->GetBinContent(nn);
if(nevtperbin0[nn] > maxbin) { maxbin=nevtperbin0[nn]; nmaxbin=nn; }
errorbin0[nn] = mh1->GetBinError(nn);
nevttot+=nevtperbin0[nn];
if(nevtperbin0[nn] > 0 && nminbord == 0) nminbord=nn;
if(nevtperbin0[nn] == 0 && (nn > nminbord +10) && nmaxbord==0 && nminbord > 0) nmaxbord=nn;
}
cout<<"Minbordl "<<nminbord<<" with events: "<<nevtperbin0[nminbord]<<endl;
cout<<"Maxbordl "<<nmaxbord<<" with events: "<<nevtperbin0[nmaxbord]<<endl;
nminbord+=0;
nmaxbord-=0;
Int_t nmin0=nminbord;
while(nevtperbin0[nminbord] < nevtperbin0[nmaxbin]*0.025) nminbord++;
while(nevtperbin0[nmaxbord] < nevtperbin0[nmaxbin]*0.025) nmaxbord--;
// the above was just to get the info and low/high bins
// Set the fit range ! This is for total fit !
Float_t fitl=xmin;
float fith=xmax;
// Float_t fitl=0.07, fith=0.2;// this works better for pileup
// Float_t fitl=0.08, fith=0.18;// this works even better for pileup
// if(etapi0flag == 1)
// {
// fitl=0.35; fith=0.75;
//}
// if(fitl < xaxis->GetBinCenter(nmin0)) fitl = xaxis->GetBinCenter(nmin0);
//if(fith > xaxis->GetBinCenter(nmaxbord)) fith = xaxis->GetBinCenter(nmaxbord);
cout<<" fit range "<<fitl<<" -- "<<fith<<endl;
cout <<"Bin size "<<binsiz<<endl;
cout<<"Total events "<<nevttot<<endl;
cout<<"MaxBin "<<nmaxbin<<" with events: "<<nevtperbin0[nmaxbin]<<endl;
cout<<"Minbord "<<nminbord<<" with events: "<<nevtperbin0[nminbord]<<endl;
cout<<"Maxbord "<<nmaxbord<<" with events: "<<nevtperbin0[nmaxbord]<<endl;
mh1->DrawCopy("sep");
Float_t lowgauss=0.135-4.*0.010;
Float_t highgauss=0.135+4.*0.010;
if(etapi0flag == 1)
{
lowgauss=0.55-5.*0.025;
highgauss=0.55+5.*0.025;
}
Int_t nlowgauss=Int_t((lowgauss-xaxis->GetBinCenter(1))/Float_t(binsiz)+0.5);
Int_t nhighgauss=Int_t((highgauss-xaxis->GetBinCenter(1))/Float_t(binsiz)+0.5);
cout <<xaxis->GetBinCenter(nlowgauss)<<" "<<xaxis->GetBinCenter(nhighgauss)<<endl;
// now make the "background" histogram and fit it with p4
Float_t lowvalgauss=nevtperbin0[nlowgauss];
Float_t increm=(nevtperbin0[nhighgauss]-nevtperbin0[nlowgauss])/Float_t(nhighgauss-nlowgauss);
TH1F *hbkg = (TH1F*)mh1->Clone();
hbkg->SetName("bkg_clone");
for (Int_t nn=nlowgauss; nn<=nhighgauss; nn++)
{
hbkg->SetBinContent(nn,Float_t(lowvalgauss+(nn-nlowgauss)*increm));
hbkg->SetBinError(nn,sqrt(lowvalgauss+(nn-nlowgauss)*increm));
}
hbkg->DrawCopy("samesep");
// break;
// Now define the "gaussian" histogram
TH1F *hgauss = (TH1F*)mh1->Clone();
hgauss->SetName("gauss_clone");
hgauss->Sumw2();
hgauss->Add(mh1,hbkg,1,-1); // if errors are independent Add needs to be used !
for (Int_t nn=1; nn <= nbins; nn++)
{
if(hgauss->GetBinContent(nn) < 0.) hgauss->SetBinContent(nn,0.001*nevtperbin0[nmaxbin]);
hgauss->SetBinError(nn,sqrt(hgauss->GetBinContent(nn)));
}
// Declare function with wich to fit
TF1 *g1 = new TF1("g1","gaus",lowgauss,highgauss);
hgauss->Fit(g1,"R0");
hgauss->DrawCopy("sep");
g1->Draw("same");
// break;
char *polff = new char[20];
sprintf(polff,"pol%d",npol);
TF1 *p4bkg;
if(etapi0flag != 1)
p4bkg = new TF1("pm2",polff, xaxis->GetBinCenter(nminbord),xaxis->GetBinCenter(nmaxbord));
else
p4bkg = new TF1("pm2",polff, 0.35,0.75);
hbkg->Fit(p4bkg,"R0");
hbkg->DrawCopy("sep");
p4bkg->SetLineStyle(kDashed);
p4bkg->Draw("same");
// break;
Double_t par[20],parf[20],errparf[20];
g1->GetParameters(&par[0]);
p4bkg->GetParameters(&par[3]);
char *totff = new char[20];
sprintf(totff,"gaus(0)+pol%d(3)",npol);
TF1 *total = new TF1("total",totff,fitl,fith);
TF1 *p4bkgfin = new TF1("pm2",polff,fitl,fith);
total->SetParameters(par);
if(etapi0flag==0){
total->SetParLimits(1,0.10,0.15);
total->SetParLimits(2,0.135*0.06,0.135*0.3);
}else{
total->SetParLimits(1,0.35,0.65);
}
// total->FixParameter(1,1.21340e-01);
// total->FixParameter(2,2.69780e-02);
mh1->Fit(total,"R0");
cout<<" yield.. "<< total->GetParameter(0) <<"+/- " << total->GetParError(0)<<endl;
total->GetParameters(parf);
for( Int_t nn=0; nn < 3+npol+1; nn++) errparf[nn]=total->GetParError(nn);
g1->SetParameters(&parf[0]);
p4bkgfin->SetParameters(&parf[3]);
cout <<" Piz Mass = "<<parf[1]*1000.<<" +- "<<errparf[1]*1000.<<
" Sigma ="<<parf[2]*1000.<<" +- "<<errparf[2]*1000.<<endl;
cout << " Sigma Rel. = "<< parf[2]/parf[1]<<" +- "
<< errparf[2]/parf[1] <<endl;
Float_t int_min=parf[1]-3.*parf[2];
Float_t int_max=parf[1]+3.*parf[2];
Float_t sig_peak=g1->Integral(int_min,int_max)/binsiz;
Float_t bkgd_peak=p4bkgfin->Integral(int_min,int_max)/binsiz;
cout<<" In +-3. sigma window: Signal="<<sig_peak<<" Bkgd="<<bkgd_peak<<endl;
Float_t SB=sig_peak/bkgd_peak; Float_t SBerr=SB*(sqrt(1./sig_peak+1./bkgd_peak));
cout<<" Signal/Bkgd "<<SB<<" +- "<<SBerr<<endl;
int_min=parf[1]-2.*parf[2];
int_max=parf[1]+2.*parf[2];
sig_peak=g1->Integral(int_min,int_max)/binsiz;
bkgd_peak=p4bkgfin->Integral(int_min,int_max)/binsiz;
cout<<" In +-2.sigma window: Signal="<<sig_peak<<" Bkgd="<<bkgd_peak<<endl;
SB=sig_peak/bkgd_peak; SBerr=SB*(sqrt(1./sig_peak+1./bkgd_peak));
cout<<" Signal/Bkgd "<<SB<<" +- "<<SBerr<<endl;
float S = sig_peak;
float B = bkgd_peak;
int_min=parf[1]-20.*parf[2];
int_max=parf[1]+20.*parf[2];
float S_all = g1->Integral(int_min,int_max)/binsiz;
float test_sall = parf[0] * parf[2] * sqrt(acos(-1)) / binsiz;
cout<<"signal all: "<< S_all << " "<< test_sall <<endl;
float Serr_all = errparf[0]/ parf[0] * S_all;
res[0] = S_all;
res[1] = Serr_all;
res[2] = parf[1];
res[3] = errparf[1];
res[4] = parf[2];
res[5] = errparf[2];
res[6] = SB;
res[7] = SBerr;
total->SetLineWidth(3);
total->SetLineColor(kBlue);
p4bkgfin->SetLineWidth(3);
p4bkgfin->SetLineColor(kRed);
mh1->DrawCopy("sep");
// total->SetRange(0.07,0.185);
// p4bkgfin->SetRange(0.07,0.185);
total->Draw("same");
p4bkgfin->SetLineStyle(kDashed);
p4bkgfin->Draw("same");
TLatex l;
// l.SetTextSize(0.06);
l.SetTextSize(0.05);
l.SetTextColor(1);
l.SetNDC();
float sigma = parf[2]/ parf[1]*100;
float sigmaerr = errparf[2]/ parf[1]*100;
char *sigma_name = new char[50];
if(sigmaerr>0.005)
sprintf(sigma_name,"#sigma = %3.2f #pm %3.2f %% ",sigma,sigmaerr);
else sprintf(sigma_name,"#sigma = %3.2f %% ",sigma);
if(posFlag==1){
l.DrawLatex(0.54,0.75,sigma_name);
}else if( posFlag==2){
l.DrawLatex(0.54,0.3,sigma_name);
}
// sprintf(sigma_name,"S/B = %3.2f #pm %3.2f ",SB,SBerr);
//
sprintf(sigma_name,"S = %2.1f #pm %2.1f",S_all,Serr_all);
//
// l.DrawLatex(0.5,0.5,sigma_name);
sprintf(sigma_name,"M = %3.1f #pm %3.1f MeV",parf[1]*1000.,errparf[1]*1000);
if(posFlag==1){
l.DrawLatex(0.54,0.82,sigma_name);
}else if( posFlag==2){
l.DrawLatex(0.54,0.37,sigma_name);
}
///l.DrawLatex(0.169,470.,"d)");
c2->Modified();
c2->Update();
// c2->SaveAs("nice_pi0.gif");
if( text_x >0 && text_y >0){
TLatex * tex = new TLatex(text_x, text_y, texName);
tex->SetNDC();
tex->SetTextSize(0.06);
tex->SetLineWidth(2);
tex->Draw();
}
char *filename = new char[1000];
sprintf(filename,"%s/%s.gif",dirName,histName);
c2->Print(filename);
sprintf(filename,"%s/%s.C",dirName,histName);
c2->Print(filename);
// .x pi0_mfitpeak.C ("pi0ana_508030.root","minv_spb",0)
// .x pi0_mfitpeak.C ("pi0ana_npu.root","minv_bkg",0)
// .x pi0_mfitpeak.C ("pi0ana_punormv2.root","minv_spb",0)
}
//------------------------------------------------------------------------------
//
// drawXS
//
//------------------------------------------------------------------------------
void drawXS(UInt_t theCharge = WInclusive)
{
gStyle->SetEndErrorSize(5);
// 7 TeV inclusive
//----------------------------------------------------------------------------
xs_value[WInclusive][EEE] = 23.00;
xs_value[WInclusive][EEM] = 19.67;
xs_value[WInclusive][MME] = 19.81;
xs_value[WInclusive][MMM] = 21.02;
xs_value[WInclusive][all] = 20.76;
xs_stat[WInclusive][EEE] = 3.10;
xs_stat[WInclusive][EEM] = 2.73;
xs_stat[WInclusive][MME] = 2.60;
xs_stat[WInclusive][MMM] = 2.30;
xs_stat[WInclusive][all] = 1.32;
xs_syst[WInclusive][EEE] = 1.39;
xs_syst[WInclusive][EEM] = 1.50;
xs_syst[WInclusive][MME] = 1.55;
xs_syst[WInclusive][MMM] = 1.47;
xs_syst[WInclusive][all] = 1.13;
xs_lumi[WInclusive][EEE] = 0.51;
xs_lumi[WInclusive][EEM] = 0.43;
xs_lumi[WInclusive][MME] = 0.44;
xs_lumi[WInclusive][MMM] = 0.46;
xs_lumi[WInclusive][all] = 0.46;
// 7 TeV W+
//----------------------------------------------------------------------------
xs_value[WPlus][EEE] = 13.39;
xs_value[WPlus][EEM] = 13.18;
xs_value[WPlus][MME] = 14.14;
xs_value[WPlus][MMM] = 11.43;
xs_value[WPlus][all] = 12.73;
xs_stat[WPlus][EEE] = 2.39;
xs_stat[WPlus][EEM] = 2.24;
xs_stat[WPlus][MME] = 2.19;
xs_stat[WPlus][MMM] = 1.71;
xs_stat[WPlus][all] = 1.04;
xs_syst[WPlus][EEE] = 0.75;
xs_syst[WPlus][EEM] = 0.64;
xs_syst[WPlus][MME] = 0.74;
xs_syst[WPlus][MMM] = 0.53;
xs_syst[WPlus][all] = 0.59;
xs_lumi[WPlus][EEE] = 0.29;
xs_lumi[WPlus][EEM] = 0.29;
xs_lumi[WPlus][MME] = 0.31;
xs_lumi[WPlus][MMM] = 0.25;
xs_lumi[WPlus][all] = 0.28;
// 7 TeV W-
//----------------------------------------------------------------------------
xs_value[WMinus][EEE] = 9.49;
xs_value[WMinus][EEM] = 6.51;
xs_value[WMinus][MME] = 5.73;
xs_value[WMinus][MMM] = 9.48;
xs_value[WMinus][all] = 7.46;
xs_stat[WMinus][EEE] = 1.95;
xs_stat[WMinus][EEM] = 1.58;
xs_stat[WMinus][MME] = 1.40;
xs_stat[WMinus][MMM] = 1.52;
xs_stat[WMinus][all] = 0.79;
xs_syst[WMinus][EEE] = 0.60;
xs_syst[WMinus][EEM] = 0.37;
xs_syst[WMinus][MME] = 0.37;
xs_syst[WMinus][MMM] = 0.50;
xs_syst[WMinus][all] = 0.40;
xs_lumi[WMinus][EEE] = 0.21;
xs_lumi[WMinus][EEM] = 0.14;
xs_lumi[WMinus][MME] = 0.13;
xs_lumi[WMinus][MMM] = 0.21;
xs_lumi[WMinus][all] = 0.16;
// Do the work
//----------------------------------------------------------------------------
TGraphErrors* gStat = new TGraphErrors(nChannel);
TGraphErrors* gSyst = new TGraphErrors(nChannel);
TGraphErrors* gLumi = new TGraphErrors(nChannel);
for (UInt_t i=0; i<nChannel; i++)
{
Double_t errorSquared = (xs_stat[theCharge][i] * xs_stat[theCharge][i]);
gStat->SetPointError(i, sqrt(errorSquared) / xs_nlo[theCharge], 0.0);
errorSquared += (xs_syst[theCharge][i] * xs_syst[theCharge][i]);
gSyst->SetPointError(i, sqrt(errorSquared) / xs_nlo[theCharge], 0.0);
errorSquared += (xs_lumi[theCharge][i] * xs_lumi[theCharge][i]);
gLumi->SetPointError(i, sqrt(errorSquared) / xs_nlo[theCharge], 0.0);
gStat->SetPoint(i, xs_value[theCharge][i] / xs_nlo[theCharge], nChannel-i-1);
gSyst->SetPoint(i, xs_value[theCharge][i] / xs_nlo[theCharge], nChannel-i-1);
gLumi->SetPoint(i, xs_value[theCharge][i] / xs_nlo[theCharge], nChannel-i-1);
}
// Cosmetics
//----------------------------------------------------------------------------
gStat->SetLineWidth (2);
gStat->SetMarkerSize (1.3);
gStat->SetMarkerStyle(kFullCircle);
gSyst->SetLineColor (kRed);
gSyst->SetLineWidth (2);
gSyst->SetMarkerSize (1.3);
gSyst->SetMarkerStyle(kFullCircle);
gLumi->SetLineColor (kBlue);
gLumi->SetLineWidth (2);
gLumi->SetMarkerSize (1.3);
gLumi->SetMarkerStyle(kFullCircle);
// Draw
//----------------------------------------------------------------------------
TString suffix = "7TeV_" + sCharge[theCharge];
TCanvas* canvas = new TCanvas("ratioNLO_" + suffix, "ratioNLO_" + suffix);
canvas->SetLeftMargin(canvas->GetRightMargin());
Double_t xmin = 0.0;
Double_t xmax = 2.0;
Double_t ylegend = 1.2;
Double_t ymin = -0.6;
Double_t ymax = nChannel + ymin + ylegend;
TH2F* h2 = new TH2F("h2_" + suffix, "", 100, xmin, xmax, 100, ymin, ymax);
h2->Draw();
// NLO WZ cross-section
//----------------------------------------------------------------------------
TBox* nlo = new TBox(1. - xs_nlo_left [theCharge] / xs_nlo[theCharge], ymin,
1. + xs_nlo_right[theCharge] / xs_nlo[theCharge], ymax - ylegend);
nlo->SetLineColor(0);
nlo->SetFillColor(kGray);
nlo->SetFillStyle(1001);
nlo->Draw("e2,same");
TLine* line = new TLine(1., ymin, 1., ymax - ylegend);
line->SetLineColor(kGray+1);
line->SetLineWidth(2);
line->Draw("same");
// Cross sections
//----------------------------------------------------------------------------
gLumi->Draw("p,same");
gSyst->Draw("p,same");
gStat->Draw("p,same");
// Labels
//----------------------------------------------------------------------------
for (UInt_t i=0; i<nChannel; i++) {
Double_t x = gStat->GetX()[i];
Double_t y = gStat->GetY()[i];
Double_t gStatError = gStat->GetErrorX(i);
Double_t gSystError = gSyst->GetErrorX(i);
Double_t gLumiError = gLumi->GetErrorX(i);
DrawTLatex(42, xmin+0.06, y+0.15, 0.035, 12,
Form("%s %.2f #pm %.2f",
lChannel[i].Data(), x, gLumiError), 0);
gLumiError = sqrt(gLumiError*gLumiError - gSystError*gSystError);
gSystError = sqrt(gSystError*gSystError - gStatError*gStatError);
DrawTLatex(42, xmin+0.06, y-0.15, 0.025, 12,
Form("%.2f #pm %.2f #pm %.2f #pm %.2f",
x, gStatError, gSystError, gLumiError), 0);
}
DrawTLatex(42, 0.050, 0.975, _bigLabelSize, 13, "CMS Preliminary");
DrawTLatex(42, 0.940, 0.983, _bigLabelSize, 33,
Form("#sqrt{s} = 7 TeV, L = %.1f fb^{-1}", luminosity/1e3));
TString swz = "";
if (theCharge == WPlus) swz = "W^{+}Z";
else if (theCharge == WMinus) swz = "W^{-}Z";
else swz = "W^{#pm}Z";
h2->GetXaxis()->CenterTitle();
h2->GetXaxis()->SetTitleOffset(1.4);
h2->GetXaxis()->SetTitle(Form("#sigma_{%s}^{exp} / #sigma_{%s}^{theory}",
swz.Data(),
swz.Data()));
h2->GetYaxis()->SetTitle("");
// Remove y-axis labels
//----------------------------------------------------------------------------
TAxis* yaxis = h2->GetYaxis();
for (Int_t j=1; j<yaxis->GetNbins(); j++) yaxis->SetBinLabel(j, "");
// Additional legend
//----------------------------------------------------------------------------
DrawLegend(0.645, 0.840, gStat, " stat.", "lp");
DrawLegend(0.645, 0.795, nlo, " theory", "f");
DrawLegend(0.800, 0.840, gSyst, " syst.", "l");
DrawLegend(0.800, 0.795, gLumi, " lumi.", "l");
// Save
//----------------------------------------------------------------------------
canvas->Update();
canvas->GetFrame()->DrawClone();
canvas->RedrawAxis();
canvas->SaveAs(Form("pdf/ratioNLO_%s.pdf", suffix.Data()));
canvas->SaveAs(Form("png/ratioNLO_%s.png", suffix.Data()));
}
int fitHisto(int siteNum,string dataVer)
{
//===>initialize variable
bool anaLiHe=true;//He8/Li9 bg
int ADNumOfSite[3]={0};
int daqHistNum=5;
if( dataVer.find("13")!=-1 || dataVer.find("14")!=-1 || dataVer.find("15")!=-1 || dataVer.find("16")!=-1)
{
ADNumOfSite[0]=2;
ADNumOfSite[1]=2;
ADNumOfSite[2]=4;
daqHistNum=5;
} else
{
if( dataVer.find("11")!=-1 || dataVer.find("12")!=-1 )
{
ADNumOfSite[0]=2;
ADNumOfSite[1]=1;
ADNumOfSite[2]=3;
daqHistNum=4;
}
}
string site;
if( siteNum==1 )
{
site="EH1";
} else if(siteNum==2)
{
site="EH2";
}else if (siteNum==3)
{
site="EH3";
}else
{
site="EH1";
}
//===>initialize histograms
//livetime
string runnum;
TH1F* h[daqHistNum];//the fifth is for daqtime
Double_t totalTime[5]={0.};
//Li9 He8
double n98total=0.;
//double in98total=0.;
double ifitn98total=0.;
double n98Rate=0.;
double in98Rate=0.;
double tlivetime=0.;
TH1F* showermuonNum[6];
TH1F* time2lastshowermuon[6];
TH1F* hh[6];
//===>get histograms from .root file for analyse
string filename;
filename=site;
filename+="mergedHist_";
filename+=dataVer;
filename+=".root";
TFile* f=new TFile(filename.c_str());
//livetime
for( int i=0 ; i<daqHistNum ; i++ )
{
stringstream hname;
if( i==daqHistNum-1 )
{
hname<<"LiveTime/DaqTime";
} else
{
hname<<"LiveTime/AD";
hname<<i+1;
hname<<"LiveTime";
}
h[i] = (TH1F*)f->Get(hname.str().c_str());
if( !(h[i]) )
{
cout<<"Can not get Hist : "<<hname.str()<<" from "<<site<<"/"<<runnum<<" ."<<endl;
//return true;
continue;
}
}
//Li9 He8
if(anaLiHe)
{
for( int i=0 ; i<6 ; i++ )
{
TString hnameLi;
hnameLi="lidj/showermuonNum";
hnameLi+=i+1;
showermuonNum[i]=(TH1F*)f->Get(hnameLi);
hnameLi="lidj/time2lastshowermuon";
hnameLi+=i+1;
hnameLi+="4Li";
time2lastshowermuon[i]=(TH1F*)f->Get(hnameLi);
}
}
//===>analyse
TAxis *xaxis = h[0]->GetXaxis();
int binNum = xaxis->GetNbins();
int BinBound=h[0]->FindBin(1346428800);//2012.9.1 0:0:0
//livetime
if( BinBound!=0 )
{
if( site=="EH2" )
{
for(int j=1 ; j<=BinBound ; j++ )
{
h[1]->SetBinContent(j,0);
}
}
if( site=="EH3" )
{
for(int j=1 ; j<=BinBound ; j++ )
{
h[3]->SetBinContent(j,0);
}
}
}
double totalTimeSpecical=0.;
for( int j=BinBound ; j<=binNum ; j++ )
{
totalTimeSpecical+=h[4]->GetBinContent(j);
}
for( int i=0 ; i<5 ; i++ )
{
totalTime[i]=0.;
for( int j=1 ; j<=binNum ; j++ )
{
totalTime[i]+=h[i]->GetBinContent(j);
}
}
double totalDaqtime=0.;
if( site=="EH2" )
{
totalDaqtime=totalTime[4]+totalTimeSpecical;
}else if( site=="EH3" )
{
totalDaqtime=totalTime[4]*3+totalTimeSpecical;
} else
{
totalDaqtime=totalTime[4]*2;
}
//Li He
std::cout<<"begin to analyse Li "<<endl;
if(anaLiHe)
{
int hnum=time2lastshowermuon[0]->FindBin(100);
//std::cout<<"0.001 : "<<time2lastshowermuon[0]->FindBin(0.001)<<endl;
//std::cout<<"100 : "<<time2lastshowermuon[0]->FindBin(100)<<endl;
//std::cout<<"hnum : "<<hnum<<endl;
for( int k=0 ; k<6 ; k++ )
{
TString hhname="slice";
hhname+=k+1;
hh[k]=new TH1F(hhname,"hh",hnum-2,0.001,100);
for( int i=1 ; i<hnum-2 ; i++ )
{
hh[k]->SetBinContent(i,time2lastshowermuon[k]->GetBinContent(i+1));
}
hh[k]->SetOption("E1");
}
double showerTh[7] = {0.02, 0.5, 1.5, 2.5, 3.5, 4.5, 5.0};
TH1F* LiResult[5];
LiResult[0]= new TH1F("LiResult", "All", 6, showerTh);
LiResult[1]= new TH1F("LiResult", "AD1", 6, showerTh);
LiResult[2]= new TH1F("LiResult", "AD2", 6, showerTh);
LiResult[3]= new TH1F("LiResult", "AD3", 6, showerTh);
LiResult[4]= new TH1F("LiResult", "AD4", 6, showerTh);
double NumMuon[6]={0.};
double RateMuon[6]={0.};
double NumIbd[6]={0.};
RooRealVar x("x","x",0.001,40., "s");
RooRealVar tauLi9("tauLi9", "tauLi9", -0.257, "s");
RooRealVar tauHe8("tauHe8", "tauHe8", -0.172, "s");
RooRealVar rateMu("rateMu","rate of showermuon",-0.1,-10., 0.,"Hz");
RooRealVar Li9Frac("Li9Frac","Li9's Frac", 0.0);//R
RooRealVar N98("N98","total number of Li9 and He8",500.,0.,1.e5);
//RooRealVar N98("N98","total number of Li9 and He8",3e2, 1e1, 2.e5);
RooFormulaVar lambdaLi9("lambdaLi9","lambdaLi9","1/@0 + @1",RooArgList(tauLi9, rateMu));
RooFormulaVar lambdaHe8("lambdaHe8","lambdaHe8","1/@0 + @1",RooArgList(tauHe8, rateMu));
RooFormulaVar coeLi9("coeLi9","coeLi9","@0 * @1 ",RooArgList(N98,Li9Frac));
RooFormulaVar coeHe8("coeHe8","coeHe8","@0 * ( 1 - @1 )",RooArgList(N98,Li9Frac));
RooRealVar NIbd("NIbd","number of background",3e2, 1e1, 2.e6);
RooExponential expLi9("expLi9", "Li9 distribution", x, lambdaLi9);
RooExponential expHe8("expHe8", "He8 distribution", x, lambdaHe8);
double Ibdrate[3]={0.0076,0.0067,0.00082};
RooRealVar rateIbd("rateIbd","rateIbd",-Ibdrate[siteNum-1],-10,0.,"Hz");
RooFormulaVar lambdaIbd("lambdaIbd","lambdaIbd","@0 + @1",RooArgList(rateIbd, rateMu));
RooExponential expIbd("expIbd","Ibd distribution",x,rateMu);
//RooExponential expIbd("expIbd","Ibd distribution",x,lambdaIbd);
RooFitResult* fitres;
RooAddPdf* sum;
RooDataHist* data;
RooPlot* mesframe[6];
double n98[41]={0.};
double in98[41]={0.};
double nIbd[41]={0.};
double inIbd[41]={0.};
double minNLL[41]={0.};
double rateMuValue[41]={0.};
double rateMuErr[41]={0.};
//double minNl[6]={0.};
int minindex[6]={0};
double n98fit[6]={0.};
double in98fit[6]={0.};
double rateMufit[6]={0.};
double binwidth=0.;
TH1F* lh[5][6];
TString lname[5]={"","AD1","AD2","AD3","AD4"};
int lcolor[5]={4,3,2,6,5};
bool draw6slice=false;
TCanvas* c;
TString xTitle[6]={"slice 1 : 0.02~0.5GeV","slice 2 : 0.5~1.5GeV","slice 3 : 1.5~2.5GeV","slice 4 : 2.5~3.5GeV","slice 5 : 3.5~4.5GeV","slice 6 : >4.5GeV"};
if( draw6slice )
{
c = new TCanvas("c","c",2000,800) ;
c->Divide(3,2);
gStyle->SetEndErrorSize(5.0);
gStyle->SetMarkerSize(0.1);
//gStyle->SetHistLineWidth(1);
if( 0 )
{
// it's strange ,if you can't draw following six figs in the big 3*2 pad,you can fist use these code,run once,don't exit the ROOT,then you can draw six figs!!!
data = new RooDataHist("data", "data", x, time2lastshowermuon[0]);
sum = new RooAddPdf("sum","sum",RooArgList(expLi9, expHe8, expIbd),RooArgList(coeLi9, coeHe8, NIbd));
RooPlot* mesframe = x.frame() ;
data->plotOn(mesframe) ;
c->cd(1);
mesframe->Draw();
return true;
}
}
for( int ihist=0 ; ihist<1 ; ihist++ )
{
double minNl[6]={0.};
for( int j=0 ; j<6 ; j++ )
{
std::cout<<"now is "<< j+1<<endl;
NumIbd[j]=hh[j]->Integral(1,hh[j]->FindBin(40));
hh[j]->Rebin(100);
data = new RooDataHist("data", "data", x, hh[j]);
sum = new RooAddPdf("sum","sum",RooArgList(expLi9, expHe8, expIbd),RooArgList(coeLi9, coeHe8, NIbd));
for( int i=0 ; i<41 ; i++ )
{
Li9Frac.setVal(i*0.025);
fitres = sum->fitTo((*data),Save(),PrintLevel(-1),Extended(kTRUE));
//fitres->Print();
n98[i]=N98.getVal(0);
in98[i]=N98.getError();
nIbd[i]=NIbd.getVal(0);
inIbd[i]=NIbd.getError();
rateMuValue[i]=rateMu.getVal(0);
rateMuErr[i]=rateMu.getError();
minNLL[i] = fitres->minNll();
if( minNLL[i]<minNl[j] )
{
minNl[j]=minNLL[i];
minindex[j]=i;
}
}
n98fit[j]=n98[minindex[j]];
in98fit[j]=in98[minindex[j]];
rateMufit[j]=rateMuValue[minindex[j]];
if( draw6slice )
{
//for drawing fit figure
Li9Frac.setVal(minindex[j]*0.025);
fitres = sum->fitTo((*data),Save(),PrintLevel(-1),Extended(kTRUE));
//fitres->Print();
mesframe[j] = x.frame() ;
data->plotOn(mesframe[j]) ;
sum->plotOn(mesframe[j]);
sum->plotOn(mesframe[j],Components(expIbd),LineStyle(kDashed),LineColor(kGreen)) ;
sum->plotOn(mesframe[j],Components(RooArgSet(expLi9,expHe8)),LineStyle(kDashed),LineColor(kRed)) ;
xTitle[j]+=" time since last muon (s)";
mesframe[j]->GetXaxis()->SetTitle(xTitle[j]);
mesframe[j]->GetYaxis()->SetTitle("Entries");
c->cd(j+1);
mesframe[j]->Draw();
//gPad->SetLogy();
}
}
n98total=(n98fit[0]+n98fit[1]+n98fit[2]+(n98fit[3]+n98fit[4]+n98fit[5])*exp(-1/0.257))/0.678;
ifitn98total=sqrt(in98fit[0]*in98fit[0]+in98fit[1]*in98fit[1]+in98fit[2]*in98fit[2]+((in98fit[3]+in98fit[4]+in98fit[5])*exp(-1/0.257)*(in98fit[3]+in98fit[4]+in98fit[5])*exp(-1/0.257)))/0.678;
if( ihist==0 )
{
for( int i=0 ; i<ADNumOfSite[siteNum-1] ; i++ )
{
tlivetime+=totalTime[i];
}
}else
{
tlivetime=totalTime[ihist-1];
}
n98Rate=n98total/(tlivetime/(24*3600));
in98Rate=sqrt((ifitn98total/(tlivetime/(24*3600)))*(ifitn98total/(tlivetime/(24*3600)))+(n98total/(tlivetime/(24*3600))/2)*(n98total/(tlivetime/(24*3600))/2));
for( int j=0 ; j<6 ; j++ )
{
LiResult[ihist]->SetBinContent(j+1,n98fit[j]);
LiResult[ihist]->SetBinError(j+1,in98fit[j]);
for( int jbin=0 ; jbin<binNum ; jbin++ )
{
NumMuon[j]+=showermuonNum[j]->GetBinContent(jbin);
}
RateMuon[j]=NumMuon[j]/totalDaqtime;
//std::cout<<"RateMuon[j] : "<<RateMuon[j]<<endl;
//std::cout<<"RateMuon0[j] : "<<RateMuon0[j]<<endl;
std::cout<<" R "<<minindex[j]*0.025<<" n98["<<minindex[j]<<"] "<<n98fit[j]<<" in98["<<minindex[j]<<"] "<< in98fit[j]<<" fitRateMu["<<minindex[j]<<"] "<<rateMufit[j]<<" realRateMu "<<RateMuon[j]<<" NumTol "<<NumIbd[j]<<endl;
}
std::cout<<"n98Num : "<<n98total<<" +- "<<ifitn98total<<" Rate : "<<n98Rate<<" +- "<< in98Rate<<endl;
}
/*
//TCanvas* c4 = new TCanvas("c4", "c4", 600, 400);
//gStyle->SetEndErrorSize(0.0);
LiResult[0]->SetMarkerStyle(20);
LiResult[0]->SetMarkerColor(lcolor[0]);
LiResult[0]->SetLineColor(lcolor[0]);
LiResult[0]->SetMarkerSize(1.0);
LiResult[0]->SetMinimum(0);
LiResult[0]->SetMaximum(LiResult[0]->GetMaximum()*1.5);
LiResult[0]->GetXaxis()->SetTitle("Muon visible energy (GeV)");
LiResult[0]->GetYaxis()->SetTitle("Fitted ^{9}Li events");
LiResult[0]->SetTitle("");
LiResult[0]->SetStats(kFALSE);
LiResult[0]->Draw("EP");
TLegend *legend=new TLegend(.6,.65,.79,.89);
TString legendLabel=dataVer+" "+site+" "+"All";
legend->AddEntry(LiResult[0],legendLabel,"lp");
for( int ihist=1 ; ihist<ADNumOfSite[siteNum-1]+1; ihist++ )
{
LiResult[ihist]->SetMarkerStyle(20);
LiResult[ihist]->SetMarkerColor(lcolor[ihist]);
LiResult[ihist]->SetLineColor(lcolor[ihist]);
LiResult[ihist]->SetMarkerSize(1.0);
LiResult[ihist]->SetStats(kFALSE);
LiResult[ihist]->Draw("EPsame");
legend->AddEntry(LiResult[ihist],lname[ihist],"lp");
}
legend->SetFillColor(0);
legend->Draw();
*/
}
//f->Close();
//===>print result
std::cout<<""<<endl;
std::cout<<site <<"'s infomation : "<<endl;
std::cout<<""<<endl;
for( int i=0 ; i<ADNumOfSite[siteNum-1] ; i++ )
{
std::cout<<"Total AD"<<i+1<<"LiveTime : "<<totalTime[i]/(24*3600)<<endl;
}
std::cout<<"Total DaqTime : "<<totalTime[daqHistNum-1]/(24*3600)<<" day" <<endl;
std::cout<<""<<endl;
if(anaLiHe)
{
std::cout<<" "<<endl;
/*
std::cout<<"Li9/He8 "<<endl;
std::cout<<"n98total : "<<n98total <<" +- "<<in98total <<" Rate:"<<n98total/totalTime[0]*24*3600 <<" +- "<<in98total/totalTime[0]*24*3600 <<endl;
std::cout<<"n98total0(without rpc) : "<<n98total0 <<" +- "<<in98total0 <<" Rate:"<<n98total0/totalTime0[0]*24*3600 <<" +- "<<in98total0/totalTime0[0]*24*3600 <<endl;
*/
}
//===>write into .root file
string rootname=site;
rootname+="FitResult_"+dataVer+".root";
TFile* file = new TFile(rootname.c_str(),"RECREATE");
file->cd();
for( int i=0 ; i<daqHistNum ; i++ )
{
h[i]->Write();
}
if( anaLiHe )
{
//for( int i=0 ; i<ADNumOfSite[siteNum-1] ; i++ )
for( int i=0 ; i<6 ; i++ )
{
hh[i]->Write();
}
}
file->Close();
f->Close();
return 0;
}
Double_t effSigma(TH1 *hist )
{
TAxis *xaxis = hist->GetXaxis();
Int_t nb = xaxis->GetNbins();
if(nb < 10) {
cout << "effsigma: Not a valid histo. nbins = " << nb << endl;
return 0.;
}
Double_t bwid = xaxis->GetBinWidth(1);
if(bwid == 0) {
cout << "effsigma: Not a valid histo. bwid = " << bwid << endl;
return 0.;
}
Double_t xmin = xaxis->GetXmin();
Double_t ave = hist->GetMean();
Double_t rms = hist->GetRMS();
Double_t total=0.;
for(Int_t i=0; i<nb+2; i++) {
total+=hist->GetBinContent(i);
}
if(total < 100.) {
cout << "effsigma: Too few entries " << total << endl;
return 0.;
}
Int_t ierr=0;
Int_t ismin=999;
Double_t rlim=0.683*total;
Int_t nrms=rms/(bwid); // Set scan size to +/- rms
if(nrms > nb/10) nrms=nb/10; // Could be tuned...
Double_t widmin=9999999.;
for(Int_t iscan=-nrms;iscan<nrms+1;iscan++) { // Scan window centre
Int_t ibm=(ave-xmin)/bwid+1+iscan;
Double_t x=(ibm-0.5)*bwid+xmin;
Double_t xj=x;
Double_t xk=x;
Int_t jbm=ibm;
Int_t kbm=ibm;
Double_t bin=hist->GetBinContent(ibm);
total=bin;
for(Int_t j=1;j<nb;j++){
if(jbm < nb) {
jbm++;
xj+=bwid;
bin=hist->GetBinContent(jbm);
total+=bin;
if(total > rlim) break;
}
else ierr=1;
if(kbm > 0) {
kbm--;
xk-=bwid;
bin=hist->GetBinContent(kbm);
total+=bin;
if(total > rlim) break;
}
else ierr=1;
}
Double_t dxf=(total-rlim)*bwid/bin;
Double_t wid=(xj-xk+bwid-dxf)*0.5;
if(wid < widmin) {
widmin=wid;
ismin=iscan;
}
}
if(ismin == nrms || ismin == -nrms) ierr=3;
if(ierr != 0) cout << "effsigma: Error of type " << ierr << endl;
return widmin;
}
//from Andrius
//******************************************//
// author: Chris Seez
//
// This function evaluates the effective
// sigma of a histogram.
//
//******************************************//
Double_t StudySel::calc_effSigma(TH1 * hist)
{
using std::cout;
using std::endl;
TAxis *xaxis = hist->GetXaxis();
Int_t nb = xaxis->GetNbins();
if(nb < 10) {
cout << "effsigma: Not a valid histo. nbins = " << nb << endl;
return 0.;
}
Double_t bwid = hist->GetBinWidth(1);
if(bwid == 0) {
cout << "effsigma: Not a valid histo. bwid = " << bwid << endl;
return 0.;
}
//Double_t xmax = xaxis->GetXmax(); // not used
Double_t xmin = xaxis->GetXmin();
Double_t ave = hist->GetMean();
Double_t rms = hist->GetRMS();
Double_t total=0.;
for(Int_t i=0; i<nb+2; i++) {
total+=hist->GetBinContent(i);
}
if(total < 10.) {
cout << "effsigma: Too few entries " << total << endl;
return 0.;
}
Int_t ierr=0;
Int_t ismin=999;
Double_t rlim=0.683*total;
Int_t nrms= Int_t(2.0*rms/(bwid)); // Set scan size to +/- rms
//if(nrms > nb/10) nrms=nb/10; // Could be tuned...
Double_t widmin=9999999.;
for(Int_t iscan=-nrms;iscan<nrms+1;iscan++) { // Scan window centre
Int_t ibm=Int_t((ave-xmin)/bwid+1+iscan);
Double_t x=(ibm-0.5)*bwid+xmin;
Double_t xj=x;
Double_t xk=x;
Int_t jbm=ibm;
Int_t kbm=ibm;
// ibm -- curent bin value
// x, xj, xk -- value of the x-axis
// jbm, kbm -- bin values
Double_t bin=hist->GetBinContent(ibm);
total=bin;
for(Int_t j=1;j<nb;j++){
if(jbm < nb) {
jbm++;
xj+=bwid;
bin=hist->GetBinContent(jbm);
total+=bin;
if(total > rlim) break;
}
else ierr=1;
if(kbm > 0) {
kbm--;
xk-=bwid;
bin=hist->GetBinContent(kbm);
total+=bin;
if(total > rlim) break;
}
else ierr=1;
}
Double_t dxf=(total-rlim)*bwid/bin;
Double_t wid=(xj-xk+bwid-dxf)*0.5;
if(wid < widmin) {
widmin=wid;
ismin=iscan;
}
}
if(ismin == nrms || ismin == -nrms) {
cout << endl << endl << "CRAP!!!" << endl;
cout << ismin << '\t' << nrms << endl;
ierr=3;
}
if(ierr != 0 && ierr != 1) cout << "effsigma: Error of type " << ierr <<endl;
return widmin;
}
TCanvas* plotting36GS( bool logScale=false )
{
std::cout << "plotting mu + standalone " << std::endl;
TGaxis::SetMaxDigits(3);
// channels, ordered as in the legend
vector<TString> channels;
vector<TString> hnames;
vector<TString> type;
map<TString,int> fillColor_;
map<TString,int> lineColor_;
int lineWidth1(2);
int lineWidth2(1);
bool salamanderStyle=true;
if( salamanderStyle )
{
fillColor_["Signal"] = kOrange-2;
lineColor_["Signal"] = kOrange+3;
fillColor_["EWK"] = kOrange+7;
lineColor_["EWK"] = kOrange+3;
fillColor_["QCD"] = kViolet-5;
lineColor_["QCD"] = kViolet+3;
fillColor_["ttbar"] = kRed+2;
lineColor_["ttbar"] = kRed+4;
fillColor_["gamma+jet"] = kMagenta+4;
lineColor_["gamma+jet"] = kViolet+3;
}
else
{
lineWidth1 = 2;
lineWidth2 = 2;
fillColor_["Signal"] = kPink+6;
lineColor_["Signal"] = kMagenta+3;
fillColor_["EWK"] = kAzure+8;
lineColor_["EWK"] = kAzure+4;
fillColor_["QCD"] = kYellow-7;
lineColor_["QCD"] = kYellow+4;
fillColor_["ttbar"] = kGreen;
lineColor_["ttbar"] = kGreen+2;
fillColor_["gamma+jet"] = kOrange;
lineColor_["gamma+jet"] = kOrange+2;
}
// root file, where the data is
TString fname("root/");
// histogram limits, in linear and logarithmic
int nbin_(100);
float xmin_(0.), xmax_(0.);
float ymin_(0.), ymax_(0.);
float yminl_(0.), ymaxl_(0.);
// titles and axis, marker size
TString xtitle;
TString ytitle;
int ndivx(510);
int ndivy(510);
float markerSize(0.);
float titleOffset(1.);
float r0_ = 1.;
float dr_ = 0.3;
if( use_chi )
{
r0_ = 0.;
dr_ = 7.5;
//dr_ = 3.0;
}
// canvas name
TString cname("");
TString ctitle;
// legend position and scale;
float xl_ = 0.;
float yl_ = 0.;
float scalel_ = 0.0;
{
if( logScale )
// fname += "Zmumu_40-200_36pb";
fname += "Zmusta_36pb";
else
fname += "Zmusta_36pb";
if( logScale )
{
lineWidth1 = 1;
lineWidth2 = 1;
}
channels.push_back("Zmumu");
hnames.push_back(" Z #rightarrow #mu^{+}#mu^{-}");
type.push_back("Signal");
bool revert(false);
if( logScale )
{
if( revert )
{
channels.push_back("EWK");
hnames.push_back(" EWK");
type.push_back("EWK");
channels.push_back("tt");
hnames.push_back(" t#bar{t}");
type.push_back("ttbar");
channels.push_back("QCD");
hnames.push_back(" QCD");
type.push_back("QCD");
}
else
{
channels.push_back("EWK");
hnames.push_back(" EWK");
type.push_back("EWK");
channels.push_back("tt");
hnames.push_back(" t#bar{t}");
type.push_back("ttbar");
channels.push_back("QCD");
hnames.push_back(" QCD");
type.push_back("QCD");
}
}
if( !logScale )
{
// lin scale
xmin_ = 60;
xmax_ = 120;
ymin_ = 0.01;
ymax_ = 2100;
}
else
{
// log scale
xmin_ = 40;
xmax_ = 200;
yminl_ = 0.08;
ymaxl_ = 3000;
}
xtitle = "M(#mu^{+}#mu^{-}) [GeV]";
ytitle = "number of events /";
ndivx = 504;
if( logScale )
{
ytitle += "5 GeV";
ndivy = 510;
}
else
{
ytitle += " GeV";
ndivy = 506;
}
if( logScale )
{
markerSize = 0.48;
}
else
{
markerSize = 0.75;
}
cname += "Zmusta";
ctitle = "Z to mu sta analysis";
if( logScale )
{
xl_ = 0.60;
yl_ = 0.50;
scalel_ = 0.065;
}
else
{
xl_ = 0.22;
yl_ = 0.50;
scalel_ = 0.072;
}
}
if( logScale ) cname += "MuSta_log";
else cname += "MuStaNotInThePAPER_lin";
//Open the root file containing histograms and graphs
fname += ".root";
TFile* f_ = TFile::Open(fname,"READ");
TCanvas* c_ = new TCanvas(cname,ctitle,300,300,479,510);
c_->SetLeftMargin( 87./479 );
c_->SetRightMargin( 42./479 );
c_->SetTopMargin( 30./510 );
c_->SetBottomMargin( 80./510 );
c_->SetFillColor(0);
c_->SetTickx(1);
c_->SetTicky(1);
c_->SetFrameFillStyle(0);
c_->SetFrameLineWidth(2);
c_->SetFrameBorderMode(0);
Double_t scale = 4;
Double_t wbin = 42*scale;
Double_t left = 8*scale;
Double_t right = 5*scale;
Double_t h1 = 135*scale;
Double_t h2 = 45*scale;
Double_t top1 = 15*scale;
Double_t bot1 = 3*scale;
Double_t top2 = 3*scale;
// Double_t bot1 = 0*scale;
// Double_t top2 = 0*scale;
Double_t bot2 = 80*scale;
Double_t W = left + wbin + right;
Double_t H = h1 + h2;
Double_t s[2] = {1, h1/h2 };
TPad* pad[2];
pad[0] = new TPad( "top", "top",
0, h2/H, 1, 1,
kWhite,0,0);
pad[0]->SetLeftMargin( left/W );
pad[0]->SetRightMargin( right/W );
pad[0]->SetTopMargin( top1/H );
pad[0]->SetBottomMargin( bot1/H );
pad[1] = new TPad( "bottom", "bottom",
0, 0, 1, h2/H,
kWhite,0,0);
pad[1]->SetLeftMargin( left/W );
pad[1]->SetRightMargin( right/W );
pad[1]->SetTopMargin( top2/H );
pad[1]->SetBottomMargin( bot2/H );
pad[1]->SetGridy();
for( int ii=0; ii<2; ii++ )
{
pad[ii]->SetFillColor(0);
pad[ii]->SetTickx(1);
pad[ii]->SetTicky(1);
pad[ii]->SetFrameFillStyle(0);
pad[ii]->SetFrameLineWidth(2);
pad[ii]->SetFrameBorderMode(0);
pad[ii]->SetFrameFillStyle(0);
pad[ii]->SetFrameLineWidth(2);
pad[ii]->SetFrameBorderMode(0);
}
// a dummy histogram with the correct x axis
// Warning: setTDRstyle() must be called before
TH1F* h_= new TH1F( "bidon", "bidon", nbin_, xmin_, xmax_ );
TAxis* ax_ = h_->GetXaxis();
TAxis* ay_ = h_->GetYaxis();
ax_->SetTitle(xtitle);
ax_->CenterTitle();
ax_->SetTitleOffset(1.0);
ax_->SetNdivisions(ndivx);
ay_->SetTitle(ytitle);
ay_->CenterTitle();
ay_->SetNdivisions(ndivy);
ay_->SetTitleOffset(titleOffset);
ay_->SetLabelOffset(0.015);
// fetch histograms and dress them
vector<TH1F*> histos;
size_t nChan=channels.size();
for( size_t ii=0;ii<nChan;ii++)
{
TH1F* tmp = (TH1F*)f_->Get(channels[ii]);
tmp->SetFillColor( fillColor_[type[ii]] );
tmp->SetLineColor( lineColor_[type[ii]] );
tmp->SetLineWidth( lineWidth2 );
histos.push_back(tmp);
}
//
// stack histograms
//
TH1* h_stack = (TH1*) histos[nChan-1]->Clone();
h_stack -> Reset();
TString stackName_ = TString("Mll");
vector<TH1*> listOfStackedHists;
for( size_t ii=0; ii<nChan; ii++ )
{
TH1* hh_ = (TH1*) histos[nChan-ii-1]->Clone();
stackName_ += "_";
stackName_ += hh_->GetName();
TAxis* xaxis = h_stack->GetXaxis();
for( int iBin=1; iBin<=xaxis->GetNbins(); iBin++ )
{
hh_ -> AddBinContent( iBin, h_stack->GetBinContent( iBin ) );
}
hh_->SetName( stackName_ );
delete h_stack;
h_stack = hh_;
listOfStackedHists.push_back( (TH1*)hh_->Clone() );
}
delete h_stack;
TH1* totalHisto = listOfStackedHists[nChan-1];
// colors the stacked histogram
totalHisto->SetLineColor( lineColor_["Signal"] );
totalHisto->SetLineWidth( lineWidth1 );
// The data points are presented as a TGraph
// - error bars indicate the Poisson confidence interval at 68%
// - bins with zero entry are removed
TH1* hdata = (TH1*) f_->Get("hdata");
// hdata->Sumw2();
//hdata->Rebin(2);
RooHist* roohist;
TGraphAsymmErrors* dataGraph;
roohist = new RooHist((*hdata));
int Nn0=0;
vector<double> vY;
vector<double> vX;
vector<double > veY;
vector<double > veX;
vector<double> tmp(0,2);
for(int ip=0;ip<roohist->GetN();ip++)
{
double Y,X;
roohist->GetPoint(ip,X,Y);
if(Y!=0)
{
Nn0++;
vY.push_back(Y);
vX.push_back(X);
veX.push_back( roohist->GetErrorXlow(ip) );
veX.push_back( roohist->GetErrorXhigh(ip) );
veY.push_back( roohist->GetErrorYlow(ip) );
veY.push_back( roohist->GetErrorYhigh(ip) );
}
}
dataGraph=new TGraphAsymmErrors(Nn0);
for(int ip=0;ip<Nn0;ip++)
{
dataGraph->SetPoint(ip,vX[ip],vY[ip]);
dataGraph->SetPointError(ip,veX[ip*2],veX[ip*2+1],veY[ip*2],veY[ip*2+1]);
}
dataGraph->SetName("data");
dataGraph->SetMarkerStyle(kFullCircle);
dataGraph->SetMarkerColor(kBlack);
dataGraph->SetMarkerSize(markerSize);
TGraph* dummyGraph = (TGraph*) dataGraph->Clone("dummyGraph");
dummyGraph->SetLineColor(0);
dummyGraph->SetMarkerSize(1.5*markerSize);
// Remove the horizontal bars (at Michael's request)
double x_(0), y_(0);
for( int ii=0; ii<dataGraph->GetN(); ii++ )
{
dataGraph->SetPointEXlow(ii,0);
dataGraph->SetPointEXhigh(ii,0);
dataGraph->GetPoint(ii,x_,y_ );
if( y_==0 )
{
dataGraph->RemovePoint( ii );
ii--;
}
}
// get the ratio data/fit
TGraphAsymmErrors* ratioGraph = (TGraphAsymmErrors*) dataGraph->Clone("ratio");
TH1* hfit = totalHisto;
for( int ii=0; ii<dataGraph->GetN(); ii++ )
{
dataGraph->GetPoint(ii,x_,y_ );
ratioGraph->SetPointEYlow(ii,0);
ratioGraph->SetPointEYhigh(ii,0);
ratioGraph->SetPoint(ii,x_,0 );
double eyl_ = dataGraph->GetErrorYlow(ii);
double eyh_ = dataGraph->GetErrorYhigh(ii);
int jj = hfit->FindBin(x_);
float fit_ = hfit->GetBinContent( jj );
if( fit_>0 )
{
if( use_chi )
{
ratioGraph->SetPointEYlow(ii,eyl_/sqrt(fit_));
ratioGraph->SetPointEYhigh(ii,eyh_/sqrt(fit_));
ratioGraph->SetPoint(ii,x_,(y_-fit_)/sqrt(fit_) );
}
else
{
ratioGraph->SetPointEYlow(ii,eyl_/fit_);
ratioGraph->SetPointEYhigh(ii,eyh_/fit_);
ratioGraph->SetPoint(ii,x_,y_/fit_ );
}
}
// cout << ii << " ratio=" << ratioGraph->GetY()[ii]
// << "+" << ratioGraph->GetEYhigh()[ii]
// << "-" << ratioGraph->GetEYlow()[ii] << endl;
}
TH1* hratio_ = (TH1*) h_->Clone("hratio");
ax_->SetLabelOffset(99);
ax_->SetTitleOffset(99);
//
// now plotting
//
c_->Draw();
c_->cd();
TPad* p_ = pad[0];
p_->Draw();
p_->cd();
if( logScale )
{
p_->SetLogy(true);
}
else
{
p_->SetLogy(false);
}
if( !logScale )
{
h_->GetYaxis()->SetRangeUser(ymin_+0.001*(ymax_-ymin_),ymax_);
}
else
{
h_->GetYaxis()->SetRangeUser(yminl_,ymaxl_);
}
h_->Draw();
float dxl_ = scalel_*3.5;
float dyl_ = scalel_*1.8;
if( logScale )
{
dxl_ = scalel_*4;
dyl_ = scalel_*3.4;
}
TLegend* legend=new TLegend(xl_,yl_,xl_+dxl_,yl_+dyl_);
legend->SetLineColor(0);
legend->SetFillColor(0);
legend->SetTextFont(42);
legend->SetTextSize(0.048);
legend->AddEntry(dummyGraph," data","pl");
if( logScale )
{
legend->AddEntry(dummyGraph," ","0");
}
for(size_t ii=0;ii<nChan;ii++)
{
legend->AddEntry(histos[ii],hnames[ii],"f");
}
legend->Draw("same");
totalHisto->Draw("same");
for( size_t ii=0; ii<nChan; ii++ )
{
// listOfStackedHists[nChan-ii-1]->Sumw2();
listOfStackedHists[nChan-ii-1]->Rebin(1.);
listOfStackedHists[nChan-ii-1]->Scale(1.);
listOfStackedHists[nChan-ii-1]->Draw("Same");
}
// draw the data points
dataGraph->Draw("PE");
// redraw axis
p_->RedrawAxis();
//lumi pad, cms prelim pad etc..
{
int txtFont = 42; // bold is 62
float txtSize1 = 0.055;
float txtX1 = 0.91;
float txtY1 = 0.935;
float txtSize2 = 0.05;
float txtX2 = 0.85;
float txtY2 = 0.83;
// TEST FOR THE NAME ZMT, ZMMNONISO, ZMS
float txtSize3 = 0.055;
float txtX3 = 0.3;
float txtY3 = 0.935;
TLatex latex;
latex.SetNDC();
latex.SetTextFont(txtFont);
latex.SetTextSize(txtSize1);
latex.SetTextAlign(31); // align right
latex.DrawLatex(txtX1,txtY1,"CMS");
latex.SetTextAlign(31); // align right
latex.SetTextSize(txtSize2);
latex.DrawLatex(txtX2,txtY2,"36 pb^{-1} at #sqrt{s} = 7 TeV");
latex.SetTextAlign(21); // align left???
latex.SetTextSize(txtSize3);
latex.DrawLatex(txtX3,txtY3,"global plus standalone muon");
}
c_->cd();
p_ = pad[1];
p_->Draw();
p_->cd();
TAxis* xratio_ = hratio_->GetXaxis();
TAxis* yratio_ = hratio_->GetYaxis();
yratio_->SetRangeUser(r0_-0.9999*dr_,r0_+0.9999*dr_);
yratio_->SetLabelSize( s[1]*yratio_->GetLabelSize() );
yratio_->SetTitleSize( s[1]*yratio_->GetTitleSize() );
yratio_->SetLabelOffset( yratio_->GetLabelOffset() );
yratio_->SetTitleOffset( yratio_->GetTitleOffset()/s[1] );
if( use_chi )
{
yratio_->SetTitle("#chi");
yratio_->SetNdivisions(4);
}
else
{
yratio_->SetTitle("data/fit");
yratio_->SetNdivisions(3);
}
xratio_->SetLabelSize( s[1]*xratio_->GetLabelSize() );
xratio_->SetTitleSize( s[1]*xratio_->GetTitleSize() );
xratio_->SetTitleOffset( 1.0 );
xratio_->CenterTitle();
xratio_->SetLabelOffset( xratio_->GetLabelOffset()*s[1] );
xratio_->SetTickLength( xratio_->GetTickLength()*s[1] );
hratio_->Draw();
ratioGraph->SetMarkerSize( ratioGraph->GetMarkerSize()*1. );
ratioGraph->SetLineColor( kBlack );
ratioGraph->SetMarkerColor( kGray+2 );
ratioGraph->SetMarkerStyle( kFullCircle );
ratioGraph->DrawClone("PE");
ratioGraph->SetMarkerColor( kBlack );
ratioGraph->SetMarkerStyle( kOpenCircle );
ratioGraph->DrawClone("PE");
p_->RedrawAxis();
c_->cd();
return c_;
}
TauAnalysisSelector::TauAnalysisSelector(const std::string& puWeight, bool isEmbedded,
const std::string& embeddingWTauMuFile, const std::string& embeddingWTauMuPath,
const std::string& mcTauMultiplicity, const std::string& mcTauMode,
const std::string& embeddingNormalizationMode,
TH1 *embeddingMuonWeights):
BaseSelector(),
//fMuons("Emb"),
fGenTaus(isEmbedded ? "gentausOriginal" : "gentaus", true),
fGenTausEmbedded("gentausEmbedded", true),
fPuWeightName(puWeight),
fIsEmbedded(isEmbedded),
fEmbeddingWTauMuWeights(0),
fMCTauMultiplicity(parseMCTauMultiplicity(mcTauMultiplicity)),
fMCTauMode(parseMCTauMode(mcTauMode)),
fEmbeddingNormalizationMode(parseEmbeddingNormalizationMode(embeddingNormalizationMode)),
fEmbeddingMuonWeights(embeddingMuonWeights),
cAll(fEventCounter.addCounter("All events")),
//cElectronVeto(fEventCounter.addCounter("Electron veto")),
cGeneratorWeight(fEventCounter.addCounter("Vis. pt weight")),
cTauBRWeight(fEventCounter.addCounter("Tau BR weighting")),
cGenTauFound(fEventCounter.addCounter("Gen tau found")),
cTauMCSelection(fEventCounter.addCounter("Tau MC requirement")),
cOnlyWMu(fEventCounter.addCounter("Only W->mu")),
cWTauMuWeight(fEventCounter.addCounter("W->tau->mu weighting")),
cTriggerEffWeight(fEventCounter.addCounter("Muon trigger eff weighting")),
cIdEffWeight(fEventCounter.addCounter("Muon ID eff weighting")),
cMuonWeight(fEventCounter.addCounter("Muon corr weighting (from argument)")),
cJetSelection(fEventCounter.addCounter("Jet selection")),
cPrimaryVertex(fEventCounter.addCounter("Primary vertex")),
cAllTauCandidates(fEventCounter.addCounter(">= 1 tau candidate")),
cPrePtCut(fEventCounter.addCounter("Pre Pt cut")),
cDecayModeFinding(fEventCounter.addCounter("Decay mode finding")),
cEtaCut(fEventCounter.addCounter("Eta cut")),
cPtCut(fEventCounter.addCounter("Pt cut")),
cLeadingTrackPtCut(fEventCounter.addCounter("Leading track pt")),
cEcalCracks(fEventCounter.addCounter("ECAL fiducial: cracks")),
cEcalGap(fEventCounter.addCounter("ECAL fiducial: gap")),
cAgainstElectron(fEventCounter.addCounter("Against electron")),
cAgainstMuon(fEventCounter.addCounter("Against muon")),
cIsolation(fEventCounter.addCounter("Isolation")),
cOneProng(fEventCounter.addCounter("One prong")),
cRtau(fEventCounter.addCounter("Rtau")),
cMuTrigger(fEventCounter.addCounter("Mu trigger"))
{
if(isEmbedded && !embeddingWTauMuFile.empty()) {
TFile *file = TFile::Open(embeddingWTauMuFile.c_str());
TEfficiency *eff = dynamic_cast<TEfficiency *>(file->Get(embeddingWTauMuPath.c_str()));
TAxis *xaxis = eff->GetPassedHistogram()->GetXaxis();
fEmbeddingWTauMuWeights = new TH1F("weights", "weights", xaxis->GetNbins(), xaxis->GetBinLowEdge(xaxis->GetFirst()), xaxis->GetBinUpEdge(xaxis->GetLast()));
fEmbeddingWTauMuWeights->SetDirectory(0);
for(int bin=1; bin <= xaxis->GetNbins(); ++bin) {
fEmbeddingWTauMuWeights->SetBinContent(bin, eff->GetEfficiency(bin));
std::cout << "Bin " << bin << " low edge " << fEmbeddingWTauMuWeights->GetXaxis()->GetBinLowEdge(bin) << " value " << fEmbeddingWTauMuWeights->GetBinContent(bin) << std::endl;
}
fEmbeddingWTauMuWeights->SetBinContent(xaxis->GetNbins()+1, fEmbeddingWTauMuWeights->GetBinContent(xaxis->GetNbins()));
file->Close();
}
if(isEmbedded) {
fMuons.setIdEfficiencyName("efficiency_Run2011AB");
fMuons.setTriggerEfficiencyName("efficiency_trigger");
}
}
