TracksToRecords.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 ALICEO2_MFT_TRACKS_TO_RECORDS_H
#define ALICEO2_MFT_TRACKS_TO_RECORDS_H
 
#include <vector>
#include <gsl/gsl>
 
#include <TTree.h>
#include <TChain.h>
 
#include "Framework/ProcessingContext.h"
#include "DataFormatsITSMFT/TopologyDictionary.h"
#include "DataFormatsMFT/TrackMFT.h"
#include "DataFormatsITSMFT/ROFRecord.h"
#include "DataFormatsITSMFT/CompCluster.h"
#include "ReconstructionDataFormats/BaseCluster.h"
#include "ForwardAlign/MillePedeRecord.h"
#include "ForwardAlign/MilleRecordWriter.h"
#include "MFTAlignment/AlignPointHelper.h"
#include "MFTAlignment/AlignPointControl.h"
#include "MFTBase/GeometryTGeo.h"
 
#include "MFTAlignment/Aligner.h"
 
namespace o2
{
namespace mft
{
 
class TracksToRecords : public Aligner
{
 public:
  TracksToRecords();
 
  ~TracksToRecords() override;
 
  void init() override;
 
  // simple setters
 
  void setClusterDictionary(const o2::itsmft::TopologyDictionary* d) { mDictionary = d; }
  void setRunNumber(const int value) { mRunNumber = value; }
  void setBz(const float bz) { mBz = bz; }
  void setMinNumberClusterCut(const int value) { mMinNumberClusterCut = value; }
  void setWithControl(const bool choice) { mWithControl = choice; }
  void setNEntriesAutoSave(const int value) { mNEntriesAutoSave = value; }
  void setWithConstraintsRecWriter(const bool choice) { mWithConstraintsRecWriter = choice; }
 
  void processTimeFrame(o2::framework::ProcessingContext& ctx);
 
  void processRecoTracks();
 
  void processROFs(TChain* mfttrackChain, TChain* mftclusterChain);
 
  void printProcessTrackSummary();
 
  void startRecordWriter();
 
  void endRecordWriter();
 
  void startConstraintsRecWriter();
 
  void endConstraintsRecWriter();
 
 protected:
  int mRunNumber;                                          
  float mBz;                                               
  int mNumberTFs;                                          
  int mNumberOfClusterChainROFs;                           
  int mNumberOfTrackChainROFs;                             
  int mCounterLocalEquationFailed;                         
  int mCounterSkippedTracks;                               
  int mCounterUsedTracks;                                  
  std::vector<double> mGlobalDerivatives;                  
  std::vector<double> mLocalDerivatives;                   
  int mMinNumberClusterCut;                                
  double mWeightRecord;                                    
  const o2::itsmft::TopologyDictionary* mDictionary;       
  o2::mft::AlignPointHelper* mAlignPoint;                  
  bool mWithControl;                                       
  long mNEntriesAutoSave = 10000;                          
  o2::mft::AlignPointControl mPointControl;                
  o2::fwdalign::MilleRecordWriter* mRecordWriter;          
  bool mWithConstraintsRecWriter;                          
  o2::fwdalign::MilleRecordWriter* mConstraintsRecWriter;  
  std::vector<o2::BaseCluster<double>> mMFTClustersLocal;  
  std::vector<o2::BaseCluster<double>> mMFTClustersGlobal; 
  o2::fwdalign::MillePede2* mMillepede;                    
 
  // access these data from CTFs provided uptream by the workflow
 
  gsl::span<const o2::mft::TrackMFT> mMFTTracks;
  gsl::span<const o2::itsmft::ROFRecord> mMFTTracksROF;
  gsl::span<const int> mMFTTrackClusIdx;
  gsl::span<const o2::itsmft::CompClusterExt> mMFTClusters;
  gsl::span<const o2::itsmft::ROFRecord> mMFTClustersROF;
  gsl::span<const unsigned char> mMFTClusterPatterns;
  gsl::span<const unsigned char>::iterator mPattIt;
 
 protected:
  bool setLocalDerivative(Int_t index, Double_t value);
 
  bool setGlobalDerivative(Int_t index, Double_t value);
 
  bool resetLocalDerivative();
 
  bool resetGlocalDerivative();
 
  bool setLocalEquationX();
 
  bool setLocalEquationY();
 
  bool setLocalEquationZ();
 
  ClassDefOverride(TracksToRecords, 0);
};
 
} // namespace mft
} // namespace o2
 
#endif