int main(int argc, char *argv[])
{
# include "setRootCase.H"
# include "createTime.H"
# include "createMesh.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Read in the existing solution files.
Info << "Reading field U" << endl;
volVectorField U
(
IOobject
(
"U",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
),
mesh
);
Info << "Reading field T" << endl;
volScalarField T
(
IOobject
(
"T",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
),
mesh
);
Info << "Reading field p_rgh" << endl;
volScalarField p_rgh
(
IOobject
(
"p_rgh",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
),
mesh
);
// Compute the velocity flux at the faces. This is needed
// by the laminar transport model.
Info<< "Creating/Calculating face flux field, phi..." << endl;
surfaceScalarField phi
(
IOobject
(
"phi",
runTime.timeName(),
mesh,
IOobject::READ_IF_PRESENT,
IOobject::AUTO_WRITE
),
linearInterpolate(U) & mesh.Sf()
);
// Read the gravitational acceleration. This is needed
// for calculating dp/dn on boundaries.
Info << "Reading gravitational acceleration..." << endl;
uniformDimensionedVectorField g
(
IOobject
(
"g",
runTime.constant(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
)
);
// Read the value of TRef in the transportProperties file.
singlePhaseTransportModel laminarTransport(U, phi);
dimensionedScalar TRef(laminarTransport.lookup("TRef"));
// Use Tref and the T field to compute rhok, which is needed
// to calculate dp/dn on boundaries.
Info<< "Creating the kinematic density field, rhok..." << endl;
volScalarField rhok
(
IOobject
(
"rhok",
runTime.timeName(),
mesh
),
1.0 - (T - TRef)/TRef
);
// Get access to the input dictionary.
IOdictionary setFieldsABLDict
(
IOobject
(
"setFieldsABLDict",
runTime.time().system(),
runTime,
IOobject::MUST_READ,
IOobject::NO_WRITE
)
);
// Read in the setFieldsABLDict entries.
word velocityInitType(setFieldsABLDict.lookup("velocityInitType"));
word temperatureInitType(setFieldsABLDict.lookup("temperatureInitType"));
word tableInterpTypeU(setFieldsABLDict.lookupOrDefault<word>("tableInterpTypeU","linear"));
word tableInterpTypeT(setFieldsABLDict.lookupOrDefault<word>("tableInterpTypeT","linear"));
scalar deltaU(setFieldsABLDict.lookupOrDefault<scalar>("deltaU",1.0));
scalar deltaV(setFieldsABLDict.lookupOrDefault<scalar>("deltaV",1.0));
scalar zPeak(setFieldsABLDict.lookupOrDefault<scalar>("zPeak",0.03));
scalar Uperiods(setFieldsABLDict.lookupOrDefault<scalar>("Uperiods",4));
scalar Vperiods(setFieldsABLDict.lookupOrDefault<scalar>("Vperiods",4));
scalar xMin(setFieldsABLDict.lookupOrDefault<scalar>("xMin",0.0));
scalar yMin(setFieldsABLDict.lookupOrDefault<scalar>("yMin",0.0));
scalar zMin(setFieldsABLDict.lookupOrDefault<scalar>("zMin",0.0));
scalar xMax(setFieldsABLDict.lookupOrDefault<scalar>("xMax",3000.0));
scalar yMax(setFieldsABLDict.lookupOrDefault<scalar>("yMax",3000.0));
scalar zMax(setFieldsABLDict.lookupOrDefault<scalar>("zMax",1000.0));
scalar zRef(setFieldsABLDict.lookupOrDefault<scalar>("zRef",600.0));
bool useWallDistZ(setFieldsABLDict.lookupOrDefault<bool>("useWallDistZ",false));
bool scaleVelocityWithHeight(setFieldsABLDict.lookupOrDefault<bool>("scaleVelocityWithHeight",false));
scalar zInversion(setFieldsABLDict.lookupOrDefault<scalar>("zInversion",600.0));
scalar Ug(setFieldsABLDict.lookupOrDefault<scalar>("Ug",15.0));
scalar UgDir(setFieldsABLDict.lookupOrDefault<scalar>("UgDir",270.0));
scalar Tbottom(setFieldsABLDict.lookupOrDefault<scalar>("Tbottom",300.0));
scalar Ttop(setFieldsABLDict.lookupOrDefault<scalar>("Ttop",304.0));
scalar dTdz(setFieldsABLDict.lookupOrDefault<scalar>("dTdz",0.003));
scalar widthInversion(setFieldsABLDict.lookupOrDefault<scalar>("widthInversion",80.0));
scalar TPrimeScale(setFieldsABLDict.lookupOrDefault<scalar>("TPrimeScale",0.0));
scalar z0(setFieldsABLDict.lookupOrDefault<scalar>("z0",0.016));
scalar kappa(setFieldsABLDict.lookupOrDefault<scalar>("kappa",0.40));
List<List<scalar> > profileTable(setFieldsABLDict.lookup("profileTable"));
bool updateInternalFields(setFieldsABLDict.lookupOrDefault<bool>("updateInternalFields",true));
bool updateBoundaryFields(setFieldsABLDict.lookupOrDefault<bool>("updateBoundaryFields",true));
// Change the table profiles from scalar lists to scalar fields
scalarField zProfile(profileTable.size(),0.0);
scalarField UProfile(profileTable.size(),0.0);
scalarField VProfile(profileTable.size(),0.0);
scalarField TProfile(profileTable.size(),0.0);
forAll(zProfile,i)
{
zProfile[i] = profileTable[i][0];
UProfile[i] = profileTable[i][1];
VProfile[i] = profileTable[i][2];
TProfile[i] = profileTable[i][3];
}
void MultiHistoOverlap(TString namesandlabels, Int_t nOfFiles, const TString& outDir="./"){
gROOT->Reset();
gROOT->ProcessLine(".L tdrstyle.C");
gROOT->ProcessLine("setTDRStyle()");
// gSystem->Load("libRooFit");
// using namespace RooFit;
// preamble
TPaveText *cmsprel = new TPaveText(0.19, 0.95, 0.95, 0.99, "NDC");
cmsprel->SetTextSize(0.03);
cmsprel->SetTextFont(42);
cmsprel->SetFillColor(0);
cmsprel->SetBorderSize(0);
cmsprel->SetMargin(0.01);
cmsprel->SetTextAlign(12); // align left
TString text = "CMS Preliminary 2011";
cmsprel->AddText(0.0, 0.5,text);
TString text2 = "#sqrt{s} = 7 TeV |#eta_{#mu}|<2.4";
cmsprel->AddText(0.8, 0.5, text2);
TList* FileList = new TList();
TList* LabelList = new TList();
TObjArray *nameandlabelpairs = namesandlabels.Tokenize(",");
for (Int_t i = 0; i < nameandlabelpairs->GetEntries(); ++i) {
TObjArray *aFileLegPair = TString(nameandlabelpairs->At(i)->GetName()).Tokenize("=");
if(aFileLegPair->GetEntries() == 2) {
FileList->Add( TFile::Open(aFileLegPair->At(0)->GetName()) );
LabelList->Add( aFileLegPair->At(1) );
} else {
std::cout << "Please give file name and legend entry in the following form:\n" << " filename1=legendentry1,filename2=legendentry2\n";
}
}
Int_t NOfFiles = FileList->GetSize();
if ( NOfFiles!=nOfFiles ){
std::cout<<"&MSG-e: NOfFiles = "<<nOfFiles<<std::endl;
return;
}
std::vector<TString> LegLabels;
LegLabels.reserve(nOfFiles);
for(Int_t j=0; j < nOfFiles; j++) {
TObjString* legend = (TObjString*)LabelList->At(j);
LegLabels.push_back(legend->String());
std::cout<<"LegLabels["<<j<<"]"<<LegLabels[j]<<std::endl;
}
TLegend *leg=0;
TCanvas* c0 = new TCanvas("c0", "c0",50, 20, 800,600);
TCanvas* c1 = new TCanvas("c1", "c1",50, 20, 800,600);
TCanvas* c2 = new TCanvas("c2", "c2",50, 20, 800,600);
TCanvas* c3 = new TCanvas("c3", "c3",50, 20, 800,600);
TCanvas* c4 = new TCanvas("c4", "c4",50, 20, 800,600);
TCanvas* c5 = new TCanvas("c5", "c5",50, 20, 1200,800);
TCanvas* c6 = new TCanvas("c6", "c6",50, 20, 1200,800);
TCanvas* c0s = new TCanvas("c0s", "c0s",50, 20, 800,600);
TCanvas* c1s = new TCanvas("c1s", "c1s",50, 20, 800,600);
TCanvas* c2s = new TCanvas("c2s", "c2s",50, 20, 800,600);
TCanvas* c3s = new TCanvas("c3s", "c3s",50, 20, 800,600);
TCanvas* cFit = new TCanvas("cFit", "cFit",50, 20, 1600, 800);
//----------------- CANVAS C0 --------------//
c0->SetFillColor(0);
c0->cd();
leg = new TLegend(0.50,0.25,0.90,0.40);
leg->SetBorderSize(1);
leg->SetFillColor(0);
leg->SetTextFont(42);
// Mass VS muon phi plus -------------------------------
TH1D *histoMassVsPhiPlus[nOfFiles];
for(Int_t j=0; j < nOfFiles; j++) {
TFile *fin = (TFile*)FileList->At(j);
if (( histoMassVsPhiPlus[j] = (TH1D*)fin->Get("MassVsPhiPlus/allHistos/meanHisto"))){
histoMassVsPhiPlus[j]->SetLineStyle(linestylelist[j]);
histoMassVsPhiPlus[j]->SetMarkerColor(colorlist[j]);
histoMassVsPhiPlus[j]->SetLineColor(colorlist[j]);
histoMassVsPhiPlus[j]->SetMarkerStyle(markerstylelist[j]);
// histoMassVsPhiPlus[j]->SetMarkerSize(0.75);
if ( j == 0 ) {
histoMassVsPhiPlus[j]->GetXaxis()->SetTitle("positive muon #phi (rad)");
histoMassVsPhiPlus[j]->GetYaxis()->SetTitle("M_{#mu#mu} (GeV)");
// histoMassVsPhiPlus[j]->GetYaxis()->SetRangeUser(88.5,93.5);
histoMassVsPhiPlus[j]->GetYaxis()->SetRangeUser(90.0,91.5);
histoMassVsPhiPlus[j]->GetXaxis()->SetRangeUser(-3.14,3.14);
histoMassVsPhiPlus[j]->Draw();
} else {
histoMassVsPhiPlus[j]->Draw("SAME");
}
leg->AddEntry(histoMassVsPhiPlus[j],LegLabels[j],"PL");
}
}
//cmsprel->Draw("same");
leg->Draw("same");
c0->SaveAs(outDir+"MassVsPhiPlus.png");
//----------------- CANVAS C1 --------------//
c1->SetFillColor(0);
c1->cd();
leg = new TLegend(0.50,0.25,0.90,0.40);
leg->SetBorderSize(1);
leg->SetFillColor(0);
leg->SetTextFont(42);
// Mass VS muon eta plus -------------------------------
TH1D *histoMassVsEtaPlus[nOfFiles];
for(Int_t j=0; j < nOfFiles; j++) {
TFile *fin = (TFile*)FileList->At(j);
if (( histoMassVsEtaPlus[j] = (TH1D*)fin->Get("MassVsEtaPlus/allHistos/meanHisto"))){
histoMassVsEtaPlus[j]->SetLineStyle(linestylelist[j]);
histoMassVsEtaPlus[j]->SetMarkerColor(colorlist[j]);
histoMassVsEtaPlus[j]->SetLineColor(colorlist[j]);
histoMassVsEtaPlus[j]->SetMarkerStyle(markerstylelist[j]);
// histoMassVsEtaPlus[j]->SetMarkerSize(0.75);
if ( j == 0 ) {
histoMassVsEtaPlus[j]->GetXaxis()->SetTitle("positive muon #eta");
histoMassVsEtaPlus[j]->GetYaxis()->SetTitle("M_{#mu#mu} (GeV)");
// histoMassVsEtaPlus[j]->GetYaxis()->SetRangeUser(88.5,93.5);
histoMassVsEtaPlus[j]->GetYaxis()->SetRangeUser(90.0,91.5);
histoMassVsEtaPlus[j]->GetXaxis()->SetRangeUser(-2.41,2.41);
histoMassVsEtaPlus[j]->Draw();
} else {
histoMassVsEtaPlus[j]->Draw("SAME");
}
leg->AddEntry(histoMassVsEtaPlus[j],LegLabels[j],"PL");
}
}
//cmsprel->Draw("same");
leg->Draw("same");
c1->SaveAs(outDir+"MassVsEtaPlus.png");
//----------------- CANVAS C2 --------------//
c2->SetFillColor(0);
c2->cd();
leg = new TLegend(0.50,0.25,0.90,0.40);
leg->SetBorderSize(1);
leg->SetFillColor(0);
leg->SetTextFont(42);
// Mass VS muon eta plus - eta minus -------------------------------
TH1D *histoMassVsEtaPlusMinusDiff[nOfFiles];
for(Int_t j=0; j < nOfFiles; j++) {
TFile *fin = (TFile*)FileList->At(j);
if (( histoMassVsEtaPlusMinusDiff[j] = (TH1D*)fin->Get("MassVsEtaPlusMinusDiff/allHistos/meanHisto"))){
histoMassVsEtaPlusMinusDiff[j]->SetLineStyle(linestylelist[j]);
histoMassVsEtaPlusMinusDiff[j]->SetMarkerColor(colorlist[j]);
histoMassVsEtaPlusMinusDiff[j]->SetLineColor(colorlist[j]);
histoMassVsEtaPlusMinusDiff[j]->SetMarkerStyle(markerstylelist[j]);
// histoMassVsEtaPlusMinusDiff[j]->SetMarkerSize(0.75);
if ( j == 0 ) {
histoMassVsEtaPlusMinusDiff[j]->GetXaxis()->SetTitle("#eta pos. muon #eta neg. muon");
histoMassVsEtaPlusMinusDiff[j]->GetYaxis()->SetTitle("M_{#mu#mu} (GeV)");
// histoMassVsEtaPlusMinusDiff[j]->GetYaxis()->SetRangeUser(88.0,96.0);
histoMassVsEtaPlusMinusDiff[j]->GetYaxis()->SetRangeUser(90.0,91.5);
histoMassVsEtaPlusMinusDiff[j]->GetXaxis()->SetRangeUser(-3,3);
histoMassVsEtaPlusMinusDiff[j]->Draw();
} else {
histoMassVsEtaPlusMinusDiff[j]->Draw("SAME");
}
leg->AddEntry(histoMassVsEtaPlusMinusDiff[j],LegLabels[j],"PL");
}
}
//cmsprel->Draw("same");
leg->Draw("same");
c2->SaveAs(outDir+"MassVsEtaPlusMinusDiff.png");
//----------------- CANVAS C3 --------------//
c3->SetFillColor(0);
c3->cd();
leg = new TLegend(0.50,0.25,0.90,0.40);
leg->SetBorderSize(1);
leg->SetFillColor(0);
leg->SetTextFont(42);
// Mass VS muon phi minus -------------------------------
TH1D *histoMassVsPhiMinus[nOfFiles];
for(Int_t j=0; j < nOfFiles; j++) {
TFile *fin = (TFile*)FileList->At(j);
if (( histoMassVsPhiMinus[j] = (TH1D*)fin->Get("MassVsPhiMinus/allHistos/meanHisto"))){
histoMassVsPhiMinus[j]->SetLineStyle(linestylelist[j]);
histoMassVsPhiMinus[j]->SetMarkerColor(colorlist[j]);
histoMassVsPhiMinus[j]->SetLineColor(colorlist[j]);
histoMassVsPhiMinus[j]->SetMarkerStyle(markerstylelist[j]);
// histoMassVsPhiMinus[j]->SetMarkerSize(0.75);
if ( j == 0 ) {
histoMassVsPhiMinus[j]->GetXaxis()->SetTitle("negative muon #phi (rad)");
histoMassVsPhiMinus[j]->GetYaxis()->SetTitle("M_{#mu#mu} (GeV)");
// histoMassVsPhiMinus[j]->GetYaxis()->SetRangeUser(88.5,93.5);
histoMassVsPhiMinus[j]->GetYaxis()->SetRangeUser(90.0,91.5);
histoMassVsPhiMinus[j]->GetXaxis()->SetRangeUser(-3.14,3.14);
histoMassVsPhiMinus[j]->Draw();
} else {
histoMassVsPhiMinus[j]->Draw("SAME");
}
leg->AddEntry(histoMassVsPhiMinus[j],LegLabels[j],"PL");
}
}
//cmsprel->Draw("same");
leg->Draw("same");
c3->SaveAs(outDir+"MassVsPhiMinus.png");
//----------------- CANVAS C4 --------------//
c4->SetFillColor(0);
c4->cd();
leg = new TLegend(0.50,0.25,0.90,0.40);
leg->SetBorderSize(1);
leg->SetFillColor(0);
leg->SetTextFont(42);
// Mass VS muon eta minus -------------------------------
TH1D *histoMassVsEtaMinus[nOfFiles];
for(Int_t j=0; j < nOfFiles; j++) {
TFile *fin = (TFile*)FileList->At(j);
if (( histoMassVsEtaMinus[j] = (TH1D*)fin->Get("MassVsEtaMinus/allHistos/meanHisto"))){
histoMassVsEtaMinus[j]->SetLineStyle(linestylelist[j]);
histoMassVsEtaMinus[j]->SetMarkerColor(colorlist[j]);
histoMassVsEtaMinus[j]->SetLineColor(colorlist[j]);
histoMassVsEtaMinus[j]->SetMarkerStyle(markerstylelist[j]);
// histoMassVsEtaMinus[j]->SetMarkerSize(0.75);
if ( j == 0 ) {
histoMassVsEtaMinus[j]->GetXaxis()->SetTitle("negative muon #eta");
histoMassVsEtaMinus[j]->GetYaxis()->SetTitle("M_{#mu#mu} (GeV)");
// histoMassVsEtaMinus[j]->GetYaxis()->SetRangeUser(88.5,93.5);
histoMassVsEtaMinus[j]->GetYaxis()->SetRangeUser(90.0,91.5);
histoMassVsEtaMinus[j]->GetXaxis()->SetRangeUser(-2.41,2.41);
histoMassVsEtaMinus[j]->Draw();
} else {
histoMassVsEtaMinus[j]->Draw("SAME");
}
leg->AddEntry(histoMassVsEtaMinus[j],LegLabels[j],"PL");
}
}
//cmsprel->Draw("same");
leg->Draw("same");
c4->SaveAs(outDir+"MassVsEtaMinus.png");
//----------------- CANVAS C5 --------------//
c5->SetFillColor(0);
c5->cd();
leg = new TLegend(0.50,0.25,0.90,0.40);
leg->SetBorderSize(1);
leg->SetFillColor(0);
leg->SetTextFont(42);
// Mass VS muon phi plus -------------------------------
TH2D *histoMassVsEtaPhiPlus[nOfFiles];
TStyle *newStyle;
newStyle->SetPalette(1);
// newStyle->SetOptTitle(1);
Double_t zMin(82.);
Double_t zMax(96.);
for(Int_t j=0; j < nOfFiles; j++) {
TFile *fin = (TFile*)FileList->At(j);
if (( histoMassVsEtaPhiPlus[j] = (TH2D*)fin->Get("MassVsEtaPhiPlus/allHistos/meanHisto"))){
if ( j == 0 ) {
histoMassVsEtaPhiPlus[j]->SetTitle(LegLabels[j]);
histoMassVsEtaPhiPlus[j]->GetXaxis()->SetTitle("positive muon #phi (rad)");
histoMassVsEtaPhiPlus[j]->GetYaxis()->SetTitle("positive muon #eta");
zMin = histoMassVsEtaPhiPlus[j]->GetMinimum();
zMax = histoMassVsEtaPhiPlus[j]->GetMaximum();
histoMassVsEtaPhiPlus[j]->Draw("COLZ");
c5->SaveAs(outDir+"MassVsEtaPhiPlus_file0.png");
} else {
histoMassVsEtaPhiPlus[j]->SetTitle(LegLabels[j]);
histoMassVsEtaPhiPlus[j]->SetMinimum(zMin);
histoMassVsEtaPhiPlus[j]->SetMaximum(zMax);
histoMassVsEtaPhiPlus[j]->Draw("COLZ");
c5->SaveAs(outDir+"MassVsEtaPhiPlus_file"+(TString)Form("%d",(Int_t)j)+".png");
}
}
}
//cmsprel->Draw("same");
// //----------------- CANVAS C6 --------------//
// c6->SetFillColor(0);
// c6->cd();
// leg = new TLegend(0.50,0.25,0.90,0.40);
// leg->SetBorderSize(1);
// leg->SetFillColor(0);
// leg->SetTextFont(42);
// // Mass VS muon phi minus -------------------------------
// TH2D *histoMassVsEtaPhiMinus[nOfFiles];
// for(Int_t j=0; j < nOfFiles; j++) {
// TFile *fin = (TFile*)FileList->At(j);
// if (( histoMassVsEtaPhiMinus[j] = (TH2D*)fin->Get("MassVsEtaPhiMinus/allHistos/meanHisto"))){
// if ( j == 0 ) {
// histoMassVsEtaPhiMinus[j]->GetXaxis()->SetTitle("negative muon #phi (rad)");
// histoMassVsEtaPhiMinus[j]->GetYaxis()->SetTitle("negative muon #eta");
// zMin = histoMassVsEtaPhiMinus[j]->GetMinimum();
// zMax = histoMassVsEtaPhiMinus[j]->GetMaximum();
// histoMassVsEtaPhiMinus[j]->Draw();
// } else {
// histoMassVsEtaPhiMinus[j]->SetMinimum(zMin);
// histoMassVsEtaPhiMinus[j]->SetMaximum(zMax);
// histoMassVsEtaPhiMinus[j]->Draw("SAME");
// }
// leg->AddEntry(histoMassVsEtaPhiMinus[j],LegLabels[j],"PL");
// }
// }
// //cmsprel->Draw("same");
// leg->Draw("same");
// c6->SaveAs(outDir+"MassVsEtaPhiMinus.png");
// newStyle->SetOptTitle(0);
const Color_t colorlist_resol[7]={kBlack,kGreen,kBlue,kMagenta,kCyan,kTeal,kRed};
const Int_t linestylelist_resol[7]={1,1,1,1,1,1,1};
const Int_t stylelist_resol[7]={1,1,1,1,1,1,1};
const Style_t markerstylelist_resol[7]={kOpenCircle,kOpenTriangleUp,kOpenTriangleUp,kOpenCircle,kOpenTriangleUp,kOpenCircle,kOpenTriangleUp};
// //----------------- CANVAS C0S --------------//
// c0s->SetFillColor(0);
// c0s->cd();
// leg = new TLegend(0.50,0.25,0.90,0.40);
// leg->SetBorderSize(1);
// leg->SetFillColor(0);
// leg->SetTextFont(42);
// // Sigma VS muon phi plus -------------------------------
// TH1D *histoSigmaVsPhiPlus[nOfFiles];
// for(Int_t j=0; j < nOfFiles; j++) {
// TFile *fin = (TFile*)FileList->At(j);
// if (( histoSigmaVsPhiPlus[j] = (TH1D*)fin->Get("MassVsPhiPlus/allHistos/sigmaHisto"))){
// histoSigmaVsPhiPlus[j]->SetLineStyle(linestylelist_resol[j]);
// histoSigmaVsPhiPlus[j]->SetMarkerColor(colorlist_resol[j]);
// histoSigmaVsPhiPlus[j]->SetLineColor(colorlist_resol[j]);
// histoSigmaVsPhiPlus[j]->SetMarkerStyle(markerstylelist_resol[j]);
// // histoSigmaVsPhiPlus[j]->SetMarkerSize(0.75);
// if ( j == 0 ) {
// histoSigmaVsPhiPlus[j]->GetXaxis()->SetTitle("positive muon #phi (rad)");
// histoSigmaVsPhiPlus[j]->GetYaxis()->SetTitle("#sigma(M_{#mu#mu}) (GeV)");
// // histoSigmaVsPhiPlus[j]->GetYaxis()->SetRangeUser(88.5,93.5);
// histoSigmaVsPhiPlus[j]->GetYaxis()->SetRangeUser(0.,3.);
// histoSigmaVsPhiPlus[j]->GetXaxis()->SetRangeUser(-3.14,3.14);
// histoSigmaVsPhiPlus[j]->Draw();
// } else {
// histoSigmaVsPhiPlus[j]->Draw("SAME");
// }
// leg->AddEntry(histoSigmaVsPhiPlus[j],LegLabels[j],"PL");
// }
// }
// //cmsprel->Draw("same");
// leg->Draw("same");
// c0s->SaveAs(outDir+"SigmaVsPhiPlus.png");
//----------------- CANVAS C1S --------------//
c1s->SetFillColor(0);
c1s->cd();
leg = new TLegend(0.50,0.25,0.90,0.40);
leg->SetBorderSize(1);
leg->SetFillColor(0);
leg->SetTextFont(42);
// Sigma VS muon eta plus -------------------------------
TH1D *histoSigmaVsEtaPlus[nOfFiles];
for(Int_t j=0; j < nOfFiles; j++) {
TFile *fin = (TFile*)FileList->At(j);
if (( histoSigmaVsEtaPlus[j] = (TH1D*)fin->Get("MassVsEtaPlus/allHistos/sigmaHisto"))){
histoSigmaVsEtaPlus[j]->SetLineStyle(linestylelist_resol[j]);
histoSigmaVsEtaPlus[j]->SetMarkerColor(colorlist_resol[j]);
histoSigmaVsEtaPlus[j]->SetLineColor(colorlist_resol[j]);
histoSigmaVsEtaPlus[j]->SetMarkerStyle(markerstylelist_resol[j]);
// histoSigmaVsEtaPlus[j]->SetMarkerSize(0.75);
if ( j == 0 ) {
histoSigmaVsEtaPlus[j]->GetXaxis()->SetTitle("positive muon #eta");
histoSigmaVsEtaPlus[j]->GetYaxis()->SetTitle("#sigma(M_{#mu#mu}) (GeV)");
// histoSigmaVsEtaPlus[j]->GetYaxis()->SetRangeUser(88.5,93.5);
histoSigmaVsEtaPlus[j]->GetYaxis()->SetRangeUser(0.,3.);
histoSigmaVsEtaPlus[j]->GetXaxis()->SetRangeUser(-2.41,2.41);
histoSigmaVsEtaPlus[j]->Draw();
} else {
histoSigmaVsEtaPlus[j]->Draw("SAME");
}
leg->AddEntry(histoSigmaVsEtaPlus[j],LegLabels[j],"PL");
}
}
//cmsprel->Draw("same");
leg->Draw("same");
c1s->SaveAs(outDir+"SigmaVsEtaPlus.png");
// //----------------- CANVAS C2S --------------//
// c2s->SetFillColor(0);
// c2s->cd();
// leg = new TLegend(0.50,0.25,0.90,0.40);
// leg->SetBorderSize(1);
// leg->SetFillColor(0);
// leg->SetTextFont(42);
// // Sigma VS muon eta plus - eta minus -------------------------------
// TH1D *histoSigmaVsEtaPlusMinusDiff[nOfFiles];
// for(Int_t j=0; j < nOfFiles; j++) {
// TFile *fin = (TFile*)FileList->At(j);
// if (( histoSigmaVsEtaPlusMinusDiff[j] = (TH1D*)fin->Get("MassVsEtaPlusMinusDiff/allHistos/sigmaHisto"))){
// histoSigmaVsEtaPlusMinusDiff[j]->SetLineStyle(linestylelist_resol[j]);
// histoSigmaVsEtaPlusMinusDiff[j]->SetMarkerColor(colorlist_resol[j]);
// histoSigmaVsEtaPlusMinusDiff[j]->SetLineColor(colorlist_resol[j]);
// histoSigmaVsEtaPlusMinusDiff[j]->SetMarkerStyle(markerstylelist_resol[j]);
// // histoSigmaVsEtaPlusMinusDiff[j]->SetMarkerSize(0.75);
// if ( j == 0 ) {
// histoSigmaVsEtaPlusMinusDiff[j]->GetXaxis()->SetTitle("#eta pos. muon - #eta neg. muon");
// histoSigmaVsEtaPlusMinusDiff[j]->GetYaxis()->SetTitle("#sigma(M_{#mu#mu}) (GeV)");
// // histoSigmaVsEtaPlusMinusDiff[j]->GetYaxis()->SetRangeUser(88.0,96.0);
// histoSigmaVsEtaPlusMinusDiff[j]->GetYaxis()->SetRangeUser(0.,3.);
// //histoSigmaVsEtaPlusMinusDiff[j]->GetYaxis()->SetRangeUser(90.60,90.75);
// histoSigmaVsEtaPlusMinusDiff[j]->GetXaxis()->SetRangeUser(-3.2,3.2);
// histoSigmaVsEtaPlusMinusDiff[j]->Draw();
// } else {
// histoSigmaVsEtaPlusMinusDiff[j]->Draw("SAME");
// }
// leg->AddEntry(histoSigmaVsEtaPlusMinusDiff[j],LegLabels[j],"PL");
// }
// }
// //cmsprel->Draw("same");
// leg->Draw("same");
// c2s->SaveAs(outDir+"SigmaVsEtaPlusMinusDiff.png");
// //----------------- CANVAS C3S --------------//
// c3s->SetFillColor(0);
// c3s->cd();
// leg = new TLegend(0.35,0.15,0.55,0.35);
// leg->SetBorderSize(1);
// leg->SetFillColor(0);
// leg->SetTextFont(42);
// // Sigma VS muon pT -------------------------------
// TH1D *histoSigmaVsPt[nOfFiles];
// for(Int_t j=0; j < nOfFiles; j++) {
// TFile *fin = (TFile*)FileList->At(j);
// if (( histoSigmaVsPt[j] = (TH1D*)fin->Get("MassVsPt/allHistos/sigmaHisto"))){
// histoSigmaVsPt[j]->SetLineStyle(linestylelist_resol[j]);
// histoSigmaVsPt[j]->SetMarkerColor(colorlist_resol[j]);
// histoSigmaVsPt[j]->SetLineColor(colorlist_resol[j]);
// histoSigmaVsPt[j]->SetMarkerStyle(markerstylelist_resol[j]);
// // histoSigmaVsPt[j]->SetMarkerSize(0.75);
// if ( j == 0 ) {
// histoSigmaVsPt[j]->GetXaxis()->SetTitle("muon p_T (GeV)");
// histoSigmaVsPt[j]->GetYaxis()->SetTitle("#sigma(M_{#mu#mu}) (GeV)");
// // histoSigmaVsPt[j]->GetYaxis()->SetRangeUser(88.0,96.0);
// histoSigmaVsPt[j]->GetYaxis()->SetRangeUser(0.,3.);
// //histoSigmaVsPt[j]->GetYaxis()->SetRangeUser(90.60,90.75);
// histoSigmaVsPt[j]->GetXaxis()->SetRangeUser(15.,105.);
// histoSigmaVsPt[j]->Draw();
// } else {
// histoSigmaVsPt[j]->Draw("SAME");
// }
// leg->AddEntry(histoSigmaVsPt[j],LegLabels[j],"PL");
// }
// }
// //cmsprel->Draw("same");
// leg->Draw("same");
// c3s->SaveAs(outDir+"SigmaVsPt.png");
//----------------- CANVAS CFIT --------------//
cFit->SetFillColor(0);
cFit->cd();
Float_t nN = TMath::Sqrt(nOfFiles);
Int_t nX = (Int_t)nN;
if ( nN-nX > 0.5 ) nX++;
Int_t nY = (Int_t)(nOfFiles/nX);
std::cout << nX << " ," << nY << std::endl;
cFit->Divide(nOfFiles,1);
// Mass VS muon phi plus -------------------------------
TFile *ZFitFile = new TFile("ZFitFile.root","RECREATE");
RooPlot *histoLineShape[nOfFiles];
for(Int_t j=0; j < nOfFiles; j++) {
TFile *fin = (TFile*)FileList->At(j);
if (( histoLineShape[j] = (RooPlot*)fin->Get("hRecBestResAllEvents_Mass_frame"))){
std::cout<<"Writing fit histogrem file n. "<<j<<std::endl;
histoLineShape[j]->Write();
cFit->cd(j+1);
histoLineShape[j]->SetTitle(LegLabels[j]);
histoLineShape[j]->Draw();
histoLineShape[j]->GetXaxis()->SetTitle("M_{#mu#mu} (GeV)");
// TPaveText *cmsprel2 = new TPaveText(0.19, 0.95, 0.95, 0.99, "NDC");
// cmsprel2->SetTextSize(0.03);
// cmsprel2->SetTextFont(42);
// cmsprel2->SetFillColor(0);
// cmsprel2->SetBorderSize(0);
// cmsprel2->SetMargin(0.01);
// cmsprel2->SetTextAlign(12); // align left
// cmsprel2->AddText(0.666666, 0.5, LegLabels[j]);
}
}
ZFitFile->Close();
// cmsprel2->Draw("same");
cFit->SaveAs("ZFitFile.root");
return;
};
void TestWithSubQuery(embDB::TBPVector<embDB::ZOrderPoint2DU32>& vecPoint, CommonLib::TRect2D<uint32>& extent)
{
/*embDB::TBPVector<embDB::ZOrderPoint2DU32> vecQueryPoint;
for (uint32 x = extent.m_minX; x < extent.m_maxX + 1; ++x)
{
for (uint32 y = extent.m_minY; y < extent.m_maxY + 1; ++y)
{
embDB::ZOrderPoint2DU32 zVal(x, y);
vecQueryPoint.push_back(zVal);
}
}
embDB::ZPointComp<embDB::ZOrderPoint2DU32> comp;
vecQueryPoint.quick_sort(comp);
*/
embDB::ZPointComp<embDB::ZOrderPoint2DU32> comp;
embDB::ZOrderPoint2DU32 zMin(extent.m_minX, extent.m_minY);
embDB::ZOrderPoint2DU32 zMax(extent.m_maxX, extent.m_maxY);
embDB::ZOrderPoint2DU32 zLast;
embDB::ZOrderPoint2DU32 zOutMin = zMin;
short nType = 0;
int nIndex = vecPoint.lower_bound(zMin,nType, comp);
int nInRect = 0;
int nInOut = 0;
int nTotal = 0;
for (size_t i = nIndex; i < vecPoint.size();)
{
if(comp.LE(zMax, vecPoint[i]))
break;
uint32 x, y;
embDB::ZOrderPoint2DU32 zVal = vecPoint[i];
vecPoint[i].getXY(x, y);
if(extent.isPoinInRect(x, y))
{
nInRect++;
++i;
zLast = zVal;
}
else
{
nInOut++;
int nQIndex = vecPoint.lower_bound(zVal,nType, comp);
embDB::ZOrderPoint2DU32 zQVal = nQIndex == vecPoint.size() ? vecPoint.back() : vecPoint[nQIndex];
embDB::ZOrderPoint2DU32 zQValFind;
FindMinZVal(zVal, zMin, zMax, zQValFind);
if(zQVal.m_nZValue != zQValFind.m_nZValue)
{
uint32 x1, y1;
zOutMin.getXY(x1, y1);
int d = 0;
d++;
}
uint32 x1, y1;
zQValFind.getXY(x1, y1);
zOutMin = embDB::ZOrderPoint2DU32(x1, extent.m_minY);
int index = vecPoint.lower_bound(/*zQVal*/zQValFind,nType,comp);
if(index <= i)
{
int d = 0;
d++;
}
i = index;
}
nTotal++;
}
std::cout<< "TestWithSubQuery InRect " << nInRect << " InOut " << nInOut << " Total " << nTotal << std::endl;
}
