source: svn/trunk/Resolutions.cpp@ 74

/*
  ---- FastSim ----
  A Fast Simulator for general purpose LHC detector
  S. Ovyn ~~~~ severine.ovyn@uclouvain.be

  Center for Particle Physics and Phenomenology (CP3)
  Universite Catholique de Louvain (UCL)
  Louvain-la-Neuve, Belgium
*/

/// \file Smearing.cpp
/// \brief executable for the FastSim

#include "TChain.h"
#include "TApplication.h"

#include "Utilities/ExRootAnalysis/interface/ExRootTreeReader.h"
#include "Utilities/ExRootAnalysis/interface/ExRootTreeWriter.h"
#include "Utilities/ExRootAnalysis/interface/ExRootTreeBranch.h"

#include "H_BeamParticle.h"
#include "H_BeamLine.h"
#include "H_RomanPot.h"

#include "interface/DataConverter.h"
#include "interface/HEPEVTConverter.h"
#include "interface/LHEFConverter.h"
#include "interface/STDHEPConverter.h"

#include "interface/SmearUtil.h"
#include "Utilities/Fastjet/include/fastjet/PseudoJet.hh"
#include "Utilities/Fastjet/include/fastjet/ClusterSequence.hh"

// get info on how fastjet was configured
#include "Utilities/Fastjet/include/fastjet/config.h"

// make sure we have what is needed
#ifdef ENABLE_PLUGIN_SISCONE
#  include "Utilities/Fastjet/plugins/SISCone/SISConePlugin.hh"
#endif
#ifdef ENABLE_PLUGIN_CDFCONES
#  include "Utilities/Fastjet/plugins/CDFCones/CDFMidPointPlugin.hh"
#  include "Utilities/Fastjet/plugins/CDFCones/CDFJetCluPlugin.hh"
#endif

#include<vector>
#include<iostream>

#include "interface/TreeClasses.h"
using namespace std;

//------------------------------------------------------------------------------

// //********************************** PYTHIA INFORMATION*********************************

TSimpleArray<TRootGenParticle> TauHadr(const TClonesArray *GEN)
 {
   TIter it((TCollection*)GEN);
   it.Reset();
   TRootGenParticle *gen1;
   TSimpleArray<TRootGenParticle> array,array2;

   while((gen1 = (TRootGenParticle*) it.Next()))
      {
        array.Add(gen1);
      }
   it.Reset();
   bool tauhad;
   while((gen1 = (TRootGenParticle*) it.Next()))
    {
       tauhad=false;
       if(abs(gen1->PID)==15)
         {
            int d1=gen1->D1;
            int d2=gen1->D2;

            if((d1 < array.GetEntries()) && (d1 > 0) && (d2 < array.GetEntries()) && (d2 > 0))
               {
                 tauhad=true;
                 for(int d=d1; d < d2+1; d++)
                    {
                      if(abs(array[d]->PID)== pE || abs(array[d]->PID)== pMU)tauhad=false;
                    }
               }
         }
        if(tauhad)array2.Add(gen1);
     }
   return array2;
 }



void PairingJet(TLorentzVector &JETSm, const TLorentzVector &JET,  vector<fastjet::PseudoJet> sorted_jetsS)
{
  JETSm.SetPxPyPzE(0,0,0,0);
  float deltaRtest=5000;
  for (unsigned int i = 0; i < sorted_jetsS.size(); i++) {
      TLorentzVector Att;
      Att.SetPxPyPzE(sorted_jetsS[i].px(),sorted_jetsS[i].py(),sorted_jetsS[i].pz(),sorted_jetsS[i].E());
      if(DeltaR(JET.Phi(),JET.Eta(),Att.Phi(),Att.Eta()) < deltaRtest)
        {
          deltaRtest = DeltaR(JET.Phi(),JET.Eta(),Att.Phi(),Att.Eta());
          if(deltaRtest < 0.25)
             {
               JETSm = Att;
             }
        }
    }
}


int main(int argc, char *argv[])
{
  int appargc = 2;
  char *appName = "Smearing";
  char *appargv[] = {appName, "-b"};
  TApplication app(appName, &appargc, appargv);
  
  if(argc != 4 && argc != 3) {
      cout << " Usage: " << argv[0] << " input_file" << " output_file" << " data_card " << endl;
      cout << " input_list - list of files in Ntpl, StdHep of LHEF format," << endl;
      cout << " output_file - output file." << endl;
      cout << " data_card - Datacard containing resolution variables for the detector simulation (optional) "<<endl;
      exit(1);
  }

  srand (time (NULL));         /* Initialisation du générateur */
  
  //read the input TROOT file
  string inputFileList(argv[1]), outputfilename(argv[2]);
  if(outputfilename.find(".root") > outputfilename.length() ) {
    cout << "output_file should be a .root file!\n";
    return -1;
  }
  TFile *outputFile = TFile::Open(outputfilename.c_str(), "RECREATE"); // Creates the file, but should be closed just after
  outputFile->Close();
  
  string line;
  ifstream infile(inputFileList.c_str());
  infile >> line; // the first line determines the type of input files
  
  DataConverter *converter=0;
  
  if(strstr(line.c_str(),".hep"))
    {                           
      cout<<"*************************************************************************"<<endl;
      cout<<"************         StdHEP file format detected           **************"<<endl;
      cout<<"************     Starting convertion to TRoot format       **************"<<endl;
      cout<<"*************************************************************************"<<endl;
      converter = new STDHEPConverter(inputFileList,outputfilename);//case ntpl file in input list
    }
  else if(strstr(line.c_str(),".lhe"))
    {
      cout<<"*************************************************************************"<<endl;
      cout<<"************          LHEF file format detected            **************"<<endl;
      cout<<"************     Starting convertion to TRoot format       **************"<<endl;
      cout<<"*************************************************************************"<<endl;
      converter = new LHEFConverter(inputFileList,outputfilename);//case ntpl file in input list
    }
  else if(strstr(line.c_str(),".root"))
    {
      cout<<"*************************************************************************"<<endl;
      cout<<"************         h2root file format detected           **************"<<endl;
      cout<<"************     Starting convertion to TRoot format       **************"<<endl;
      cout<<"*************************************************************************"<<endl;
      converter = new HEPEVTConverter(inputFileList,outputfilename);//case ntpl file in input list
    }
  else { cout << "***  " << line.c_str() << "\n***  file format not identified\n***  Exiting\n"; return -1;};
  
  TChain chain("GEN");
  chain.Add(outputfilename.c_str());
  ExRootTreeReader *treeReader = new ExRootTreeReader(&chain);
  const TClonesArray *branchGen = treeReader->UseBranch("Particle");
  TIter itGen((TCollection*)branchGen);
  
  //write the output root file
  ExRootTreeWriter *treeWriter = new ExRootTreeWriter(outputfilename, "Analysis");
  ExRootTreeBranch *branchjet = treeWriter->NewBranch("JetPTResol", RESOLJET::Class());
  ExRootTreeBranch *branchelec = treeWriter->NewBranch("ElecEResol", RESOLELEC::Class());
  ExRootTreeBranch *branchmuon = treeWriter->NewBranch("MuonPTResol", RESOLMUON::Class());
  ExRootTreeBranch *branchtaujet = treeWriter->NewBranch("TauJetPTResol", TAUHAD::Class());
  ExRootTreeBranch *branchetmis = treeWriter->NewBranch("ETmisResol",ETMIS::Class());
  
  TRootGenParticle *particle;
  
  RESOLELEC * elementElec;
  RESOLMUON *elementMuon;
  RESOLJET *elementJet;
  TAUHAD *elementTaujet;
  ETMIS *elementEtmis;
  
  
  //read the datacard input file
  string DetDatacard("");
  if(argc==4)  DetDatacard =argv[3];
  RESOLution *DET = new RESOLution();   
  DET->ReadDataCard(DetDatacard);
  
  TLorentzVector genMomentum(0,0,0,0);
  LorentzVector jetMomentum;
  vector<TLorentzVector> TrackCentral;
  
  vector<fastjet::PseudoJet> input_particles;//for FastJet algorithm
  vector<fastjet::PseudoJet> inclusive_jets;
  vector<fastjet::PseudoJet> sorted_jets;
  
  vector<fastjet::PseudoJet> input_particlesS;//for FastJet algorithm
  vector<fastjet::PseudoJet> inclusive_jetsS;
  vector<fastjet::PseudoJet> sorted_jetsS;

  vector<fastjet::PseudoJet> input_particlesT;//for FastJet algorithm
  vector<fastjet::PseudoJet> inclusive_jetsT;
  vector<fastjet::PseudoJet> sorted_jetsT;

  vector<PhysicsTower> towers;
  
  fastjet::JetDefinition jet_def;
  fastjet::JetDefinition jet_defS;
  fastjet::JetDefinition jet_defT;
  fastjet::JetDefinition::Plugin * plugins;
  fastjet::JetDefinition::Plugin * pluginsS;
  fastjet::JetDefinition::Plugin * pluginsT;
  
  // set up a CDF midpoint jet definition
#ifdef ENABLE_PLUGIN_CDFCONES
  plugins = new fastjet::CDFJetCluPlugin(0,DET->CONERADIUS,DET->C_ADJACENCYCUT,DET->C_MAXITERATIONS,DET->C_IRATCH,DET->OVERLAPTHRESHOLD);
  jet_def = fastjet::JetDefinition(plugins);
#else
  plugins = NULL;
#endif
  
  // set up a CDF midpoint jet definition
#ifdef ENABLE_PLUGIN_CDFCONES
  pluginsS = new fastjet::CDFJetCluPlugin(1,DET->CONERADIUS,DET->C_ADJACENCYCUT,DET->C_MAXITERATIONS,DET->C_IRATCH,DET->OVERLAPTHRESHOLD);
  jet_defS = fastjet::JetDefinition(pluginsS);
#else
  pluginsS = NULL;
#endif
  
 // set up a CDF midpoint jet definition
 #ifdef ENABLE_PLUGIN_CDFCONES
 pluginsT = new fastjet::CDFJetCluPlugin(0,DET->CONERADIUS,DET->C_ADJACENCYCUT,DET->C_MAXITERATIONS,DET->C_IRATCH,DET->OVERLAPTHRESHOLD);
 jet_defT = fastjet::JetDefinition(pluginsT);
 #else
 pluginsT = NULL;
 #endif
 
  
  // Loop over all events
  Long64_t entry, allEntries = treeReader->GetEntries();
  cout << "** Chain contains " << allEntries << " events" << endl;
  for(entry = 0; entry < allEntries; ++entry)
    {
      TLorentzVector PTmisS(0,0,0,0);
      TLorentzVector PTmis(0,0,0,0);
      treeReader->ReadEntry(entry);
      treeWriter->Clear();
      if((entry % 100) == 0 && entry > 0 )  cout << "** Processing element # " << entry << endl;
      
      TSimpleArray<TRootGenParticle> bGen;
      itGen.Reset();
      TrackCentral.clear();
      TSimpleArray<TRootGenParticle> NFCentralQ;
   
      sorted_jetsS.clear();
      input_particlesS.clear();
      inclusive_jetsS.clear();

      sorted_jetsT.clear();
      input_particlesT.clear();
      inclusive_jetsT.clear();

      sorted_jets.clear();
      input_particles.clear();
      inclusive_jets.clear();
      towers.clear();
      
      // Loop over all particles in event
      while( (particle = (TRootGenParticle*) itGen.Next()) )
        {
          genMomentum.SetPxPyPzE(particle->Px, particle->Py, particle->Pz, particle->E);
          
          int pid = abs(particle->PID);
          float eta = fabs(particle->Eta);
          
          if(particle->Status == 1 && eta < DET->MAX_CALO_FWD)
            {
              input_particles.push_back(fastjet::PseudoJet(genMomentum.Px(),genMomentum.Py(),genMomentum.Pz(), genMomentum.E()));
            }
          
          if((pid == pNU1) || (pid == pNU2) || (pid == pNU3))PTmis = PTmis + genMomentum;
          // keeps only final particles, visible by the central detector, including the fiducial volume
          // the ordering of conditions have been optimised for speed : put first the STATUS condition
          if( (particle->Status == 1)    &&
              ( 
               (pid == pMU  && eta < DET->MAX_MU) ||
               (pid != pMU  && (pid != pNU1) && (pid != pNU2) && (pid != pNU3) && eta < DET->MAX_CALO_FWD) )
              ) 
            {
              //if((pid != pNU1) && (pid != pNU2) && (pid != pNU3))PTmis = PTmis + genMomentum;//ptmis

              Float_t nonS=0;
              switch(pid) {
              case pE: // all electrons with eta < DET->MAX_CALO_FWD
                nonS = genMomentum.E();
                DET->SmearElectron(genMomentum);
                if(eta < DET->MAX_TRACKER){
                elementElec=(RESOLELEC*) branchelec->NewEntry();
                elementElec->NonSmeareE = nonS;
                elementElec->SmeareE = genMomentum.E();}
                break; // case pE
              case pGAMMA: // all photons with eta < DET->MAX_CALO_FWD
                DET->SmearElectron(genMomentum);
                break; // case pGAMMA
              case pMU: // all muons with eta < DET->MAX_MU
                elementMuon = (RESOLMUON*) branchmuon->NewEntry();
                elementMuon->OneoverNonSmearePT = (1/genMomentum.Pt());
                DET->SmearMu(genMomentum);
                elementMuon->OneoverSmearePT = (1/genMomentum.Pt());
                break; // case pMU
              case pLAMBDA: // all lambdas with eta < DET->MAX_CALO_FWD
              case pK0S:    // all K0s with eta < DET->MAX_CALO_FWD
                DET->SmearHadron(genMomentum, 0.7);
                break; // case hadron
              default:   // all other final particles with eta < DET->MAX_CALO_FWD
                DET->SmearHadron(genMomentum, 1.0);
                break;
              } // switch (pid)
              
              if(pid != pMU && genMomentum.Et() !=0)
                {
                  towers.push_back(PhysicsTower(LorentzVector(genMomentum.Px(),genMomentum.Py(),genMomentum.Pz(), genMomentum.E())));
                  input_particlesS.push_back(fastjet::PseudoJet(genMomentum.Px(),genMomentum.Py(),genMomentum.Pz(), genMomentum.E()));
                }
              
              // all final charged particles
              if(
                 ((rand()%100) < DET->TRACKING_EFF)  &&
                 (genMomentum.E()!=0) &&
                 (fabs(particle->Eta) < DET->MAX_TRACKER) && 
                 (genMomentum.Pt() > DET->PT_TRACKS_MIN ) &&     // pt too small to be taken into account
                 (pid != pGAMMA)    && 
                 (pid != pPI0)      &&
                 (pid != pK0L)      &&
                 (pid != pN)        &&
                 (pid != pSIGMA0)   &&
                 (pid != pDELTA0)   &&
                 (pid != pK0S)   // not charged particles : invisible by tracker
                 )
                TrackCentral.push_back(genMomentum);
            } // switch
        } // while
    
     TLorentzVector Att(0.,0.,0.,0.);
     for(unsigned int i=0; i < towers.size(); i++) 
       {
         Att.SetPxPyPzE(towers[i].fourVector.px,towers[i].fourVector.py,towers[i].fourVector.pz,towers[i].fourVector.E);
         PTmisS = PTmisS + Att;
       }

      elementEtmis= (ETMIS*) branchetmis->NewEntry();
      elementEtmis->Et = (PTmis).Pt();
      elementEtmis->EtSmeare = (PTmisS).Pt()-(PTmis).Pt();
      
      //*****************************
      
      double ptmin=1;
      if(input_particles.size()!=0)
        {
          fastjet::ClusterSequence clust_seq(input_particles, jet_def);
          inclusive_jets = clust_seq.inclusive_jets(ptmin);
          sorted_jets = sorted_by_pt(inclusive_jets);
        }
      
      if(input_particlesS.size()!=0)
        {
          fastjet::ClusterSequence clust_seqS(input_particlesS, jet_defS);
          inclusive_jetsS = clust_seqS.inclusive_jets(ptmin);
          sorted_jetsS = sorted_by_pt(inclusive_jetsS);
        }
      
      TSimpleArray<TRootGenParticle> TausHadr = TauHadr(branchGen);

      TLorentzVector JETSm(0,0,0,0);
      for (unsigned int i = 0; i < sorted_jets.size(); i++) {
        TLorentzVector JET(0,0,0,0);
        JET.SetPxPyPzE(sorted_jets[i].px(),sorted_jets[i].py(),sorted_jets[i].pz(),sorted_jets[i].E());
        PairingJet(JETSm,JET,sorted_jetsS);
        if(JETSm.Pt()>1)
          {
            elementJet= (RESOLJET*) branchjet->NewEntry();
            elementJet->NonSmearePT = JET.Et();
            elementJet->SmearePT = JETSm.Et()/JET.Et();
          }
      }
      for (unsigned int i = 0; i < sorted_jetsS.size(); i++) {
        TLorentzVector JETT(0,0,0,0);
        JETT.SetPxPyPzE(sorted_jetsS[i].px(),sorted_jetsS[i].py(),sorted_jetsS[i].pz(),sorted_jetsS[i].E());
        if(fabs(JETT.Eta()) < (DET->MAX_TRACKER - DET->TAU_CONE_TRACKS)) 
           {
            for(Int_t i=0; i<TausHadr.GetEntries();i++)
              {
                if(DeltaR(TausHadr[i]->Phi,TausHadr[i]->Eta,JETT.Phi(),JETT.Eta())<0.1)
                  {
                    elementTaujet= (TAUHAD*) branchtaujet->NewEntry();
                    elementTaujet->EnergieCen = (DET->EnergySmallCone(towers,JETT.Eta(),JETT.Phi())/JETT.E());
                    elementTaujet->NumTrack = DET->NumTracks(TrackCentral,DET->PT_TRACK_TAU,JETT.Eta(),JETT.Phi());
                 }
              }
           }
         
        
      } // for itJet : loop on all jets
      
      treeWriter->Fill();
    } // Loop over all events
  treeWriter->Write();
  
  cout << "** Exiting..." << endl;
  
  delete treeWriter;
  delete treeReader;
  delete DET;
  if(converter) delete converter;
}