RawToDigitConverterSpec.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.
 
#include <vector>
#include <chrono>
#include "Framework/DataProcessorSpec.h"
#include "Framework/Task.h"
#include "Framework/ConcreteDataMatcher.h"
#include "DataFormatsCPV/Digit.h"
#include "DataFormatsCPV/TriggerRecord.h"
#include "DataFormatsCPV/CalibParams.h"
#include "DataFormatsCPV/BadChannelMap.h"
#include "DataFormatsCPV/Pedestals.h"
#include "CPVReconstruction/RawDecoder.h"
#include "CCDB/BasicCCDBManager.h"
 
namespace o2
{
 
namespace cpv
{
 
namespace reco_workflow
{
 
class RawToDigitConverterSpec : public framework::Task
{
 public:
  RawToDigitConverterSpec(bool isPedestal, bool useBadChannelMap, bool useGainCalibration) : framework::Task(),
                                                                                             mIsUsingGainCalibration(useGainCalibration),
                                                                                             mIsUsingBadMap(useBadChannelMap),
                                                                                             mIsPedestalData(isPedestal){};
 
  ~RawToDigitConverterSpec() override = default;
 
  void init(framework::InitContext& ctx) final;
 
  void run(framework::ProcessingContext& ctx) final;
  void finaliseCCDB(framework::ConcreteDataMatcher& matcher, void* obj) final;
 
 protected:
  char CheckHWAddress(short ddl, short hwAddress, short& fee);
 
 private:
  void updateTimeDependentParams(framework::ProcessingContext& ctx);
 
 private:
  bool mIsUsingGainCalibration;                                      
  bool mIsUsingBadMap;                                               
  bool mIsPedestalData;                                              
  const o2::cpv::Pedestals* mPedestals = nullptr;                    
  const o2::cpv::BadChannelMap* mBadMap = nullptr;                   
  const o2::cpv::CalibParams* mGains = nullptr;                      
  std::vector<Digit> mOutputDigits;                                  
  std::vector<TriggerRecord> mOutputTriggerRecords;                  
  std::vector<RawDecoderError> mOutputHWErrors;                      
  bool mIsMuteDecoderErrors = false;                                 
  int mDecoderErrorsCounterWhenMuted = 0;                            
  int mDecoderErrorsPerMinute = 0;                                   
  int mMinutesPassed = 0;                                            
  std::chrono::time_point<std::chrono::system_clock> mStartTime;     
  std::chrono::time_point<std::chrono::system_clock> mTimeWhenMuted; 
};
 
o2::framework::DataProcessorSpec getRawToDigitConverterSpec(bool askDISTSTF = true,
                                                            bool isPedestal = false,
                                                            bool useBadChannelMap = true,
                                                            bool useGainCalibration = true);
 
} // namespace reco_workflow
 
} // namespace cpv
 
} // namespace o2