CbmRichGeoOpt.h

Go to the documentation of this file.

/* Copyright (C) 2014-2015 UGiessen/JINR-LIT, Giessen/Dubna
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Tariq Mahmoud, Semen Lebedev [committer] */
 
#
#ifndef CBM_RICH_GEO_OPT
#define CBM_RICH_GEO_OPT
 
#include "CbmRichPoint.h"
#include "FairTask.h"
 
#include <fstream>
#include <sstream>
 
class TVector3;
class TH1;
class TH2;
class TH1D;
class TH2D;
class TH3D;
class TClonesArray;
class CbmRichRing;
class CbmRichRingLight;
 
class TCanvas;
 
#include "TVector3.h"
 
#include <map>
#include <vector>
 
using namespace std;
 
class CbmRichGeoOpt : public FairTask {
 
 public:
  CbmRichGeoOpt();
 
  virtual ~CbmRichGeoOpt();
 
  virtual InitStatus Init();
 
  virtual void Exec(Option_t* option);
 
  virtual void Finish();
 
 
 private:
  TClonesArray* fRichPoints;
  TClonesArray* fMcTracks;
  TClonesArray* fRefPoints;
  TClonesArray* fRichHits;
  TClonesArray* fRichRings;
  TClonesArray* fRichRingMatches;
 
  Int_t fEventNum;
  Int_t PMTPointsFilled;
  Int_t fMinNofHits;  // Min number of hits in ring for detector acceptance calculation.
 
  Int_t nPhotonsNotOnPlane;
  Int_t nPhotonsNotOnSphere;
  Int_t nTotalPhorons;
  //TVector3 NormToXYPlane;
  //TVector3 XYPlane_P0;TVector3 XYPlane_P1;TVector3 XYPlane_P2;
  //double RotAngleX;
  //double RotAngleY;
 
  //Parameters to be read from a parameters file
  vector<TVector3> PMTPlanePoints;
  TVector3 PMTPlaneCenter;
  TVector3 ReadPMTPlaneCenter;
  TVector3 ReadPMTPlaneCenterOrig;
  TVector3 MirrorCenter;
  //TVector3 ReadMirrorCenter;
  double RotX;
  double RotY;
  TVector3 PMT_r1;
  TVector3 PMT_r2;
  TVector3 PMT_norm;
  double PMTPlaneCenterX;
  double PMTPlaneCenterY;
  double PMTPlaneThirdX;
  TVector3 MirrPosition;  //double MirrPosX; double MirrPosY; double MirrPosZ;
 
  Int_t SensPointsFilled;
  vector<TVector3> SensPlanePoints;
  TVector3 Sens_r1;
  TVector3 Sens_r2;
  TVector3 Sens_norm;
 
  //double PMTPlaneXatThird; double PMTPlaneYatThird;
 
  void FillMcHist();
 
  void InitHistograms();
 
  void WriteHistograms();
 
  CbmRichPoint* GetPMTPoint(int TrackIdOfSensPlane);
 
 
  void HitsAndPointsWithRef();
  void HitsAndPoints();
  void RingParameters();
 
  void FillPointsAtPMT();
 
  void FillPointsAtPMTSensPlane();
 
  float GetDistanceMirrorCenterToPMTPoint(TVector3 PMTpoint);
  float GetIntersectionPointsLS(TVector3 MirrCenter, TVector3 G_P1, TVector3 G_P2, float R);
 
  bool CheckPointLiesOnSphere(TVector3 Point);
 
  bool CheckPointLiesOnPlane(TVector3 Point, TVector3 p0, TVector3 n);
  bool CheckLineIntersectsSphere(TVector3 Point);
 
  bool CheckLineIntersectsPlane(TVector3 Point);
 
  //  void GetPlaneCenter(float RotMir, float RotX, float RotY);
 
  void GetPMTRotAngels();
 
  CbmRichGeoOpt(const CbmRichGeoOpt&);
 
 
  TH1D* H_Diff_LineRefPMT_MomAtPMT;
  TH1D* H_Theta_TwoVectors;
 
  TH1D* H_DistancePMTtoMirrCenter;
  TH1D* H_DistancePMTtoMirr;
  TH1D* H_MomPrim;
  TH1D* H_PtPrim;
  TH2D* H_MomPt;
  TH2D* H_Mom_Theta_MC;
  TH2D* H_Pt_Theta_MC;
  TH2D* H_Mom_Theta_Rec;
  TH2D* H_Pt_Theta_Rec;
  TH2D* H_Mom_Theta_Acc;
  TH2D* H_Pt_Theta_Acc;
 
  TH1D* H_MomRing;
  TH1D* H_acc_mom_el;
  TH2D* H_acc_pty_el;
  TH3D* H_Mom_XY_Theta25;
 
 
  TH1D* H_MomPrim_RegularTheta;
  TH1D* H_acc_mom_el_RegularTheta;
 
 
  TH2D* H_Hits_XY;  // distribution of X and Y position of hits
  TH2D* H_Hits_XY_LeftHalf;
  ;
  TH2D* H_Hits_XY_RightHalf;
  TH2D* H_Hits_XY_Left2Thirds;
  TH2D* H_Hits_XY_RightThird;
 
  TH2D* H_PointsIn_XY;  // distribution of X and Y position of points
  TH2D* H_PointsIn_XY_LeftHalf;
  TH2D* H_PointsIn_XY_RightHalf;
  TH2D* H_PointsIn_XY_Left2Thirds;
  TH2D* H_PointsIn_XY_RightThird;
 
  TH2D* H_PointsOut_XY;             // distribution of X and Y position of points (tilting pmt plane)
  TH1D* H_NofPhotonsPerEv;          // Number of photons per hit
  TH1D* H_NofPhotonsPerHit;         // Number of photons per hit
  TH1D* H_NofPhotonsSmallerThan30;  // Number of photons per hit
  TH1D* H_DiffXhit;
  TH1D* H_DiffYhit;
 
  TH1D* H_dFocalPoint_Delta;
  TH1D* H_dFocalPoint_Rho;
  TH1D* H_Alpha;
 
  TH1D* H_Alpha_UpLeft;
  TH1D* H_Alpha_UpLeft_II;
  TH1D* H_Alpha_UpLeft_RegularTheta;
  TH1D* H_Alpha_UpLeft_LeftHalf;
  TH1D* H_Alpha_UpLeft_RightHalf;
  TH1D* H_Alpha_UpLeft_RightThird;
  TH1D* H_Alpha_UpLeft_Left2Thirds;
  //H_Alpha_UpLeft_RighttHalf
  TH3D* H_Alpha_XYposAtDet;
  TH3D* H_Alpha_XYposAtDet_RegularTheta;
  TH3D* H_Alpha_XYposAtDet_LeftHalf;
  TH3D* H_Alpha_XYposAtDet_RightHalf;
  TH3D* H_Alpha_XYposAtDet_RightThird;
  TH3D* H_Alpha_XYposAtDet_Left2Thirds;
 
 
  TH1D* H_NofHitsAll;
  TH1D* H_NofRings;
  TH2D* H_NofRings_NofHits;
 
  TH1D* H_RingCenterX;
  TH1D* H_RingCenterY;
  TH2D* H_RingCenter;
  TH1D* H_Radius;
  TH1D* H_aAxis;
  TH1D* H_bAxis;
 
  TH1D* H_boa;
  TH1D* H_boa_RegularTheta;
  TH1D* H_boa_LeftHalf;
  TH1D* H_boa_RightHalf;
  TH1D* H_boa_RightThird;
  TH1D* H_boa_Left2Thirds;
 
 
  TH1D* H_dR;
  TH1D* H_dR_aa;
  TH1D* H_dR_RegularTheta;
  TH1D* H_dR_LeftHalf;
  TH1D* H_dR_RightHalf;
  TH1D* H_dR_RightThird;
  TH1D* H_dR_Left2Thirds;
 
  TH3D* H_RingCenter_Aaxis;
  TH3D* H_RingCenter_Baxis;
 
  TH3D* H_RingCenter_boa;
  TH3D* H_RingCenter_boa_RegularTheta;
  TH3D* H_RingCenter_boa_LeftHalf;
  TH3D* H_RingCenter_boa_RightHalf;
  TH3D* H_RingCenter_boa_RightThird;
  TH3D* H_RingCenter_boa_Left2Thirds;
 
  TH3D* H_RingCenter_dR;
  TH3D* H_RingCenter_dR_RegularTheta;
  TH3D* H_RingCenter_dR_LeftHalf;
  TH3D* H_RingCenter_dR_RightHalf;
  TH3D* H_RingCenter_dR_RightThird;
  TH3D* H_RingCenter_dR_Left2Thirds;
 
  CbmRichGeoOpt& operator=(const CbmRichGeoOpt&);
 
 
  ClassDef(CbmRichGeoOpt, 1)
};
 
#endif