CbmBbaAlignmentMcbmTask.h

Go to the documentation of this file.

/* Copyright (C) 2023-2025 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: S.Gorbunov[committer], N.Bluhme */

 
#ifndef CbmBbaAlignmentMcbmTask_H
#define CbmBbaAlignmentMcbmTask_H
 
 
#include "CbmDefs.h"
#include "CbmKfTrackFitter.h"
#include "FairTask.h"
#include "TString.h"
 
#include <vector>
 
class TObject;
class TH1F;
class TClonesArray;
class TFile;
class TDirectory;
class TH1F;
 

 
class CbmBbaAlignmentMcbmTask : public FairTask {
 public:
  // Constructors/Destructors ---------
  CbmBbaAlignmentMcbmTask(const char* name = "CbmBbaAlignmentMcbmTask", Int_t iVerbose = 0,
                          TString histoFileName = "./CbmBbaAlignmentHisto.root");
  ~CbmBbaAlignmentMcbmTask();
 
  Int_t GetZtoNStation(Double_t getZ);
 
  InitStatus Init();
  void Exec(Option_t* opt);
  void Finish();
 
  void SetMcbmTrackingMode() { fTrackingMode = TrackingMode::kMcbm; }
  void SetStsTrackingMode() { fTrackingMode = TrackingMode::kSts; }
 
  void SetSimulatedMisalignmentRange(double range) { fSimulatedMisalignmentRange = range; }
  void SetRandomSeed(int seed) { fRandomSeed = seed; }
 
  void SetMatrixOutFileName(TString sMatrixOutFileName) { fsMatrixOutFileName = sMatrixOutFileName; }
 
 public:
  enum TrackingMode
  {
    kSts,
    kMcbm
  };
 
  class Trajectory : public CbmKfTrackFitter<cbm::algo::kf::DoFitTime::N>::Trajectory {
   public:
    using CbmKfTrackFitter<cbm::algo::kf::DoFitTime::N>::Trajectory::Trajectory;
 
    static int GetSensorId(const Node& node) { return node.userReferences[3]; }
 
    static void SetSensorId(Node& node, int sensorId) { node.userReferences[3] = sensorId; }
 
    void SetSensorId(size_t inode, int sensorId) { SetSensorId(fNodes[inode], sensorId); }
  };

  struct TrackContainer {
 
    Trajectory fUnalignedTrack;                           // track before alignment
    Trajectory fAlignedTrack;                             // track after alignment
    cbm::algo::kf::TrackParamD fFittedAlignedTrackParam;  // fitted track parameters after alignment
 
    int fNmvdHits{0};    // number of MVD hits
    int fNstsHits{0};    // number of STS hits
    int fNmuchHits{0};   // number of MUCH hits
    int fNtrd1dHits{0};  // number of TRD hits
    int fNtrd2dHits{0};  // number of TRD hits
    int fNtofHits{0};    // number of TOF hits
 
    bool fIsActive{1};  // is the track active
    void MakeConsistent();
  };
 
  struct AlignmentBody {
    int fTrackingStation{-1};
  };
 
  struct Sensor {  // TGeoNode to be aligned
    ECbmModuleId fSystemId{0};
    int fTrackingStation{-1};
    int fAlignmentBody{-1};
    std::string fNodePath{""};  // full path to the node in the root geometry
 
    bool operator<(const Sensor& other) const
    {
      if (fSystemId < other.fSystemId) return true;
      if (fSystemId > other.fSystemId) return false;
      if (fTrackingStation < other.fTrackingStation) return true;
      if (fTrackingStation > other.fTrackingStation) return false;
      return (fNodePath < other.fNodePath);
    };
 
    bool operator==(const Sensor& other) const { return fNodePath == other.fNodePath; };
  };
 
 private:
  const CbmBbaAlignmentMcbmTask& operator=(const CbmBbaAlignmentMcbmTask&);
  CbmBbaAlignmentMcbmTask(const CbmBbaAlignmentMcbmTask&);
 
  void WriteHistosCurFile(TObject* obj);
 
  void ApplyAlignment(const std::vector<double>& par);
 
  double CostFunction(const std::vector<double>& par);
 
  void ApplyConstraints(std::vector<double>& par);
 
  void ConstrainStation(std::vector<double>& par, int iSta, int ixyz);
 
 
  TrackingMode fTrackingMode = TrackingMode::kMcbm;
 
  // input data arrays
 
  TClonesArray* fInputGlobalTracks{nullptr};
  TClonesArray* fInputStsTracks{nullptr};
 
  TClonesArray* fInputMcTracks{nullptr};            // Mc info for debugging
  TClonesArray* fInputGlobalTrackMatches{nullptr};  // Mc info for debugging
  TClonesArray* fInputStsTrackMatches{nullptr};     // Mc info for debugging
 
  int fNthreads = 1;
 
  CbmKfTrackFitter<cbm::algo::kf::DoFitTime::N> fFitter;
 
  // collection of selected tracks and hits
  std::vector<TrackContainer> fTracks;
 
 
  //output file with histograms
  TString fsMatrixOutFileName{"AlignmentMatrices_finetuning.root"};
  TString fHistoFileName{"CbmBbaAlignmentHisto.root"};
  TFile* fHistoFile{nullptr};
  TDirectory* fHistoDir{nullptr};
 
  Int_t fNEvents{0};
 
  Int_t fMaxNtracks{0};
 
  int fNtrackingStations{0};
  int fNalignmentBodies{0};
 
  double fCostIdeal{1.e10};
  double fCostInitial{0.};
 
  double fSimulatedMisalignmentRange{0.};  // misalignment range for simulated misalignment
 
  int fRandomSeed{1};
 
  double fChi2Total{0.};
  long fNdfTotal{0};
  long fFixedNdf{-1};
 
 
  std::vector<Sensor> fSensors;
  std::vector<AlignmentBody> fAlignmentBodies;
 
  //histograms
 
  std::vector<TH1F*> hResidualsBeforeAlignmentX{};
  std::vector<TH1F*> hResidualsBeforeAlignmentY{};
  std::vector<TH1F*> hResidualsAfterAlignmentX{};
  std::vector<TH1F*> hResidualsAfterAlignmentY{};
 
  std::vector<TH1F*> hPullsBeforeAlignmentX{};
  std::vector<TH1F*> hPullsBeforeAlignmentY{};
  std::vector<TH1F*> hPullsAfterAlignmentX{};
  std::vector<TH1F*> hPullsAfterAlignmentY{};
 
  ClassDef(CbmBbaAlignmentMcbmTask, 1);
};
 
#endif