CbmRichRonchiAna.h

Go to the documentation of this file.

/* Copyright (C) 2018-2019 GSI/JINR-LIT, Darmstadt/Dubna
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Semen Lebedev, Andrey Lebedev [committer] */
 
#ifndef RICH_MIRRORS_CBMRICHRONCHIANA_H_
#define RICH_MIRRORS_CBMRICHRONCHIANA_H_
 
#include "TObject.h"
#include "TVector3.h"
 
#include <cmath>
#include <string>
#include <vector>
 
using namespace std;
 
class TH2;
 
class CbmRichRonchiIntersectionData {
 public:
  CbmRichRonchiIntersectionData()
    : fPixelX(0)
    , fPixelY(0)
    , fLineX(0)
    , fLineY(0)
    , fNormalRadX(0.)
    , fNormalRadY(0.)
    , fOrderedLineX(0)
    , fOrderedLineY(0)
    , fCcdV()
    , fRulingV()
    , fMirrorV()
    ,
 
    fTL()
    , fTR()
    , fBL()
    , fBR()
    ,
 
    fTLRot()
    , fTRRot()
    , fBLRot()
    , fBRRot()
    ,
 
    fTLSph()
    , fTRSph()
    , fBLSph()
    , fBRSph()
    ,
 
    fDeviation(0.)
    , fRLoc(0.)
  {
  }
 
  int fPixelX;
  int fPixelY;
  int fLineX;
  int fLineY;
 
  double fNormalRadX;  // Normal X in radians
  double fNormalRadY;
 
  int fOrderedLineX;
  int fOrderedLineY;
 
  TVector3 fCcdV;     // XYZ positions CCD in microns
  TVector3 fRulingV;  // XYZ positions ronchi ruling in microns
  TVector3 fMirrorV;  // XYZ positions of mirror in microns
 
  TVector3 fTL;  // corners of segment BEFORE rotation
  TVector3 fTR;
  TVector3 fBL;
  TVector3 fBR;
 
  TVector3 fTLRot;  // corners of segment AFTER rotation
  TVector3 fTRRot;
  TVector3 fBLRot;
  TVector3 fBRRot;
 
  TVector3 fTLSph;  // corners of segment after 'DoSphere'
  TVector3 fTRSph;
  TVector3 fBLSph;
  TVector3 fBRSph;
 
 
  std::vector<double>
    fVecTL;  // vectors that point from center of a segment to the corners (for calculation of rotations)       --CAN BE DELETED!?
  std::vector<double> fVecTR;
  std::vector<double> fVecBL;
  std::vector<double> fVecBR;
 
  double fDeviation;
  double fRLoc;
};
 
class CbmRichRonchiLineData {
 public:
  CbmRichRonchiLineData() : fNofPoints(0), fMeanPrimary(0), fMeanSecondary(0), fLineInd(0) {}
 
  int fNofPoints;
  double fMeanPrimary;
  double fMeanSecondary;
  int fLineInd;
};
 
class CbmRichRonchiAna : public TObject {
 public:
  CbmRichRonchiAna();
 
  virtual ~CbmRichRonchiAna();
 
  void Run();
 
  void SetTiffFileNameV(const string& fileName) { fTiffFileNameV = fileName; }
  void SetTiffFileNameH(const string& fileName) { fTiffFileNameH = fileName; }
 
 private:
  string fTiffFileNameV;
  string fTiffFileNameH;
 
  // constant values
  double fPi;
  double fRadiusMirror;   // in microns
  double fEdgeLengthCCD;  // in microns
  double fCcdPixelSize;   // in microns
  double fPitchGrid;      // in microns; distance of lines
  double fImageWidth;     // in pixels
 
  // values to be measured first
  double fDistRulingCCD;  // in microns
  double fDistMirrorCCD;  // in microns
  double fDistMirrorRuling;
  double fOffsetCCDOptAxisX;      // in microns; horizontal distance of center of CCD to optical axis of mirror
  double fOffsetCCDOptAxisY;      // in microns; vertical distance of center of CCD to optical axis of mirror
  double fOffsetLEDOpticalAxisX;  // in microns; horizontal distance of light source to optical axis of mirror
  double fOffsetLEDOpticalAxisY;
  double fCorrection;  // correction value; defines center of mirror at exactly 3,000,000 mum in z dircetion
 
  // values that will be determined by function
  double fCenterCcdX;  // in pixels; approximate center of image on CCD, will be defined in 'DoLocalNormal' function
  double fCenterCcdY;  // in pixels
  double fImageCenterMirrorX;  // in pixels; approximate center of image on mirror  (NEEDED??)
  double fImageCenterMirrorY;  // in pixels
 
  vector<vector<double>> ReadTiffFile(const string& fileName);
 
  void DoRotation(vector<vector<double>>& data);
 
  void FillH2WithVector(TH2* hist, const vector<vector<double>>& data);
 
  void DoMeanIntensityY(vector<vector<double>>& data);
 
  void DoPeakFinderY(vector<vector<double>>& data);
 
  void DoSmoothLines(vector<vector<double>>& data);
 
  void DoLineSearch(vector<vector<double>>& data);
 
  vector<vector<double>> DoSuperpose(const vector<vector<double>>& dataH, const vector<vector<double>>& dataV);
 
  vector<CbmRichRonchiIntersectionData> DoIntersection(vector<vector<double>>& dataH,
                                                       const vector<vector<double>>& dataV);
 
  void DoOrderLines(vector<CbmRichRonchiIntersectionData>& intersections, const string& option);
  bool AreTwoSegmentsSameLine(const CbmRichRonchiLineData* line1, const CbmRichRonchiLineData* line2);
  void UpdateIntersectionLineInd(vector<CbmRichRonchiIntersectionData>& intersections, CbmRichRonchiLineData* line1,
                                 CbmRichRonchiLineData* line2, const string& option);
 
  void DoLocalNormal(vector<CbmRichRonchiIntersectionData>& data);
  void DrawXYMum(vector<CbmRichRonchiIntersectionData>& data);
  void DrawXZProjection(vector<CbmRichRonchiIntersectionData>& data, int orderedLineY, double scale);
  void DrawMirrorSegments(vector<CbmRichRonchiIntersectionData>& data, int orderedLineX, int orderedLineY);
  void DrawMirrorSegmentsSphereAll(vector<CbmRichRonchiIntersectionData>& data);
  void DrawMirrorSegmentsSphere(vector<CbmRichRonchiIntersectionData>& data, int orderedLineX, int orderedLineY);
  void DrawOneMirrorSegment(const TVector3& tl, const TVector3& tr, const TVector3& bl, const TVector3& br, int color);
  void DrawSphere(vector<CbmRichRonchiIntersectionData>& data);
  void DrawRLocMum(vector<CbmRichRonchiIntersectionData>& data);
 
  void DoHeight(vector<CbmRichRonchiIntersectionData>& intersections);
 
  void DoSphere(vector<CbmRichRonchiIntersectionData>& intersections);
 
  int GetIndexForLineXLineY(int lineX, int lineY, vector<CbmRichRonchiIntersectionData>& data);
  int GetMinIndexForLineX(int lineX, vector<CbmRichRonchiIntersectionData>& data);
  int GetMinIndexForLineY(int lineY, vector<CbmRichRonchiIntersectionData>& data);
 
  void DoHeightCorners(vector<CbmRichRonchiIntersectionData>& intersections);
 
  void DoScanLineHeight(vector<CbmRichRonchiIntersectionData>& intersections);
 
  void DoCalculateRemaining(vector<CbmRichRonchiIntersectionData>& intersections);
 
  void DoIntegrate(vector<CbmRichRonchiIntersectionData>& intersections);
 
  void DoAverageSurroundings(vector<CbmRichRonchiIntersectionData>& intersections);
 
  void RotatePointImpl(TVector3* inPos, TVector3* outPos, Double_t rotX, Double_t rotY, TVector3* cV);
 
  void DoDeviation(vector<CbmRichRonchiIntersectionData>& data);
 
  void DoRLoc(vector<CbmRichRonchiIntersectionData>& data);
 
  CbmRichRonchiAna(const CbmRichRonchiAna&);
 
  CbmRichRonchiAna& operator=(const CbmRichRonchiAna&);
 
  ClassDef(CbmRichRonchiAna, 1)
};
 
#endif /* RICH_MIRRORS_CBMRICHRONCHIANA_H_ */