Run2LikeAO2D.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
 
//******************************************************************
// AO2D helper information
//
// This header contains basic info needed to mimick a Run 2-like
// converted AO2D file. Its current use case is the ALICE 3
// G3/G4 simulation to AO2D conversion.
//
//******************************************************************
#ifndef RUN2LIKE_AOD_H
#define RUN2LIKE_AOD_H
#include <TString.h>
 
namespace o2
{
namespace upgrades_utils
{
 
enum TreeIndex {     // Index of the output trees
  kEvents = 0,       //ok
  kEventsExtra,      //ok
  kTracks,           //ok
  kCalo,             //N/A
  kCaloTrigger,      //N/A
  kMuon,             //N/A
  kZdc,              //N/A
  kFV0A,             //N/A
  kFV0C,             //N/A
  kFT0,              //N/A
  kFDD,              //N/A
  kV0s,              //may be ok (requires tuning)
  kCascades,         //may be ok (requires tuning)
  kTOF,              //N/A... for now
  kMcParticle,       //MC operation
  kMcCollision,      //MC operation
  kMcTrackLabel,     //MC operation
  kMcCaloLabel,      //N/A
  kMcCollisionLabel, //MC operation
  kBC,               //N/A
  kTrees             //N/A
};
 
enum MCParticleFlags : uint8_t {
  ProducedInTransport = 1 // Bit 0: 0 = from generator; 1 = from transport
};
 
const TString gTreeName[kTrees] = {"O2collision", "DbgEventExtra", "O2track", "O2calo", "O2calotrigger", "O2muon", "O2zdc", "O2fv0a", "O2fv0c", "O2ft0", "O2fdd", "O2v0", "O2cascade", "O2tof", "O2mcparticle", "O2mccollision", "O2mctracklabel", "O2mccalolabel", "O2mccollisionlabel", "O2bc"};
const TString gTreeTitle[kTrees] = {"Collision tree", "Collision extra", "Barrel tracks", "Calorimeter cells", "Calorimeter triggers", "MUON tracks", "ZDC", "FV0A", "FV0C", "FT0", "FDD", "V0s", "Cascades", "TOF hits", "Kinematics", "MC collisions", "MC track labels", "MC calo labels", "MC collision labels", "BC info"};
 
const Bool_t gSaveTree[kTrees] = {kTRUE, kFALSE, kTRUE, kFALSE, kFALSE, kFALSE, kTRUE, kTRUE, kTRUE, kTRUE, kTRUE,
                                  //V0 and cascade (not done for now)
                                  kFALSE, kFALSE,
                                  //TOF
                                  kFALSE,
                                  //MC information (not done for now)
                                  kTRUE, kTRUE, kTRUE, kFALSE, kTRUE, kTRUE};
 
//+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// structs for AO2D convenience
// straight from AO2D converter
struct {
  // Event data
  Int_t fBCsID = 0u; 
  // Primary vertex position
  Float_t fPosX = -999.f; 
  Float_t fPosY = -999.f; 
  Float_t fPosZ = -999.f; 
  // Primary vertex covariance matrix
  Float_t fCovXX = 999.f; 
  Float_t fCovXY = 0.f;   
  Float_t fCovXZ = 0.f;   
  Float_t fCovYY = 999.f; 
  Float_t fCovYZ = 0.f;   
  Float_t fCovZZ = 999.f; 
  // Quality parameters
  Float_t fChi2 = 999.f; 
  UInt_t fN = 0u;        
 
  // The calculation of event time certainly will be modified in Run3
  // The prototype below can be switched on request
  Float_t fCollisionTime = 10;      
  Float_t fCollisionTimeRes = 1e-3; 
  UChar_t fCollisionTimeMask = 0u;  
 
} collision; 
 
struct {
  // Start indices and numbers of elements for data in the other trees matching this vertex.
  // Needed for random access of collision-related data, allowing skipping data discarded by the user
  Int_t fStart[kTrees] = {0};    
  Int_t fNentries[kTrees] = {0}; 
} eventextra;                    
 
struct {
  int fRunNumber = -1;         
  ULong64_t fGlobalBC = 0u;    
  ULong64_t fTriggerMask = 0u; 
} bc;                          
 
struct {
  // Track data
 
  Int_t fCollisionsID = -1; 
 
  uint8_t fTrackType = 0; // Type of track: global, ITS standalone, tracklet, ...
 
  // In case we need connection to TOF clusters, activate next lines
  // Int_t   fTOFclsIndex;     /// The index of the associated TOF cluster
  // Int_t   fNTOFcls;         /// The number of TOF clusters
 
  // Coordinate system parameters
  Float_t fX = -999.f;     
  Float_t fAlpha = -999.f; 
 
  // Track parameters
  Float_t fY = -999.f;         
  Float_t fZ = -999.f;         
  Float_t fSnp = -999.f;       
  Float_t fTgl = -999.f;       
  Float_t fSigned1Pt = -999.f; 
 
  // "Covariance matrix"
  // The diagonal elements represent the errors = Sqrt(C[i,i])
  // The off-diagonal elements are the correlations = C[i,j]/Sqrt(C[i,i])/Sqrt(C[j,j])
  // The off-diagonal elements are multiplied by 128 (7bits) and packed in Char_t
  Float_t fSigmaY = -999.f;   
  Float_t fSigmaZ = -999.f;   
  Float_t fSigmaSnp = -999.f; 
  Float_t fSigmaTgl = -999.f; 
  Float_t fSigma1Pt = -999.f; 
  Char_t fRhoZY = 0;          
  Char_t fRhoSnpY = 0;        
  Char_t fRhoSnpZ = 0;        
  Char_t fRhoTglY = 0;        
  Char_t fRhoTglZ = 0;        
  Char_t fRhoTglSnp = 0;      
  Char_t fRho1PtY = 0;        
  Char_t fRho1PtZ = 0;        
  Char_t fRho1PtSnp = 0;      
  Char_t fRho1PtTgl = 0;      
 
  // Additional track parameters
  Float_t fTPCinnerP = -999.f; 
 
  // Track quality parameters
  UInt_t fFlags = 0u; 
 
  // Clusters and tracklets
  UChar_t fITSClusterMap = 0u;                 
  UChar_t fTPCNClsFindable = 0u;               
  Char_t fTPCNClsFindableMinusFound = 0;       
  Char_t fTPCNClsFindableMinusCrossedRows = 0; 
  UChar_t fTPCNClsShared = 0u;                 
  UChar_t fTRDPattern = 0u;                    
 
  // Chi2
  Float_t fITSChi2NCl = -999.f; 
  Float_t fTPCChi2NCl = -999.f; 
  Float_t fTRDChi2 = -999.f;    
  Float_t fTOFChi2 = -999.f;    
 
  // PID
  Float_t fTPCSignal = -999.f; 
  Float_t fTRDSignal = -999.f; 
  Float_t fTOFSignal = -999.f; 
  Float_t fLength = -999.f;    
  Float_t fTOFExpMom = -999.f; 
 
  // Track extrapolation to EMCAL surface
  Float_t fTrackEtaEMCAL = -999.f; 
  Float_t fTrackPhiEMCAL = -999.f; 
} tracks;                          
 
struct {
  // MC collision
  Int_t fBCsID = 0u;          
  Short_t fGeneratorsID = 0u; 
  Float_t fPosX = -999.f;     
  Float_t fPosY = -999.f;     
  Float_t fPosZ = -999.f;     
  Float_t fT = -999.f;        
  Float_t fWeight = -999.f;   
  // Generation details (HepMC3 in the future)
  Float_t fImpactParameter = -999.f; 
} mccollision;                       
 
struct {
  // Track label to find the corresponding MC particle
  UInt_t fLabel = 0;       
  UShort_t fLabelMask = 0; 
} mctracklabel;            
 
struct {
  // MC particle
 
  Int_t fMcCollisionsID = -1; 
 
  // MC information (modified version of TParticle
  Int_t fPdgCode = -99999;    
  Int_t fStatusCode = -99999; 
  uint8_t fFlags = 0;         
  Int_t fMother0 = 0;         
  Int_t fMother1 = 0;
  Int_t fDaughter0 = 0; 
  Int_t fDaughter1 = 0;
  Float_t fWeight = 1; 
 
  Float_t fPx = -999.f; 
  Float_t fPy = -999.f; 
  Float_t fPz = -999.f; 
  Float_t fE = -999.f;  
 
  Float_t fVx = -999.f; 
  Float_t fVy = -999.f; 
  Float_t fVz = -999.f; 
  Float_t fVt = -999.f; 
  // We do not use the polarisation so far
} mcparticle; 
 
struct {
  // MC collision label
  UInt_t fLabel = 0;       
  UShort_t fLabelMask = 0; 
} mccollisionlabel;        
 
struct {
  Int_t fBCsID = 0u;              
  Float_t fAmplitudeA[4] = {0.f}; 
  Float_t fAmplitudeC[4] = {0.f}; 
  Float_t fTimeA = 56.7f;         
  Float_t fTimeC = 65.3f;         
  uint8_t fTriggerMask = 0;       
} fdd;
 
struct {
  Int_t fBCsID = 0u;              
  Float_t fAmplitude[48] = {0.f}; 
  Float_t fTime = 11.f;           
  uint8_t fTriggerMask = 0;       
} fv0a;                           
 
struct {
  Int_t fBCsID = 0u;              
  Float_t fAmplitude[32] = {0.f}; 
  Float_t fTime = 3.6f;           
} fv0c;                           
 
struct {
  Int_t fBCsID = 0u;                
  Float_t fAmplitudeA[96] = {0.f};  
  Float_t fAmplitudeC[112] = {0.f}; 
  Float_t fTimeA = 0.02f;           
  Float_t fTimeC = 0.03f;           
  uint8_t fTriggerMask = 0;         
} ft0;                              
 
struct {
  Int_t fBCsID = 0u;                   
  Float_t fEnergyZEM1 = 0.f;           
  Float_t fEnergyZEM2 = 0.f;           
  Float_t fEnergyCommonZNA = 0.f;      
  Float_t fEnergyCommonZNC = 0.f;      
  Float_t fEnergyCommonZPA = 0.f;      
  Float_t fEnergyCommonZPC = 0.f;      
  Float_t fEnergySectorZNA[4] = {0.f}; 
  Float_t fEnergySectorZNC[4] = {0.f}; 
  Float_t fEnergySectorZPA[4] = {0.f}; 
  Float_t fEnergySectorZPC[4] = {0.f}; 
  Float_t fTimeZEM1 = 0.f;             
  Float_t fTimeZEM2 = 0.f;             
  Float_t fTimeZNA = 0.055f;           
  Float_t fTimeZNC = -0.049f;          
  Float_t fTimeZPA = 0.f;              
  Float_t fTimeZPC = 0.f;              
} zdc;
} // namespace upgrades_utils
} // namespace o2
 
#endif