CbmRichRonchiAna.h

Go to the documentation of this file.

#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_ */