void
CorrelationTimeArcGrbcat::initiate()
{
TRACE("X: range = " << getXRange() << ", points = " << getXPoints() << ", delta = " << getXDelta());
TRACE("Y: range = " << getYRange() << ", points = " << getYPoints() << ", delta = " << getYDelta());
_histData.resize(getYPoints(), std::vector<std::size_t>(getXPoints(), 0));
_histModel.resize(getYPoints(), std::vector<std::size_t>(getXPoints(), 0));
_cf.resize(getYPoints(), std::vector<type::Float>(getXPoints(), 0.0));
}
void
CorrelationTimeArcGrbcat::doGenerate(Catalog& catalogData, Catalog& catalogModel)
{
initiate();
TRACE("GENERATING DATA HISTOGRAM");
_pairsData = generateCF(catalogData, _histData);
TRACE("GENERATING MODEL HISTOGRAM");
_pairsModel = generateCF(catalogModel, _histModel);
TRACE("PAIRS: DATA = " << _pairsData << ", MODEL = " << _pairsModel);
for (std::size_t i = 0; i < getYPoints(); ++i)
{
for (std::size_t j = 0; j < getXPoints(); ++j)
{
if (_histModel[i][j])
{
_cf[i][j] = _histData[i][j];
_cf[i][j] /= 1.0 * _histModel[i][j];
}
}
}
normalize(_cf, _pairsModel / _pairsData);
}
void PairRegressionAnalyzer::printResults(QTableWidget * table) {
table->setColumnCount(results.count());
table->setRowCount(results[0].count());
table->setHorizontalHeaderItem(0,new QTableWidgetItem("x"));
table->setHorizontalHeaderItem(1,new QTableWidgetItem("y"));
table->setHorizontalHeaderItem(2,new QTableWidgetItem("y''"));
for(int col=0;col<results.count();col++)
for(int row=0;row<results[col].count();row++)
table->setItem(row,col,new QTableWidgetItem(QString::number(results[col][row])));
Point3D coords;
coords.x = 5.0f;
coords.y = 5.0f;
coords.z = 5.0f;
Point3D coordsScale;
coordsScale.x = 5.0/maxElement(results[0]);
coordsScale.y = 5.0/maxElement(results[1]);
coordsScale.z = 1;
QList<QString> coordLables;
QWidget * tab1 = AdditionalWidgets.at(0);
tab1->setObjectName("График");
PairRegressionAnalyzerGraphic * g1 = new PairRegressionAnalyzerGraphic(tab1);
coordLables.append("");
coordLables.append("");
g1->SetCoordsData(coords, coordLables,Figure3D::black, Figure3D::darkGreen, &coordsScale);
g1->SetPoints(getYPoints());
g1->SetLinePoints(getY2Points());
g1->SetErrorText("Качество оценивания: " + QString::number(R));
g1->SetEquation("y'' = " + QString::number(A) + " + " + QString::number(B) + "x");
tab1->setLayout(new QGridLayout());
tab1->layout()->addWidget(g1);
}
void
CorrelationTimeArcGrbcat::normalize(std::vector< std::vector<type::Float>>& cf, type::Float norm)
{
for (std::size_t i = 0; i < getYPoints(); ++i)
{
for (std::size_t j = 0; j < getXPoints(); ++j)
{
cf[i][j] *= norm;
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void RegularGridSampleSurfaceMesh::setupFilterParameters()
{
FilterParameterVector parameters = getFilterParameters();
parameters.push_back(IntFilterParameter::New("X Points", "XPoints", getXPoints(), FilterParameter::Parameter));
parameters.push_back(IntFilterParameter::New("Y Points", "YPoints", getYPoints(), FilterParameter::Parameter));
parameters.push_back(IntFilterParameter::New("Z Points", "ZPoints", getZPoints(), FilterParameter::Parameter));
parameters.push_back(FloatVec3FilterParameter::New("Resolution", "Resolution", getResolution(), FilterParameter::Parameter));
parameters.push_back(FloatVec3FilterParameter::New("Origin", "Origin", getOrigin(), FilterParameter::Parameter));
parameters.push_back(StringFilterParameter::New("Data Container", "DataContainerName", getDataContainerName(), FilterParameter::CreatedArray));
parameters.push_back(SeparatorFilterParameter::New("Cell Data", FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Cell Attribute Matrix", "CellAttributeMatrixName", getCellAttributeMatrixName(), FilterParameter::CreatedArray));
parameters.push_back(StringFilterParameter::New("Feature Ids", "FeatureIdsArrayName", getFeatureIdsArrayName(), FilterParameter::CreatedArray));
setFilterParameters(parameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
void RegularGridSampleSurfaceMesh::readFilterParameters(AbstractFilterParametersReader* reader, int index)
{
SampleSurfaceMesh::readFilterParameters(reader, index);
reader->openFilterGroup(this, index);
setXPoints(reader->readValue("XPoints", getXPoints()));
setYPoints(reader->readValue("YPoints", getYPoints()));
setZPoints(reader->readValue("ZPoints", getZPoints()));
setResolution(reader->readFloatVec3("Resolution", getResolution()));
setOrigin(reader->readFloatVec3("Origin", getOrigin()));
setDataContainerName(reader->readString("DataContainerName", getDataContainerName()));
setCellAttributeMatrixName(reader->readString("CellAttributeMatrixName", getCellAttributeMatrixName() ) );
setFeatureIdsArrayName(reader->readString("FeatureIdsArrayName", getFeatureIdsArrayName() ) );
reader->closeFilterGroup();
}
std::size_t
CorrelationTimeArcGrbcat::generateCF(Catalog& catalog,
std::vector< std::vector<std::size_t> > hist)
{
std::size_t pairs = 0;
GreatCircleDistance distance(_formula);
std::vector<CatalogEntry*> entries;
filterEntries(catalog, entries);
const std::size_t points = entries.size();
const std::size_t pairsAll = points * (points -1) / 2;
const std::size_t mod = std::pow(10.0, std::floor(std::log10(pairsAll)) - 4);
std::printf("ENTRIES = %ld, PAIRS = %ld\n", points, pairsAll);
std::size_t k = 0;
for (std::size_t i = 0; i < points - 1; ++i)
{
CatalogEntryGrbcat* iEntry = static_cast<CatalogEntryGrbcat*>(entries[i]);
for (std::size_t j = i + 1; j < points; ++j)
{
CatalogEntryGrbcat* jEntry = static_cast<CatalogEntryGrbcat*>(entries[j]);
type::Float time = std::fabs(jEntry->getCoodinates().getTimeMJD() -
iEntry->getCoodinates().getTimeMJD());
type::Float dist = distance(jEntry->getCoodinates(), iEntry->getCoodinates());
std::size_t xIdx = std::floor(time * getXDelta());
std::size_t yIdx = std::floor(dist * getYDelta());
if (xIdx < getXPoints() && yIdx < getYPoints())
{
++hist[yIdx][xIdx];
++pairs;
}
if (++k % mod == 0)
{
std::printf("\rProgress %3.2f%% %ld/%ld - pairs = %ld" ,
100.0 * k / pairsAll, k, pairsAll, pairs);
}
}
}
std::printf("\rProgress %3.2f%% %ld/%ld - pairs = %ld\n" ,
100.0 * k / pairsAll, k, pairsAll, pairs);
return pairs;
}
void drawSinglePtBin(TFile* file, int iPtBin, const std::string& recoGen, Float_t& extrapReso, Float_t& extrapReso_err, Float_t& trueReso, Float_t& trueReso_err, Float_t& intrReso, Float_t& intrReso_err, Float_t& extrapResp, Float_t& extrapResp_err, Float_t& trueResp, Float_t& trueResp_err, Float_t& intrResp, Float_t& intrResp_err, Float_t& imbalanceResp, Float_t& imbalanceResp_err) {
Double_t Lower[NBINS_PT];
fitTools::getPtBins(NBINS_PT, Lower);
Double_t ptMin = Lower[iPtBin];
Double_t ptMax = Lower[iPtBin+1];
Int_t nPoints = 5;
char xHistoName[90];
sprintf( xHistoName, "ptBin_%d_%d/pt2ndJet%sMean_%d", (int)ptMin, (int)ptMax, recoGen.c_str(), iPtBin);
Float_t x[nPoints];
Float_t x_err[nPoints];
getXPoints( file, xHistoName, nPoints, x, x_err);
Float_t y_resp_recoPhot[nPoints];
Float_t y_resp_recoPhot_err[nPoints];
Float_t y_resp_genPhot[nPoints];
Float_t y_resp_genPhot_err[nPoints];
Float_t y_resp_recoGen[nPoints];
Float_t y_resp_recoGen_err[nPoints];
Float_t y_resp_genPart[nPoints];
Float_t y_resp_genPart_err[nPoints];
Float_t y_resp_partPhot[nPoints];
Float_t y_resp_partPhot_err[nPoints];
Float_t y_reso_recoPhot[nPoints];
Float_t y_reso_recoPhot_err[nPoints];
Float_t y_reso_genPhot[nPoints];
Float_t y_reso_genPhot_err[nPoints];
Float_t y_reso_recoGen[nPoints];
Float_t y_reso_recoGen_err[nPoints];
Float_t y_reso_genPart[nPoints];
Float_t y_reso_genPart_err[nPoints];
Float_t y_reso_partPhot[nPoints];
Float_t y_reso_partPhot_err[nPoints];
char yHistoName[100];
sprintf( yHistoName, "ptBin_%d_%d/r_RecoPhot_vs_%s_%d", (int)ptMin, (int)ptMax, recoGen.c_str(), iPtBin);
getYPoints( file, yHistoName, nPoints, y_resp_recoPhot, y_resp_recoPhot_err, y_reso_recoPhot, y_reso_recoPhot_err);
sprintf( yHistoName, "ptBin_%d_%d/r_GenPhot_vs_%s_%d", (int)ptMin, (int)ptMax, recoGen.c_str(), iPtBin);
getYPoints( file, yHistoName, nPoints, y_resp_genPhot, y_resp_genPhot_err, y_reso_genPhot, y_reso_genPhot_err);
sprintf( yHistoName, "ptBin_%d_%d/r_RecoGen_vs_%s_%d", (int)ptMin, (int)ptMax, recoGen.c_str(), iPtBin);
getYPoints( file, yHistoName, nPoints, y_resp_recoGen, y_resp_recoGen_err, y_reso_recoGen, y_reso_recoGen_err);
sprintf( yHistoName, "ptBin_%d_%d/r_GenPart_vs_%s_%d", (int)ptMin, (int)ptMax, recoGen.c_str(), iPtBin);
getYPoints( file, yHistoName, nPoints, y_resp_genPart, y_resp_genPart_err, y_reso_genPart, y_reso_genPart_err);
sprintf( yHistoName, "ptBin_%d_%d/r_PartPhot_vs_%s_%d", (int)ptMin, (int)ptMax, recoGen.c_str(), iPtBin);
getYPoints( file, yHistoName, nPoints, y_resp_partPhot, y_resp_partPhot_err, y_reso_partPhot, y_reso_partPhot_err);
//draw response histograms:
TGraphErrors* gr_resp_recoPhot = new TGraphErrors(nPoints, x, y_resp_recoPhot, x_err, y_resp_recoPhot_err);
gr_resp_recoPhot->SetMarkerStyle(20);
gr_resp_recoPhot->SetMarkerColor(kRed);
TGraphErrors* gr_resp_genPhot = new TGraphErrors(nPoints, x, y_resp_genPhot, x_err, y_resp_genPhot_err);
gr_resp_genPhot->SetMarkerStyle(22);
gr_resp_genPhot->SetMarkerColor(kBlack);
TGraphErrors* gr_resp_recoGen = new TGraphErrors(nPoints, x, y_resp_recoGen, x_err, y_resp_recoGen_err);
gr_resp_recoGen->SetMarkerStyle(21);
gr_resp_recoGen->SetMarkerColor(kBlue);
TGraphErrors* gr_resp_genPart = new TGraphErrors(nPoints, x, y_resp_genPart, x_err, y_resp_genPart_err);
gr_resp_genPart->SetMarkerStyle(23);
gr_resp_genPart->SetMarkerColor(kGreen);
TGraphErrors* gr_resp_partPhot = new TGraphErrors(nPoints, x, y_resp_partPhot, x_err, y_resp_partPhot_err);
gr_resp_partPhot->SetMarkerStyle(22);
gr_resp_partPhot->SetMarkerColor(kBlack);
Float_t lastX = x[nPoints-1];
Float_t xMax_fit = lastX+2.;
Float_t xMax_fit_green = x[2]+2.;
Float_t xMax_axis;
if( lastX <=12. )
xMax_axis = 15.;
else if( lastX <= 20. )
xMax_axis = 25.;
else if( lastX <= 25. )
xMax_axis = 30.;
else if( lastX <= 35. )
xMax_axis = 40.;
std::string xTitle;
if( recoGen=="Reco" ) {
xTitle = "p_{T}^{2ndJet reco} [GeV/c]";
} else if( recoGen=="Gen" ) {
xTitle = "p_{T}^{2ndJet gen} [GeV/c]";
} else if( recoGen=="RecoRel" ) {
xTitle = "p_{T}^{2ndJet reco}/p_{T}^{#gamma} [%]";
} else if( recoGen=="GenRel" ) {
xTitle = "p_{T}^{2ndJet gen}/p_{T}^{#gamma} [%]";
}
std::string fitFunct_name;
// if( ptMin <=150. )
fitFunct_name = "[0] - x*x*[1]";
// else
// fitFunct_name = "[0] - x*[1]";
TF1* fit_resp_genPart = new TF1("fit_resp_genPart", fitFunct_name.c_str());
fit_resp_genPart->SetRange(0., xMax_fit);
fit_resp_genPart->SetLineWidth(0.5);
fit_resp_genPart->SetLineColor(kGreen);
gr_resp_genPart->Fit( fit_resp_genPart, "RQ");
TF1* fit_resp_genPhot = new TF1("fit_resp_genPhot", fitFunct_name.c_str());
fit_resp_genPhot->SetRange(0., xMax_fit);
fit_resp_genPhot->SetLineWidth(0.5);
fit_resp_genPhot->SetLineColor(kBlack);
gr_resp_genPhot->Fit( fit_resp_genPhot, "RQ");
TF1* fit_resp_recoGen = new TF1("fit_resp_recoGen", "[0]");
fit_resp_recoGen->SetRange(0., xMax_fit);
fit_resp_recoGen->SetLineWidth(0.5);
fit_resp_recoGen->SetLineColor(kBlue);
gr_resp_recoGen->Fit( fit_resp_recoGen, "RQ");
TF1* fit_resp_partPhot = new TF1("fit_resp_partPhot", fitFunct_name.c_str());
fit_resp_partPhot->SetRange(0., xMax_fit);
fit_resp_partPhot->SetLineWidth(0.5);
fit_resp_partPhot->SetLineColor(kBlack);
gr_resp_partPhot->Fit( fit_resp_partPhot, "RQ");
std::string total_resp_str = (ONLYBLACK) ? "fit_resp_recoGen*fit_resp_genPhot" : "fit_resp_partPhot * fit_resp_genPart * fit_resp_recoGen";
TF1* total_resp = new TF1("total_resp", total_resp_str.c_str());
total_resp->SetRange(0., xMax_fit);
total_resp->SetLineColor(kGray+2);
fitFunct_name = "[0]*[1] - x*x*[2]";
TF1* fit_respParabola = new TF1("fit_respParabola", fitFunct_name.c_str());
fit_respParabola->SetRange(0., xMax_fit);
if( NOQ ) //to evaluate syst
fit_respParabola->FixParameter(1, 0.5*fit_resp_genPhot->GetParameter(0));
else
fit_respParabola->FixParameter(1, fit_resp_genPhot->GetParameter(0));
fit_respParabola->SetLineColor(kRed);
fit_respParabola->SetLineWidth(0.5);
gr_resp_recoPhot->Fit( fit_respParabola, "RQ" );
extrapResp = fit_respParabola->GetParameter(0);
extrapResp_err = fit_respParabola->GetParError(0);
intrResp = fit_resp_recoGen->GetParameter(0);
intrResp_err = fit_resp_recoGen->GetParError(0);
imbalanceResp = fit_resp_genPhot->GetParameter(0) - 1.;
imbalanceResp_err = fit_resp_genPhot->GetParError(0);
Float_t y0_partPhot = fit_resp_partPhot->GetParameter(0);
Float_t y0_genPart = fit_resp_genPart->GetParameter(0);
Float_t y0_recoGen = fit_resp_recoGen->GetParameter(0);
Float_t y0_genPhot = fit_resp_genPhot->GetParameter(0);
Float_t y0_err_partPhot = fit_resp_partPhot->GetParError(0);
Float_t y0_err_genPart = fit_resp_genPart->GetParError(0);
Float_t y0_err_recoGen = fit_resp_recoGen->GetParError(0);
Float_t y0_err_genPhot = fit_resp_genPhot->GetParError(0);
if( ONLYBLACK ) {
trueResp = y0_genPhot*y0_recoGen;
trueResp_err = y0_err_genPhot*y0_err_genPhot*y0_recoGen*y0_recoGen;
trueResp_err += y0_genPhot*y0_genPhot*y0_err_recoGen*y0_err_recoGen;
trueResp_err = sqrt( trueResp_err );
} else {
trueResp = y0_partPhot*y0_genPart*y0_recoGen;
trueResp_err = y0_err_partPhot*y0_err_partPhot*y0_genPart*y0_genPart*y0_recoGen*y0_recoGen;
trueResp_err += y0_partPhot*y0_partPhot*y0_err_genPart*y0_err_genPart*y0_recoGen*y0_recoGen;
trueResp_err += y0_partPhot*y0_partPhot*y0_genPart*y0_genPart*y0_err_recoGen*y0_err_recoGen;
trueResp_err = sqrt( trueResp_err );
}
//Float_t yMin_axis = (Lower[iPtBin]<50.) ? 0.7 : 0.8;
Float_t yMin_axis = 0.8;
TH2D* h2_axes_resp = new TH2D("axes_resp", "", 10, 0., xMax_axis, 10, yMin_axis, 1.1);
h2_axes_resp->SetXTitle(xTitle.c_str());
h2_axes_resp->GetXaxis()->SetTitleOffset(1.1);
h2_axes_resp->SetYTitle("Response");
h2_axes_resp->GetYaxis()->SetTitleOffset(1.2);
TLegend* legend_resp = new TLegend(0.65, 0.65, 0.88, 0.88);
legend_resp->SetTextSize(0.04);
legend_resp->SetFillStyle(0);
legend_resp->SetFillColor(kWhite);
legend_resp->AddEntry(gr_resp_recoGen, "Intrinsic", "P");
if( ONLYBLACK ) {
legend_resp->AddEntry(gr_resp_genPhot, "Imbalance", "P");
} else {
legend_resp->AddEntry(gr_resp_partPhot, "Imbalance", "P");
legend_resp->AddEntry(gr_resp_genPart, "Out of cone", "P");
}
legend_resp->AddEntry(total_resp, "Total", "L");
legend_resp->AddEntry(gr_resp_recoPhot, "#gamma + jet", "P");
char labeltext[50];
sprintf(labeltext, "%d < p_{T}^{#gamma} < %d GeV/c", (int)ptMin, (int)ptMax);
TPaveText* label_resp = new TPaveText(0.15, 0.15, 0.4, 0.2, "brNDC");
label_resp->SetFillColor(kWhite);
label_resp->SetTextSize(0.035);
label_resp->AddText(labeltext);
TCanvas* c1_resp = new TCanvas("c1_resp", "c1_resp", 800, 600);
c1_resp->cd();
h2_axes_resp->Draw();
total_resp->Draw("same");
gr_resp_recoGen->Draw("Psame");
if( ONLYBLACK ) {
gr_resp_genPhot->Draw("Psame");
} else {
gr_resp_genPart->Draw("Psame");
gr_resp_partPhot->Draw("Psame");
}
gr_resp_recoPhot->Draw("Psame");
legend_resp->Draw("same");
label_resp->Draw("same");
char canvasName_resp[100];
sprintf(canvasName_resp, "%s/response_ptBin_%d_%d_%s.%s", OUTPUTDIR_.c_str(), (int)ptMin, (int)ptMax, recoGen.c_str(), PICTURE_FORMAT.c_str());
c1_resp->SaveAs(canvasName_resp);
delete c1_resp;
delete h2_axes_resp;
delete legend_resp;
delete label_resp;
//draw resolution histograms:
TGraphErrors* gr_reso_recoPhot = new TGraphErrors(nPoints, x, y_reso_recoPhot, x_err, y_reso_recoPhot_err);
gr_reso_recoPhot->SetMarkerStyle(20);
gr_reso_recoPhot->SetMarkerColor(kRed);
TGraphErrors* gr_reso_genPhot = new TGraphErrors(nPoints, x, y_reso_genPhot, x_err, y_reso_genPhot_err);
gr_reso_genPhot->SetMarkerStyle(22);
gr_reso_genPhot->SetMarkerColor(kBlack);
TGraphErrors* gr_reso_recoGen = new TGraphErrors(nPoints, x, y_reso_recoGen, x_err, y_reso_recoGen_err);
gr_reso_recoGen->SetMarkerStyle(21);
gr_reso_recoGen->SetMarkerColor(kBlue);
TGraphErrors* gr_reso_genPart = new TGraphErrors(nPoints, x, y_reso_genPart, x_err, y_reso_genPart_err);
gr_reso_genPart->SetMarkerStyle(23);
gr_reso_genPart->SetMarkerColor(kGreen);
TGraphErrors* gr_reso_partPhot = new TGraphErrors(nPoints, x, y_reso_partPhot, x_err, y_reso_partPhot_err);
gr_reso_partPhot->SetMarkerStyle(22);
gr_reso_partPhot->SetMarkerColor(kBlack);
Double_t x1, x2, y1, y2;
TF1* fit_reso_genPart;
if( FIT_RMS=="RMS" ) {
fit_reso_genPart = new TF1("fit_reso_genPart", "[0] + x*[1]");
fit_reso_genPart->SetRange(0., xMax_fit);
} else {
fit_reso_genPart = new TF1("fit_reso_genPart", "[0]");
fit_reso_genPart->SetRange(0., xMax_fit_green);
}
gr_reso_genPart->GetPoint(1, x1, y1);
fit_reso_genPart->SetParameter(0, y1);
fit_reso_genPart->SetLineWidth(0.5);
fit_reso_genPart->SetLineColor(kGreen);
gr_reso_genPart->Fit(fit_reso_genPart, "RQ");
fit_reso_genPart->SetRange(0., xMax_fit);
TF1* fit_reso_partPhot = new TF1("fit_reso_partPhot", "[0] + x*[1]");
fit_reso_partPhot->SetRange(0., xMax_fit);
gr_reso_partPhot->GetPoint(1, x1, y1);
gr_reso_partPhot->GetPoint(2, x2, y2);
fit_reso_partPhot->SetParameter(0, 0.);
fit_reso_partPhot->SetParameter(1, (y2-y1)/(x2-x1));
fit_reso_partPhot->SetLineWidth(0.5);
fit_reso_partPhot->SetLineColor(kBlack);
gr_reso_partPhot->Fit(fit_reso_partPhot, "RQ");
TF1* fit_reso_genPhot = new TF1("fit_reso_genPhot", "[0] + x*[1]");
fit_reso_genPhot->SetRange(0., xMax_fit);
fit_reso_genPhot->SetLineWidth(0.5);
fit_reso_genPhot->SetLineColor(kBlack);
gr_reso_genPhot->Fit(fit_reso_genPhot, "RQ");
// std::cout << " ptBin: " << ptMin << "-" << ptMax << "\t" << "slope: " << fit_reso_genPhot->GetParameter(1) << "+/-" << fit_reso_genPhot->GetParError(1)<< std::endl;
TF1* fit_reso_recoGen = new TF1("fit_reso_recoGen", "[0]");
fit_reso_recoGen->SetRange(0., xMax_fit);
gr_reso_recoGen->GetPoint(1, x1, y1);
gr_reso_recoGen->GetPoint(2, x2, y2);
fit_reso_recoGen->SetParameter(0, y1);
fit_reso_recoGen->SetLineWidth(0.5);
fit_reso_recoGen->SetLineColor(kBlue);
gr_reso_recoGen->Fit(fit_reso_recoGen, "RQ");
TF1* sum_intrinsic = new TF1("sum_intrinsic", "sqrt( fit_reso_genPart*fit_reso_genPart + fit_reso_recoGen*fit_reso_recoGen )");
sum_intrinsic->SetRange(0., xMax_fit);
sum_intrinsic->SetLineColor(kViolet);
sum_intrinsic->SetLineStyle(3);
std::string sum_str;
if( ONLYBLACK ) {
sum_str = "sqrt( fit_reso_recoGen*fit_reso_recoGen + fit_reso_genPhot*fit_reso_genPhot )";
} else {
sum_str = "sqrt( sum_intrinsic*sum_intrinsic + fit_reso_partPhot*fit_reso_partPhot )";
}
TF1* sum= new TF1("sum", sum_str.c_str());
sum->SetRange(0., xMax_fit);
sum->SetLineColor(kGray+2);
Double_t x1_reco, y1_reco;
gr_reso_recoPhot->GetPoint(1, x1_reco, y1_reco);
Double_t x2_reco, y2_reco;
gr_reso_recoPhot->GetPoint(2, x2_reco, y2_reco);
// genPhot: y = mx + q
// recoGen: y = c
Float_t c = fit_reso_recoGen->GetParameter(0);
Float_t q = fit_reso_genPhot->GetParameter(0);
Float_t m = fit_reso_genPhot->GetParameter(1);
// [0] = c; [1] = q; [2] = m
TF1* fit_extrapToZero_sqrt = new TF1("fit_extrapToZero_sqrt", "sqrt([0]*[0] + [1]*[1] + 2.*[1]*[2]*x + [2]*[2]*x*x)");
fit_extrapToZero_sqrt->SetRange(0., xMax_fit);
fit_extrapToZero_sqrt->SetParameter(0, c);
fit_extrapToZero_sqrt->SetParLimits(0, 0.01, 0.3);
if( NOQ )
fit_extrapToZero_sqrt->FixParameter(1, 0.5*q); //to evaluate syst
else
fit_extrapToZero_sqrt->FixParameter(1, q); //fixed
//fit_extrapToZero_sqrt->SetParLimits(1, 0., 0.1);
fit_extrapToZero_sqrt->SetParameter(2, m);
fit_extrapToZero_sqrt->SetParLimits(2, 0., 0.05);
fit_extrapToZero_sqrt->SetLineColor(kRed);
fit_extrapToZero_sqrt->SetLineWidth(0.5);
TF1* fit_extrapToZero_line = new TF1("fit_extrapToZero_line", "[0]+[1]*x");
fit_extrapToZero_line->SetRange(0., xMax_fit);
fit_extrapToZero_line->SetParameter(0, y1_reco);
fit_extrapToZero_line->SetParameter(1, (y2_reco-y1_reco)/(x2_reco-x1_reco));
fit_extrapToZero_line->SetParLimits(0, 0., 0.4);
fit_extrapToZero_line->SetLineColor(kRed);
fit_extrapToZero_line->SetLineWidth(0.5);
gr_reso_recoPhot->Fit(fit_extrapToZero_sqrt, "RQ");
extrapReso = fit_extrapToZero_sqrt->GetParameter(0);
extrapReso_err = fit_extrapToZero_sqrt->GetParError(0);
//extrapReso = sqrt(fit_extrapToZero_sqrt->GetParameter(0));
//extrapReso_err = ( 1. / (2.*sqrt(extrapReso)) * fit_extrapToZero_sqrt->GetParError(0)); //error propag
intrReso = fit_reso_recoGen->GetParameter(0);
intrReso_err = fit_reso_recoGen->GetParError(0);
trueReso = sum->Eval(0.);
if( ONLYBLACK )
trueReso_err = sqrt( fit_reso_genPhot->GetParError(0)*fit_reso_genPhot->GetParError(0) + fit_reso_recoGen->GetParError(0)*fit_reso_recoGen->GetParError(0) );
else
trueReso_err = sqrt( fit_reso_genPart->GetParError(0)*fit_reso_genPart->GetParError(0) + fit_reso_recoGen->GetParError(0)*fit_reso_recoGen->GetParError(0) + fit_reso_partPhot->GetParError(0)*fit_reso_partPhot->GetParError(0) );
Float_t ymax;
if( Lower[iPtBin] < 40. ) ymax = (RECOTYPE_=="pf") ? 0.5 : 0.8;
else if( Lower[iPtBin] < 70. ) ymax = (RECOTYPE_=="pf") ? 0.4 : 0.6;
else ymax = 0.3;
TH2D* h2_axes_reso = new TH2D("axes_reso", "", 10, 0., xMax_axis, 10, 0., ymax);
h2_axes_reso->SetXTitle(xTitle.c_str());
h2_axes_reso->GetXaxis()->SetTitleOffset(1.1);
h2_axes_reso->SetYTitle("Resolution");
h2_axes_reso->GetYaxis()->SetTitleOffset(1.2);
TPaveText* label_reso = new TPaveText(0.67, 0.83, 0.8, 0.86, "brNDC");
label_reso->SetFillColor(kWhite);
label_reso->SetTextSize(0.035);
label_reso->AddText(labeltext);
Float_t minLegend = (ONLYBLACK) ? 0.2 : 0.15;
TLegend* legend_reso = new TLegend(minLegend, 0.6, 0.45, 0.85);
legend_reso->SetTextSize(0.04);
legend_reso->SetFillStyle(0);
legend_reso->SetFillColor(kWhite);
legend_reso->AddEntry(gr_reso_recoGen, "Intrinsic", "P");
if( ONLYBLACK ) {
legend_reso->AddEntry(gr_reso_genPhot, "Imbalance", "P");
} else {
legend_reso->AddEntry(gr_reso_partPhot, "Imbalance", "P");
legend_reso->AddEntry(gr_reso_genPart, "Out of Cone", "P");
}
if( !ONLYBLACK )
legend_reso->AddEntry(sum_intrinsic, "Intrinsic #oplus OoC", "L");
legend_reso->AddEntry(sum, "Total", "L");
legend_reso->AddEntry(gr_reso_recoPhot, "#gamma + jet", "P");
TCanvas* c1_reso = new TCanvas("c1_reso", "c1_reso", 800, 600);
c1_reso->cd();
h2_axes_reso->Draw();
sum->Draw("same");
if( !ONLYBLACK )
sum_intrinsic->Draw("same");
gr_reso_recoPhot->Draw("Psame");
gr_reso_recoGen->Draw("Psame");
if( ONLYBLACK ) {
gr_reso_genPhot->Draw("Psame");
} else {
gr_reso_genPart->Draw("Psame");
gr_reso_partPhot->Draw("Psame");
}
legend_reso->Draw("same");
label_reso->Draw("same");
char canvasName_reso[100];
sprintf(canvasName_reso, "%s/resolution_ptBin_%d_%d_%s.%s", OUTPUTDIR_.c_str(), (int)ptMin, (int)ptMax, recoGen.c_str(), PICTURE_FORMAT.c_str());
c1_reso->SaveAs(canvasName_reso);
if( ptMin==197. ) {
h2_axes_reso->Draw();
sum->Draw("same");
if( !ONLYBLACK )
sum_intrinsic->Draw("same");
gr_reso_recoGen->Draw("Psame");
if( ONLYBLACK ) {
gr_reso_genPhot->Draw("Psame");
} else {
gr_reso_genPart->Draw("Psame");
gr_reso_partPhot->Draw("Psame");
}
legend_reso->Draw("same");
label_reso->Draw("same");
sprintf(canvasName_reso, "%s/resolution_ptBin_%d_%d_%s_NORECO.%s", OUTPUTDIR_.c_str(), (int)ptMin, (int)ptMax, recoGen.c_str(), PICTURE_FORMAT.c_str());
c1_reso->SaveAs(canvasName_reso);
}
delete c1_reso;
delete h2_axes_reso;
delete legend_reso;
delete label_reso;
delete gr_resp_recoPhot;
delete gr_resp_genPart;
delete gr_resp_partPhot;
delete gr_resp_recoGen;
delete gr_reso_recoPhot;
delete gr_reso_genPart;
delete gr_reso_partPhot;
delete gr_reso_recoGen;
}
