cbmroot/CbmRichGeoOpt_8h_source.html

#

#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