Aligner.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_MCH_ALIGNER
#define ALICEO2_MCH_ALIGNER
 
#include <string>
#include <vector>
 
#include "DataFormatsMCH/Cluster.h"
#include "DetectorsCommonDataFormats/AlignParam.h"
#include "ForwardAlign/MillePede2.h"
#include "ForwardAlign/MillePedeRecord.h"
#include "MCHGeometryTransformer/Transformations.h"
#include "MCHTracking/Track.h"
 
#include <TFile.h>
#include <TGeoManager.h>
#include <TGeoMatrix.h>
#include <TObject.h>
#include <TString.h>
#include <TTree.h>
 
namespace o2
{
 
namespace mch
{
 
class LocalTrackParam
{
 public:
  //* construction
  LocalTrackParam() = default;
  ~LocalTrackParam() = default;
 
  // private:
  //* y and z
  double fTrackX = 0.0;
  double fTrackY = 0.0;
  double fTrackZ = 0.0;
  double fTrackSlopeX = 0.0;
  double fTrackSlopeY = 0.0;
}; // class LocalTrackParam
 
class LocalTrackClusterResidual
{
 public:
  //* construction
  LocalTrackClusterResidual() = default;
  ~LocalTrackClusterResidual() = default;
 
  // private:
  //* y and z
  int fClDetElem = 0.0;
  int fClDetElemNumber = 0.0;
 
  float fClusterX = 0.0;
  float fClusterY = 0.0;
  float fClusterZ = 0.0;
  float fClusterXloc = 0.0;
  float fClusterYloc = 0.0;
 
  float fTrackX = 0.0;
  float fTrackY = 0.0;
  float fTrackZ = 0.0;
  float fTrackXloc = 0.0;
  float fTrackYloc = 0.0;
 
  float fTrackSlopeX = 0.0;
  float fTrackSlopeY = 0.0;
 
  float fBendingMomentum = 0.0;
 
  float fResiduXGlobal = 0.0;
  float fResiduYGlobal = 0.0;
 
  float fResiduXLocal = 0.0;
  float fResiduYLocal = 0.0;
 
  float fCharge = 0.0;
 
  float fBx = 0.0;
  float fBy = 0.0;
  float fBz = 0.0;
 
}; // class LocalTrackClusterResidual
 
class Aligner : public TObject
{
 
 public:
  Aligner();
 
  ~Aligner();
 
  // initialize
  void init(TString DataRecFName = "millerecords.root", TString ConsRecFName = "milleconstraints.root");
 
  // terminate
  void terminate();
 
  // array dimendions
  enum {
    fgNSt = 5,
 
    fgNCh = 10,
 
    fgNTrkMod = 16,
 
    fgNHalfCh = 20,
 
    fgNDetHalfChMax = 13,
 
    fgNDetElem = 156,
 
    fNLocal = 4, // t_x, t_y, x0, y0
 
    fgNParCh = 4, // x,y,z,phi
 
    fNGlobal = fgNParCh * fgNDetElem
  };
 
  static const int fgNDetElemCh[fgNCh];
 
  static const int fgSNDetElemCh[fgNCh + 1];
 
  static const int fgNDetElemHalfCh[fgNHalfCh];
 
  static const int fgDetElemHalfCh[fgNHalfCh][fgNDetHalfChMax];
 
  enum ParameterMask {
    ParX = 1 << 0,
    ParY = 1 << 1,
    ParZ = 1 << 2,
    ParTZ = 1 << 3,
 
    ParAllTranslations = ParX | ParY | ParZ,
    ParAllRotations = ParTZ,
    ParAll = ParAllTranslations | ParAllRotations
 
  };
 
  enum SidesMask {
    SideTop = 1 << 0,
    SideLeft = 1 << 1,
    SideBottom = 1 << 2,
    SideRight = 1 << 3,
    SideTopLeft = SideTop | SideLeft,
    SideTopRight = SideTop | SideRight,
    SideBottomLeft = SideBottom | SideLeft,
    SideBottomRight = SideBottom | SideRight,
    AllSides = SideTop | SideBottom | SideLeft | SideRight
  };
 
  void ProcessTrack(Track& track, const o2::mch::geo::TransformationCreator& transformation, Bool_t doAlignment, Double_t weight = 1);
 
  //@name modifiers
 
  void SetRunNumber(int id)
  {
    fRunNumber = id;
  }
 
  void SetBFieldOn(bool value)
  {
    fBFieldOn = value;
  }
 
  void SetDoEvaluation(bool value)
  {
    fDoEvaluation = value;
  }
 
  void SetRefitStraightTracks(bool value)
  {
    fRefitStraightTracks = value;
  }
 
  void SetAllowedVariation(int iPar, double value);
 
  void SetSigmaXY(double sigmaX, double sigmaY);
 
  void FixAll(unsigned int parameterMask = ParAll);
 
  void FixChamber(int iCh, unsigned int parameterMask = ParAll);
 
  void FixDetElem(int iDetElemId, unsigned int parameterMask = ParAll);
 
  void FixHalfSpectrometer(const bool* bChOnOff, unsigned int sidesMask = AllSides, unsigned int parameterMask = ParAll);
 
  void FixParameter(int iPar);
 
  void FixParameter(int iDetElem, int iPar)
  {
    FixParameter(iDetElem * fgNParCh + iPar);
  }
 
 
  //@name releasing detectors
 
  void ReleaseChamber(int iCh, unsigned int parameterMask = ParAll);
 
  void ReleaseDetElem(int iDetElemId, unsigned int parameterMask = ParAll);
 
  void ReleaseParameter(int iPar);
 
  void ReleaseParameter(int iDetElem, int iPar)
  {
    ReleaseParameter(iDetElem * fgNParCh + iPar);
  }
 
 
  //@name grouping detectors
 
  void GroupChamber(int iCh, unsigned int parameterMask = ParAll);
 
  void GroupHalfChamber(int iCh, int iHalf, unsigned int parameterMask = ParAll);
 
  void GroupDetElems(int detElemMin, int detElemMax, unsigned int parameterMask = ParAll);
 
  void GroupDetElems(const int* detElemList, int nDetElem, unsigned int parameterMask = ParAll);
 
 
  //@name define non linearity
 
  void SetChamberNonLinear(int iCh, unsigned int parameterMask);
 
  void SetDetElemNonLinear(int iSt, unsigned int parameterMask);
 
  void SetParameterNonLinear(int iPar);
 
  void SetParameterNonLinear(int iDetElem, int iPar)
  {
    SetParameterNonLinear(iDetElem * fgNParCh + iPar);
  }
 
 
  //@name constraints
 
  void AddConstraints(const bool* bChOnOff, unsigned int parameterMask);
 
  void AddConstraints(const bool* bChOnOff, const bool* lVarXYT, unsigned int sidesMask = AllSides);
 
 
  void InitGlobalParameters(double* par);
 
  void GlobalFit(std::vector<double>& params, std::vector<double>& errors, std::vector<double>& pulls);
 
  void PrintGlobalParameters(void) const;
 
  double GetParError(int iPar) const;
 
  o2::fwdalign::MillePedeRecord& GetRecord() { return fTrackRecord; }
 
  void ReAlign(std::vector<o2::detectors::AlignParam>& params, std::vector<double>& misAlignments);
 
  void SetAlignmentResolution(const TClonesArray* misAlignArray, int chId, double chResX, double chResY, double deResX, double deResY);
 
  TTree* GetResTree()
  {
    return fTTree;
  }
 
  void SetReadOnly()
  {
    mRead = true;
  }
 
  void DisableRecordWriter()
  {
    fDisableRecordWriter = true;
  }
 
 private:
  Aligner(const Aligner& right);
 
  Aligner& operator=(const Aligner& right);
 
  void SetLocalDerivative(int index, double value)
  {
    fLocalDerivatives[index] = value;
  }
 
  void SetGlobalDerivative(int index, double value)
  {
    fGlobalDerivatives[index] = value;
  }
 
  LocalTrackParam RefitStraightTrack(Track&, double) const;
 
  void FillDetElemData(const Cluster*);
 
  void FillRecPointData(const Cluster*);
 
  void FillTrackParamData(const TrackParam*);
 
  void LocalEquationX(const double* r);
 
  void LocalEquationY(const double* r);
 
  TGeoCombiTrans DeltaTransform(const double* detElemMisAlignment) const;
 
  bool isMatrixConvertedToAngles(const double* rot, double& psi, double& theta, double& phi) const;
 
 
 
  void AddConstraint(double* parameters, double value);
 
  int GetChamberId(int iDetElemNumber) const;
 
  bool DetElemIsValid(int iDetElemId) const;
 
  int GetDetElemNumber(int iDetElemId) const;
 
  TString GetParameterMaskString(unsigned int parameterMask) const;
 
  TString GetSidesMaskString(unsigned int sidesMask) const;
 
 
  bool fInitialized;
 
  int fRunNumber;
 
  bool fBFieldOn;
 
  bool fRefitStraightTracks;
 
  double fAllowVar[fgNParCh];
 
  double fStartFac;
 
  double fResCutInitial;
 
  double fResCut;
 
  o2::fwdalign::MillePede2* fMillepede; // AliMillePede2 implementation
 
  int fNStdDev;
 
  double fClustPos[3];
 
  double fTrackSlope0[2];
 
  double fTrackSlope[2];
 
  double fTrackPos0[3];
 
  double fTrackPos[3];
 
  double fMeas[2];
 
  double fSigma[2];
 
  enum {
    kFixedParId = -1,
    kFreeParId = kFixedParId - 1,
    kGroupBaseId = -10
  };
 
  std::vector<int> fGlobalParameterStatus;
 
  std::vector<double> fGlobalDerivatives;
 
  std::vector<double> fLocalDerivatives;
 
  int fDetElemNumber;
 
  o2::fwdalign::MillePedeRecord fTrackRecord;
 
  o2::mch::geo::TransformationCreator fTransformCreator;
 
  bool fDoEvaluation;
 
  bool fDisableRecordWriter;
 
  LocalTrackClusterResidual* fTrkClRes;
 
  TFile* fTFile;
 
  TTree* fTTree;
 
  bool mRead;
 
  long mNEntriesAutoSave = 10000; 
 
  o2::fwdalign::MilleRecordWriter* mRecordWriter;         
  bool mWithConstraintsRecWriter;                         
  o2::fwdalign::MilleRecordWriter* mConstraintsRecWriter; 
 
  o2::fwdalign::MilleRecordReader* mRecordReader;         
  bool mWithConstraintsRecReader = false;                 
  o2::fwdalign::MilleRecordReader* mConstraintsRecReader; 
 
}; // class Alignment
 
} // namespace mch
} // namespace o2
#endif // ALICEO2_MCH_ALIGNER_H_