EMCALCalibParams.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.
 
 
#ifndef EMCAL_CALIB_INIT_PARAMS_H_
#define EMCAL_CALIB_INIT_PARAMS_H_
 
#include "CommonUtils/ConfigurableParam.h"
#include "CommonUtils/ConfigurableParamHelper.h"
 
namespace o2
{
namespace emcal
{
 
// class containing the parameters to trigger the calibrations
struct EMCALCalibParams : public o2::conf::ConfigurableParamHelper<EMCALCalibParams> {
 
  // parameters for bad channel calibration
  unsigned int minNEvents_bc = 1e7;     
  unsigned int minNEntries_bc = 1e6;    
  bool useNEventsForCalib_bc = true;    
  bool useScaledHisto_bc = true;        
  bool enableTestMode_bc = false;       
  int nBinsEnergyAxis_bc = 1000;        
  bool useTimeInfoForCalib_bc = true;   
  float maxValueEnergyAxis_bc = 40;     
  int nBinsTimeAxis_bc = 1000;          
  float rangeTimeAxisLow_bc = -500;     
  float rangeTimeAxisHigh_bc = 500;     
  float minCellEnergyTime_bc = 0.1;     
  float sigmaTime_bc = 5;               
  float sigmaTimePreTrigg_bc = 10.;     
  float sigmaTimePostTrigg_bc = 10.;    
  unsigned int slotLength_bc = 0;       
  bool UpdateAtEndOfRunOnly_bc = false; 
  float minNHitsForMeanEnergyCut = 100; 
  float minNHitsForNHitCut = 1;         
  float minCellEnergy_bc = 0.1;         
  float fractionEvents_bc = 1.;         
  size_t nThreads_bc = 4;               
  float fracMaskSMFully_bc = 0.5;       
  float fracMaskFECFully_bc = 0.9;      
 
  // parameters for time calibration
  unsigned int minNEvents_tc = 1e7;      
  unsigned int minNEntries_tc = 1e6;     
  bool useNEventsForCalib_tc = true;     
  float minCellEnergy_tc = 0.5;          
  int minTimeForFit_tc = -300;           
  int maxTimeForFit_tc = 300;            
  int restrictFitRangeToMax_tc = 25;     
  int nBinsTimeAxis_tc = 1500;           
  int minValueTimeAxis_tc = -500;        
  int maxValueTimeAxis_tc = 1000;        
  float lowGainOffset_tc = 8.8;          
  unsigned int slotLength_tc = 0;        
  bool UpdateAtEndOfRunOnly_tc = false;  
  float maxAllowedDeviationFromMax = 10; 
  float fractionEvents_tc = 1.;          
  size_t nThreads_tc = 2;                
 
  // common parameters
  std::string calibType = "time";                      
  std::string localRootFilePath = "";                  
  bool enableFastCalib = false;                        
  bool enableTimeProfiling = false;                    
  bool setSavedSlotAllowed_EMC = true;                 
  bool setSavedSlotAllowedSOR_EMC = true;              
  long endTimeMargin = 2592000000;                     
  std::string selectedClassMasks = "C0TVX-B-NOPF-EMC"; 
  int bcShiftCTP = 0;                                  
  std::string filePathSave = "./emc_calib";            
  bool requireSameFill = false;                        
  bool requireSameRunType = true;                      
  int tsDiffMax = 48;                                  
  unsigned int minNEventsSaveSlot = 100000;            
  bool useStaticStartTimeSlot = true;                  
 
  // Parameters for pedestal calibration
  short maxPedestalRMS = 10; 
 
  // old parameters. Keep them for a bit (can be deleted after september 5th) as otherwise ccdb and o2 version might not be in synch
  unsigned int minNEvents = 1e7;              
  unsigned int minNEntries = 1e6;             
  bool useNEventsForCalib = true;             
  bool useScaledHistoForBadChannelMap = true; 
  bool enableTestMode = false;                
  float minCellEnergyForTimeCalib = 0.5;      
  unsigned int slotLength = 0;                
  bool UpdateAtEndOfRunOnly = false;          
  int minTimeForFit = -300;                   
  int maxTimeForFit = 300;                    
  int restrictFitRangeToMax = 25;             
 
  O2ParamDef(EMCALCalibParams, "EMCALCalibParams");
};
 
} // namespace emcal
 
namespace framework
{
template <typename T>
struct is_messageable;
template <>
struct is_messageable<o2::emcal::EMCALCalibParams> : std::true_type {
};
} // namespace framework
 
} // namespace o2
 
#endif /*EMCAL_CALIB_INIT_PARAMS_H_ */