---

ReactorEvent.hh

Go to the documentation of this file.

#ifndef REACTOREVENT_HH
#define REACTOREVENT_HH
#include <math.h>
#include <iostream.h>
#include <string>
#include "ReactorConstants.hh"

class ReactorEvent{

public:

  ReactorEvent(int newNevents,
               double newRmaxgen=RMAXGEN,
               double newEmin=Emin,
               double newEmax=Emax,
               int newXCorder=XCorder);
  ~ReactorEvent();
  ReactorEvent(const ReactorEvent& Event);
  ReactorEvent& operator=(const ReactorEvent& rhs);
  //
  // for reweighting-- not implemented
  //
  double XCReweight();
  double XCReweight(double Enu);
  double XCReweight(ReactorEvent& Event);

  std::string eventType;
  std::string pmtRad;

//  static const int Pdim = 7;
//  static const int Rdim = 7;
    int Pdim;
    int Rdim;


  std::string GetPmtRad() const {return pmtRad;}

  int GetNevent() const {return Nevent;}

  int GetNumNubar() const {return Nnubar;}
  int GetNumPositron() const {return Npositron;}
  int GetNumElectron() const {return Nelectron;}
  int GetNumNeutron() const {return Nneutron;}
  int GetNumGamma() const {return Ngamma;}

  double GetXCWeight() const {return XCWeight;}
  double GetFluxWeight() const {return FluxWeight;}

  double GetEnu(int& n) const {return Pnubar[0+n*Pdim];}
  double GetNubarParentProcess(int& n) const {return Pnubar[6+n*Pdim];}

  double GetElectronKE(int& n) const {return Pelectron[4+n*Pdim];}
  double GetElectronCosTheta(int& n) const {return Pelectron[3+n*Pdim]/Pelectron[5+n*Pdim];}
  double GetElectronPhi(int& n) const {return atan2(Pelectron[2+n*Pdim],Pelectron[1+n*Pdim]);}
  double GetElectronParentProcess(int& n) const {return Pelectron[6+n*Pdim];}
  double* const GetElectronPxyz(){return Pelectron+1;}

  double GetPositronKE(int& n) const {return Ppositron[4+n*Pdim];}
  double GetPositronCosTheta(int& n) const {return Ppositron[3+n*Pdim]/Ppositron[5+n*Pdim];}
  double GetPositronPhi(int& n) const {return atan2(Ppositron[2+n*Pdim],Ppositron[1+n*Pdim]);}
  double GetPositronParentProcess(int& n) const {return Ppositron[6+n*Pdim];}
  double* const GetPositronPxyz(){return Ppositron+1;}

  double GetNeutronKE(int& n) const {return Pneutron[4+n*Pdim];}
  double GetNeutronCosTheta(int& n) const {return Pneutron[3+n*Pdim]/Pneutron[5+n*Pdim];}
  double GetNeutronPhi(int& n) const {return atan2(Pneutron[2+n*Pdim],Pneutron[1+n*Pdim]);}
  double GetNeutronParentProcess(int& n) const {return Pneutron[6+n*Pdim];}
  double* const GetNeutronPxyz(){return Pneutron+1;}

  double GetGammaKE(int& n) const {return Pgamma[0+n*Pdim];}
  double GetGammaParentProcess(int& n) const {return Pgamma[6+n*Pdim];}

  double GetNubarTime(int& n) const {return Rnubar[0+n*Rdim];}
  double GetElectronTime(int& n) const {return Relectron[0+n*Rdim];}
  double GetPositronTime(int& n) const {return Rpositron[0+n*Rdim];}
  double GetNeutronTime(int& n) const {return Rneutron[0+n*Rdim];}
  double GetGammaTime(int& n) const {return Rgamma[0+n*Rdim];}

  double GetNubarVertexR(int& n) const {return Rnubar[4+n*Rdim];}
  double GetNubarVertexCosTheta(int& n) const {return Rnubar[5+n*Rdim];}
  double GetNubarVertexPhi(int& n) const {return Rnubar[6+n*Rdim];}
  double* const GetNubarVertexXYZ() {return Rnubar+1;}

  double GetElectronVertexR(int& n) const {return Relectron[4+n*Rdim];}
  double GetElectronVertexCosTheta(int& n) const {return Relectron[5+n*Rdim];}
  double GetElectronVertexPhi(int& n) const {return Relectron[6+n*Rdim];}
  double* const GetElectronVertexXYZ() {return Relectron+1;}

  double GetPositronVertexR(int& n) const {return Rpositron[4+n*Rdim];}
  double GetPositronVertexCosTheta(int& n) const {return Rpositron[5+n*Rdim];}
  double GetPositronVertexPhi(int& n) const {return Rpositron[6+n*Rdim];}
  double* const GetPositronVertexXYZ() {return Rpositron+1;}

  double GetNeutronVertexR(int& n) const {return Rneutron[4+n*Rdim];}
  double GetNeutronVertexCosTheta(int& n) const {return Rneutron[5+n*Rdim];}
  double GetNeutronVertexPhi(int& n) const {return Rneutron[6+n*Rdim];}
  double* const GetNeutronVertexXYZ() {return Rneutron+1;}

  double GetGammaVertexR(int& n) const {return Rgamma[4+n*Rdim];}
  double GetGammaVertexCosTheta(int& n) const {return Rgamma[5+n*Rdim];}
  double GetGammaVertexPhi(int& n) const {return Rgamma[6+n*Rdim];}
  double* const GetGammaVertexXYZ() {return Rgamma+1;}

  double GetGeneratedElectronTime(int& n) const {return Rgenele[0+n*Rdim];}
  double GetGeneratedElectronVertexR(int& n) const {return Rgenele[4+n*Rdim];}
  double GetGeneratedElectronVertexCosTheta(int& n) const {return Rgenele[5+n*Rdim];}
  double GetGeneratedElectronVertexPhi(int& n) const {return Rgenele[6+n*Rdim];}
  double* const GetGeneratedElectronVertexXYZ() {return Rgenele+1;}

  double GetGeneratedPositronTime(int& n) const {return Rgenpos[0+n*Rdim];}
  double GetGeneratedPositronVertexR(int& n) const {return Rgenpos[4+n*Rdim];}
  double GetGeneratedPositronVertexCosTheta(int& n) const {return Rgenpos[5+n*Rdim];}
  double GetGeneratedPositronVertexPhi(int& n) const {return Rgenpos[6+n*Rdim];}
  double* const GetGeneratedPositronVertexXYZ() {return Rgenpos+1;}

  double GetGeneratedNeutronTime(int& n) const {return Rgenneu[0+n*Rdim];}
  double GetGeneratedNeutronVertexR(int& n) const {return Rgenneu[4+n*Rdim];}
  double GetGeneratedNeutronVertexCosTheta(int& n) const {return Rgenneu[5+n*Rdim];}
  double GetGeneratedNeutronVertexPhi(int& n) const {return Rgenneu[6+n*Rdim];}
  double* const GetGeneratedNeutronVertexXYZ() {return Rgenneu+1;}


  void SetPositronVertex(int& n,double* rpos){
    for(int i=0;i<Rdim;i++)Rpositron[i+n*Rdim]=*(rpos+(i+n*Rdim));}

  void SetNeutronVertex(int& n,double* rneu){
    for(int i=0;i<Rdim;i++)Rneutron[i+n*Rdim]=*(rneu+(i+n*Rdim));}

private:

  int XCorder_RE;  
  double Emin_RE;
  double Emax_RE;
  double Rmaxgen_RE;
  int Nevents;

  int Nevent;

  double XCWeight;
  double FluxWeight;

  int Nnubar, Nneutron, Nelectron, Npositron, Ngamma;

  double* Pnubar;
  double* Pneutron;
  double* Pelectron;
  double* Ppositron;
  double* Pgamma;

  double* Rnubar;
  double* Rneutron;
  double* Rgenneu;
  double* Relectron;
  double* Rgenele;
  double* Rpositron;
  double* Rgenpos;
  double* Rgamma;

  // for muon input
  static const int Mdim = 26799;
};
#endif

---