void PTCut::EventLoop()
{
if (fChain == 0) return;
Long64_t nentries = fChain->GetEntries();
cout << nentries << endl;
timer.setParams(nentries,500);
timer.startTiming();
for (Long64_t jentry=0; jentry!=nentries; ++jentry) {
if (jentry!=0&&jentry%500==0) timer.printTime();
fChain->GetEntry(jentry);
if ( !ParticlesToJetsorterInput() ) continue;
// Run Fastjet algorithm
vector <fastjet::PseudoJet> inclusiveJets;
fastjet::ClusterSequence clustSeq(fjInputs, *jetDef);
inclusiveJets = clustSeq.inclusive_jets( pTMin );
// Extract inclusive jets sorted by pT (note minimum pT of 20.0 GeV)
sortedJets = sorted_by_pt(inclusiveJets);
// Inspect the amount of jets
jetMultipl->Fill( sortedJets.size() );
// Loop through the generated jets
JetLoop();
}
}
void PTCut::JetLoop()
{
int counter = 0;
TLorentzVector zero(0,0,0,0);
for (unsigned int i = 0; i < sortedJets.size(); i++) {
if (fabs(sortedJets[i].pseudorapidity()) > etaMax) continue;
if (counter++ == 2) continue;
jetParts = sorted_by_pt(sortedJets[i].constituents());
if ( jetParts.size() < 2 ) continue;
// Initialize four-momentum sums
sumPPt = zero; sumPHCAL = zero; sumP3GeV = zero; sumPHi = zero;
sumCaloPPt = zero; sumCaloPHCAL = zero; sumCaloP3GeV = zero;
sumHistPt = zero; histCh = zero; histNh = zero; histE = zero;
histMu = zero; histPh = zero;
// Loop over particles within a jet
ParticleLoop();
// Fill the histograms:
HistFill(i);
}
}
void GroomingTreeProducer::ProduceTree()
{
TFile OutputFile (outFileName.c_str(), "RECREATE");
Float_t mass_PFjet, mass_Filtered_PFjet, mass_Pruned_PFjet, mass_Pruned_PFjet_subtracted, mass_Trimmed_PFjet, pt_PFjet, mass_GENjet, mass_Filtered_GENjet, mass_Pruned_GENjet, mass_Trimmed_GENjet, pt_GENjet, mass_PFjet_subtracted, mass_soft_drop;
Int_t nPU;
TTree *PF_tree = new TTree("PF", "PF");
TTree *GEN_tree = new TTree("GEN", "GEN");
PF_tree -> Branch("mass_PFjet",&mass_PFjet,"mass_PFjet/F");
PF_tree -> Branch("mass_PFjet_subtracted",&mass_PFjet_subtracted,"mass_PFjet_subtracted/F");
PF_tree -> Branch("pt_PFjet",&pt_PFjet,"pt_PFjet/F");
PF_tree -> Branch("mass_Pruned_PFjet",&mass_Pruned_PFjet,"mass_Pruned_PFjet/F");
PF_tree -> Branch("mass_Pruned_PFjet_subtracted",&mass_Pruned_PFjet_subtracted,"mass_Pruned_PFjet_subtracted/F");
PF_tree -> Branch("mass_Trimmed_PFjet",&mass_Trimmed_PFjet,"mass_Trimmed_PFjet/F");
PF_tree -> Branch("mass_Filtered_PFjet",&mass_Filtered_PFjet,"mass_Filtered_PFjet/F");
PF_tree -> Branch("mass_soft_drop",&mass_soft_drop,"mass_soft_drop/F");
PF_tree -> Branch("nPU",&nPU,"nPU/I");
GEN_tree -> Branch("mass_GENjet",&mass_GENjet,"mass_GENjet/F");
GEN_tree -> Branch("pt_GENjet",&pt_GENjet,"pt_GENjet/F");
GEN_tree -> Branch("mass_Pruned_GENjet",&mass_Pruned_GENjet,"mass_Pruned_GENjet/F");
GEN_tree -> Branch("mass_Trimmed_GENjet",&mass_Trimmed_GENjet,"mass_Trimmed_GENjet/F");
GEN_tree -> Branch("mass_Filtered_GENjet",&mass_Filtered_GENjet,"mass_Filtered_GENjet/F");
GEN_tree -> Branch("nPU",&nPU,"nPU/I");
for (unsigned int jj = 0; jj < inputFileNames.size(); jj++)
{
TFile* fIn = TFile::Open((prefixSamples + inputFileNames.at(jj)).c_str());
TTree* tree = (TTree*) fIn->Get("Events");
TClonesArray *PF = new TClonesArray("baconhep::TPFPart");
TClonesArray *Gen = new TClonesArray("baconhep::TGenParticle");
TEventInfo *ev_Info = new TEventInfo();
tree -> SetBranchAddress("PFPart", &PF);
tree -> SetBranchAddress("GenParticle", &Gen);
tree -> SetBranchAddress("Info",&ev_Info);
for(int i0 =0; i0 <tree -> GetEntriesFast(); i0++)
{
//1, event loop
tree -> GetEntry(i0);
bool leptonic = false;
std::vector<fastjet::PseudoJet> PFparticles;
std::vector<fastjet::PseudoJet> GENparticles;
nPU = ev_Info -> nPU;
for( int i1 = 0; i1 < PF -> GetEntriesFast(); i1++)
{
//2,entries loop,fill the vector particles with PF particles
baconhep::TPFPart *PFTmp = (baconhep::TPFPart*)((*PF)[i1]);
double Px=PFTmp->pt*cos(PFTmp->phi);
double Py= PFTmp->pt*sin(PFTmp->phi);
double theta = 2*atan(exp(-PFTmp->eta)); //eta = -ln(tan(theta/2))
double Pz = PFTmp->pt/tan(theta);
double E = PFTmp->e;
fastjet::PseudoJet tmp_psjet(Px, Py, Pz, E);
PFparticles.push_back(tmp_psjet);
}
//loop over genparticles
for( int i3 = 0; i3 < Gen -> GetEntriesFast(); i3++)
{
baconhep::TGenParticle *GenParticleTmp = (baconhep::TGenParticle*)((*Gen)[i3]);
double Px=GenParticleTmp->pt*cos(GenParticleTmp->phi);
double Py= GenParticleTmp->pt*sin(GenParticleTmp->phi);
double theta = 2*atan(exp(-GenParticleTmp->eta)); //eta = -ln(tan(theta/2))
double Pz = GenParticleTmp->pt/tan(theta);
double Genmass = GenParticleTmp -> mass;
double E = sqrt(Px*Px + Py*Py + Pz*Pz + Genmass*Genmass);
fastjet::PseudoJet tmp_genpsjet(Px, Py, Pz, E);
// cout << "Number "<< i3 << "|status " << GenParticleTmp -> status << "| pdgId " << GenParticleTmp -> pdgId << "| parent " << GenParticleTmp -> parent << endl;
//check if W decays leptonically
if (fabs(GenParticleTmp -> pdgId) == 11 || fabs(GenParticleTmp -> pdgId) == 13 || fabs(GenParticleTmp -> pdgId) == 15)
{
if ( fabs(((baconhep::TGenParticle*)((*Gen)[GenParticleTmp -> parent])) -> pdgId) == 24) leptonic = true;
}
if ((GenParticleTmp -> status) == 1 && fabs(GenParticleTmp -> pdgId)!=12 && fabs(GenParticleTmp -> pdgId)!=14 && fabs(GenParticleTmp -> pdgId)!=16 ) GENparticles.push_back(tmp_genpsjet);//taking particles only with status == 1 and filtering neutrinos
}
if (leptonic) continue;//use only leptonically decays of W
fastjet::AreaDefinition area_def(active_area_explicit_ghosts,GhostedAreaSpec(SelectorAbsRapMax(4.0)));
fastjet::ClusterSequenceArea clust_seq_PF(PFparticles, jet_def, area_def);
fastjet::ClusterSequenceArea clust_seq_GEN(GENparticles, jet_def, area_def);
std::vector<fastjet::PseudoJet> PF_jets_basic = sorted_by_pt(clust_seq_PF.inclusive_jets(300.0));
std::vector<fastjet::PseudoJet> GEN_jets_basic = sorted_by_pt(clust_seq_GEN.inclusive_jets(300.0));
fastjet::Selector rho_range = SelectorAbsRapMax(4.0);
JetMedianBackgroundEstimator bge_rho (rho_range, clust_seq_PF);
JetMedianBackgroundEstimator bge_rhom(rho_range, clust_seq_PF);
BackgroundJetPtMDensity m_density;
bge_rhom.set_jet_density_class(&m_density);
contrib::SafeAreaSubtractor *area_subtractor = new contrib::SafeAreaSubtractor(&bge_rho, &bge_rhom);
double RCut= 0.5;
Pruner pruner(jet_def, 0.1,RCut);
Filter trimmer(jet_def_filtering ,SelectorPtFractionMin(0.05) );
Filter filter(jet_def_filtering , SelectorNHardest(3) );
contrib::SoftDrop softdrop(2., 0.1, 1.0);
trimmer.set_subtractor(area_subtractor);
filter.set_subtractor(area_subtractor);
softdrop.set_subtractor(area_subtractor);
PseudoJet pruned_jet, pruned_jet_subtracted, trimmed_jet, filtered_jet, subtracted_jet, soft_drop_jet;
for (unsigned j =0; j < PF_jets_basic.size();++j)
{
subtracted_jet = (PseudoJet) (*area_subtractor)(PF_jets_basic.at(j));
trimmed_jet = (PseudoJet) trimmer.result(PF_jets_basic.at(j));
filtered_jet = (PseudoJet) filter.result(PF_jets_basic.at(j));
soft_drop_jet= (PseudoJet) softdrop.result(PF_jets_basic.at(j));
pruned_jet = pruner(PF_jets_basic.at(j));
pruned_jet_subtracted = pruner(subtracted_jet);
mass_PFjet = PF_jets_basic.at(j).m();
mass_PFjet_subtracted = subtracted_jet.m();
pt_PFjet = PF_jets_basic.at(j).pt();
mass_Pruned_PFjet = pruned_jet.m();
mass_Pruned_PFjet_subtracted = pruned_jet_subtracted.m();
mass_Filtered_PFjet = filtered_jet.m();
mass_Trimmed_PFjet = trimmed_jet.m();
mass_soft_drop = soft_drop_jet.m();
PF_tree -> Fill();
}
for (unsigned j =0; j < GEN_jets_basic.size();++j)
{
pruned_jet = pruner(GEN_jets_basic.at(j));
trimmed_jet = (PseudoJet) trimmer.result(GEN_jets_basic.at(j));
filtered_jet = (PseudoJet) filter.result(GEN_jets_basic.at(j));
mass_GENjet = GEN_jets_basic.at(j).m();
pt_GENjet = GEN_jets_basic.at(j).pt();
mass_Pruned_GENjet = pruned_jet.m();
mass_Filtered_GENjet = filtered_jet.m();
mass_Trimmed_GENjet = trimmed_jet.m();
GEN_tree -> Fill();
}
PF_jets_basic.clear();
GEN_jets_basic.clear();
}//end of event loop
}
OutputFile.cd();
GEN_tree -> Write();
PF_tree -> Write();
}
///
///________________________________________________________________________________
///
Bool_t
UEJetAreaFinder::find( TClonesArray& Input, vector<UEJetWithArea>& _jets )
{
/// return if no four-vectors are provided
if ( Input.GetSize() == 0 ) return kFALSE;
/// prepare input
std::vector<fastjet::PseudoJet> fjInputs;
fjInputs.reserve ( Input.GetSize() );
int iJet( 0 );
for( int i(0); i < Input.GetSize(); ++i )
{
TLorentzVector *v = (TLorentzVector*)Input.At(i);
if ( TMath::Abs(v->Eta()) > etaRegionInput ) continue;
if ( v->Pt() < ptThreshold ) continue;
fjInputs.push_back (fastjet::PseudoJet (v->Px(), v->Py(), v->Pz(), v->E()) );
fjInputs.back().set_user_index(iJet);
++iJet;
}
/// return if no four-vectors in visible phase space
if ( fjInputs.size() == 0 ) return kFALSE;
/// print out info on current jet algorithm
// cout << endl;
// cout << mJetDefinition->description() << endl;
// cout << theAreaDefinition->description() << endl;
/// return if active area is not chosen to be calculated
if ( ! theAreaDefinition ) return kFALSE;
// cout << "fastjet::ClusterSequenceActiveArea* clusterSequence" << endl;
fastjet::ClusterSequenceArea* clusterSequence
= new fastjet::ClusterSequenceArea (fjInputs, *mJetDefinition, *theAreaDefinition );
// cout << "retrieve jets for selected mode" << endl;
/// retrieve jets for selected mode
double mJetPtMin( 1. );
std::vector<fastjet::PseudoJet> jets( clusterSequence->inclusive_jets (mJetPtMin) );
unsigned int nJets( jets.size() );
if ( nJets == 0 )
{
delete clusterSequence;
return kFALSE;
}
//Double_t ptByArea[ nJets ];
// int columnwidth( 10 );
//cout << "found " << jets.size() << " jets" << endl;
// cout.width( 5 );
// cout << "jet";
// cout.width( columnwidth );
// cout << "eta";
// cout.width( columnwidth );
// cout << "phi";
// cout.width( columnwidth );
// cout << "pT";
// cout.width( columnwidth );
// cout << "jetArea";
// cout.width( 15 );
// cout << "pT / jetArea";
// cout << endl;
_jets.reserve( nJets );
vector< fastjet::PseudoJet > sorted_jets ( sorted_by_pt( jets ));
for ( int i(0); i<nJets; ++i )
{
//ptByArea[i] = jets[i].perp()/clusterSequence->area(jets[i]);
// cout.width( 5 );
// cout << i;
// cout.width( columnwidth );
// cout << jets[i].eta();
// cout.width( columnwidth );
// cout << jets[i].phi();
// cout.width( columnwidth );
// cout << jets[i].perp();
// cout.width( columnwidth );
// cout << clusterSequence->area(jets[i]);
// cout.width( 15 );
// cout << ptByArea[i];
// cout << endl;
/// save
///
/// TLorentzVector
/// area
/// nconstituents
fastjet::PseudoJet jet( sorted_jets[i] );
vector< fastjet::PseudoJet > constituents( clusterSequence->constituents(jet) );
TLorentzVector* mom = new TLorentzVector( jet.px(), jet.py(), jet.pz(), jet.e() );
double area = clusterSequence->area(jet);
// double median = TMath::Median( nJets, ptByArea );
unsigned int nconst = constituents.size();
UEJetWithArea* theJet = new UEJetWithArea( *mom, area, nconst);
//_jets[i] = *theJet;
_jets.push_back( *theJet );
delete mom;
delete theJet;
}
delete clusterSequence;
return kTRUE;
}
