---

ReactorDetector.hh

Go to the documentation of this file.

#ifndef REACTORDETECTOR_HH
#define REACTORDETECTOR_HH
#include <math.h>
#include <iostream.h>
#include <string.h>
#include "ReactorEvent.hh"
#include "ReactorFortran.hh"
#include "ReactorConstants.hh"
#include "ReactorXC.hh"

class ReactorDetector{
  //
  // Simple detector simulation implementation
  //
public:

  ReactorDetector();
  ~ReactorDetector();
  ReactorDetector(const ReactorDetector& Detector);
  ReactorDetector& operator=(const ReactorDetector& rhs);

  void LightsOut(ReactorEvent& Event);
  //
  // Access functions
  //
  double GetPHpositron() const {return PHpositron;}
  double GetPHneutron() const {return PHneutron;}
  double GetPHposReco() const {return PHposReco;}
  double GetPHneuReco() const {return PHneuReco;}

  double GetMeanNpePos()const {return MeanNpe[0];}
  double GetMeanAttenPos() const {return MeanAtten[0];}
  double GetMeanSfactorPos() const {return MeanSfactor[0];}
  double GetMeanNpeNeu()const {return MeanNpe[1];}
  double GetMeanAttenNeu() const {return MeanAtten[1];}
  double GetMeanSfactorNeu() const {return MeanSfactor[1];}
  double GetHitFracPos() {return GetHitFrac('P');} 
  double GetHitFracNeu() {return GetHitFrac('N');} 
  
  double GetAbsorber(int& n) const {return Absorber[n];}
  double GetNeutronSteps(int& n) const {return NeutronSteps[n];}

  int GetNcosbins() const {return Ncosbins;}
  int GetNphibins() const {return Nphibins;}

  int GetNgamma() const {return Ngamma;}
  double* const GetEgamma() {return Egamma;} 
  double* const GetTgamma() {return Tgamma;} 
  int GetNgamma(char parent);
  void GetGamma(char parent,double* xyz);
  void GetGamma(char parent,double* e,double* t,double* r,
                double* c, double* f);
  //
  double* const GetPositronDipole() {return DipolePositron;}
  double* const GetNeutronDipole() {return DipoleNeutron;}
  //
  int GetNpmt() const {return Npmt;}
  void ReactorDetector::GetPMTdata(int npmt,double* XYZpmt,
                                   int& npos,double* PHpos,double* Tpos,
                                   int& nneu,double* PHneu,double* Tneu);
  //
  // Functions to reset detector parameters
  //
  void SetParam_R0(double x) {R0=x;}
  void SetParam_R1(double x) {R1 =x;}
  void SetParam_R2(double x) {R2 =x;SetPMT();}
  void SetParam_GdConcentration(double x);
  void SetParam_refracGd(double x) {refracGd =x;}
  void SetParam_refracSc(double x) {refracSc =x;}
  void SetParam_mfpGd(double x) {mfpGd=x;}
  void SetParam_mfpSc(double x) {mfpSc =x;}
  void SetParam_MeanNeuDispl(double x) {MeanNeuDispl =x;}
  void SetParam_FastNeutronOption(bool x) {FastNeutronOption =x;}
  void SetParam_Temperature(double x) {Temperature =x;}
  void SetParam_tGd(double x) {tGd =x;}
  void SetParam_tSc(double x) {tSc =x;}
  void SetParam_GdCaptureFraction(double x) {GdCaptureFraction =x;}
  void SetParam_GammasPerGd(double x) {GammasPerGd =x;}
  void SetParam_attenlGd(double x) {attenlGd =x;}
  void SetParam_attenlSc(double x) {attenlSc =x;}
  void SetParam_PhotonsPerMeV(double x) {PhotonsPerMeV =x;}
  void SetParam_PMTcoverage(double x){PMTcoverage=x;SetPMT();}
  void SetParam_PMTdiameter(double x){PMTdiameter=x;SetPMT();}
  void SetParam_PMTqe(double x) {PMTqe =x;}
  void SetParam_ScintDecayTime(double x) {ScintDecayTime =x;}

private:

  static ReactorConstants RC;
  //
  //  constants, nominal from ReactorConstants.hh unless reset
  //
  double R0;
  double R1;
  double R2;
  double GdConcentration;
  double refracGd;
  double refracSc;
  double mfpGd;
  double mfpSc;
  double MeanNeuDispl;
  bool FastNeutronOption;
  double Temperature;
  double tGd;
  double tSc;
  double GdCaptureFraction;
  double GammasPerGd;
  double attenlGd;
  double attenlSc;
  double PhotonsPerMeV;
  double ShortPosFrac0;
  double ShortPosFrac1;
  double LongPosFrac;
  double ShortPosTime0;
  double ShortPosTime1;
  double LongPosTime;
  double PMTcoverage;
  double PMTdiameter;
  double PMTqe;
  double ScintDecayTime;
  //
  //
  //
  int Npmt;
  int Ncosbins;
  int Nphibins;
  int pmtRadCount;
  //
  double* Xpmt;
  double* Ypmt;
  double* Zpmt;
  //
  double PHpositron;
  double PHneutron;
  //
  double PHposReco;
  double PHneuReco;
  //
  double TimePositron;
  double TimeNeutron;
  //
  double DipolePositron[3];
  double DipoleNeutron[3];
  //
  double MeanNpe[2];
  double MeanAtten[2];
  double MeanSfactor[2];
  //
  int Nneutron;
  double* Absorber;
  double* NeutronSteps;
  //
  int Ngamma;
  double* Rgamma;
  double* Egamma;
  double* Tgamma;
  char* Ogamma;

  class PMT;
  int PMTsize;
  int PMTlen;
  PMT* PMTdata;
  PMT* ResizePMT();
  PMT* PMTpositron;
  PMT* PMTneutron;
  void ConsolidatePMT();

  void SetNominalParameters();
  void SetPMT();

  double GetHitFrac(char parent);

  void GenerateSecondaries(ReactorEvent& Event);
  void GenerateResponse(ReactorEvent& Event);
  void GenerateGammas(ReactorEvent& Event);
  void CalculateDipoleMoment(char parent);
  void ImproveDipoleMoment(char parent);

  class PMT{
  public:
    PMT();
    ~PMT();
    PMT(const PMT& p);
    PMT& operator=(const PMT& rhs);
    PMT operator+(const PMT& rhs);
    PMT& operator+=(const PMT& rhs);

    int npmt;
    double xyz[3]; 
    double TimeGen;
    double TimeSmr;
    double PHgen;
    double PHsmr;
    double PathGd;
    double PathSc;
    double Atten;
    double Sfactor;
    int Npe;
    double Xpe;
    char Parent;

    int SubHits;
    PMT** SubHitsPtr;

    void SetSubHitsPtr(int subhits);

  };
};
#endif

---