treeNode* myTree(treeNode *head,char inBoard[BOARDROWS][BOARDCOLS],char pColour, char cColour){
char boardHolder[BOARDROWS][BOARDCOLS];
int numChildren;
node* ptr;
if (head->board[0][0] != 'W' && head->board[0][0] != 'B' && head->board[0][0] != 'O' ){
copyBoard(inBoard,head->board);
}
if (head->numChildren == 0){
node* moves = getMoves(head->board,cColour,pColour);
numChildren = getListSize(moves);
head->numChildren = numChildren;
//printf("Generated %i moves from the head node.\n", numChildren);
head->children = malloc(sizeof(treeNode) * numChildren);
for(int i=0;i<numChildren;i++){
// printf("for\n");
copyBoard(head->board,boardHolder);
applyMove(moves,boardHolder);
//printBoard(boardHolder);
head->children[i] = malloc(sizeof(treeNode));
copyBoard(boardHolder,head->children[i]->board);
head->children[i]->numChildren = 0;
ptr = moves->next;
free(moves);
moves = ptr;
}
}else{//this should happen when there are already children in the tree
for(int i=0;i<head->numChildren;i++){
head->children[i] = myTree(head->children[i],head->children[i]->board,cColour,pColour);
}
}
return head;
}
void FillHistograms(TString SAMPLE)
{
cout<<"Processing sample "<<SAMPLE<<endl;
//TString PATH("root://eoscms//eos/cms/store/cmst3/user/kkousour/ttH/flat/");
TString PATH("/afs/cern.ch/work/k/kkousour/private/CMSSW_7_4_12/src/KKousour/TopAnalysis/prod/ttH/");
TFile *inf = TFile::Open(PATH+"flatTree_"+SAMPLE+".root");
TFile *outf = TFile::Open(TString::Format("Histo_%s.root",SAMPLE.Data()),"RECREATE");
TIter nextKey(inf->GetListOfKeys());
TKey *key;
while ((key = (TKey*)nextKey())) {
TString dirName(key->GetName());
cout<<"Found directory "<<dirName<<endl;
TH1F *hPass = (TH1F*)inf->Get(dirName+"/TriggerPass");
outf->mkdir(dirName);
TDirectory *dir = (TDirectory*)outf->Get(dirName);
TTree *tr = (TTree*)inf->Get(dirName+"/events");
TreeClass myTree(tr);
dir->cd();
hPass->Write("TriggerPass");
myTree.Loop(dir);
cout<<"Loop finished"<<endl;
dir->Close();
delete tr;
}
outf->Close();
inf->Close();
}
int main(int argc, char *argv[]) {
if (argc != 2) {
showUsage(argc, argv, "tree directory");
return;
}
myTree(argv[1], 0);
}
void FillHistograms(TString SAMPLE)
{
cout<<"Processing sample "<<SAMPLE<<endl;
TString PATH("../../prod/ttbar/");
TFile *inf = TFile::Open(PATH+"flatTree_"+SAMPLE+".root");
TFile *outf = TFile::Open(TString::Format("Histo_%s.root",SAMPLE.Data()),"RECREATE");
TIter nextKey(inf->GetListOfKeys());
TKey *key;
while ((key = (TKey*)nextKey())) {
TString dirName(key->GetName());
cout<<"Found directory "<<dirName<<endl;
TH1F *hPass = (TH1F*)inf->Get(dirName+"/TriggerPass");
outf->mkdir(dirName);
TDirectory *dir = (TDirectory*)outf->Get(dirName);
TTree *tr = (TTree*)inf->Get(dirName+"/events");
if (dirName.Contains("Boost")) {
TreeClassBoosted myTree(tr);
dir->cd();
hPass->Write("TriggerPass");
myTree.Loop(dir);
cout<<"Loop finished"<<endl;
dir->Close();
cout<<"directory closed"<<endl;
delete tr;
cout<<"Tree deleted"<<endl;
}
else {
TreeClassResolved myTree(tr);
dir->cd();
hPass->Write("TriggerPass");
myTree.Loop(dir);
cout<<"Loop finished"<<endl;
dir->Close();
cout<<"directory closed"<<endl;
delete tr;
cout<<"Tree deleted"<<endl;
}
}
outf->Close();
inf->Close();
}
int main(int argc, char* argv[]) {
Tree myTree(5);
myTree.insert(4);
myTree.insert(6);
myTree.insert(10);
myTree.insert(24);
myTree.print();
return 0;
}
int main(void)
{
typedef tree<double> treeType;
typedef treeType::subTreeType subTreeType;
treeType myTree(0);
myTree.addSubTree(std::unique_ptr<subTreeType>(new treeType(1)));
myTree.printTree();
return 0;
}
int main(int argc, char *argv[])
{
std::string initName = cli::inputName();
tree::Tree myTree(initName);
cli::printUseMsg();
char ch;
while (std::cin >> ch)
{
cli::clear();
switch(ch)
{
case 'H':
case 'h':
{
cli::printHelpMsg();
break;
}
case 'I':
case 'i':
{
std::string iName = cli::inputName();
if (cli::chooseBranch())
try
{
myTree > iName;
}
catch(tree::InsertError& e)
{
std::cout << e << std::endl;
}
else
try
{
myTree < iName;
}
catch(tree::InsertError& e)
{
std::cout << e << std::endl;
}
break;
}
case 'U':
case 'u':
{
myTree.setName(cli::inputName());
break;
}
case 'd':
case 'D':
{
if (cli::chooseBranch())
{
myTree.deleteRight();
}
else
{
myTree.deleteLeft();
}
break;
}
case 'L':
case 'l':
{
try
{
myTree.moveLeft();
}
catch (tree::AddressError& e)
{
std::cout << e << std::endl;
}
break;
}
case 'R':
case 'r':
{
try
{
myTree.moveRight();
}
catch (tree::AddressError& e)
{
std::cout << e << std::endl;
}
break;
}
case 'T':
case 't':
{
myTree.moveTop();
break;
}
case 'G':
case 'g':
{
std::string oName = myTree.getName();
std::string oLeftName = "NULL";
std::string oRightName = "NULL";
try
{
myTree.moveLeft();
oLeftName = myTree.getName();
myTree.moveTop();
}
catch (tree::AddressError)
{
oLeftName = "NULL";
}
try
{
myTree.moveRight();
oRightName = myTree.getName();
myTree.moveTop();
}
catch (tree::AddressError)
{
oRightName = "NULL";
}
std::cout << oName << ": "
<< oLeftName << ", "
<< oRightName << std::endl;
break;
}
case 'P':
case 'p':
{
std::cout << myTree;
break;
}
case 'Q':
case 'q':
{
return 0;
}
default:
break;
}
}
return 0;
}
void myTree(char *path, int level) {
if (level > 5) {
return;
}
int i = 0;
char flagChar = '-';
if (isDir(path) == 1) {
int pathLength = strlen(path);
DIR *dir;
struct dirent *ptr;
char *tempPath = NULL;
int tempPathSize = 0;
int pathIsNew = 0;
if (*(path + pathLength - 1) != '/') {
tempPath = malloc(pathLength + 2);
memcpy(tempPath, path, pathLength);
memcpy(tempPath + pathLength, suffix, 2);
path = tempPath;
tempPath = NULL;
pathLength++;
pathIsNew = 1;
}
dir = opendir(path);
while ((ptr = readdir(dir)) != NULL) {
if (strcmp(ptr->d_name, ".") == 0 || strcmp(ptr->d_name, "..") == 0) {
continue;
}
if ((pathLength + strlen(ptr->d_name) + 1) > tempPathSize) {
if (tempPath != NULL) {
free(tempPath);
}
tempPathSize = pathLength + strlen(ptr->d_name) + 1;
tempPath = malloc(pathLength + strlen(ptr->d_name) + 1);
}
memcpy(tempPath, path, pathLength);
memcpy(tempPath + pathLength, ptr->d_name, strlen(ptr->d_name) + 1);
putcharRepeat(flagChar, level);
printf("%s\n", tempPath);
if (isDir(tempPath) == 1) {
putcharRepeat(flagChar, level);
myTree(tempPath, level + 1);
}
}
if (tempPath != NULL) {
free(tempPath);
tempPath = NULL;
}
if (pathIsNew == 1) {
free(path);
}
closedir(dir);
} else {
putcharRepeat(flagChar, level);
printf("%s\n", path);
}
}
int main(int argc, char** argv)
{
//Check if all nedeed arguments to parse are there
if(argc != 2)
{
std::cerr << ">>>>> analysis.cpp::usage: " << argv[0] << " configFileName" << std::endl ;
return 1;
}
// Parse the config file
parseConfigFile (argv[1]) ;
std::string treeName = gConfigParser -> readStringOption("Input::treeName");
std::string inputFile = gConfigParser -> readStringOption("Input::inputFile");
int entryMAX = gConfigParser -> readIntOption("Input::entryMAX");
int entryMIN = gConfigParser -> readIntOption("Input::entryMIN");
int entryMOD = gConfigParser -> readIntOption("Input::entryMOD");
std::cout << ">>>>> input::entryMIN " << entryMIN << std::endl;
std::cout << ">>>>> input::entryMAX " << entryMAX << std::endl;
std::cout << ">>>>> input::entryMOD " << entryMOD << std::endl;
// Open ntple
TChain* chain = new TChain(treeName.c_str());
chain->Add(inputFile.c_str());
treeReader reader((TTree*)(chain));
///----------------
///---- output ----
std::string OutFileName = gConfigParser -> readStringOption("Output::outFileName");
std::cout << ">>>>> Output::outFileName " << OutFileName << std::endl;
TFile outFile(OutFileName.c_str(),"RECREATE");
outFile.cd();
TTree myTree("myTree","myTree");
double Eta;
double pT;
double ET;
double EoP;
double SwissE4;
double MaxEnergy;
TH2F *h2ShowerShapeEB = new TH2F("h2ShowerShapeEB","Shower Shape i#phi i#eta",170,-85,85,360,0,360);
TH2F *h2ShowerShapeEE = new TH2F("h2ShowerShapeEE","Shower Shape ix iy",100,0,100,100,0,100);
h2ShowerShapeEB->GetXaxis()->SetTitle("i#eta");
h2ShowerShapeEB->GetYaxis()->SetTitle("i#phi");
h2ShowerShapeEE->GetXaxis()->SetTitle("ix");
h2ShowerShapeEE->GetYaxis()->SetTitle("iy");
myTree.Branch("Eta",&Eta,"Eta/D");
myTree.Branch("ET",&ET,"ET/D");
myTree.Branch("pT",&pT,"pT/D");
myTree.Branch("EoP",&EoP,"EoP/D");
myTree.Branch("SwissE4",&SwissE4,"SwissE4/D");
myTree.Branch("MaxEnergy",&MaxEnergy,"MaxEnergy/D");
myTree.Branch("h2ShowerShapeEB","TH2F",&h2ShowerShapeEB,128000,0);
myTree.Branch("h2ShowerShapeEE","TH2F",&h2ShowerShapeEE,128000,0);
double start, end;
if (entryMAX == -1) entryMAX = reader.GetEntries();
else if (reader.GetEntries() < entryMAX) entryMAX = reader.GetEntries();
start = clock();
for(int iEvent = entryMIN ; iEvent < entryMAX ; ++iEvent) {
reader.GetEntry(iEvent);
if((iEvent%entryMOD) == 0) std::cout << ">>>>> analysis::GetEntry " << iEvent << ":" << entryMAX << std::endl;
h2ShowerShapeEB->Reset();
h2ShowerShapeEE->Reset();
int nXtal = reader.GetFloat("E_xtal")->size();
for (int iXtal = 0; iXtal < nXtal; iXtal++){
if (reader.GetInt("ix_xtal")->at(iXtal) == -1000) {
///==== Barrel EB ====
h2ShowerShapeEB->Fill(reader.GetInt("ieta_xtal")->at(iXtal),reader.GetInt("iphi_xtal")->at(iXtal),reader.GetFloat("E_xtal")->at(iXtal));
}
else {
///==== Endcap EE ====
h2ShowerShapeEE->Fill(reader.GetInt("ix_xtal")->at(iXtal),reader.GetInt("iy_xtal")->at(iXtal),reader.GetFloat("E_xtal")->at(iXtal));
}
}
if (reader.GetInt("runId")->size()!=0){
TString TitleEB = Form ("Shower Shape i#phi i#eta Run = %d --- lumi = %d --- event = %d",reader.GetInt("runId")->at(0),reader.GetInt("lumiId")->at(0),reader.GetInt("eventId")->at(0));
h2ShowerShapeEB->SetTitle(TitleEB);
TString TitleEE = Form ("Shower Shape ix iy Run = %d --- lumi = %d --- event = %d",reader.GetInt("runId")->at(0),reader.GetInt("lumiId")->at(0),reader.GetInt("eventId")->at(0));
h2ShowerShapeEE->SetTitle(TitleEE);
}
int nEles = reader.Get4V("electrons")->size();
for (int iEle = 0; iEle < nEles; iEle++){
// std::cerr << "iEle = " << iEle << " : " << nEles << std::endl;
if (
(reader.Get4V("met")->at(0)).Et() > 20
&& reader.Get4V("electrons")->at(iEle).Pt() > 10
&& reader.Get4V("electrons")->at(iEle).Pt() < 60
&& deltaPhi(reader.Get4V("electrons")->at(iEle).Phi(),(reader.Get4V("met")->at(0)).Phi()) > 0.75
&& (((reader.Get4V("met")->at(0)).Et() / reader.GetFloat("sumEt")->at(0)) > (-0.07 * (reader.Get4V("met")->at(0)).Et() + 3.5 )
|| ((reader.Get4V("met")->at(0)).Et() / reader.GetFloat("sumEt")->at(0)) > 0.4)
)
{
std::cerr << "selected ..." << std::endl;
pT = reader.Get4V("electrons")->at(iEle).Pt();
ET = (reader.GetFloat("electrons_scE")->at(iEle)) * sin(reader.Get4V("electrons")->at(iEle).Theta());
EoP = reader.GetFloat("electrons_eOverP")->at(iEle);
Eta = reader.Get4V("electrons")->at(iEle).Eta();
SwissE4 = reader.GetFloat("SwissE4")->at(iEle);
MaxEnergy = reader.GetFloat("MaxEnergy")->at(iEle);
myTree.Fill();
}
}
} //loop over the events
end = clock();
std::cout <<"Time = " << ((double) (end - start)) << " (a.u.)" << std::endl;
myTree.Write();
outFile.Write();
return 0;
}
void EffRapPbPb1S(){ // Change function name
gROOT->Macro("logon.C+");
TChain myTree("hionia/myTree"); // Change source of tree
myTree.Add("/scratch_menkar/CMS_Trees/OniaTrees_2015_5TeV/PbPb_MC_Official/OniaTree_Pythia8_Ups1SMM_ptUps_00_03_Hydjet_MB_HINPbPbWinter16DR-75X_mcRun2_HeavyIon_v13-v1.root"); // Change tree being added (Different for pp1S, pp2S, PbPb1S, PbPb2S)
myTree.Add("/scratch_menkar/CMS_Trees/OniaTrees_2015_5TeV/PbPb_MC_Official/OniaTree_Pythia8_Ups1SMM_ptUps_03_06_Hydjet_MB_HINPbPbWinter16DR-75X_mcRun2_HeavyIon_v13-v1.root");
myTree.Add("/scratch_menkar/CMS_Trees/OniaTrees_2015_5TeV/PbPb_MC_Official/OniaTree_Pythia8_Ups1SMM_ptUps_06_09_Hydjet_MB_HINPbPbWinter16DR-75X_mcRun2_HeavyIon_v13-v1.root");
myTree.Add("/scratch_menkar/CMS_Trees/OniaTrees_2015_5TeV/PbPb_MC_Official/OniaTree_Pythia8_Ups1SMM_ptUps_09_12_Hydjet_MB_HINPbPbWinter16DR-75X_mcRun2_HeavyIon_v13-v1.root");
myTree.Add("/scratch_menkar/CMS_Trees/OniaTrees_2015_5TeV/PbPb_MC_Official/OniaTree_Pythia8_Ups1SMM_ptUps_12_15_Hydjet_MB_HINPbPbWinter16DR-75X_mcRun2_HeavyIon_v13-v1.root");
myTree.Add("/scratch_menkar/CMS_Trees/OniaTrees_2015_5TeV/PbPb_MC_Official/OniaTree_Pythia8_Ups1SMM_ptUps_15_30_Hydjet_MB_HINPbPbWinter16DR-75X_mcRun2_HeavyIon_v13-v1.root");
Float_t muMiDxy;
Float_t muMiDz;
Int_t muMiNPxlLayers;
Int_t muMiNTrkLayers;
Bool_t muMiGoodMu;
Float_t muPlDxy;
Float_t muPlDz;
Int_t muPlNPxlLayers;
Int_t muPlNTrkLayers;
Bool_t muPlGoodMu;
Float_t vProb;
double ptWeight;
double ptWeightArr[6]={3.10497,4.11498,2.2579,1.2591,0.567094,0.783399};
double centWeight;
double RapBin[nRapBin] = {0.6,1.8}; // RapBin
double RapBinErr[nRapBin] = {0.6,0.6}; // RapBinErr
Float_t RapBinEdges[nRapBin+1] = {0,1.2,2.4};
double ptReweight;
Int_t Centrality;
ULong64_t HLTriggers;
Int_t Reco_QQ_size;
Int_t Reco_QQ_sign[36]; //[Reco_QQ_size]
TClonesArray *Reco_QQ_4mom;
TClonesArray *Reco_QQ_mupl_4mom;
TClonesArray *Reco_QQ_mumi_4mom;
ULong64_t Reco_QQ_trig[36]; //[Reco_QQ_size]
Float_t Reco_QQ_VtxProb[36]; //[Reco_QQ_size]
Bool_t Reco_QQ_mupl_isGoodMuon[36]; //[Reco_QQ_size]
Bool_t Reco_QQ_mumi_isGoodMuon[36]; //[Reco_QQ_size]
Int_t Reco_QQ_mupl_nPixWMea[36]; //[Reco_QQ_size]
Int_t Reco_QQ_mumi_nPixWMea[36]; //[Reco_QQ_size]
Int_t Reco_QQ_mupl_nTrkWMea[36]; //[Reco_QQ_size]
Int_t Reco_QQ_mumi_nTrkWMea[36]; //[Reco_QQ_size]
Float_t Reco_QQ_mupl_dxy[36]; //[Reco_QQ_size]
Float_t Reco_QQ_mumi_dxy[36]; //[Reco_QQ_size]
Float_t Reco_QQ_mupl_dz[36]; //[Reco_QQ_size]
Float_t Reco_QQ_mumi_dz[36]; //[Reco_QQ_size]
Int_t Gen_QQ_size;
Int_t Gen_QQ_sign[36]; //[Gen_QQ_size]
TClonesArray *Gen_QQ_4mom;
TClonesArray *Gen_QQ_mupl_4mom;
TClonesArray *Gen_QQ_mumi_4mom;
Float_t Gen_QQ_VtxProb[36]; //[Gen_QQ_size]
Bool_t Gen_QQ_mupl_isGoodMuon[36]; //[Gen_QQ_size]
Bool_t Gen_QQ_mumi_isGoodMuon[36]; //[Gen_QQ_size]
Int_t Gen_QQ_mupl_nPixWMea[36]; //[Gen_QQ_size]
Int_t Gen_QQ_mumi_nPixWMea[36]; //[Gen_QQ_size]
Int_t Gen_QQ_mupl_nTrkWMea[36]; //[Gen_QQ_size]
Int_t Gen_QQ_mumi_nTrkWMea[36]; //[Gen_QQ_size]
Float_t Gen_QQ_mupl_dxy[36]; //[Gen_QQ_size]
Float_t Gen_QQ_mumi_dxy[36]; //[Gen_QQ_size]
Float_t Gen_QQ_mupl_dz[36]; //[Gen_QQ_size]
Float_t Gen_QQ_mumi_dz[36]; //[Gen_QQ_size]
TBranch *b_Centrality; //!
TBranch *b_HLTriggers; //!
TBranch *b_Reco_QQ_size; //!
TBranch *b_Reco_QQ_sign; //!
TBranch *b_Reco_QQ_4mom; //!
TBranch *b_Reco_QQ_mupl_4mom; //!
TBranch *b_Reco_QQ_mumi_4mom; //!
TBranch *b_Reco_QQ_trig; //!
TBranch *b_Reco_QQ_VtxProb; //!
TBranch *b_Reco_QQ_mupl_isGoodMuon; //!
TBranch *b_Reco_QQ_mumi_isGoodMuon; //!
TBranch *b_Reco_QQ_mupl_nPixWMea; //!
TBranch *b_Reco_QQ_mumi_nPixWMea; //!
TBranch *b_Reco_QQ_mupl_nTrkWMea; //!
TBranch *b_Reco_QQ_mumi_nTrkWMea; //!
TBranch *b_Reco_QQ_mupl_dxy; //!
TBranch *b_Reco_QQ_mumi_dxy; //!
TBranch *b_Reco_QQ_mupl_dz; //!
TBranch *b_Reco_QQ_mumi_dz; //!
TBranch *b_Gen_QQ_size; //
TBranch *b_Gen_QQ_4mom; //!
TBranch *b_Gen_QQ_mupl_4mom; //!
TBranch *b_Gen_QQ_mumi_4mom; //!
//Set object pointer, Initialize
Reco_QQ_4mom = 0;
Reco_QQ_mupl_4mom = 0;
Reco_QQ_mumi_4mom = 0;
Gen_QQ_4mom = 0;
Gen_QQ_mupl_4mom = 0;
Gen_QQ_mumi_4mom = 0;
myTree.SetBranchAddress("Centrality", &Centrality, &b_Centrality);
myTree.SetBranchAddress("HLTriggers", &HLTriggers, &b_HLTriggers);
myTree.SetBranchAddress("Reco_QQ_size", &Reco_QQ_size, &b_Reco_QQ_size);
myTree.SetBranchAddress("Reco_QQ_sign", Reco_QQ_sign, &b_Reco_QQ_sign);
myTree.SetBranchAddress("Reco_QQ_4mom", &Reco_QQ_4mom, &b_Reco_QQ_4mom);
myTree.SetBranchAddress("Reco_QQ_mupl_4mom", &Reco_QQ_mupl_4mom, &b_Reco_QQ_mupl_4mom);
myTree.SetBranchAddress("Reco_QQ_mumi_4mom", &Reco_QQ_mumi_4mom, &b_Reco_QQ_mumi_4mom);
myTree.SetBranchAddress("Reco_QQ_trig", Reco_QQ_trig, &b_Reco_QQ_trig);
myTree.SetBranchAddress("Reco_QQ_VtxProb", Reco_QQ_VtxProb, &b_Reco_QQ_VtxProb);
myTree.SetBranchAddress("Reco_QQ_mupl_isGoodMuon", Reco_QQ_mupl_isGoodMuon, &b_Reco_QQ_mupl_isGoodMuon);
myTree.SetBranchAddress("Reco_QQ_mumi_isGoodMuon", Reco_QQ_mumi_isGoodMuon, &b_Reco_QQ_mumi_isGoodMuon);
myTree.SetBranchAddress("Reco_QQ_mupl_nPixWMea", Reco_QQ_mupl_nPixWMea, &b_Reco_QQ_mupl_nPixWMea);
myTree.SetBranchAddress("Reco_QQ_mumi_nPixWMea", Reco_QQ_mumi_nPixWMea, &b_Reco_QQ_mumi_nPixWMea);
myTree.SetBranchAddress("Reco_QQ_mupl_nTrkWMea", Reco_QQ_mupl_nTrkWMea, &b_Reco_QQ_mupl_nTrkWMea);
myTree.SetBranchAddress("Reco_QQ_mumi_nTrkWMea", Reco_QQ_mumi_nTrkWMea, &b_Reco_QQ_mumi_nTrkWMea);
myTree.SetBranchAddress("Reco_QQ_mupl_dxy", Reco_QQ_mupl_dxy, &b_Reco_QQ_mupl_dxy);
myTree.SetBranchAddress("Reco_QQ_mumi_dxy", Reco_QQ_mumi_dxy, &b_Reco_QQ_mumi_dxy);
myTree.SetBranchAddress("Reco_QQ_mupl_dz", Reco_QQ_mupl_dz, &b_Reco_QQ_mupl_dz);
myTree.SetBranchAddress("Reco_QQ_mumi_dz", Reco_QQ_mumi_dz, &b_Reco_QQ_mumi_dz);
myTree.SetBranchAddress("Gen_QQ_size", &Gen_QQ_size, &b_Gen_QQ_size);
myTree.SetBranchAddress("Gen_QQ_4mom", &Gen_QQ_4mom, &b_Gen_QQ_4mom);
myTree.SetBranchAddress("Gen_QQ_mupl_4mom", &Gen_QQ_mupl_4mom, &b_Gen_QQ_mupl_4mom);
myTree.SetBranchAddress("Gen_QQ_mumi_4mom", &Gen_QQ_mumi_4mom, &b_Gen_QQ_mumi_4mom);
TH1D *RecoEvents=new TH1D("RecoEvents","Reconstructed", nRapBin, RapBinEdges);
TH1D *GenEvents=new TH1D("GenEvents","Generated", nRapBin, RapBinEdges);
RecoEvents->Sumw2();
GenEvents->Sumw2();
// TH1D* hEff = new TH1D("Eff", "", nRapBin, RapBinEdges);
TFile* ReweightFunctions = new TFile("dNdpT_root5.root", "Open");
ReweightFunctions->GetObject("AA1S", AA1S);
ReweightFunctions->GetObject("AA1Smc", AA1Smc);
Long64_t nentries = myTree.GetEntries();
cout << nentries<<endl;
for (Long64_t jentry=0; jentry<nentries; jentry++){
myTree.GetEntry(jentry);
//looping over all the dimuons
for (int iQQ=0; iQQ<Reco_QQ_size;iQQ++){
TLorentzVector *qq4mom = (TLorentzVector*) Reco_QQ_4mom->At(iQQ);
TLorentzVector *mumi4mom = (TLorentzVector*) Reco_QQ_mumi_4mom->At(iQQ);
TLorentzVector *mupl4mom = (TLorentzVector*) Reco_QQ_mupl_4mom->At(iQQ);
//--Muid cuts for muon minus
muMiDxy=Reco_QQ_mumi_dxy[iQQ];
muMiDz=Reco_QQ_mumi_dz[iQQ];
muMiNPxlLayers=Reco_QQ_mumi_nPixWMea[iQQ];
muMiNTrkLayers=Reco_QQ_mumi_nTrkWMea[iQQ];
muMiGoodMu = Reco_QQ_mumi_isGoodMuon[iQQ];
//--Muid cuts for muon plus
muPlDxy=Reco_QQ_mupl_dxy[iQQ];
muPlDz=Reco_QQ_mupl_dz[iQQ];
muPlNPxlLayers=Reco_QQ_mupl_nPixWMea[iQQ];
muPlNTrkLayers=Reco_QQ_mupl_nTrkWMea[iQQ];
muPlGoodMu = Reco_QQ_mupl_isGoodMuon[iQQ];
vProb = Reco_QQ_VtxProb[iQQ];
bool mupl_cut = 0;
bool mumi_cut = 0;
bool acceptMu = 0;
bool trigL1Dmu = 0;
bool PtCutPass = 0;
bool MassCutPass = 0;
//--Muon id cuts
if( (muPlGoodMu==1) && muPlNTrkLayers> 5 && muPlNPxlLayers > 0 && TMath::Abs(muPlDxy) < 0.3 && TMath::Abs(muPlDz) < 20 && vProb > 0.01){mupl_cut = 1;}
if( (muMiGoodMu==1) && muMiNTrkLayers> 5 && muMiNPxlLayers > 0 && TMath::Abs(muMiDxy) < 0.3 && TMath::Abs(muMiDz) < 20 ){mumi_cut = 1;}
//check if muons are in acceptance
if(IsAccept(mupl4mom) && IsAccept(mumi4mom)){acceptMu = 1;}
if (PtCut(mupl4mom) && PtCut(mumi4mom)){ PtCutPass = 1; }
MassCutPass = MassCut(qq4mom, m1S_low, m1S_high);
//check if trigger bit is matched to dimuon
if((HLTriggers&1)==1 && (Reco_QQ_trig[iQQ]&1)==1){trigL1Dmu = 1;}
//weights only needed for PbPb
double weight = 0;
ptWeight=0;
centWeight = FindCenWeight(Centrality);
if(qq4mom->Pt()<=3){ptWeight = ptWeightArr[0];}
if(qq4mom->Pt()>3 && qq4mom->Pt()<=6){ptWeight = ptWeightArr[1];}
if(qq4mom->Pt()>6 && qq4mom->Pt()<=9){ptWeight = ptWeightArr[2];}
if(qq4mom->Pt()>9 && qq4mom->Pt()<=12){ptWeight = ptWeightArr[3];}
if(qq4mom->Pt()>12 && qq4mom->Pt()<=15){ptWeight = ptWeightArr[4];}
if(qq4mom->Pt()>15 && qq4mom->Pt()<=30){ptWeight = ptWeightArr[5];}
// if(qq4mom->Pt()<=30){ptReweight = PtReweight(qq4mom, PbPb1S_coefficient, PbPb1S_constant);}
if(qq4mom->Pt()<=30){ptReweight = (AA1S->Eval(qq4mom->Pt()))/(AA1Smc->Eval(qq4mom->Pt()));}
weight = centWeight*ptWeight*ptReweight;
bool L1Pass=0;
if (Reco_QQ_sign[iQQ]==0 && acceptMu && mupl_cut && mumi_cut && trigL1Dmu){L1Pass=1;}
if(qq4mom->Pt()<30 && Centrality < 160){
for(int i = 0; i<nRapBin;i++){
if(TMath::Abs(qq4mom->Rapidity())>(RapBin[i]-RapBinErr[i]) && TMath::Abs(qq4mom->Rapidity())<(RapBin[i]+RapBinErr[i])){
if(L1Pass == 1 && PtCutPass ==1 && MassCutPass == 1){RecoEvents->Fill(TMath::Abs(qq4mom->Rapidity()),weight);}
}
}
// */
// if(L1Pass == 1 && PtCutPass ==1 && MassCutPass == 1){RecoEvents->Fill(TMath::Abs(qq4mom->Rapidity()),weight);}
}
}
//Dinonminator loop
for (int iQQ=0; iQQ<Gen_QQ_size;iQQ++){
TLorentzVector *qq4mom = (TLorentzVector*) Gen_QQ_4mom->At(iQQ);
TLorentzVector *mumi4mom = (TLorentzVector*) Gen_QQ_mumi_4mom->At(iQQ);
TLorentzVector *mupl4mom = (TLorentzVector*) Gen_QQ_mupl_4mom->At(iQQ);
//--Muid cuts for muon minus
muMiDxy=Gen_QQ_mumi_dxy[iQQ];
muMiDz=Gen_QQ_mumi_dz[iQQ];
muMiNPxlLayers=Gen_QQ_mumi_nPixWMea[iQQ];
muMiNTrkLayers=Gen_QQ_mumi_nTrkWMea[iQQ];
muMiGoodMu = Gen_QQ_mumi_isGoodMuon[iQQ];
//--Muid cuts for muon plus
muPlDxy=Gen_QQ_mupl_dxy[iQQ];
muPlDz=Gen_QQ_mupl_dz[iQQ];
muPlNPxlLayers=Gen_QQ_mupl_nPixWMea[iQQ];
muPlNTrkLayers=Gen_QQ_mupl_nTrkWMea[iQQ];
muPlGoodMu = Gen_QQ_mupl_isGoodMuon[iQQ];
vProb = Gen_QQ_VtxProb[iQQ];
bool mupl_cut = 0;
bool mumi_cut = 0;
bool acceptMu = 0;
bool trigL1Dmu = 0;
// bool trigL3Dmu = 0;
bool PtCutPass = 0;
bool MassCutPass = 0;
//--Muon id cuts
if( (muPlGoodMu==1) && muPlNTrkLayers> 5 && muPlNPxlLayers > 0 && TMath::Abs(muPlDxy) < 0.3 && TMath::Abs(muPlDz) < 20 && vProb > 0.01){mupl_cut = 1;}
if( (muMiGoodMu==1) && muMiNTrkLayers> 5 && muMiNPxlLayers > 0 && TMath::Abs(muMiDxy) < 0.3 && TMath::Abs(muMiDz) < 20 ){mumi_cut = 1;}
//check if muons are in acceptance
if(IsAccept(mupl4mom) && IsAccept(mumi4mom)){acceptMu = 1;}
if (PtCut(mupl4mom) && PtCut(mumi4mom)){ PtCutPass = 1; }
MassCutPass = MassCut(qq4mom, m1S_low, m1S_high);
//check if trigger bit is matched to dimuon
// if((HLTriggers&1)==1){trigL1Dmu = 1;}
// if((HLTriggers&262144)==262144 && (Gen_QQ_trig[iQQ]&262144)==262144){trigL3Dmu = 1;}
//weights only needed for PbPb
double weight = 0;
ptWeight=0;
centWeight = FindCenWeight(Centrality);
if(qq4mom->Pt()<=3){ptWeight = ptWeightArr[0];}
if(qq4mom->Pt()>3 && qq4mom->Pt()<=6){ptWeight = ptWeightArr[1];}
if(qq4mom->Pt()>6 && qq4mom->Pt()<=9){ptWeight = ptWeightArr[2];}
if(qq4mom->Pt()>9 && qq4mom->Pt()<=12){ptWeight = ptWeightArr[3];}
if(qq4mom->Pt()>12 && qq4mom->Pt()<=15){ptWeight = ptWeightArr[4];}
if(qq4mom->Pt()>15 && qq4mom->Pt()<=30){ptWeight = ptWeightArr[5];}
// if(qq4mom->Pt()<=30){ptReweight = PtReweight(qq4mom, PbPb1S_coefficient, PbPb1S_constant);}
if(qq4mom->Pt()<=30){ptReweight = (AA1S->Eval(qq4mom->Pt()))/(AA1Smc->Eval(qq4mom->Pt()));}
weight = centWeight*ptWeight*ptReweight;
// bool L1Pass=0;
// bool L3Pass=0;
// if (acceptMu){L1Pass=1;}
// if (acceptMu){L3Pass=1;}
if(qq4mom->Pt()<30 && Centrality < 160){
for(int i = 0; i<nRapBin;i++){
if(TMath::Abs(qq4mom->Rapidity())>(RapBin[i]-RapBinErr[i]) && TMath::Abs(qq4mom->Rapidity())<(RapBin[i]+RapBinErr[i])){
if(acceptMu == 1 && PtCutPass == 1 && MassCutPass == 1){GenEvents->Fill(TMath::Abs(qq4mom->Rapidity()), weight);}
}
}
// */
// if(acceptMu == 1 && PtCutPass == 1 && MassCutPass == 1){GenEvents->Fill(TMath::Abs(qq4mom->Rapidity()), weight);}
}
}
}
TCanvas *c1 = new TCanvas("c1","c1",1000,680);
//From Ota
// RecoEvents->Sumw2();
// GenEvents->Sumw2();
// hEff->Divide(RecoEvents, GenEvents);
// TCanvas *c1 = new TCanvas("c1","c1",600,400);
// Will use TGraphAsymmErrors
// TGraphAsymmErrors *TrigEff = new TGraphAsymmErrors(hEff);
// TGraphAsymmErrors *TrigEff = new TGraphAsymmErrors(nPtBin);
// TrigEff->Divide(RecoEvents, GenEvents, "cl=0.683 b(1,1) mode");
// TGraphErrors *TrigEff = new TGraphErrors(nPtBin,ptBin , Efficiency,ptBinErr , EfficiencyErr);
TGraphAsymmErrors *TrigEff = new TGraphAsymmErrors(nRapBin);
TrigEff->BayesDivide(RecoEvents, GenEvents);
TrigEff->SetName("Eff");
TrigEff->SetMarkerSize(2.0);
TrigEff->SetMarkerColor(kBlue);
TrigEff->SetMarkerStyle(21);
TrigEff->SetLineColor(kBlue);
TrigEff->SetTitle("");
// TrigEff->SetMarkerStyle(21);
// TrigEff->SetMarkerColor(2);
TrigEff->GetYaxis()->SetTitle("Efficiency[#varUpsilon(1S)]_{PbPb}");
TrigEff->GetXaxis()->SetTitle("|y|");
TrigEff->GetYaxis()->SetRangeUser(0,1);
TrigEff->GetXaxis()->SetRangeUser(0.0, 2.4);
TrigEff->GetXaxis()->CenterTitle();
TrigEff->GetYaxis()->CenterTitle();
TrigEff->Draw("AP"); // */
c1->Update();
c1->SaveAs("EfficiencyVsRapidityUpsilonPbPb1S.png");
TFile* MyFileEff;
MyFileEff = new TFile("RapPbPbEff1S.root", "Recreate");
TrigEff->Write();
MyFileEff->Close();
for (Int_t i = 0; i < (nRapBin); i++){
cout << TrigEff->Eval(RapBin[i]) << " , - " << TrigEff->GetErrorYlow(i) << " , + " << TrigEff->GetErrorYhigh(i) << endl;
}
ReweightFunctions->Close();
}
