Changes in / [93bf9c6:b982244] in git

Files:

• cards/FCC/FCChh_PileUpVtx.tcl (modified) (8 diffs)
• cards/FCC/FCChh_PileUpVtx_new.tcl (deleted)
• cards/FCC/trackResolutionFCChh.tcl (deleted)
• modules/ModulesLinkDef.h (modified) (2 diffs)
• modules/TimeSmearing.cc (modified) (6 diffs)
• modules/TimeSmearing.h (modified) (1 diff)
• modules/TimeSmearingNeutral.cc (deleted)
• modules/TimeSmearingNeutral.h (deleted)
• modules/TrackTimingPileUpSubtractor.cc (modified) (4 diffs)
• modules/TrackTimingPileUpSubtractor.h (modified) (1 diff)
• modules/VertexFinderDA4D.cc (modified) (1 diff)

cards/FCC/FCChh_PileUpVtx.tcl

@@ -17 +17 @@
 set ExecutionPath {
 
+  BeamSpotFilter
   PileUpMerger
   ParticlePropagator
@@ -34 +35 @@
 
   TrackSmearing
-  TimeSmearing      
+  TimeSmearing  
+
+  VertexFinderDA4D  
+
+  TrackTimingPileUpSubtractor  
 
   ECal
@@ -42 +47 @@
   EFlowMerger
   EFlowFilter
-
-  TimeSmearingMIP
-  TimeSmearingPhotons
-  TimeSmearingNH    
-
-  VertexFinderDA4D
-  TrackTimingPileUpSubtractor
-
-  HighMassVertexRecover    
 
   PhotonEfficiency
@@ -85 +81 @@
 
   TreeWriter
+}
+
+#######################
+# GenBeamSpotFilter
+# Saves a particle intended to represent the beamspot
+#######################
+
+module BeamSpotFilter BeamSpotFilter {
+    set InputArray Delphes/stableParticles
+    set OutputArray beamSpotParticle
+
 }
 
@@ -294 +301 @@
 
   # assume 20 ps resolution for now
-  set TimeResolution {20E-12}
+  set TimeResolution 20E-12
+}
+
+##################################
+# Primary vertex reconstruction
+##################################
+
+
+module VertexFinderDA4D VertexFinderDA4D {
+  set InputArray TimeSmearing/tracks
+
+  set OutputArray tracks
+  set VertexOutputArray vertices
+
+  set Verbose 0
+  set MinPT 1.0
+
+  # in mm
+  set VertexSpaceSize 0.5
+
+  # in s
+  set VertexTimeSize 10E-12
+
+  set UseTc 1
+  set BetaMax 0.1
+  set BetaStop 1.0
+  set CoolingFactor 0.8
+  set MaxIterations 100
+
+  # in mm
+  set DzCutOff 40
+  set D0CutOff 30
+
+}
+
+##########################
+# Track pile-up subtractor
+##########################
+
+module TrackTimingPileUpSubtractor TrackTimingPileUpSubtractor {
+# add InputArray InputArray OutputArray
+
+  add InputArray ChargedHadronMomentumSmearing/chargedHadrons
+  add InputArray ElectronMomentumSmearing/electrons
+  add InputArray MuonMomentumSmearing/muons
+  
+  set VertexInputArray VertexFinderDA4D/vertices
+  # assume perfect pile-up subtraction for tracks with |z| > fZVertexResolution
+  # Z vertex resolution in m
+  set ZVertexResolution {0.0001}
 }
 
@@ -463 +519 @@
 }
 
+
 #################
 # Electron filter
@@ -529 +586 @@
 }
 
-########################################
-#   Time Smearing Neutral MIP
-########################################
-
-module TimeSmearing TimeSmearingMIP {
-  set InputArray HCal/eflowTracks
-  set OutputArray timeSmearingMIP
-
-  # assume 30 ps resolution for now
-  set TimeResolution {30E-12}
-}
-
-########################################
-#   Time Smearing Neutral Photons
-########################################
-
-module TimeSmearing TimeSmearingPhotons {
-  set InputArray ECal/eflowPhotons
-  set OutputArray timeSmearingPhotons
-}
-
-########################################
-#   Time Smearing Neutral NeutralHadrons
-########################################
-#
-module TimeSmearing TimeSmearingNH {
-  set InputArray HCal/eflowNeutralHadrons
-  set OutputArray timeSmearingNH
-
-  # assume 30 ps resolution for now
-  set TimeResolution {30E-12}
-}
-
-
-##################################
-# Primary vertex reconstruction
-##################################
-
-
-module VertexFinderDA4D VertexFinderDA4D {
-  set InputArray TimeSmearing/tracks
-
-  set OutputArray tracks
-  set VertexOutputArray vertices
-
-  set Verbose 0
-  set MinPT 1.0
-
-  # in mm
-  set VertexSpaceSize 0.5
-
-  # in s
-  set VertexTimeSize 10E-12
-
-  set UseTc 1
-  set BetaMax 0.1
-  set BetaStop 1.0
-  set CoolingFactor 0.8
-  set MaxIterations 100
-
-  # in mm
-  set DzCutOff 40
-  set D0CutOff 30
-
-}
-
-##########################
-# Track pile-up subtractor
-##########################
-
-module TrackTimingPileUpSubtractor TrackTimingPileUpSubtractor {
-# add InputArray InputArray OutputArray
-
-  add InputArray TimeSmearing/tracks
-  add InputArray TimeSmearingPhotons/timeSmearingPhotons
-  add InputArray TimeSmearingNH/timeSmearingNH
-
-  set VertexInputArray VertexFinderDA4D/vertices
-
-  set fChargedMinSignificance {3}
-  set fNeutralMinSignificance {3}
-}
-
-######################################
-# Heavy(slow) particles vertex recover
-######################################
-
-module HighMassVertexRecover HighMassVertexRecover {
-  set TrackInputArray VertexFinderDA4D/tracks
-  set VertexInputArray VertexFinderDA4D/vertices
-
-  set TrackOutputArray tracks
-  set VertexOutputArray vertices
-
-  set Verbose 0
-
-}
 
 ###################
@@ -1077 +1037 @@
   add Branch ScalarHT/energy ScalarHT ScalarHT
   add Branch VertexFinderDA4D/vertices Vertex4D Vertex
-
-  add Branch HighMassVertexRecover/tracks Track Track
-}
-
+}
+

modules/ModulesLinkDef.h

@@ -56 +56 @@
 #include "modules/PileUpMerger.h"
 #include "modules/JetPileUpSubtractor.h"
+#include "modules/TrackPileUpSubtractor.h"
 #include "modules/TrackTimingPileUpSubtractor.h"
 #include "modules/TaggingParticlesSkimmer.h"
@@ -113 +114 @@
 #pragma link C++ class PileUpMerger+;
 #pragma link C++ class JetPileUpSubtractor+;
+#pragma link C++ class TrackPileUpSubtractor+;
 #pragma link C++ class TrackTimingPileUpSubtractor+;
 #pragma link C++ class TaggingParticlesSkimmer+;

modules/TimeSmearing.cc

@@ -53 +53 @@
 
 TimeSmearing::TimeSmearing() :
-  fItInputArray(0)
+  fFormula(0), fItInputArray(0)
 {
+  fFormula = new DelphesFormula;
 }
 
@@ -60 +61 @@
 
 TimeSmearing::~TimeSmearing()
-{  
+{
+  if(fFormula) delete fFormula;
 }
 
@@ -69 +71 @@
   // read resolution formula
 
-  fTimeResolution = GetDouble("TimeResolution", 1.);
+  fFormula->Compile(GetString("TimeResolution", "1.0"));
 
   // import input array
@@ -75 +77 @@
   fInputArray = ImportArray(GetString("InputArray", "MuonMomentumSmearing/muons"));
   fItInputArray = fInputArray->MakeIterator();
+
   // create output array
 
@@ -92 +95 @@
 {
   Candidate *candidate, *mother;
-  Double_t ti, tf_smeared, tf;
-  Double_t pt, eta, phi, e, p, l;
-  Double_t sigma_t, beta_particle;
+  Double_t ti, tf_smeared, tf, timeResolution;
+  Double_t pt, eta, phi, e, d0, dz, ctgTheta;
 
 
   const Double_t c_light = 2.99792458E8;
-
-  cout << " STARTINNNGG ---------->" << endl;
 
   fItInputArray->Reset();
@@ -114 +114 @@
     pt = candidateMomentum.Pt();
     e = candidateMomentum.E();
-    p = candidateMomentum.P();
-    beta_particle = p/e;
-    l = candidate->L;
+    d0 = candidate->D0;
+    dz = candidate->DZ;
+    ctgTheta = candidate->CtgTheta;
+
     // apply smearing formula
+    
+    timeResolution = fFormula->Eval(pt, eta, phi, e, d0, dz, ctgTheta);
+    if(fabs(candidate->Position.Eta())<fEtaMax)
+    { 
+      tf_smeared = tf + timeResolution*gRandom->Gaus(0, 1);
+    }
+    else continue;
 
-    if(candidate->Charge != 0)
-    { 
-      tf_smeared = tf + fTimeResolution*gRandom->Gaus(0, 1);
-      //mother = candidate;
-      //candidate = static_cast<Candidate*>(candidate->Clone());  // I am not sure that we need these lines !!!
-      //candidate->AddCandidate(mother);
-      candidate->InitialPosition.SetT((100+ti)*1.0E3*c_light);
-      candidate->Position.SetT(tf_smeared*1.0E3*c_light);
-      candidate->ErrorT = fTimeResolution*1.0E3*c_light;
-      fOutputArray->Add(candidate);
-    }
-    else
-    {
-        sigma_t = sqrt(pow(20,2) + pow(150,2)/e);
-        ti = sigma_t - l*1.0E3/(c_light*beta_particle);   
-        candidate->InitialPosition.SetT(ti);
-        candidate->ErrorT = sigma_t*1.0E3*c_light;              // Do we need to sum with 100 like in upside ?
-        fOutputArray->Add(candidate);
-    }
-   
+    // double beta_particle = candidate->Momentum.P()/candidate->Momentum.E();
+    // ti = tf_smeared - candidate->Ld*1.0E-3/(c_light*beta_particle);
+
+    mother = candidate;
+    candidate = static_cast<Candidate*>(candidate->Clone());
+    candidate->AddCandidate(mother);
+    candidate->InitialPosition.SetT((100+ti)*1.0E3*c_light);
+    candidate->Position.SetT(tf_smeared*1.0E3*c_light);
+    candidate->ErrorT = timeResolution*1.0E3*c_light;
+
+    fOutputArray->Add(candidate);
   }
 }

modules/TimeSmearing.h

@@ -45 +45 @@
 
 private:
-  Double_t fTimeResolution; //!
+  DelphesFormula *fFormula; //!
   Double_t fEtaMax;
 

modules/TrackTimingPileUpSubtractor.cc

@@ -75 +75 @@
 
   // read resolution formula in m
-  fChargedMinSignificance = GetDouble("ChargedMinSignificance", 3);
-  fNeutralMinSignificance = GetDouble("NeutralMinSignificance", 3);
+  fFormula->Compile(GetString("ZVertexResolution", "0.001"));
 
   fPTMin = GetDouble("PTMin", 0.);
@@ -129 +128 @@
   Double_t tempPTSquare = 0;
   Double_t pt, eta, phi, e;
-  Double_t distanceCharged, distanceNeutral = 0;
+  Double_t distance = 0;
 
   // find z position of primary vertex
@@ -144 +143 @@
       tvtx = candidate->Position.T();
       tvtx_err = candidate->PositionError.T();
+      cout << " initial : " << candidate->InitialPosition.T() << " final : " << candidate->Position.T() << endl;
     } 
   }
@@ -167 +167 @@
       z = particle->Position.Z();
       z_err = particle->PositionError.Z();
-      t = particle->InitialPosition.T();
+      t = particle->Position.T();
       t_err = particle->PositionError.T();
 
-      distanceCharged = pow((zvtx - z),2)/pow((zvtx_err - z_err),2) + pow((tvtx - t),2)/pow((tvtx_err - t_err),2);
-      distanceNeutral = pow((tvtx - t),2)/pow((tvtx_err - t_err),2);
+      // apply pile-up subtraction
+      distance = pow((zvtx - z),2)/pow((zvtx_err - z_err),2) + pow((tvtx - t),2)/pow((tvtx_err - t_err),2);
+      //cout << " t : " << tvtx << "  t(particle)" << t << endl;
+      // here I calculated distance using Z and T of selected vertex (highest sum Pt square) and particles
+      // however z_err of vertices is gives 0 because of using CMS trackResolutionCMS.tcl (in that formula, there is limitation on |eta| < 2.5)
+      // thats why I used TMath::Abs(z - zvtx) < 0.005 && TMath::Abs(t - tvtx) < 5.0
 
-      if(candidate->Charge != 0 && distanceCharged < fChargedMinSignificance)
+      if(candidate->Charge != 0 && TMath::Abs(z - zvtx) < 0.005 && TMath::Abs(t - tvtx) < 5.0)
       {
         candidate->IsRecoPU = 1;
       }
-      else if(candidate->Charge == 0 && distanceNeutral < fNeutralMinSignificance)
-      {
-        candidate->IsRecoPU = 1;
-      }  
       else
       {

modules/TrackTimingPileUpSubtractor.h

@@ -49 +49 @@
   DelphesFormula *fFormula; //!
 
-  Double_t fChargedMinSignificance;
-  Double_t fNeutralMinSignificance;
-
   Double_t fPTMin;
 

modules/VertexFinderDA4D.cc

@@ -425 +425 @@
     candidate->ClusterIndex = k;
     candidate->Position.SetXYZT(0.0, 0.0, vtx.z[k] , vtx.t[k]*1E-9*c_light);
-    candidate->InitialPosition.SetXYZT(0.0, 0.0, vtx.z[k] , vtx.t[k]*1E-9*c_light);    
     candidate->PositionError.SetXYZT(0.0, 0.0, fVertexZSize , fVertexTSize*1E-9*c_light);
     candidate->SumPT2 = 0;