Heavy Neutral Lepton final-state product generator. More...

#include <HNLDecayer.h>

Inheritance diagram for genie::hnl::Decayer:

Collaboration diagram for genie::hnl::Decayer:

Public Member Functions
	Decayer ()

	Decayer (string config)

	~Decayer ()

void	ProcessEventRecord (GHepRecord *event) const

void	Configure (const Registry &config)

void	Configure (string config)

double	GetHNLLifetime () const

double	GetHNLMass () const

std::vector< double >	GetHNLCouplings () const

bool	IsHNLMajorana () const

std::string	GetHNLInterestingChannels () const

std::vector< double >	GetPGunOrigin () const

std::vector< double >	GetPGunDOrigin () const

double	GetPGunEnergy () const

std::vector< double >	GetPGunDirection () const

std::vector< double >	GetPGunDeviation () const

Public Member Functions inherited from genie::hnl::DecayRecordVisitorI
virtual	~DecayRecordVisitorI ()

Public Member Functions inherited from genie::EventRecordVisitorI
virtual	~EventRecordVisitorI ()

Public Member Functions inherited from genie::Algorithm
virtual	~Algorithm ()

virtual void	FindConfig (void)

virtual const Registry &	GetConfig (void) const

Registry *	GetOwnedConfig (void)

virtual const AlgId &	Id (void) const
	Get algorithm ID. More...

virtual AlgStatus_t	GetStatus (void) const
	Get algorithm status. More...

virtual bool	AllowReconfig (void) const

virtual AlgCmp_t	Compare (const Algorithm *alg) const
	Compare with input algorithm. More...

virtual void	SetId (const AlgId &id)
	Set algorithm ID. More...

virtual void	SetId (string name, string config)

const Algorithm *	SubAlg (const RgKey &registry_key) const

void	AdoptConfig (void)

void	AdoptSubstructure (void)

virtual void	Print (ostream &stream) const
	Print algorithm info. More...

Private Member Functions
void	LoadConfig (void)

void	AddInitialState (GHepRecord *event) const

void	GenerateDecayProducts (GHepRecord *event) const

void	UpdateEventRecord (GHepRecord *event) const

void	SetHNLCouplings (double Ue42, double Um42, double Ut42) const

void	SetBeam2User (std::vector< double > translation, std::vector< double > rotation) const

void	SetProdVtxPosition (const TLorentzVector &v4) const

void	ReadCreationInfo (GHepRecord *event) const

genie::hnl::SimpleHNL	GetHNLInstance () const

std::vector< double > *	GenerateDecayPosition (GHepRecord *event) const

std::vector< double > *	GenerateMomentum (GHepRecord *event) const

double	CalcPolMag (int parPdg, int lepPdg, double M) const

double	CalcPolMod (double polMag, int lepPdg, int hadPdg, double M) const

bool	UnpolarisedDecay (TGenPhaseSpace &fPSG, PDGCodeList pdgv, double wm) const

bool	PolarisedDecay (TGenPhaseSpace &fPSG, PDGCodeList pdgv, double wm, TVector3 vPolDir) const

Private Attributes
int	fCurrInitStatePdg

genie::hnl::HNLDecayMode_t	fCurrDecayMode

int	fParentPdg

int	fProdLepPdg

int	fDecLepPdg

int	fDecHadPdg

std::vector< double >	fPolDir

bool	fIsConfigLoaded = false

double	fMass

double	fUe42 = -1.0

double	fUm42 = -1.0

double	fUt42 = -1.0

bool	fIsMajorana = false

bool	fDoPol = false

std::vector < genie::hnl::HNLDecayMode_t >	fIntChannels

int	fChanBits [10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }

std::vector< double >	fB2UTranslation

double	fTx = -1.0

double	fTy = -1.0

double	fTz = -1.0

std::vector< double >	fB2URotation

double	fR1 = -1.0

double	fR2 = -1.0

double	fR3 = -1.0

TH3D *	fProdVtxHist = 0

TLorentzVector *	fProdVtx = 0

TLorentzVector *	fISMom = 0

double	fPGOx = 0.0

double	fPGOy = 0.0

double	fPGOz = 0.0

double	fPGDx = 0.0

double	fPGDy = 0.0

double	fPGDz = 0.0

double	fPGE = 0.0

double	fPGCx = 0.0

double	fPGCy = 0.0

double	fPGCz = 0.0

double	fPGDTheta = 0.0

double	fPGDPhi = 0.0

bool	fGetCMFrameInstead = false

Additional Inherited Members
Static Public Member Functions inherited from genie::Algorithm
static string	BuildParamVectKey (const std::string &comm_name, unsigned int i)

static string	BuildParamVectSizeKey (const std::string &comm_name)

static string	BuildParamMatKey (const std::string &comm_name, unsigned int i, unsigned int j)

static string	BuildParamMatRowSizeKey (const std::string &comm_name)

static string	BuildParamMatColSizeKey (const std::string &comm_name)

Protected Member Functions inherited from genie::hnl::DecayRecordVisitorI
	DecayRecordVisitorI ()

	DecayRecordVisitorI (string name)

	DecayRecordVisitorI (string name, string config)

Protected Member Functions inherited from genie::EventRecordVisitorI
	EventRecordVisitorI ()

	EventRecordVisitorI (string name)

	EventRecordVisitorI (string name, string config)

Protected Member Functions inherited from genie::Algorithm
	Algorithm ()

	Algorithm (string name)

	Algorithm (string name, string config)

void	Initialize (void)

void	DeleteConfig (void)

void	DeleteSubstructure (void)

Registry *	ExtractLocalConfig (const Registry &in) const

Registry *	ExtractLowerConfig (const Registry &in, const string &alg_key) const
	Split an incoming configuration Registry into a block valid for the sub-algo identified by alg_key. More...

template<class T >
bool	GetParam (const RgKey &name, T &p, bool is_top_call=true) const

template<class T >
bool	GetParamDef (const RgKey &name, T &p, const T &def) const

template<class T >
int	GetParamVect (const std::string &comm_name, std::vector< T > &v, bool is_top_call=true) const
	Handle to load vectors of parameters. More...

int	GetParamVectKeys (const std::string &comm_name, std::vector< RgKey > &k, bool is_top_call=true) const

template<class T >
int	GetParamMat (const std::string &comm_name, TMatrixT< T > &mat, bool is_top_call=true) const
	Handle to load matrix of parameters. More...

template<class T >
int	GetParamMatSym (const std::string &comm_name, TMatrixTSym< T > &mat, bool is_top_call=true) const

int	GetParamMatKeys (const std::string &comm_name, std::vector< RgKey > &k, bool is_top_call=true) const

int	AddTopRegistry (Registry *rp, bool owns=true)
	add registry with top priority, also update ownership More...

int	AddLowRegistry (Registry *rp, bool owns=true)
	add registry with lowest priority, also update ownership More...

int	MergeTopRegistry (const Registry &r)

int	AddTopRegisties (const vector< Registry * > &rs, bool owns=false)
	Add registries with top priority, also udated Ownerships. More...

Protected Attributes inherited from genie::Algorithm
bool	fAllowReconfig

bool	fOwnsSubstruc
	true if it owns its substructure (sub-algs,...) More...

AlgId	fID
	algorithm name and configuration set More...

vector< Registry * >	fConfVect

vector< bool >	fOwnerships
	ownership for every registry in fConfVect More...

AlgStatus_t	fStatus
	algorithm execution status More...

AlgMap *	fOwnedSubAlgMp
	local pool for owned sub-algs (taken out of the factory pool) More...

Detailed Description

Heavy Neutral Lepton final-state product generator.

Author: Costas Andreopoulos <c.andreopoulos cern.ch> University of Liverpool John Plows <komninos-john.plows physics.ox.ac.uk>

Created:: February 10, 2020

License:: Copyright (c) 2003-2024, The GENIE Collaboration For the full text of the license visit http://copyright.genie-mc.org

Definition at line 41 of file HNLDecayer.h.

Constructor & Destructor Documentation

Decayer::Decayer ( )

Definition at line 37 of file HNLDecayer.cxx.

                  :
 DecayRecordVisitorI("genie::hnl::Decayer")
 {
 
 }

Decayer::Decayer ( string config )

Definition at line 43 of file HNLDecayer.cxx.

                               :
 DecayRecordVisitorI("genie::hnl::Decayer",config)
 {
 
 }

Decayer::~Decayer ( )

Definition at line 49 of file HNLDecayer.cxx.

 {
 
 }

Member Function Documentation

void Decayer::AddInitialState ( GHepRecord * event ) const

private

Definition at line 73 of file HNLDecayer.cxx.

References genie::GHepRecord::AddParticle(), GenerateDecayPosition(), GenerateMomentum(), genie::InitialState::GetProbeP4(), genie::Interaction::InitState(), genie::Interaction::InitStatePtr(), genie::kIStInitialState, genie::kRfLab, genie::GHepRecord::Particle(), genie::InitialState::ProbeE(), genie::InitialState::ProbePdg(), genie::InitialState::SetProbeP4(), and genie::GHepRecord::Vertex().

Referenced by ProcessEventRecord().

 {
   std::vector< double > * prodVtx = 0;
 
   Interaction * interaction = event->Summary();
   InitialState * init_state = interaction->InitStatePtr();
 
   TLorentzVector p4;
   if( event->Particle(0) ){
     // p4 was already set using HNLFluxCreator. No action needed.
     // Read event vertex == HNL production vertex. We will find the decay vertex later.
     p4 = *( init_state->GetProbeP4() );
 
     prodVtx = new std::vector< double >();
     prodVtx->emplace_back( event->Vertex()->X() );
     prodVtx->emplace_back( event->Vertex()->Y() );
     prodVtx->emplace_back( event->Vertex()->Z() );
     prodVtx->emplace_back( event->Vertex()->T() );
   } else {
     std::vector< double > * p3HNL = this->GenerateMomentum( event );
 
     double px = p3HNL->at(0);
     double py = p3HNL->at(1);
     double pz = p3HNL->at(2);
     double E = interaction->InitState().ProbeE(kRfLab);
 
     p4 = TLorentzVector( px, py, pz, E );
 
     if( !event->Vertex() || (event->Vertex()->Vect()).Mag() == 0.0 )
       prodVtx = this->GenerateDecayPosition( event );
     else{
       prodVtx = new std::vector< double >();
       prodVtx->emplace_back( event->Vertex()->X() );
       prodVtx->emplace_back( event->Vertex()->Y() );
       prodVtx->emplace_back( event->Vertex()->Z() );
       prodVtx->emplace_back( event->Vertex()->T() );
     }
   }
 
   TLorentzVector v4( prodVtx->at(0), prodVtx->at(1), prodVtx->at(2), prodVtx->at(3) );
 
   init_state->SetProbeP4( p4 );
 
   int hpdg = interaction->InitState().ProbePdg();
   if( !event->Particle(0) )
     event->AddParticle(hpdg, kIStInitialState, 0,-1,-1,-1, p4, v4);
 }

double Decayer::CalcPolMag	(	int	parPdg,
		int	lepPdg,
		double	M
	)		const

private

Definition at line 671 of file HNLDecayer.cxx.

References genie::PDGLibrary::Find(), genie::PDGLibrary::Instance(), and genie::utils::hnl::Kallen().

Referenced by PolarisedDecay().

 {
   PDGLibrary * pdgl = PDGLibrary::Instance();
   double mPar = pdgl->Find( std::abs( parPdg ) )->Mass();
   double mLep = pdgl->Find( std::abs( lepPdg ) )->Mass();
 
   double num1 = mLep * mLep - M * M;
   double num2 = TMath::Sqrt(utils::hnl::Kallen( mPar*mPar, M*M, mLep*mLep ));
   
   double den1 = mPar*mPar*( mLep*mLep + M*M );
   double den2 = mLep*mLep - M*M;
 
   // pMag is a modulus, not a magnitude... not positive semi-definite. See Fig.4 in 1805.06419[hep-ph]
   double pMag = -1.0 * num1*num2 / ( den1 - den2*den2 ); 
   return pMag;
 }

double Decayer::CalcPolMod	(	double	polMag,
		int	lepPdg,
		int	hadPdg,
		double	M
	)		const

private

Definition at line 688 of file HNLDecayer.cxx.

References genie::PDGLibrary::Find(), genie::PDGLibrary::Instance(), and genie::utils::hnl::Kallen().

Referenced by PolarisedDecay().

 {
   PDGLibrary * pdgl = PDGLibrary::Instance();
   double mLep = pdgl->Find( std::abs( lepPdg ) )->Mass();
   double mHad = pdgl->Find( std::abs( hadPdg ) )->Mass();
   
   double num1 = M*M - mLep*mLep;
   double num2 = TMath::Sqrt(utils::hnl::Kallen( M*M, mLep*mLep, mHad*mHad ));
   double num3 = polMag;
 
   double den1 = M*M - mLep*mLep;
   double den2 = mHad*mHad*( M*M + mLep*mLep );
 
   double pMod = num1*num2*num3 / ( den1*den1 - den2 );
   return pMod;
 }

void Decayer::Configure ( const Registry & config )

virtual

Configure the algorithm with an external registry The registry is merged with the top level registry if it is owned, Otherwise a copy of it is added with the highest priority

Reimplemented from genie::Algorithm.

Definition at line 407 of file HNLDecayer.cxx.

References genie::Algorithm::Configure(), and LoadConfig().

 {
   Algorithm::Configure(config);
   this->LoadConfig();
 }

void Decayer::Configure ( string config )

virtual

Configure the algorithm from the AlgoConfigPool based on param_set string given in input An algorithm contains a vector of registries coming from different xml configuration files, which are loaded according a very precise prioriy This methods will load a number registries in order of priority: 1) "Tunable" parameter set from CommonParametes. This is loaded with the highest prioriry and it is designed to be used for tuning procedure Usage not expected from the user. 2) For every string defined in "CommonParame" the corresponding parameter set will be loaded from CommonParameter.xml 3) parameter set specified by the config string and defined in the xml file of the algorithm 4) if config is not "Default" also the Default parameter set from the same xml file will be loaded Effectively this avoids the repetion of a parameter when it is not changed in the requested configuration

Reimplemented from genie::Algorithm.

Definition at line 413 of file HNLDecayer.cxx.

References genie::Algorithm::Configure(), and LoadConfig().

 {
   Algorithm::Configure(config);
   this->LoadConfig();
 }

std::vector< double > * Decayer::GenerateDecayPosition ( GHepRecord * event ) const

private

Definition at line 326 of file HNLDecayer.cxx.

References fProdVtxHist, genie::RandomGen::Instance(), LOG, pDEBUG, pWARN, genie::RandomGen::RndGen(), and SetProdVtxPosition().

Referenced by AddInitialState().

 {
   // let's query *where* the HNL decayed from.
   LOG( "HNL", pWARN )
     << "\nYou are seeing this message because the input dk2nu files did not give position information (for some reason)..."
     << "\nDistributing the production vertex at some point in a 1m-side box. This is not good, and results will likely be unphysical.";
   fProdVtxHist = new TH3D( "dummy", "dummy", 100, -0.5, 0.5, 100, -0.5, 0.5, 100, -0.5, 0.5 );
   assert( fProdVtxHist );
   
   RandomGen * rnd = RandomGen::Instance();
   double pvx = (rnd->RndGen()).Uniform( -0.5, 0.5 );
   double pvy = (rnd->RndGen()).Uniform( -0.5, 0.5 );
   double pvz = (rnd->RndGen()).Uniform( -0.5, 0.5 );
   std::vector< double > * prodVtx = new std::vector< double >();
   prodVtx->emplace_back( pvx ); prodVtx->emplace_back( pvy ); prodVtx->emplace_back( pvz );
   LOG( "HNL", pDEBUG )
     << "Production vertex at: ( " << prodVtx->at(0) << ", " << prodVtx->at(1) << ", " << prodVtx->at(2) << ") [cm]";
   
   TLorentzVector v4( prodVtx->at(0), prodVtx->at(1), prodVtx->at(2), 0.0 );
 
   SetProdVtxPosition( v4 );
 
   return prodVtx;
 }

void Decayer::GenerateDecayProducts ( GHepRecord * event ) const

private

Definition at line 121 of file HNLDecayer.cxx.

References genie::utils::hnl::DecayProductList(), genie::GHepParticle::E(), genie::Interaction::ExclTagPtr(), fCurrDecayMode, fCurrInitStatePdg, fDecHadPdg, fDecLepPdg, fDoPol, fGetCMFrameInstead, genie::GHepRecord::FinalStatePrimaryLepton(), genie::PDGLibrary::Find(), fIsMajorana, fPolDir, genie::GHepParticle::GetP4(), genie::GHepParticle::GetX4(), genie::RandomGen::Instance(), genie::PDGLibrary::Instance(), genie::hnl::kHNLDcyNuNuNu, genie::hnl::kHNLDcyPi0Nu, genie::hnl::kHNLDcyPi0Pi0Nu, genie::hnl::kHNLDcyTEST, genie::kIStStableFinalState, genie::kPdgPi0, genie::kPdgPiM, genie::kPdgPiP, LOG, genie::units::m, genie::utils::print::P4AsString(), genie::GHepRecord::Particle(), pDEBUG, pERROR, pINFO, pNOTICE, PolarisedDecay(), genie::GHepRecord::Probe(), genie::PDGCodeList::push_back(), pWARN, genie::RandomGen::RndGen(), genie::XclsTag::SetNPions(), genie::exceptions::EVGThreadException::SetReason(), genie::GHepParticle::Status(), genie::exceptions::EVGThreadException::SwitchOnFastForward(), and UnpolarisedDecay().

Referenced by ProcessEventRecord().

 {
   LOG("HNL", pINFO) << "Generating decay...";
   fDecLepPdg = 0; fDecHadPdg = 0;
 
   // do we have nubar?
   PDGCodeList pdgv0 = utils::hnl::DecayProductList(fCurrDecayMode);
   int typeMod = ( fCurrInitStatePdg >= 0 ) ? 1 : -1; 
   if( fCurrDecayMode == kHNLDcyPi0Nu ){
     fDecHadPdg = typeMod * kPdgPi0;
   } else if( fCurrDecayMode != kHNLDcyNuNuNu ){
     fDecHadPdg = typeMod * kPdgPiP;
   }
 
   if( event->Particle(0) && !fIsMajorana ){
     typeMod = ( event->Particle(0)->Pdg() >= 0 ) ? 1 : -1;
   } else if( event->Particle(0) && fIsMajorana ){
     // equal probability to decay to 1 of 2 charge-conjugated states
     RandomGen * Rng = RandomGen::Instance();
     double rnd = Rng->RndGen().Uniform(0.0, 1.0);
     typeMod = ( rnd >= 0.5 ) ? 1.0 : -1.0;
   }
   PDGCodeList pdgv(true);
   for( std::vector<int>::iterator it = pdgv0.begin(); it != pdgv0.end(); ++it ){
     int pdgc = *it; 
     int newpdgc = ( pdgc == genie::kPdgPi0 ) ? pdgc : typeMod * pdgc; // pi-0 is its own antiparticle
     pdgv.push_back( newpdgc );
   }
 
   assert ( pdgv.size() > 1);
 
   // if user wants to include polarisation effects, start prep now
   /*
   double fPolDirMag = 0.0;
   if( fPolDir.size() == 3 ){
     fPolDirMag = std::sqrt( ( fPolDir.at(0) * fPolDir.at(0) ) +
                             ( fPolDir.at(1) * fPolDir.at(1) ) + 
                             ( fPolDir.at(2) * fPolDir.at(2) ) );
   }
   */
   bool doPol = fDoPol && (fPolDir.size() == 3);
 
   std::ostringstream asts;
   if( !doPol ) asts << "Performing a phase space decay...";
   else asts << "Performing a polarised decay with polarisation vector:"
             << " ( " << fPolDir.at(0) << ", " << fPolDir.at(1) << ", " << fPolDir.at(2) << " )";
   LOG("HNL", pINFO) << asts.str();
 
   // Get the decay product masses
 
   vector<int>::const_iterator pdg_iter;
   int i = 0;
   double * mass = new double[pdgv.size()];
   double   sum  = 0;
   for(pdg_iter = pdgv.begin(); pdg_iter != pdgv.end(); ++pdg_iter) {
     int pdgc = *pdg_iter;
     double m = PDGLibrary::Instance()->Find(pdgc)->Mass();
     mass[i++] = m;
     sum += m;
   }
 
   LOG("HNL", pINFO)
     << "Decaying N = " << pdgv.size() << " particles / total mass = " << sum;
 
   int hnl_id = 0;
   GHepParticle * hnl = event->Particle(hnl_id);
   assert(hnl);
   TLorentzVector * p4d = hnl->GetP4(); TVector3 HNLBVec = p4d->BoostVector();
   TLorentzVector * p4d_rest = (TLorentzVector *) p4d->Clone(); p4d_rest->Boost( -HNLBVec );
   TLorentzVector * v4d = hnl->GetX4();
 
   LOG("HNL", pINFO)
     << "\nDecaying system p4 = " << utils::print::P4AsString(p4d) 
     << "\nin rest frame, p4 = " << utils::print::P4AsString(p4d_rest);
 
   // Set the decay
   TGenPhaseSpace fPhaseSpaceGenerator;
   //bool permitted = fPhaseSpaceGenerator.SetDecay(*p4d, pdgv.size(), mass);
   bool permitted = fPhaseSpaceGenerator.SetDecay(*p4d_rest, pdgv.size(), mass);
   if(!permitted) {
      LOG("HNL", pERROR)
        << " *** Phase space decay is not permitted \n"
        << " Total particle mass = " << sum << "\n"
        << " Decaying system p4 = " << utils::print::P4AsString(p4d);
      // clean-up
      delete [] mass;
      delete p4d; delete p4d_rest;
      delete v4d;
      // throw exception
      genie::exceptions::EVGThreadException exception;
      exception.SetReason("Decay not permitted kinematically");
      exception.SwitchOnFastForward();
      throw exception;
   }
 
   // Get the maximum weight
   //double wmax = fPhaseSpaceGenerator.GetWtMax();
   double wmax = -1;
   for(int idec=0; idec<200; idec++) {
      double w = fPhaseSpaceGenerator.Generate();
      wmax = TMath::Max(wmax,w);
   }
   assert(wmax>0);
   wmax *= 2;
 
   LOG("HNL", pNOTICE)
      << "Max phase space gen. weight @ current hadronic system: " << wmax;
 
   // Generate a decay
   bool decayFailed = false;
   if( doPol && fCurrDecayMode != kHNLDcyNuNuNu ){
     // if polarisation is on we must calculate the polarisation modulus for comparison
     // for now, assume 2-body production and 2-body decay describes the pol modulus
     // see arXiv:1805.06419[hep-ph]
     TVector3 vecPolDir( fPolDir.at(0), fPolDir.at(1), fPolDir.at(2) );
     LOG( "HNL", pDEBUG ) << "Doing a polarised decay...";
     decayFailed = this->PolarisedDecay( fPhaseSpaceGenerator, pdgv, wmax, vecPolDir );
   } else {
     if( doPol && fCurrDecayMode == kHNLDcyNuNuNu ){
       // no charged lepton here... warn the user about it, though
       LOG( "HNL", pWARN )
         << "Polarisation for invisible FS not implemented yet, defaulting to phase-space decay...";
     }
 
     LOG( "HNL", pDEBUG ) << "Doing a phase-space decay...";
     decayFailed = this->UnpolarisedDecay( fPhaseSpaceGenerator, pdgv, wmax );
   }
   if( decayFailed ){
     // clean up
     delete [] mass;
     delete p4d;
     delete v4d;
     // throw exception
     genie::exceptions::EVGThreadException exception;
     exception.SetReason("Couldn't select decay after N attempts");
     exception.SwitchOnFastForward();
     throw exception;
   }
 
   // Insert final state products into a TClonesArray of GHepParticle's
   TLorentzVector v4(*v4d);
   int idp = 0; int npip = 0, npi0 = 0, npim = 0;
   for(pdg_iter = pdgv.begin(); pdg_iter != pdgv.end(); ++pdg_iter) {
      int pdgc = *pdg_iter;
      TLorentzVector * p4fin = fPhaseSpaceGenerator.GetDecay(idp);
      if( !fGetCMFrameInstead )
        p4fin->Boost( HNLBVec ); // from rest to lab again
      GHepStatus_t ist = kIStStableFinalState;
      event->AddParticle(pdgc, ist, hnl_id,-1,-1,-1, *p4fin, v4);
      switch( pdgc ){
      case kPdgPiP: npip++; break;
      case kPdgPi0: npi0++; break;
      case kPdgPiM: npim++; break;
      }
      idp++;
   }
   Interaction * interaction = event->Summary();
   interaction->ExclTagPtr()->SetNPions( npip, npi0, npim );
 
   // Manually set up some mother-daughter links
   // find primary (=leading) *charged!* lepton
   double Elead = -1.0; int ilead = -1;
   std::vector< int > lpdgv = { 11, 13, 15 };
   for( std::vector<int>::iterator lit = lpdgv.begin(); lit != lpdgv.end(); ++lit ) {
     GHepParticle * tmpPart = event->FindParticle( (*lit), kIStStableFinalState, 1 );
     if( !tmpPart ) tmpPart = event->FindParticle( -1 * (*lit), kIStStableFinalState, 1 ); //antiparticle?
     if( tmpPart ){
       double tmpE = tmpPart->E();
       if( tmpE > Elead ){ Elead = tmpE; ilead = event->ParticlePosition( tmpPart ); }
     }
   }
   event->Particle( 0 )->SetFirstDaughter( ilead );
   event->Particle( 0 )->SetFirstMother(-1); // why do I need to do this explicitly?
   event->Particle( 0 )->SetLastMother(-1);
 
   assert( event->Probe() );
   if( !event->FinalStatePrimaryLepton() ){ // no charged lepton means invisible or pi0 nu or test
     LOG( "HNL", pWARN )
       << "No final state primary lepton for this event.";
     assert( fCurrDecayMode == kHNLDcyPi0Nu || fCurrDecayMode == kHNLDcyNuNuNu
             || fCurrDecayMode == kHNLDcyPi0Pi0Nu || fCurrDecayMode == kHNLDcyTEST );
   }
   //assert( event->FinalStatePrimaryLepton() );
   
   // loop over all FS particles and set their mother to HNL
   int itmp = 1, ilast = 1;
   while( event->Particle( itmp ) ){
     if( event->Particle(itmp)->Status() != kIStStableFinalState ){ itmp++; continue; }
     event->Particle(itmp)->SetFirstMother(0);
     event->Particle(itmp)->SetLastMother(-1);
     if( itmp != ilead ) ilast = itmp;
     itmp++;
   }
   event->Particle( 0 )->SetLastDaughter( ilast );
   // "last daughter" of HNL means last non-primary-FS-lepton, so can be less than "first" daughter
 
   LOG("HNL", pNOTICE)
     << "Finished with decay products. Clean up and exit!";
 
   // Clean-up
   delete [] mass;
   delete p4d;
   delete v4d;
 }

std::vector< double > * Decayer::GenerateMomentum ( GHepRecord * event ) const

private

Definition at line 351 of file HNLDecayer.cxx.

References genie::PDGLibrary::Find(), genie::Interaction::InitState(), genie::RandomGen::Instance(), genie::PDGLibrary::Instance(), genie::kPdgHNL, genie::constants::kPi, genie::kRfLab, genie::InitialState::ProbeE(), and genie::RandomGen::RndGen().

Referenced by AddInitialState().

 {
   Interaction * interaction = event->Summary();
   double E = interaction->InitState().ProbeE(kRfLab);
   double M = PDGLibrary::Instance()->Find(kPdgHNL)->Mass();
   double p = TMath::Sqrt(E*E-M*M);
 
   // set some initial deviation from beam axis due to collimation effect
   double thetaDev = 0.0; //fAngularDeviation; // deg
   thetaDev *= genie::constants::kPi / 180.0; // rad
   RandomGen * Rng = RandomGen::Instance();
   double theta = Rng->RndGen().Gaus(0.0, thetaDev);
   if( theta < 0.0 ) theta *= -1.0;
   double phi = Rng->RndGen().Uniform(0.0, 2.0 * genie::constants::kPi);
 
   double px = p * std::sin(theta) * std::cos(phi);
   double py = p * std::sin(theta) * std::sin(phi);
   double pz = p * std::cos(theta);
 
   std::vector< double > * p3HNL = new std::vector< double >();
   p3HNL->emplace_back(px);
   p3HNL->emplace_back(py);
   p3HNL->emplace_back(pz);
 
   return p3HNL;
 }

std::vector< double > Decayer::GetHNLCouplings ( ) const

virtual

Implements genie::hnl::DecayRecordVisitorI.

Definition at line 715 of file HNLDecayer.cxx.

References fUe42, fUm42, and fUt42.

Referenced by main(), and ReadInConfig().

 {
   std::vector<double> allCoups;
   allCoups.emplace_back(fUe42); allCoups.emplace_back(fUm42); allCoups.emplace_back(fUt42);
   return allCoups;
 }

SimpleHNL Decayer::GetHNLInstance ( ) const

private

Definition at line 499 of file HNLDecayer.cxx.

References fIntChannels, fIsMajorana, fMass, fR1, fR2, fR3, fTx, fTy, fTz, fUe42, fUm42, fUt42, genie::kPdgHNL, genie::kPdgKP, genie::hnl::SimpleHNL::SetAngularDeviation(), genie::hnl::SimpleHNL::SetBeam2UserRotation(), genie::hnl::SimpleHNL::SetBeam2UserTranslation(), genie::hnl::SimpleHNL::SetInterestingChannelsVec(), and genie::hnl::SimpleHNL::SetType().

Referenced by GetHNLLifetime(), and LoadConfig().

 {
   SimpleHNL sh = SimpleHNL( "HNLInstance", 0, genie::kPdgHNL, genie::kPdgKP,
                             fMass, fUe42, fUm42, fUt42, fIsMajorana );
   sh.SetType( 0 );
   sh.SetInterestingChannelsVec( fIntChannels );
   sh.SetAngularDeviation( 0.0 ); //fAngularDeviation );
   sh.SetBeam2UserTranslation( fTx, fTy, fTz );
   sh.SetBeam2UserRotation( fR1, fR2, fR3 );
   return sh;
 }

std::string Decayer::GetHNLInterestingChannels ( ) const

virtual

Implements genie::hnl::DecayRecordVisitorI.

Definition at line 727 of file HNLDecayer.cxx.

References fChanBits.

Referenced by main(), and ReadInConfig().

 {
   std::string chanInt = "";
   for( int iCBits = sizeof( fChanBits ) / sizeof( fChanBits[0] ) - 1; iCBits >= 0 ; iCBits-- ){
     chanInt.append( Form("%d", fChanBits[iCBits]) );
   }
   return chanInt;
 }

double Decayer::GetHNLLifetime ( ) const

virtual

Implements genie::hnl::DecayRecordVisitorI.

Definition at line 705 of file HNLDecayer.cxx.

References GetHNLInstance().

Referenced by main(), and ReadInConfig().

 {
   return (this->GetHNLInstance()).GetCoMLifetime();
 }

double Decayer::GetHNLMass ( ) const

virtual

Implements genie::hnl::DecayRecordVisitorI.

Definition at line 710 of file HNLDecayer.cxx.

References fMass.

Referenced by main(), and ReadInConfig().

 {
   return fMass;
 }

std::vector< double > Decayer::GetPGunDeviation ( ) const

virtual

Implements genie::hnl::DecayRecordVisitorI.

Definition at line 762 of file HNLDecayer.cxx.

References fPGDPhi, and fPGDTheta.

Referenced by GenerateOriginMomentum().

 {
   std::vector< double > PGDeviation;
   PGDeviation.emplace_back( fPGDTheta ); PGDeviation.emplace_back( fPGDPhi );
   return PGDeviation;
 }

std::vector< double > Decayer::GetPGunDirection ( ) const

virtual

Implements genie::hnl::DecayRecordVisitorI.

Definition at line 755 of file HNLDecayer.cxx.

References fPGCx, fPGCy, and fPGCz.

Referenced by GenerateOriginMomentum(), and ReadInConfig().

 {
   std::vector< double > PGDirection;
   PGDirection.emplace_back( fPGCx ); PGDirection.emplace_back( fPGCy ); PGDirection.emplace_back( fPGCz );
   return PGDirection;
 }

std::vector< double > Decayer::GetPGunDOrigin ( ) const

virtual

Implements genie::hnl::DecayRecordVisitorI.

Definition at line 743 of file HNLDecayer.cxx.

References fPGDx, fPGDy, and fPGDz.

Referenced by GenerateOriginPosition().

 {
   std::vector< double > PGDOrigin;
   PGDOrigin.emplace_back( fPGDx ); PGDOrigin.emplace_back( fPGDy ); PGDOrigin.emplace_back( fPGDz );
   return PGDOrigin;
 }

double Decayer::GetPGunEnergy ( ) const

virtual

Implements genie::hnl::DecayRecordVisitorI.

Definition at line 750 of file HNLDecayer.cxx.

References fPGE.

Referenced by main(), ReadInConfig(), and TestDecay().

 {
   return fPGE;
 }

std::vector< double > Decayer::GetPGunOrigin ( ) const

virtual

Implements genie::hnl::DecayRecordVisitorI.

Definition at line 736 of file HNLDecayer.cxx.

References fPGOx, fPGOy, and fPGOz.

Referenced by GenerateOriginPosition(), and TestDecay().

 {
   std::vector< double > PGOrigin;
   PGOrigin.emplace_back( fPGOx ); PGOrigin.emplace_back( fPGOy ); PGOrigin.emplace_back( fPGOz );
   return PGOrigin;
 }

bool Decayer::IsHNLMajorana ( ) const

virtual

Implements genie::hnl::DecayRecordVisitorI.

Definition at line 722 of file HNLDecayer.cxx.

References fIsMajorana.

Referenced by main(), and ReadInConfig().

 {
   return fIsMajorana;
 }

void Decayer::LoadConfig ( void )

private

Definition at line 419 of file HNLDecayer.cxx.

Referenced by Configure().

 {
   LOG("HNL", pDEBUG)
     << "Loading configuration from file...";
 
   this->GetParam( "HNL-Mass", fMass );
   std::vector< double > U4l2s;
   this->GetParamVect( "HNL-LeptonMixing", U4l2s );
   SetHNLCouplings( U4l2s.at(0), U4l2s.at(1), U4l2s.at(2) );
   this->GetParam( "HNL-Majorana", fIsMajorana );
   //this->GetParam( "HNL-Type", fType );
 
   //this->GetParam( "HNL-angular_deviation", fAngularDeviation );
 
   this->GetParam( "IncludePolarisation", fDoPol );
 
   this->GetParamVect( "Near2User_T", fB2UTranslation );
   this->GetParamVect( "Near2Beam_R", fB2URotation );
   SetBeam2User( fB2UTranslation, fB2URotation );
 
   fIntChannels = {}; bool itChan = false;
   //int chanBits[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 
   this->GetParam( "HNL-3B_nu_nu_nu",   itChan ); if( itChan ){ fIntChannels.push_back( kHNLDcyNuNuNu ); fChanBits[0] = 1; }
   this->GetParam( "HNL-3B_nu_e_e",     itChan ); if( itChan ){ fIntChannels.push_back( kHNLDcyNuEE ); fChanBits[1] = 1; }
   this->GetParam( "HNL-3B_nu_mu_e",    itChan ); if( itChan ){ fIntChannels.push_back( kHNLDcyNuMuE ); fChanBits[2] = 1; }
   this->GetParam( "HNL-2B_nu_pi0", itChan ); if( itChan ){ fIntChannels.push_back( kHNLDcyPi0Nu ); fChanBits[3] = 1; }
   this->GetParam( "HNL-2B_e_pi",   itChan ); if( itChan ){ fIntChannels.push_back( kHNLDcyPiE ); fChanBits[4] = 1; }
   this->GetParam( "HNL-3B_nu_mu_mu",   itChan ); if( itChan ){ fIntChannels.push_back( kHNLDcyNuMuMu ); fChanBits[5] = 1; }
   this->GetParam( "HNL-2B_mu_pi",  itChan ); if( itChan ){ fIntChannels.push_back( kHNLDcyPiMu ); fChanBits[6] = 1; }
   this->GetParam( "HNL-3B_nu_pi0_pi0", itChan ); if( itChan ){ fIntChannels.push_back( kHNLDcyPi0Pi0Nu ); fChanBits[7] = 1; }
   this->GetParam( "HNL-3B_e_pi_pi0",   itChan ); if( itChan ){ fIntChannels.push_back( kHNLDcyPiPi0E ); fChanBits[8] = 1; }
   this->GetParam( "HNL-3B_mu_pi_pi0",  itChan ); if( itChan ){ fIntChannels.push_back( kHNLDcyPiPi0Mu ); fChanBits[9] = 1; }
 
   this->GetParam( "GetCMFrameInstead", fGetCMFrameInstead );
 
   // call GetHNLInstance here, to get lifetime
   SimpleHNL sh = this->GetHNLInstance();
   double CoMLifetime = sh.GetCoMLifetime();
   assert( CoMLifetime > 0.0 );
 
   // also read in particle gun parameters
   this->GetParam( "PG-OriginX", fPGOx );
   this->GetParam( "PG-OriginY", fPGOy );
   this->GetParam( "PG-OriginZ", fPGOz );
 
   this->GetParam( "PG-OriginDX", fPGDx );
   this->GetParam( "PG-OriginDY", fPGDy );
   this->GetParam( "PG-OriginDZ", fPGDz );
 
   this->GetParam( "PG-Energy", fPGE );
   
   this->GetParam( "PG-cx", fPGCx );
   this->GetParam( "PG-cy", fPGCy );
   this->GetParam( "PG-cz", fPGCz );
 
   this->GetParam( "PG-DTheta", fPGDTheta );
   this->GetParam( "PG-DPhi", fPGDPhi );
 
   fIsConfigLoaded = true;
 }

bool Decayer::PolarisedDecay	(	TGenPhaseSpace &	fPSG,
		PDGCodeList	pdgv,
		double	wm,
		TVector3	vPolDir
	)		const

private

Definition at line 590 of file HNLDecayer.cxx.

References CalcPolMag(), CalcPolMod(), fDecHadPdg, fDecLepPdg, genie::PDGLibrary::Find(), fParentPdg, fProdLepPdg, genie::RandomGen::Instance(), genie::PDGLibrary::Instance(), genie::controls::kMaxUnweightDecayIterations, genie::kPdgElectron, genie::kPdgHNL, genie::kPdgMuon, genie::kPdgNuMu, genie::kPdgPi0, genie::kPdgTau, LOG, pWARN, genie::RandomGen::RndGen(), and UnpolarisedDecay().

Referenced by GenerateDecayProducts().

 { 
   // calculate polarisation modulus
   PDGLibrary * pdgl = PDGLibrary::Instance();
   double MHNL = pdgl->Find( kPdgHNL )->Mass();
   double polMag = this->CalcPolMag( fParentPdg, fProdLepPdg, MHNL );
   double polMod = -999.99;
   
   // do decays until weight \in Uniform[0.0, 2.0] < 1 \mp polMod * cos\theta
   unsigned int iUPD = 0;
   double polWgt = -999.9;
   RandomGen * rnd = RandomGen::Instance();
   double rwgt = 0.0;
   bool isAccepted = false;
 
   bool failed = false;
 
   // first, check to see if we have pi0 + v. Then let the neutrino be a QLep.
   bool isPi0Nu = ( pdgv.size() == 3 && 
                    std::abs( pdgv.at(1) ) == kPdgPi0 &&
                    std::abs( pdgv.at(2) ) == kPdgNuMu );
   
   while( !isAccepted && iUPD < controls::kMaxUnweightDecayIterations ){
     bool failed = this->UnpolarisedDecay( fPSG, pdgv, wm );
     
     // find charged lepton of FS. If two, take the leading one.
     // For now, this method doesn't handle vvv invisible decay mode.
     
     TVector3 lepDir;
     vector<int>::const_iterator pdg_iter;
     int idc = 0; double Elead = -1.0;
     for(pdg_iter = pdgv.begin(); pdg_iter != pdgv.end(); ++pdg_iter) {
       int pdgc = *pdg_iter; Elead = -1.0;
       bool isQLep = ( std::abs( pdgc ) == kPdgElectron ||
                       std::abs( pdgc ) == kPdgMuon ||
                       std::abs( pdgc ) == kPdgTau ||
                       ( isPi0Nu && std::abs( pdgc ) == kPdgNuMu ) );
       if( isQLep ){
         TLorentzVector * p4lep = fPSG.GetDecay(idc);
         if( p4lep->E() > Elead ){
           Elead = p4lep->E();
           lepDir = p4lep->Vect();
           fDecLepPdg = pdgc;
           if( std::abs(fDecLepPdg) != std::abs(pdgc) || polMod < -1.0 ){
             // update polarisation modulus for new leading lepton
             polMod = this->CalcPolMod( polMag, fDecLepPdg, fDecHadPdg, MHNL );
           } // std::abs(fDecLepPdg) != std::abs(pdgc) || polMod == -999.9
         } // p4lep->E() > Elead
       } // isQLep
       
       idc++;
     }
 
     // find angle \theta of leading FS QLep with vPolDir
     // assume differential decay rate \propto ( 1 \pm pMod * cos\theta )
 
     double theta = vPolDir.Angle( lepDir ); // rad
     double ctheta = TMath::Cos( theta );
 
     rwgt = rnd->RndGen().Uniform(0.0, 2.0);
     int typeMod = ( *(pdgv.begin()) > 0 ) ? 1 : -1;
     polWgt = 1 + typeMod * polMod * ctheta;
 
     isAccepted = ( rwgt >= polWgt );
 
     iUPD++;
   } // while( rwgt >= polWgt && iUPD < controls::kMaxUnweightDecayIterations )
 
   if( iUPD == controls::kMaxUnweightDecayIterations ){
     // report and return
     LOG("HNL", pWARN)
       << "Couldn't generate a polarised decay after "
       << iUPD << " attempts";
     failed = true;
     return failed;
   }
   
   return failed;
 
 }

void Decayer::ProcessEventRecord ( GHepRecord * event ) const

virtual

Implements genie::hnl::DecayRecordVisitorI.

Definition at line 54 of file HNLDecayer.cxx.

References AddInitialState(), genie::utils::hnl::AsString(), genie::XclsTag::DecayMode(), genie::Interaction::ExclTag(), fCurrDecayMode, fCurrInitStatePdg, GenerateDecayProducts(), genie::Interaction::InitState(), LOG, pNOTICE, genie::InitialState::ProbePdg(), ReadCreationInfo(), and UpdateEventRecord().

Referenced by main(), and TestDecay().

 {
 
   Interaction * interaction = event->Summary();
 
   fCurrInitStatePdg = interaction->InitState().ProbePdg();
   fCurrDecayMode = (HNLDecayMode_t) interaction->ExclTag().DecayMode();
 
   LOG("HNL", pNOTICE)
     << "Simulating HNL decay " << utils::hnl::AsString(fCurrDecayMode)
     << " for an initial state with PDG code " << fCurrInitStatePdg;
 
   this->ReadCreationInfo(event);
   this->AddInitialState(event);
   this->GenerateDecayProducts(event);
   this->UpdateEventRecord(event);
 
 }

void Decayer::ReadCreationInfo ( GHepRecord * event ) const

private

Definition at line 518 of file HNLDecayer.cxx.

References fParentPdg, fPolDir, and fProdLepPdg.

Referenced by ProcessEventRecord().

 {
   if( fPolDir.size() > 0 ) fPolDir.clear();
   /*
   fPolDir.emplace_back( gnmf.ppvx );
   fPolDir.emplace_back( gnmf.ppvy );
   fPolDir.emplace_back( gnmf.ppvz );
 
   fParentPdg = gnmf.ptype;
   fProdLepPdg = gnmf.ppmedium;
   */
 
   TLorentzVector * vv = event->Vertex();
   TLorentzVector * tmpx4 = event->Particle(0)->GetX4();
   // this will only have been modified if we have enough polarisation information to do something.
   // Otherwise, FluxCreator hasn't been run and we shouldn't do stuff.
   if( tmpx4->X() != vv->X() || tmpx4->Y() != vv->Y() || tmpx4->Z() != vv->Z() ){
     fPolDir.emplace_back( tmpx4->X() );
     fPolDir.emplace_back( tmpx4->Y() );
     int tmpMod = ( event->XSec() > 0.0 ) ? 1 : -1;
     fPolDir.emplace_back( tmpMod * std::sqrt( 1.0 - 
                                               ( tmpx4->X() * tmpx4->X() + tmpx4->Y() * tmpx4->Y() ) ) );
     
     fParentPdg = tmpx4->Z();
     fProdLepPdg = tmpx4->T();
 
     // now reset the x4 of the HNL to whatever the vertex is
     event->Particle(0)->SetPosition( vv->X(), vv->Y(), vv->Z(), vv->T() );
     event->SetXSec(0.0);
   } else { return; }
 }

void Decayer::SetBeam2User	(	std::vector< double >	translation,
		std::vector< double >	rotation
	)		const

private

Definition at line 488 of file HNLDecayer.cxx.

References fR1, fR2, fR3, fTx, fTy, and fTz.

Referenced by LoadConfig().

 {
   fTx = -1.0 * translation.at(0);
   fTy = -1.0 * translation.at(1);
   fTz = -1.0 * translation.at(2);
 
   fR1 = rotation.at(0);
   fR2 = rotation.at(1);
   fR3 = rotation.at(2);
 }

void Decayer::SetHNLCouplings	(	double	Ue42,
		double	Um42,
		double	Ut42
	)		const

private

Definition at line 481 of file HNLDecayer.cxx.

References fUe42, fUm42, and fUt42.

Referenced by LoadConfig().

 {
   fUe42 = Ue42;
   fUm42 = Um42;
   fUt42 = Ut42;
 }

void Decayer::SetProdVtxPosition ( const TLorentzVector & v4 ) const

private

Definition at line 511 of file HNLDecayer.cxx.

References fProdVtx.

Referenced by GenerateDecayPosition().

 {
   TLorentzVector * pv4 = new TLorentzVector();
   pv4->SetXYZT( v4.X(), v4.Y(), v4.Z(), v4.T() );
   fProdVtx = pv4;
 }

bool Decayer::UnpolarisedDecay	(	TGenPhaseSpace &	fPSG,
		PDGCodeList	pdgv,
		double	wm
	)		const

private

accept_decay

Definition at line 550 of file HNLDecayer.cxx.

References genie::RandomGen::Instance(), genie::controls::kMaxUnweightDecayIterations, LOG, pWARN, and genie::RandomGen::RndHadro().

Referenced by GenerateDecayProducts(), and PolarisedDecay().

 {
 
   RandomGen * rnd = RandomGen::Instance();
   
   bool accept_decay=false;
   unsigned int itry=0;
 
   bool failed = false;
   while(!accept_decay) {
     itry++;
     
     if(itry > controls::kMaxUnweightDecayIterations) {
       // report and return
       LOG("HNL", pWARN)
         << "Couldn't generate an unweighted phase space decay after "
         << itry << " attempts";
       failed = true;
       return failed;
     }
     double w  = fPSG.Generate();
     if(w > wm) {
       LOG("HNL", pWARN)
         << "Decay weight = " << w << " > max decay weight = " << wm;
     }
     double gw = wm * rnd->RndHadro().Rndm();
     accept_decay = (gw<=w);
     
     /*
       LOG("HNL", pDEBUG)
       << "Decay weight = " << w << " / R = " << gw
       << " - accepted: " << accept_decay;
     */
     
   } //!accept_decay
 
   return failed;
   
 }

void Decayer::UpdateEventRecord ( GHepRecord * event ) const

private

Definition at line 378 of file HNLDecayer.cxx.

References genie::GHepRecord::FinalStatePrimaryLepton(), genie::Interaction::InitStatePtr(), genie::Interaction::KinePtr(), genie::GHepRecord::Particle(), genie::InitialState::Probe(), genie::Kinematics::SetQ2(), genie::Kinematics::Sett(), and genie::Kinematics::SetW().

Referenced by ProcessEventRecord().

 {
   Interaction * interaction = event->Summary();
 
   interaction->KinePtr()->Sett( 0.0, true );
   interaction->KinePtr()->SetW( interaction->InitStatePtr()->Probe()->Mass(), true );
   TLorentzVector * p4HNL = event->Particle(0)->GetP4(); assert( p4HNL );
   // primary lepton is FirstDaughter() of Probe()
   // need Probe() as a GHepParticle(), not a TParticlePDG()!
   // get from event record position 0
   TLorentzVector * p4FSL = 0;
   if( event->FinalStatePrimaryLepton() ){
     int iFSL = event->Particle(0)->FirstDaughter();
     assert( event->Particle( iFSL ) );
     p4FSL = ( event->Particle( iFSL ) )->GetP4(); 
     assert( p4FSL );
     TLorentzVector p4DIF( p4HNL->Px() - p4FSL->Px(),
                           p4HNL->Py() - p4FSL->Py(),
                           p4HNL->Pz() - p4FSL->Pz(),
                           p4HNL->E() - p4FSL->E() );
     interaction->KinePtr()->SetQ2( p4DIF.M2(), true );
 
   }
   
   // clean up
   delete p4HNL;
   if(p4FSL) delete p4FSL;
 }

Member Data Documentation

std::vector< double > genie::hnl::Decayer::fB2URotation

mutableprivate

Definition at line 120 of file HNLDecayer.h.

Referenced by LoadConfig().

std::vector< double > genie::hnl::Decayer::fB2UTranslation

mutableprivate

Definition at line 118 of file HNLDecayer.h.

Referenced by LoadConfig().

int genie::hnl::Decayer::fChanBits[10] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }

mutableprivate

Definition at line 115 of file HNLDecayer.h.

Referenced by GetHNLInterestingChannels(), and LoadConfig().

genie::hnl::HNLDecayMode_t genie::hnl::Decayer::fCurrDecayMode

mutableprivate

Definition at line 100 of file HNLDecayer.h.

Referenced by GenerateDecayProducts(), and ProcessEventRecord().

int genie::hnl::Decayer::fCurrInitStatePdg

mutableprivate

Definition at line 99 of file HNLDecayer.h.

Referenced by GenerateDecayProducts(), and ProcessEventRecord().

int genie::hnl::Decayer::fDecHadPdg

mutableprivate

Definition at line 102 of file HNLDecayer.h.

Referenced by GenerateDecayProducts(), and PolarisedDecay().

int genie::hnl::Decayer::fDecLepPdg

mutableprivate

Definition at line 102 of file HNLDecayer.h.

Referenced by GenerateDecayProducts(), and PolarisedDecay().

bool genie::hnl::Decayer::fDoPol = false

mutableprivate

Definition at line 112 of file HNLDecayer.h.

Referenced by GenerateDecayProducts(), and LoadConfig().

bool genie::hnl::Decayer::fGetCMFrameInstead = false

mutableprivate

Definition at line 133 of file HNLDecayer.h.

Referenced by GenerateDecayProducts(), and LoadConfig().

std::vector< genie::hnl::HNLDecayMode_t > genie::hnl::Decayer::fIntChannels

mutableprivate

Definition at line 114 of file HNLDecayer.h.

Referenced by GetHNLInstance(), and LoadConfig().

bool genie::hnl::Decayer::fIsConfigLoaded = false

mutableprivate

Definition at line 105 of file HNLDecayer.h.

Referenced by LoadConfig().

bool genie::hnl::Decayer::fIsMajorana = false

mutableprivate

Definition at line 109 of file HNLDecayer.h.

Referenced by GenerateDecayProducts(), GetHNLInstance(), IsHNLMajorana(), and LoadConfig().

TLorentzVector* genie::hnl::Decayer::fISMom = 0

mutableprivate

Definition at line 125 of file HNLDecayer.h.

double genie::hnl::Decayer::fMass

mutableprivate

Definition at line 107 of file HNLDecayer.h.

Referenced by GetHNLInstance(), GetHNLMass(), and LoadConfig().

int genie::hnl::Decayer::fParentPdg

mutableprivate

Definition at line 102 of file HNLDecayer.h.

Referenced by PolarisedDecay(), and ReadCreationInfo().

double genie::hnl::Decayer::fPGCx = 0.0

mutableprivate

Definition at line 130 of file HNLDecayer.h.

Referenced by GetPGunDirection(), and LoadConfig().

double genie::hnl::Decayer::fPGCy = 0.0

mutableprivate

Definition at line 130 of file HNLDecayer.h.

Referenced by GetPGunDirection(), and LoadConfig().

double genie::hnl::Decayer::fPGCz = 0.0

mutableprivate

Definition at line 130 of file HNLDecayer.h.

Referenced by GetPGunDirection(), and LoadConfig().

double genie::hnl::Decayer::fPGDPhi = 0.0

mutableprivate

Definition at line 131 of file HNLDecayer.h.

Referenced by GetPGunDeviation(), and LoadConfig().

double genie::hnl::Decayer::fPGDTheta = 0.0

mutableprivate

Definition at line 131 of file HNLDecayer.h.

Referenced by GetPGunDeviation(), and LoadConfig().

double genie::hnl::Decayer::fPGDx = 0.0

mutableprivate

Definition at line 128 of file HNLDecayer.h.

Referenced by GetPGunDOrigin(), and LoadConfig().

double genie::hnl::Decayer::fPGDy = 0.0

mutableprivate

Definition at line 128 of file HNLDecayer.h.

Referenced by GetPGunDOrigin(), and LoadConfig().

double genie::hnl::Decayer::fPGDz = 0.0

mutableprivate

Definition at line 128 of file HNLDecayer.h.

Referenced by GetPGunDOrigin(), and LoadConfig().

double genie::hnl::Decayer::fPGE = 0.0

mutableprivate

Definition at line 129 of file HNLDecayer.h.

Referenced by GetPGunEnergy(), and LoadConfig().

double genie::hnl::Decayer::fPGOx = 0.0

mutableprivate

Definition at line 127 of file HNLDecayer.h.

Referenced by GetPGunOrigin(), and LoadConfig().

double genie::hnl::Decayer::fPGOy = 0.0

mutableprivate

Definition at line 127 of file HNLDecayer.h.

Referenced by GetPGunOrigin(), and LoadConfig().

double genie::hnl::Decayer::fPGOz = 0.0

mutableprivate

Definition at line 127 of file HNLDecayer.h.

Referenced by GetPGunOrigin(), and LoadConfig().

std::vector<double> genie::hnl::Decayer::fPolDir

mutableprivate

Definition at line 103 of file HNLDecayer.h.

Referenced by GenerateDecayProducts(), and ReadCreationInfo().

int genie::hnl::Decayer::fProdLepPdg

mutableprivate

Definition at line 102 of file HNLDecayer.h.

Referenced by PolarisedDecay(), and ReadCreationInfo().

TLorentzVector* genie::hnl::Decayer::fProdVtx = 0

mutableprivate

Definition at line 124 of file HNLDecayer.h.

Referenced by SetProdVtxPosition().

TH3D* genie::hnl::Decayer::fProdVtxHist = 0

mutableprivate

Definition at line 123 of file HNLDecayer.h.

Referenced by GenerateDecayPosition().

double genie::hnl::Decayer::fR1 = -1.0

mutableprivate

Definition at line 121 of file HNLDecayer.h.

Referenced by GetHNLInstance(), and SetBeam2User().

double genie::hnl::Decayer::fR2 = -1.0

mutableprivate

Definition at line 121 of file HNLDecayer.h.

Referenced by GetHNLInstance(), and SetBeam2User().

double genie::hnl::Decayer::fR3 = -1.0

mutableprivate

Definition at line 121 of file HNLDecayer.h.

Referenced by GetHNLInstance(), and SetBeam2User().

double genie::hnl::Decayer::fTx = -1.0

mutableprivate

Definition at line 119 of file HNLDecayer.h.

Referenced by GetHNLInstance(), and SetBeam2User().

double genie::hnl::Decayer::fTy = -1.0

mutableprivate

Definition at line 119 of file HNLDecayer.h.

Referenced by GetHNLInstance(), and SetBeam2User().

double genie::hnl::Decayer::fTz = -1.0

mutableprivate

Definition at line 119 of file HNLDecayer.h.

Referenced by GetHNLInstance(), and SetBeam2User().

double genie::hnl::Decayer::fUe42 = -1.0

mutableprivate

Definition at line 108 of file HNLDecayer.h.

Referenced by GetHNLCouplings(), GetHNLInstance(), and SetHNLCouplings().

double genie::hnl::Decayer::fUm42 = -1.0

mutableprivate

Definition at line 108 of file HNLDecayer.h.

Referenced by GetHNLCouplings(), GetHNLInstance(), and SetHNLCouplings().

double genie::hnl::Decayer::fUt42 = -1.0

mutableprivate

Definition at line 108 of file HNLDecayer.h.

Referenced by GetHNLCouplings(), GetHNLInstance(), and SetHNLCouplings().

The documentation for this class was generated from the following files:

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation