G4KineticTrack Class Reference

#include <G4KineticTrack.hh>

Inheritance diagram for G4KineticTrack:

Public Types
enum	CascadeState {   undefined , outside , going_in , inside ,   going_out , gone_out , captured , miss_nucleus }

Public Member Functions
G4double	BrWig (const G4double Gamma, const G4double rmass, const G4double mass) const
G4KineticTrackVector *	Decay ()
	G4KineticTrack ()
	G4KineticTrack (const G4KineticTrack &right)
	G4KineticTrack (const G4ParticleDefinition *aDefinition, G4double aFormationTime, const G4ThreeVector &aPosition, const G4LorentzVector &a4Momentum)
	G4KineticTrack (G4Nucleon *nucleon, const G4ThreeVector &aPosition, const G4LorentzVector &a4Momentum)
const G4LorentzVector &	Get4Momentum () const
G4double	GetActualMass () const
G4double *	GetActualWidth () const
G4int	GetCreatorModelID () const
const G4ParticleDefinition *	GetDefinition () const
G4double	GetFormationTime () const
G4int	GetnChannels () const
const G4ThreeVector &	GetPosition () const
G4double	GetProjectilePotential () const
CascadeState	GetState () const
const G4LorentzVector &	GetTrackingMomentum () const
void	Hit ()
G4bool	IsParticipant () const
G4bool	operator!= (const G4KineticTrack &right) const
G4bool	operator!= (const G4VKineticNucleon &right) const
G4KineticTrack &	operator= (const G4KineticTrack &right)
G4bool	operator== (const G4KineticTrack &right) const
G4bool	operator== (const G4VKineticNucleon &right) const
G4double	SampleResidualLifetime ()
void	Set4Momentum (const G4LorentzVector &a4Momentum)
void	SetCreatorModelID (G4int id)
void	SetDefinition (const G4ParticleDefinition *aDefinition)
void	SetFormationTime (G4double aFormationTime)
void	SetNucleon (G4Nucleon *aN)
void	SetPosition (const G4ThreeVector aPosition)
void	SetProjectilePotential (const G4double aPotential)
CascadeState	SetState (const CascadeState new_state)
void	SetTrackingMomentum (const G4LorentzVector &a4Momentum)
void	Update4Momentum (const G4ThreeVector &aMomentum)
void	Update4Momentum (G4double aEnergy)
void	UpdateTrackingMomentum (const G4ThreeVector &aMomentum)
void	UpdateTrackingMomentum (G4double aEnergy)
	~G4KineticTrack ()

Private Member Functions
G4double	EvaluateCMMomentum (const G4double mass, const G4double *m_ij) const
G4double	EvaluateTotalActualWidth ()
G4double	IntegrandFunction1 (G4double xmass) const
G4double	IntegrandFunction2 (G4double xmass) const
G4double	IntegrandFunction3 (G4double xmass) const
G4double	IntegrandFunction4 (G4double xmass) const
G4double	IntegrateCMMomentum (const G4double lowerLimit) const
G4double	IntegrateCMMomentum (const G4double lowerLimit, const G4double polemass) const
G4double	IntegrateCMMomentum2 () const
void	SetActualWidth (G4double *anActualWidth)
void	SetnChannels (const G4int aChannel)

Private Attributes
G4int	nChannels
G4LorentzVector	the4Momentum
G4double	theActualMass
G4double *	theActualWidth
G4int	theCreatorModel
G4double *	theDaughterMass
G4double *	theDaughterWidth
const G4ParticleDefinition *	theDefinition
G4LorentzVector	theFermi3Momentum
G4double	theFormationTime
G4Nucleon *	theNucleon
G4ThreeVector	thePosition
G4double	theProjectilePotential
CascadeState	theStateToNucleus
G4LorentzVector	theTotal4Momentum

Detailed Description

Definition at line 56 of file G4KineticTrack.hh.

Member Enumeration Documentation

CascadeState

enum G4KineticTrack::CascadeState

Enumerator
undefined
outside
going_in
inside
going_out
gone_out
captured
miss_nucleus

Definition at line 118 of file G4KineticTrack.hh.

                        {undefined, outside, going_in, inside, 
                         going_out, gone_out, captured, miss_nucleus };

Constructor & Destructor Documentation

G4KineticTrack() [1/4]

G4KineticTrack::G4KineticTrack

(

)

Definition at line 67 of file G4KineticTrack.cc.

                               :
                theDefinition(0),
                theFormationTime(0),
                thePosition(0),
                the4Momentum(0),
        theFermi3Momentum(0),
        theTotal4Momentum(0),
        theNucleon(0),
                nChannels(0),
                theActualMass(0),            
                theActualWidth(0),            
                theDaughterMass(0),
                theDaughterWidth(0),
        theStateToNucleus(undefined),
        theProjectilePotential(0),
                theCreatorModel(-1)
{
//    DEBUG   //
 
/*
 G4cerr << G4endl << G4endl << G4endl;
 G4cerr << "   G4KineticTrack default constructor invoked! \n";
 G4cerr << "   =========================================== \n" << G4endl;
*/
}

Referenced by Decay(), IntegrandFunction4(), IntegrateCMMomentum(), and IntegrateCMMomentum2().

G4KineticTrack() [2/4]

G4KineticTrack::G4KineticTrack

(

const G4KineticTrack &

right

)

Definition at line 101 of file G4KineticTrack.cc.

                                                          : G4VKineticNucleon()
{
 theDefinition = right.GetDefinition();
 theFormationTime = right.GetFormationTime();
 thePosition = right.GetPosition();
 the4Momentum = right.GetTrackingMomentum();
 theFermi3Momentum = right.theFermi3Momentum;
 theTotal4Momentum = right.theTotal4Momentum;
 theNucleon=right.theNucleon;
 nChannels = right.GetnChannels();
 theActualMass = right.GetActualMass();
 theActualWidth = new G4double[nChannels];
 for (G4int i = 0; i < nChannels; i++)
  {
    theActualWidth[i] = right.theActualWidth[i];
  }
 theDaughterMass = 0;
 theDaughterWidth = 0;
 theStateToNucleus=right.theStateToNucleus;
 theProjectilePotential=right.theProjectilePotential;
 theCreatorModel = right.GetCreatorModelID();
//    DEBUG   //
 
/*
 G4cerr << G4endl << G4endl << G4endl;
 G4cerr << "   G4KineticTrack copy constructor invoked! \n";
 G4cerr << "   ======================================== \n" <<G4endl;
*/
}

References GetActualMass(), GetCreatorModelID(), GetDefinition(), GetFormationTime(), GetnChannels(), GetPosition(), GetTrackingMomentum(), nChannels, the4Momentum, theActualMass, theActualWidth, theCreatorModel, theDaughterMass, theDaughterWidth, theDefinition, theFermi3Momentum, theFormationTime, theNucleon, thePosition, theProjectilePotential, theStateToNucleus, and theTotal4Momentum.

G4KineticTrack() [3/4]

G4KineticTrack::G4KineticTrack	(	const G4ParticleDefinition *	aDefinition,
		G4double	aFormationTime,
		const G4ThreeVector &	aPosition,
		const G4LorentzVector &	a4Momentum
	)

Definition at line 138 of file G4KineticTrack.cc.

                                                                  :
                theDefinition(aDefinition),
        theFormationTime(aFormationTime),
                thePosition(aPosition),
                the4Momentum(a4Momentum),
        theFermi3Momentum(0),
        theTotal4Momentum(a4Momentum),
        theNucleon(0),
        theStateToNucleus(undefined),
        theProjectilePotential(0),
                theCreatorModel(-1)
{
  if(G4KaonZero::KaonZero() == theDefinition ||
    G4AntiKaonZero::AntiKaonZero() == theDefinition)
  {
    if(G4UniformRand()<0.5)
    {
      theDefinition = G4KaonZeroShort::KaonZeroShort();
    }
    else
    {
      theDefinition = G4KaonZeroLong::KaonZeroLong();
    }
  }
 
//
//      Get the number of decay channels
//
 
 G4DecayTable* theDecayTable = theDefinition->GetDecayTable();
 if (theDecayTable != 0)
    {
     nChannels = theDecayTable->entries();
 
    }
 else
    {
     nChannels = 0;
    }  
 
//
//   Get the actual mass value
//
 
 theActualMass = GetActualMass();
 
//
//   Create an array to Store the actual partial widths 
//   of the decay channels
//
 
  theDaughterMass = 0;
  theDaughterWidth = 0;
  theActualWidth = 0;
  G4bool * theDaughterIsShortLived = 0;
  
  if(nChannels!=0) theActualWidth = new G4double[nChannels];
 
  //  cout << " ****CONSTR*** ActualMass ******* " << theActualMass << G4endl;
  G4int index;
  for (index = nChannels - 1; index >= 0; --index)
    {
      G4VDecayChannel* theChannel = theDecayTable->GetDecayChannel(index);
      G4int nDaughters = theChannel->GetNumberOfDaughters();
      G4double theMotherWidth;
      if (nDaughters == 2 || nDaughters == 3) 
    {
          G4double thePoleMass  = theDefinition->GetPDGMass();
          theMotherWidth = theDefinition->GetPDGWidth();
          G4double thePoleWidth = theChannel->GetBR()*theMotherWidth;
          const G4ParticleDefinition* aDaughter;
          theDaughterMass = new G4double[nDaughters];
          theDaughterWidth = new G4double[nDaughters];
      theDaughterIsShortLived = new G4bool[nDaughters];
          for (G4int n = 0; n < nDaughters; ++n)
        {
              aDaughter = theChannel->GetDaughter(n);
              theDaughterMass[n] = aDaughter->GetPDGMass();
              theDaughterWidth[n] = aDaughter->GetPDGWidth();
          theDaughterIsShortLived[n] = aDaughter->IsShortLived();
        }     
      
//
//           Check whether both the decay products are stable
//
 
          G4double theActualMom = 0.0;
          G4double thePoleMom = 0.0;
      G4SampleResonance aSampler;
      if (nDaughters==2) 
        {
          if ( !theDaughterIsShortLived[0] && !theDaughterIsShortLived[1] )
        {
          
          //              G4cout << G4endl << "Both the " << nDaughters <<
          //                              " decay products are stable!";
          //                   cout << " LB: Both decay products STABLE !" << G4endl;
          //                   cout << " parent:     " << theChannel->GetParentName() << G4endl;
          //                   cout << " particle1:  " << theChannel->GetDaughterName(0) << G4endl;
          //                   cout << " particle2:  " << theChannel->GetDaughterName(1) << G4endl;
          
          theActualMom = EvaluateCMMomentum(theActualMass, 
                            theDaughterMass);   
          thePoleMom = EvaluateCMMomentum(thePoleMass, 
                          theDaughterMass);
          //          cout << G4endl;
          //          cout << " LB: ActualMass/DaughterMass  " << theActualMass << "   " << theDaughterMass << G4endl; 
          //          cout << " LB: ActualMom " << theActualMom << G4endl;
          //          cout << " LB: PoleMom   " << thePoleMom << G4endl;
          //          cout << G4endl;
        }
          else if ( !theDaughterIsShortLived[0] && theDaughterIsShortLived[1] )   
        {
          
          //              G4cout << G4endl << "Only the first of the " << nDaughters <<" decay products is stable!";
          //           cout << " LB: only the first decay product is STABLE !" << G4endl;
          //           cout << " parent:     " << theChannel->GetParentName() << G4endl;
          //           cout << " particle1:  " << theChannel->GetDaughterName(0) << G4endl;
          //           cout << " particle2:  " << theChannel->GetDaughterName(1) << G4endl;
          
// global variable definition
          G4double lowerLimit = aSampler.GetMinimumMass(theChannel->GetDaughter(1));
          theActualMom = IntegrateCMMomentum(lowerLimit);
          thePoleMom = IntegrateCMMomentum(lowerLimit, thePoleMass);
          //          cout << " LB Parent Mass = " <<  G4KineticTrack_Gmass << G4endl;
          //          cout << " LB Actual Mass = " << theActualMass << G4endl;
          //          cout << " LB Daughter1 Mass = " <<  G4KineticTrack_Gmass1 << G4endl;
          //          cout << " LB Daughter2 Mass = " <<  G4KineticTrack_Gmass2 << G4endl;
          //          cout << " The Actual Momentum = " << theActualMom << G4endl;
          //          cout << " The Pole Momentum   = " << thePoleMom << G4endl;
          //          cout << G4endl;
          
        }        
          else if ( theDaughterIsShortLived[0] && !theDaughterIsShortLived[1] )   
        {
          
          //              G4cout << G4endl << "Only the second of the " << nDaughters <<
          //                              " decay products is stable!";
          //                   cout << " LB: only the second decay product is STABLE !" << G4endl;
          //           cout << " parent:     " << theChannel->GetParentName() << G4endl;
          //           cout << " particle1:  " << theChannel->GetDaughterName(0) << G4endl;
          //           cout << " particle2:  " << theChannel->GetDaughterName(1) << G4endl;
          
//
//               Swap the content of the theDaughterMass and theDaughterWidth arrays!!!
//
          
          G4SwapObj(theDaughterMass, theDaughterMass + 1);
          G4SwapObj(theDaughterWidth, theDaughterWidth + 1);
          
// global variable definition
          G4double lowerLimit = aSampler.GetMinimumMass(theChannel->GetDaughter(0));
          theActualMom = IntegrateCMMomentum(lowerLimit);
          thePoleMom = IntegrateCMMomentum(lowerLimit, thePoleMass);
          //          cout << " LB Parent Mass = " <<  G4KineticTrack_Gmass << G4endl;
          //          cout << " LB Actual Mass = " << theActualMass << G4endl;
          //          cout << " LB Daughter1 Mass = " <<  G4KineticTrack_Gmass1 << G4endl;
          //          cout << " LB Daughter2 Mass = " <<  G4KineticTrack_Gmass2 << G4endl;
          //          cout << " The Actual Momentum = " << theActualMom << G4endl;
          //          cout << " The Pole Momentum   = " << thePoleMom << G4endl;
          //              cout << G4endl;
          
        }        
          else if ( theDaughterIsShortLived[0] && theDaughterIsShortLived[1] )   
        {
           
//              G4cout << G4endl << "Both the " << nDaughters <<
//                              " decay products are resonances!";
          //           cout << " LB: both decay products are RESONANCES !" << G4endl;
          //           cout << " parent:     " << theChannel->GetParentName() << G4endl;
          //           cout << " particle1:  " << theChannel->GetDaughterName(0) << G4endl;
          //           cout << " particle2:  " << theChannel->GetDaughterName(1) << G4endl;
          
// global variable definition
          G4KineticTrack_Gmass = theActualMass;
          theActualMom = IntegrateCMMomentum2();
          G4KineticTrack_Gmass = thePoleMass;
          thePoleMom = IntegrateCMMomentum2();
          //          cout << " LB Parent Mass = " <<  G4KineticTrack_Gmass << G4endl;
          //          cout << " LB Daughter1 Mass = " <<  G4KineticTrack_Gmass1 << G4endl;
          //          cout << " LB Daughter2 Mass = " <<  G4KineticTrack_Gmass2 << G4endl;
          //              cout << " The Actual Momentum = " << theActualMom << G4endl;
          //              cout << " The Pole Momentum   = " << thePoleMom << G4endl;
          //              cout << G4endl;
          
        }        
        } 
      else  // (nDaughter==3)
        {
          
          G4int nShortLived = 0;
          if ( theDaughterIsShortLived[0] ) 
        { 
          ++nShortLived; 
        }
          if ( theDaughterIsShortLived[1] )
        { 
          ++nShortLived; 
          G4SwapObj(theDaughterMass, theDaughterMass + 1);
          G4SwapObj(theDaughterWidth, theDaughterWidth + 1);        
        }
          if ( theDaughterIsShortLived[2] )
        { 
          ++nShortLived; 
          G4SwapObj(theDaughterMass, theDaughterMass + 2);
          G4SwapObj(theDaughterWidth, theDaughterWidth + 2);        
        }
          if ( nShortLived == 0 ) 
        {
          theDaughterMass[1]+=theDaughterMass[2];
          theActualMom = EvaluateCMMomentum(theActualMass, 
                            theDaughterMass);   
          thePoleMom = EvaluateCMMomentum(thePoleMass, 
                          theDaughterMass);
        }
//        else if ( nShortLived == 1 )
          else if ( nShortLived >= 1 )
        { 
          // need the shortlived particle in slot 1! (very bad style...)
          G4SwapObj(theDaughterMass, theDaughterMass + 1);
          G4SwapObj(theDaughterWidth, theDaughterWidth + 1);        
          theDaughterMass[0] += theDaughterMass[2];
          theActualMom = IntegrateCMMomentum(0.0);
          thePoleMom = IntegrateCMMomentum(0.0, thePoleMass);
        }
//        else
//      {
//        throw G4HadronicException(__FILE__, __LINE__,  ("can't handle more than one shortlived in 3 particle output channel");
//      }     
          
        }
      
      //if(nDaughters<3) theChannel->GetAngularMomentum(); 
      G4double theMassRatio = thePoleMass / theActualMass;
          G4double theMomRatio = theActualMom / thePoleMom;
      // VI 11.06.2015: for l=0 one not need use pow
          //G4double l=0;
          //theActualWidth[index] = thePoleWidth * theMassRatio *
          //                        std::pow(theMomRatio, (2 * l + 1)) *
          //                        (1.2 / (1+ 0.2*std::pow(theMomRatio, (2 * l))));
          theActualWidth[index] = thePoleWidth * theMassRatio *
                                  theMomRatio;
          delete [] theDaughterMass;
      theDaughterMass = 0;
          delete [] theDaughterWidth;
      theDaughterWidth = 0;
      delete [] theDaughterIsShortLived;
          theDaughterIsShortLived = 0;
    }
      
      else //  nDaughter = 1 ( e.g. K0  decays 50% to Kshort, 50% Klong 
    {
      theMotherWidth = theDefinition->GetPDGWidth();
      theActualWidth[index] = theChannel->GetBR()*theMotherWidth;
    }
    }
 
//    DEBUG   //
 
// for (G4int y = nChannels - 1; y >= 0; --y)
//     {
//      G4cout << G4endl << theActualWidth[y];
//     }
// G4cout << G4endl << G4endl << G4endl;
 
 /*
 G4cerr << G4endl << G4endl << G4endl;
 G4cerr << "   G4KineticTrack by argument constructor invoked! \n";
 G4cerr << "   =============================================== \n" << G4endl;
 */
 
}

References G4AntiKaonZero::AntiKaonZero(), G4DecayTable::entries(), EvaluateCMMomentum(), G4KineticTrack_Gmass, G4SwapObj(), G4UniformRand, GetActualMass(), G4VDecayChannel::GetBR(), G4VDecayChannel::GetDaughter(), G4DecayTable::GetDecayChannel(), G4ParticleDefinition::GetDecayTable(), G4SampleResonance::GetMinimumMass(), G4VDecayChannel::GetNumberOfDaughters(), G4ParticleDefinition::GetPDGMass(), G4ParticleDefinition::GetPDGWidth(), IntegrateCMMomentum(), IntegrateCMMomentum2(), G4ParticleDefinition::IsShortLived(), G4KaonZero::KaonZero(), G4KaonZeroLong::KaonZeroLong(), G4KaonZeroShort::KaonZeroShort(), CLHEP::detail::n, nChannels, theActualMass, theActualWidth, theDaughterMass, theDaughterWidth, and theDefinition.

G4KineticTrack() [4/4]

G4KineticTrack::G4KineticTrack	(	G4Nucleon *	nucleon,
		const G4ThreeVector &	aPosition,
		const G4LorentzVector &	a4Momentum
	)

Definition at line 416 of file G4KineticTrack.cc.

  :     theDefinition(nucleon->GetDefinition()),
    theFormationTime(0),
    thePosition(aPosition),
    the4Momentum(a4Momentum),
    theFermi3Momentum(nucleon->GetMomentum()),
        theNucleon(nucleon),
    nChannels(0),
    theActualMass(nucleon->GetDefinition()->GetPDGMass()),
    theActualWidth(0),
    theDaughterMass(0),
    theDaughterWidth(0),
    theStateToNucleus(undefined),
    theProjectilePotential(0),
        theCreatorModel(-1)
{
    theFermi3Momentum.setE(0);
    Set4Momentum(a4Momentum);
}

References Set4Momentum(), CLHEP::HepLorentzVector::setE(), and theFermi3Momentum.

~G4KineticTrack()

G4KineticTrack::~G4KineticTrack

(

)

Definition at line 439 of file G4KineticTrack.cc.

{
 if (theActualWidth != 0) delete [] theActualWidth;
 if (theDaughterMass != 0) delete [] theDaughterMass;
 if (theDaughterWidth != 0) delete [] theDaughterWidth;
}

References theActualWidth, theDaughterMass, and theDaughterWidth.

Member Function Documentation

BrWig()

G4double G4KineticTrack::BrWig ( const G4double  Gamma, const G4double  rmass, const G4double  mass  ) const

inline

Definition at line 382 of file G4KineticTrack.hh.

{                
  G4double Norm = CLHEP::twopi;
  return (Gamma/((mass-rmass)*(mass-rmass)+Gamma*Gamma/4.))/Norm;
}

References CLHEP::twopi.

Referenced by IntegrandFunction1(), IntegrandFunction2(), IntegrandFunction3(), and IntegrandFunction4().

Decay()

G4KineticTrackVector * G4KineticTrack::Decay ( )

virtual

Reimplemented from G4VKineticNucleon.

Definition at line 485 of file G4KineticTrack.cc.

{
//
//   Select a possible decay channel
//
/*
    G4int index1;
    for (index1 = nChannels - 1; index1 >= 0; --index1)
      G4cout << "DECAY Actual Width IND/ActualW " << index1 << "  " << theActualWidth[index1] << G4endl;
      G4cout << "DECAY Actual Mass " << theActualMass << G4endl;
*/
  const G4ParticleDefinition* thisDefinition = this->GetDefinition();
  if(!thisDefinition)
  {
    G4cerr << "Error condition encountered in G4KineticTrack::Decay()"<<G4endl;
    G4cerr << "  track has no particle definition associated."<<G4endl;
    return 0;
  }
  G4DecayTable* theDecayTable = thisDefinition->GetDecayTable();
  if(!theDecayTable)
  {
    G4cerr << "Error condition encountered in G4KineticTrack::Decay()"<<G4endl;
    G4cerr << "  particle definition has no decay table associated."<<G4endl;
    G4cerr << "  particle was "<<thisDefinition->GetParticleName()<<G4endl;
    return 0;
  }
 
 G4int chargeBalance = G4lrint(theDefinition->GetPDGCharge() );     
 G4int baryonBalance = G4lrint(theDefinition->GetBaryonNumber() );
 G4LorentzVector energyMomentumBalance(Get4Momentum());
 G4double theTotalActualWidth = this->EvaluateTotalActualWidth();
 if (theTotalActualWidth !=0)
    {
 
     //AR-16Aug2016 : Repeat the sampling of the decay channel until is 
     //               kinematically above threshold or a max number of attempts is reached
     G4bool isChannelBelowThreshold = true;
     const G4int maxNumberOfLoops = 10000;
     G4int loopCounter = 0;
 
     G4int chosench;
     G4String theParentName;
     G4double theParentMass;
     G4double theBR;
     G4int theNumberOfDaughters;
     G4String theDaughtersName1;
     G4String theDaughtersName2;
     G4String theDaughtersName3;
     G4String theDaughtersName4;
     G4double masses[4]={0.,0.,0.,0.};
 
     do {       
 
       G4double theSumActualWidth = 0.0;
       G4double* theCumActualWidth = new G4double[nChannels]{};
       for (G4int index = nChannels - 1; index >= 0; --index)
          {
           theSumActualWidth += theActualWidth[index];
           theCumActualWidth[index] = theSumActualWidth;
       //    cout << "DECAY Cum. Width " << index << "  " << theCumActualWidth[index] << G4endl;
      }
       //    cout << "DECAY Total Width " << theSumActualWidth << G4endl;
       //    cout << "DECAY Total Width " << theTotalActualWidth << G4endl;
       G4double r = theTotalActualWidth * G4UniformRand();
       G4VDecayChannel* theDecayChannel(0);
       chosench=-1;
       for (G4int index = nChannels - 1; index >= 0; --index)
          {
           if (r < theCumActualWidth[index])
              {
               theDecayChannel = theDecayTable->GetDecayChannel(index);
           //        cout << "DECAY SELECTED CHANNEL" << index << G4endl;
               chosench=index;
               break; 
              }
          }
 
       delete [] theCumActualWidth;
   
       if(!theDecayChannel)
       {
         G4cerr << "Error condition encountered in G4KineticTrack::Decay()"<<G4endl;
         G4cerr << "  decay channel has 0x0 channel associated."<<G4endl;
         G4cerr << "  particle was "<<thisDefinition->GetParticleName()<<G4endl;
         G4cerr << "  channel index "<< chosench << "of "<<nChannels<<"channels"<<G4endl;
         return 0;
       }
       theParentName = theDecayChannel->GetParentName();
       theParentMass = this->GetActualMass();
       theBR = theActualWidth[chosench];
       //     cout << "**BR*** DECAYNEW  " << theBR << G4endl;
       theNumberOfDaughters = theDecayChannel->GetNumberOfDaughters();
       theDaughtersName1 = "";
       theDaughtersName2 = "";
       theDaughtersName3 = "";
       theDaughtersName4 = "";
 
       for (G4int i=0; i < 4; ++i) masses[i]=0.;
       G4int shortlivedDaughters[4];
       G4int numberOfShortliveds(0);
       G4double SumLongLivedMass(0);
       for (G4int aD=0; aD < theNumberOfDaughters ; ++aD)
       {
          const G4ParticleDefinition* aDaughter = theDecayChannel->GetDaughter(aD);
          masses[aD] = aDaughter->GetPDGMass();
          if ( aDaughter->IsShortLived() ) 
      {
          shortlivedDaughters[numberOfShortliveds]=aD;
          ++numberOfShortliveds;
      } else {
          SumLongLivedMass += aDaughter->GetPDGMass();
      }
        
       }    
       switch (theNumberOfDaughters)
          {
           case 0:
              break;
           case 1:
              theDaughtersName1 = theDecayChannel->GetDaughterName(0);
              theDaughtersName2 = "";
              theDaughtersName3 = "";
              theDaughtersName4 = "";
              break;
           case 2:    
              theDaughtersName1 = theDecayChannel->GetDaughterName(0);      
              theDaughtersName2 = theDecayChannel->GetDaughterName(1);
              theDaughtersName3 = "";
              theDaughtersName4 = "";
          if (  numberOfShortliveds == 1) 
          {   G4SampleResonance aSampler;
                  G4double massmax=theParentMass - SumLongLivedMass;
          const G4ParticleDefinition * aDaughter=theDecayChannel->GetDaughter(shortlivedDaughters[0]);
              masses[shortlivedDaughters[0]]= aSampler.SampleMass(aDaughter,massmax);
          } else if (  numberOfShortliveds == 2) {
              // choose masses one after the other, start with randomly choosen
              G4int zero= (G4UniformRand() > 0.5) ? 0 : 1;
          G4int one = 1-zero;
          G4SampleResonance aSampler;
          G4double massmax=theParentMass - aSampler.GetMinimumMass(theDecayChannel->GetDaughter(shortlivedDaughters[one]));
          const G4ParticleDefinition * aDaughter=theDecayChannel->GetDaughter(shortlivedDaughters[zero]);
          masses[shortlivedDaughters[zero]]=aSampler.SampleMass(aDaughter,massmax);
          massmax=theParentMass - masses[shortlivedDaughters[zero]];
          aDaughter=theDecayChannel->GetDaughter(shortlivedDaughters[one]);
          masses[shortlivedDaughters[one]]=aSampler.SampleMass(aDaughter,massmax);
          }
          break;        
       case 3:    
              theDaughtersName1 = theDecayChannel->GetDaughterName(0);
              theDaughtersName2 = theDecayChannel->GetDaughterName(1);
              theDaughtersName3 = theDecayChannel->GetDaughterName(2);
              theDaughtersName4 = "";
          if (  numberOfShortliveds == 1) 
          {   G4SampleResonance aSampler;
                  G4double massmax=theParentMass - SumLongLivedMass;
              const G4ParticleDefinition * aDaughter=theDecayChannel->GetDaughter(shortlivedDaughters[0]);
              masses[shortlivedDaughters[0]]= aSampler.SampleMass(aDaughter,massmax);
          }
          break;
       default:    
              theDaughtersName1 = theDecayChannel->GetDaughterName(0);
              theDaughtersName2 = theDecayChannel->GetDaughterName(1);
              theDaughtersName3 = theDecayChannel->GetDaughterName(2);
              theDaughtersName4 = theDecayChannel->GetDaughterName(3);
          if (  numberOfShortliveds == 1) 
          {   G4SampleResonance aSampler;
                  G4double massmax=theParentMass - SumLongLivedMass;
              const G4ParticleDefinition * aDaughter=theDecayChannel->GetDaughter(shortlivedDaughters[0]);
              masses[shortlivedDaughters[0]]= aSampler.SampleMass(aDaughter,massmax);
          }
              if ( theNumberOfDaughters > 4 ) {
                G4ExceptionDescription ed;
                ed << "More than 4 decay daughters: kept only the first 4" << G4endl;
                G4Exception( "G4KineticTrack::Decay()", "KINTRK5", JustWarning, ed );
              }
          break;
      }
 
          //AR-16Aug2016 : Check whether the sum of the masses of the daughters is smaller than the parent mass.
          //               If this is still not the case, but the max number of attempts has been reached,
          //               then the subsequent call thePhaseSpaceDecayChannel.DecayIt() will throw an exception.
          G4double sumDaughterMasses = 0.0;
          for (G4int i=0; i < 4; ++i) sumDaughterMasses += masses[i];
          if ( theParentMass - sumDaughterMasses > 0.0 ) isChannelBelowThreshold = false;
 
     } while ( isChannelBelowThreshold && ++loopCounter < maxNumberOfLoops );   /* Loop checking, 16.08.2016, A.Ribon */
 
//  
//      Get the decay products List
//
     
     G4GeneralPhaseSpaceDecay thePhaseSpaceDecayChannel(theParentName,
                                                        theParentMass,
                                                        theBR,
                                                        theNumberOfDaughters,
                                                        theDaughtersName1,                  
                                                theDaughtersName2,
                                                theDaughtersName3,
                                                theDaughtersName4,
                            masses);
     G4DecayProducts* theDecayProducts = thePhaseSpaceDecayChannel.DecayIt();
     if(!theDecayProducts)
     {
       G4ExceptionDescription ed;
       ed << "Error condition encountered: phase-space decay failed." << G4endl
          << "\t the decaying particle is: " << thisDefinition->GetParticleName() << G4endl
          << "\t the channel index is: "<< chosench << " of "<< nChannels << "channels" << G4endl
          << "\t " << theNumberOfDaughters << " daughter particles: "
          << theDaughtersName1 << " " << theDaughtersName2 << " " << theDaughtersName3 << " " 
          << theDaughtersName4 << G4endl;
       G4Exception( "G4KineticTrack::Decay ", "HAD_KINTRACK_001", JustWarning, ed );
       return 0;
     }
                                                
//
//      Create the kinetic track List associated to the decay products
//      
//      For the decay products of hadronic resonances, we assign as creator model ID
//      the same as their parent
     G4LorentzRotation toMoving(Get4Momentum().boostVector());
     G4DynamicParticle* theDynamicParticle;
     G4double formationTime = 0.0;
     G4ThreeVector position = this->GetPosition();
     G4LorentzVector momentum;
     G4LorentzVector momentumBalanceCMS(0);
     G4KineticTrackVector* theDecayProductList = new G4KineticTrackVector;
     G4int dEntries = theDecayProducts->entries();
     const G4ParticleDefinition * aProduct = 0;
     for (G4int i=dEntries; i > 0; --i)
        {
     theDynamicParticle = theDecayProducts->PopProducts();
         aProduct = theDynamicParticle->GetDefinition();
         chargeBalance -= G4lrint(aProduct->GetPDGCharge() );
         baryonBalance -= G4lrint(aProduct->GetBaryonNumber() );
     momentumBalanceCMS += theDynamicParticle->Get4Momentum();
         momentum = toMoving*theDynamicParticle->Get4Momentum();
         energyMomentumBalance -= momentum;
         G4KineticTrack* aDaughter = new G4KineticTrack (aProduct,
                                                         formationTime,
                                                         position,
                                                         momentum);
         if (aDaughter != nullptr) aDaughter->SetCreatorModelID(GetCreatorModelID());
         theDecayProductList->push_back(aDaughter);
         delete theDynamicParticle;
        }
     delete theDecayProducts;
     if(std::getenv("DecayEnergyBalanceCheck"))
       std::cout << "DEBUGGING energy balance in cms and lab, charge baryon balance : "
                 << momentumBalanceCMS << " " 
             <<energyMomentumBalance << " " 
             <<chargeBalance<<" "
             <<baryonBalance<<" "
             <<G4endl;
     return theDecayProductList;
    }
 else
    {
     return 0;
    }
}

References G4GeneralPhaseSpaceDecay::DecayIt(), G4DecayProducts::entries(), EvaluateTotalActualWidth(), G4cerr, G4endl, G4Exception(), G4KineticTrack(), G4lrint(), G4UniformRand, G4DynamicParticle::Get4Momentum(), Get4Momentum(), GetActualMass(), G4ParticleDefinition::GetBaryonNumber(), GetCreatorModelID(), G4VDecayChannel::GetDaughter(), G4VDecayChannel::GetDaughterName(), G4DecayTable::GetDecayChannel(), G4ParticleDefinition::GetDecayTable(), G4DynamicParticle::GetDefinition(), GetDefinition(), G4SampleResonance::GetMinimumMass(), G4VDecayChannel::GetNumberOfDaughters(), G4VDecayChannel::GetParentName(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), GetPosition(), G4ParticleDefinition::IsShortLived(), JustWarning, nChannels, G4DecayProducts::PopProducts(), G4SampleResonance::SampleMass(), SetCreatorModelID(), theActualWidth, theDefinition, and anonymous_namespace{G4CascadeDeexciteBase.cc}::zero.

Referenced by G4LMsdGenerator::ApplyYourself(), G4QMDCollision::CalKinematicsOfBinaryCollisions(), G4DecayKineticTracks::Decay(), G4NeutrinoNucleusModel::FinalBarion(), G4NeutrinoNucleusModel::FinalMeson(), and G4BCDecay::GetFinalState().

EvaluateCMMomentum()

G4double G4KineticTrack::EvaluateCMMomentum ( const G4double  mass, const G4double *  m_ij  ) const

inlineprivate

Definition at line 368 of file G4KineticTrack.hh.

{
  G4double theCMMomentum;
  if((m_ij[0]+m_ij[1])<mass)
   theCMMomentum = 1 / (2 * mass) * 
          std::sqrt (((mass * mass) - (m_ij[0] + m_ij[1]) * (m_ij[0] + m_ij[1])) *
                ((mass * mass) - (m_ij[0] - m_ij[1]) * (m_ij[0] - m_ij[1])));
  else
   theCMMomentum=0.;
 
 return theCMMomentum;
}     

Referenced by G4KineticTrack().

EvaluateTotalActualWidth()

G4double G4KineticTrack::EvaluateTotalActualWidth ( )

inlineprivate

Definition at line 349 of file G4KineticTrack.hh.

{
 G4int index;
 G4double theTotalActualWidth = 0.0;
 for (index = nChannels - 1; index >= 0; index--)
    {
     theTotalActualWidth += theActualWidth[index];
    }
 return theTotalActualWidth;
}

References nChannels, and theActualWidth.

Referenced by Decay(), and SampleResidualLifetime().

Get4Momentum()

const G4LorentzVector & G4KineticTrack::Get4Momentum ( ) const

inlinevirtual

Implements G4VKineticNucleon.

Definition at line 243 of file G4KineticTrack.hh.

{
  return theTotal4Momentum;
}

References theTotal4Momentum.

Referenced by G4MesonAbsorption::AbsorptionCrossSection(), G4CollisionManager::AddCollision(), G4BinaryCascade::ApplyCollision(), G4KineticTrackVector::Boost(), G4KineticTrackVector::BoostBeam(), G4RKFieldIntegrator::CalculateTotalEnergy(), G4BinaryCascade::Capture(), G4BinaryCascade::CorrectShortlivedPrimaryForFermi(), G4CollisionNN::CrossSection(), G4CrossSectionBuffer::CrossSection(), G4CrossSectionComposite::CrossSection(), G4CrossSectionPatch::CrossSection(), G4XAnnihilationChannel::CrossSection(), G4XMesonBaryonElastic::CrossSection(), G4XNNElasticLowE::CrossSection(), G4XNNTotalLowE::CrossSection(), G4XnpElasticLowE::CrossSection(), G4XnpTotalLowE::CrossSection(), G4XPDGElastic::CrossSection(), G4XPDGTotal::CrossSection(), G4XpimNTotal::CrossSection(), G4XpipNTotal::CrossSection(), G4XResonance::CrossSection(), G4BinaryCascade::DebugApplyCollision(), Decay(), G4VXResonance::DetailedBalance(), G4BinaryCascade::FillVoidNucleusProducts(), G4VAnnihilationCollision::FinalState(), G4VElasticCollision::FinalState(), G4VScatteringCollision::FinalState(), G4BinaryCascade::FindLateParticleCollision(), G4Absorber::FindProducts(), G4QGSMFragmentation::FragmentString(), G4ExcitedString::Get4Momentum(), G4MesonAbsorption::GetFinalState(), G4MesonAbsorption::GetTimeToAbsorption(), G4Scatterer::GetTimeToInteraction(), G4RKFieldIntegrator::Integrate(), G4BinaryLightIonReaction::Interact(), G4LundStringFragmentation::Loop_toFragmentString(), G4ExcitedString::LorentzRotate(), G4GeneratorPrecompoundInterface::MakeCoalescence(), G4VCrossSectionSource::PrintAll(), G4BinaryCascade::PrintKTVector(), G4IntraNucleiCascader::processSecondary(), G4BinaryCascade::ProductsAddFinalState(), G4DecayStrongResonances::Propagate(), G4CascadeInterface::Propagate(), G4BinaryCascade::Propagate1H1(), G4IntraNucleiCascader::releaseSecondary(), G4Scatterer::Scatter(), G4CrossSectionPatch::Transition(), G4XAnnihilationChannel::VariablePartialWidth(), G4XAnnihilationChannel::VariableWidth(), and G4Absorber::WillBeAbsorbed().

GetActualMass()

G4double G4KineticTrack::GetActualMass ( ) const

inline

Definition at line 322 of file G4KineticTrack.hh.

{
  return std::sqrt(std::abs(the4Momentum.mag2()));
}

References CLHEP::HepLorentzVector::mag2(), and the4Momentum.

Referenced by G4BinaryCascade::Capture(), G4CollisionNN::CrossSection(), Decay(), G4RKPropagation::FieldTransport(), G4VElasticCollision::FinalState(), G4VScatteringCollision::FinalState(), G4KineticTrack(), G4MesonAbsorption::GetTimeToAbsorption(), G4Scatterer::GetTimeToInteraction(), G4RKPropagation::Transport(), and G4Absorber::WillBeAbsorbed().

GetActualWidth()

G4double * G4KineticTrack::GetActualWidth ( ) const

inline

Definition at line 337 of file G4KineticTrack.hh.

{
  return theActualWidth;
}

References theActualWidth.

GetCreatorModelID()

G4int G4KineticTrack::GetCreatorModelID ( ) const

inline

Definition at line 435 of file G4KineticTrack.hh.

{
       return theCreatorModel;
}

References theCreatorModel.

Referenced by Decay(), G4DecayKineticTracks::Decay(), G4BinaryCascade::FillVoidNucleusProducts(), G4KineticTrack(), operator=(), and G4DecayStrongResonances::Propagate().

GetDefinition()

const G4ParticleDefinition * G4KineticTrack::GetDefinition ( ) const

inlinevirtual

Implements G4VKineticNucleon.

Definition at line 213 of file G4KineticTrack.hh.

{
  return theDefinition;
}

References theDefinition.

Referenced by G4MesonAbsorption::AbsorptionCrossSection(), G4CollisionManager::AddCollision(), G4BinaryCascade::ApplyCollision(), G4KineticTrackVector::BoostBeam(), G4CollisionComposite::BufferedCrossSection(), G4RKFieldIntegrator::CalculateTotalEnergy(), G4BinaryCascade::Capture(), G4BinaryCascade::CorrectShortlivedPrimaryForFermi(), G4CollisionComposite::CrossSection(), G4CollisionNN::CrossSection(), G4XAnnihilationChannel::CrossSection(), G4XAqmTotal::CrossSection(), G4XnpElasticLowE::CrossSection(), G4XnpTotalLowE::CrossSection(), G4XPDGElastic::CrossSection(), G4XPDGTotal::CrossSection(), G4XResonance::CrossSection(), G4BinaryCascade::DebugApplyCollision(), G4BinaryCascade::DebugApplyCollisionFail(), Decay(), G4DecayKineticTracks::Decay(), G4VXResonance::DegeneracyFactor(), G4VXResonance::DetailedBalance(), G4RKPropagation::FieldTransport(), G4BinaryCascade::FillVoidNucleusProducts(), G4VElasticCollision::FinalState(), G4VScatteringCollision::FinalState(), G4Absorber::FindAbsorbers(), G4MesonAbsorption::FindAndFillCluster(), G4VCrossSectionSource::FindKeyParticle(), G4BinaryCascade::FindLateParticleCollision(), G4VCrossSectionSource::FindLightParticle(), G4Absorber::FindProducts(), G4QGSMFragmentation::FragmentString(), G4ExcitedStringDecay::FragmentStrings(), G4KineticTrack(), G4BCDecay::GetCollisions(), G4MesonAbsorption::GetFinalState(), G4ParticleTypeConverter::GetGenericType(), G4ConcreteMesonBaryonToResonance::GetOutgoingParticle(), G4MesonAbsorption::GetTimeToAbsorption(), G4Scatterer::GetTimeToInteraction(), G4CollisionMesonBaryonElastic::IsInCharge(), G4CollisionNNElastic::IsInCharge(), G4CollisionnpElastic::IsInCharge(), G4ConcreteNNTwoBodyResonance::IsInCharge(), G4GeneralNNCollision::IsInCharge(), G4VXResonance::IsospinCorrection(), G4LundStringFragmentation::Loop_toFragmentString(), G4GeneratorPrecompoundInterface::MakeCoalescence(), G4XAnnihilationChannel::NormalizedClebsch(), operator=(), G4CollisionManager::Print(), G4CollisionInitialState::Print(), G4BinaryCascade::PrintKTVector(), G4IntraNucleiCascader::processSecondary(), G4BinaryCascade::ProductsAddFinalState(), G4DecayStrongResonances::Propagate(), G4CascadeInterface::Propagate(), G4BinaryCascade::Propagate1H1(), G4IntraNucleiCascader::releaseSecondary(), G4Scatterer::Scatter(), G4BinaryCascade::StepParticlesOut(), G4RKPropagation::Transport(), and G4Absorber::WillBeAbsorbed().

GetFormationTime()

G4double G4KineticTrack::GetFormationTime ( ) const

inline

Definition at line 223 of file G4KineticTrack.hh.

{
  return theFormationTime;
}

References theFormationTime.

Referenced by G4XMesonBaryonElastic::CrossSection(), G4QGSMFragmentation::FragmentString(), G4ExcitedString::G4ExcitedString(), G4KineticTrack(), G4BCLateParticle::GetCollisions(), G4LundStringFragmentation::Loop_toFragmentString(), G4GeneratorPrecompoundInterface::MakeCoalescence(), operator=(), and G4CascadeInterface::Propagate().

GetnChannels()

G4int G4KineticTrack::GetnChannels ( ) const

inline

Definition at line 327 of file G4KineticTrack.hh.

{
  return nChannels;
}

References nChannels.

Referenced by G4KineticTrack(), and operator=().

GetPosition()

const G4ThreeVector & G4KineticTrack::GetPosition ( void  ) const

inlinevirtual

Implements G4VKineticNucleon.

Definition at line 233 of file G4KineticTrack.hh.

{
  return thePosition;
}

References thePosition.

Referenced by G4RKFieldIntegrator::CalculateTotalEnergy(), G4BinaryCascade::Capture(), G4BinaryCascade::CorrectShortlivedPrimaryForFermi(), G4XMesonBaryonElastic::CrossSection(), G4BinaryCascade::DebugApplyCollision(), Decay(), G4RKPropagation::FieldTransport(), G4VAnnihilationCollision::FinalState(), G4VScatteringCollision::FinalState(), G4Absorber::FindAbsorbers(), G4MesonAbsorption::FindAndFillCluster(), G4Absorber::FindProducts(), G4QGSMFragmentation::FragmentString(), G4RKPropagation::FreeTransport(), G4ExcitedString::G4ExcitedString(), G4KineticTrack(), G4RKPropagation::GetSphereIntersectionTimes(), G4MesonAbsorption::GetTimeToAbsorption(), G4Scatterer::GetTimeToInteraction(), G4RKFieldIntegrator::Integrate(), G4LundStringFragmentation::Loop_toFragmentString(), G4GeneratorPrecompoundInterface::MakeCoalescence(), G4BinaryCascade::PrintKTVector(), G4IntraNucleiCascader::processSecondary(), G4CascadeInterface::Propagate(), G4KineticTrackVector::Shift(), and G4RKPropagation::Transport().

GetProjectilePotential()

G4double G4KineticTrack::GetProjectilePotential ( ) const

inline

Definition at line 424 of file G4KineticTrack.hh.

{
    return theProjectilePotential;
}

References theProjectilePotential.

Referenced by G4RKPropagation::Transport().

GetState()

G4KineticTrack::CascadeState G4KineticTrack::GetState ( ) const

inline

Definition at line 405 of file G4KineticTrack.hh.

{
    return theStateToNucleus;
}

References theStateToNucleus.

Referenced by G4BinaryCascade::Absorb(), G4BinaryCascade::ApplyCollision(), G4BinaryCascade::Capture(), G4BinaryCascade::CorrectShortlivedPrimaryForFermi(), G4BinaryCascade::FindLateParticleCollision(), G4BinaryCascade::PrintKTVector(), G4BinaryCascade::StepParticlesOut(), and G4RKPropagation::Transport().

GetTrackingMomentum()

const G4LorentzVector & G4KineticTrack::GetTrackingMomentum ( ) const

inline

Definition at line 248 of file G4KineticTrack.hh.

{
   return the4Momentum;
}

References the4Momentum.

Referenced by G4BinaryCascade::ApplyCollision(), G4RKPropagation::FieldTransport(), G4RKPropagation::FreeTransport(), G4KineticTrack(), G4RKPropagation::GetSphereIntersectionTimes(), G4MesonAbsorption::GetTimeToAbsorption(), G4Scatterer::GetTimeToInteraction(), operator=(), G4BinaryCascade::PrintKTVector(), G4BinaryCascade::StepParticlesOut(), and G4RKPropagation::Transport().

Hit()

void G4KineticTrack::Hit ( )

inline

Definition at line 389 of file G4KineticTrack.hh.

{
  if(theNucleon) 
  {
    theNucleon->Hit(1);
  }
}

References G4Nucleon::Hit(), and theNucleon.

Referenced by G4BinaryCascade::ApplyCollision(), and G4BinaryCascade::Capture().

IntegrandFunction1()

G4double G4KineticTrack::IntegrandFunction1 ( G4double  xmass ) const

private

Definition at line 746 of file G4KineticTrack.cc.

{
  G4double mass = theActualMass;   /* the actual mass value */
  G4double mass1 = theDaughterMass[0];
  G4double mass2 = theDaughterMass[1];
  G4double gamma2 = theDaughterWidth[1];
  
  G4double result = (1. / (2 * mass)) *
    std::sqrt(std::max((((mass * mass) - (mass1 + xmass) * (mass1 + xmass)) *
         ((mass * mass) - (mass1 - xmass) * (mass1 - xmass))),0.0)) *
    BrWig(gamma2, mass2, xmass);
  return result;
}

References BrWig(), G4INCL::Math::max(), theActualMass, theDaughterMass, and theDaughterWidth.

Referenced by IntegrateCMMomentum().

IntegrandFunction2()

G4double G4KineticTrack::IntegrandFunction2 ( G4double  xmass ) const

private

Definition at line 760 of file G4KineticTrack.cc.

{
  G4double mass = theDefinition->GetPDGMass();   /* the pole mass value */
  G4double mass1 = theDaughterMass[0];
  G4double mass2 = theDaughterMass[1];
  G4double gamma2 = theDaughterWidth[1];
  G4double result = (1. / (2 * mass)) *
    std::sqrt(std::max((((mass * mass) - (mass1 + xmass) * (mass1 + xmass)) *
         ((mass * mass) - (mass1 - xmass) * (mass1 - xmass))),0.0)) *
    BrWig(gamma2, mass2, xmass);
 return result;
}

References BrWig(), G4ParticleDefinition::GetPDGMass(), G4INCL::Math::max(), theDaughterMass, theDaughterWidth, and theDefinition.

Referenced by IntegrateCMMomentum().

IntegrandFunction3()

G4double G4KineticTrack::IntegrandFunction3 ( G4double  xmass ) const

private

Definition at line 773 of file G4KineticTrack.cc.

{
  const G4double mass =  G4KineticTrack_Gmass;   /* the actual mass value */
//  const G4double mass1 = theDaughterMass[0];
  const G4double mass2 = theDaughterMass[1];
  const G4double gamma2 = theDaughterWidth[1];
 
  const G4double result = (1. / (2 * mass)) *
    std::sqrt(((mass * mass) - (G4KineticTrack_xmass1 + xmass) * (G4KineticTrack_xmass1 + xmass)) *
     ((mass * mass) - (G4KineticTrack_xmass1 - xmass) * (G4KineticTrack_xmass1 - xmass))) *
    BrWig(gamma2, mass2, xmass);
  return result;
}

References BrWig(), G4KineticTrack_Gmass, G4KineticTrack_xmass1, theDaughterMass, and theDaughterWidth.

Referenced by IntegrandFunction4().

IntegrandFunction4()

G4double G4KineticTrack::IntegrandFunction4 ( G4double  xmass ) const

private

Definition at line 787 of file G4KineticTrack.cc.

{
  const G4double mass =  G4KineticTrack_Gmass;
  const G4double mass1 = theDaughterMass[0];
  const G4double gamma1 = theDaughterWidth[0];
//  const G4double mass2 = theDaughterMass[1];
  
  G4KineticTrack_xmass1 = xmass;
  
  const G4double theLowerLimit = 0.0;
  const G4double theUpperLimit = mass - xmass;
  const G4int nIterations = 100;
  
  G4Integrator<const G4KineticTrack, G4double(G4KineticTrack::*)(G4double) const> integral;
  G4double result = BrWig(gamma1, mass1, xmass)*
    integral.Simpson(this, &G4KineticTrack::IntegrandFunction3, theLowerLimit, theUpperLimit, nIterations);
 
  return result;
}

References BrWig(), G4KineticTrack(), G4KineticTrack_Gmass, G4KineticTrack_xmass1, IntegrandFunction3(), theDaughterMass, and theDaughterWidth.

Referenced by IntegrateCMMomentum2().

IntegrateCMMomentum() [1/2]

G4double G4KineticTrack::IntegrateCMMomentum ( const G4double  lowerLimit ) const

private

Definition at line 807 of file G4KineticTrack.cc.

{
  const G4double theUpperLimit = theActualMass - theDaughterMass[0];
  const G4int nIterations = 100;
 
  if (theLowerLimit>=theUpperLimit) return 0.0;
 
  G4Integrator<const G4KineticTrack, G4double(G4KineticTrack::*)(G4double) const> integral;
  G4double theIntegralOverMass2 = integral.Simpson(this, &G4KineticTrack::IntegrandFunction1, 
                           theLowerLimit, theUpperLimit, nIterations);
  return theIntegralOverMass2;
}

References G4KineticTrack(), IntegrandFunction1(), theActualMass, and theDaughterMass.

Referenced by G4KineticTrack().

IntegrateCMMomentum() [2/2]

G4double G4KineticTrack::IntegrateCMMomentum ( const G4double  lowerLimit, const G4double  polemass  ) const

private

Definition at line 820 of file G4KineticTrack.cc.

{
  const G4double theUpperLimit = poleMass - theDaughterMass[0];
  const G4int nIterations = 100;
  
  if (theLowerLimit>=theUpperLimit) return 0.0;
 
  G4Integrator<const G4KineticTrack, G4double(G4KineticTrack::*)(G4double) const> integral;
  const G4double theIntegralOverMass2 = integral.Simpson(this, &G4KineticTrack::IntegrandFunction2,
                            theLowerLimit, theUpperLimit, nIterations);
  return theIntegralOverMass2;
}

References G4KineticTrack(), IntegrandFunction2(), and theDaughterMass.

IntegrateCMMomentum2()

G4double G4KineticTrack::IntegrateCMMomentum2 ( ) const

private

Definition at line 834 of file G4KineticTrack.cc.

{
  const G4double theLowerLimit = 0.0;
  const G4double theUpperLimit = theActualMass;
  const G4int nIterations = 100;
  
  if (theLowerLimit>=theUpperLimit) return 0.0;
  
  G4Integrator<const G4KineticTrack, G4double(G4KineticTrack::*)(G4double) const> integral;
  G4double theIntegralOverMass2 = integral.Simpson(this, &G4KineticTrack::IntegrandFunction4,
                           theLowerLimit, theUpperLimit, nIterations);
  return theIntegralOverMass2;
}

References G4KineticTrack(), IntegrandFunction4(), and theActualMass.

Referenced by G4KineticTrack().

IsParticipant()

G4bool G4KineticTrack::IsParticipant ( ) const

inline

Definition at line 398 of file G4KineticTrack.hh.

{ 
  if(!theNucleon) return true;
  return theNucleon->AreYouHit(); 
}

References G4Nucleon::AreYouHit(), and theNucleon.

Referenced by G4BinaryCascade::PrintKTVector(), and G4BinaryCascade::ProductsAddFinalState().

operator!=() [1/2]

G4bool G4KineticTrack::operator!=

(

const G4KineticTrack &

right

)

const

Definition at line 478 of file G4KineticTrack.cc.

{
 return (this != & right);
}

operator!=() [2/2]

G4bool G4VKineticNucleon::operator!= ( const G4VKineticNucleon &  right ) const

inherited

Definition at line 53 of file G4VKineticNucleon.cc.

{
    return this != &right;
 
}

operator=()

G4KineticTrack & G4KineticTrack::operator=

(

const G4KineticTrack &

right

)

Definition at line 448 of file G4KineticTrack.cc.

{
 if (this != &right)
    {
     theDefinition = right.GetDefinition();
     theFormationTime = right.GetFormationTime();
     the4Momentum = right.the4Momentum;  
     the4Momentum = right.GetTrackingMomentum();
     theFermi3Momentum = right.theFermi3Momentum;
     theTotal4Momentum = right.theTotal4Momentum;
     theNucleon=right.theNucleon;
     theStateToNucleus=right.theStateToNucleus;
     if (theActualWidth != 0) delete [] theActualWidth;
     nChannels = right.GetnChannels();      
     theActualWidth = new G4double[nChannels];
     for (G4int i = 0; i < nChannels; ++i) theActualWidth[i] = right.theActualWidth[i];
     theCreatorModel = right.GetCreatorModelID();
    }
 return *this;
}

References GetCreatorModelID(), GetDefinition(), GetFormationTime(), GetnChannels(), GetTrackingMomentum(), nChannels, the4Momentum, theActualWidth, theCreatorModel, theDefinition, theFermi3Momentum, theFormationTime, theNucleon, theStateToNucleus, and theTotal4Momentum.

operator==() [1/2]

G4bool G4KineticTrack::operator==

(

const G4KineticTrack &

right

)

const

Definition at line 471 of file G4KineticTrack.cc.

{
 return (this == & right);
}

operator==() [2/2]

G4bool G4VKineticNucleon::operator== ( const G4VKineticNucleon &  right ) const

inherited

Definition at line 48 of file G4VKineticNucleon.cc.

{
    return this == &right;
}

SampleResidualLifetime()

G4double G4KineticTrack::SampleResidualLifetime ( )

inline

Definition at line 360 of file G4KineticTrack.hh.

{
 G4double theTotalActualWidth = this->EvaluateTotalActualWidth();
 G4double tau = CLHEP::hbar_Planck * (-1.0 / theTotalActualWidth);
 G4double theResidualLifetime = tau * G4Log(G4UniformRand());
 return theResidualLifetime*the4Momentum.gamma();
}

References EvaluateTotalActualWidth(), G4Log(), G4UniformRand, CLHEP::HepLorentzVector::gamma(), CLHEP::hbar_Planck, and the4Momentum.

Referenced by G4BCDecay::GetCollisions().

Set4Momentum()

void G4KineticTrack::Set4Momentum ( const G4LorentzVector &  a4Momentum )

inline

Definition at line 253 of file G4KineticTrack.hh.

{
//  set the4Momentum and update theTotal4Momentum
 
  theTotal4Momentum=a4Momentum;
  the4Momentum = theTotal4Momentum;
  theFermi3Momentum=G4LorentzVector(0);
}

References the4Momentum, theFermi3Momentum, and theTotal4Momentum.

Referenced by G4BinaryCascade::ApplyCollision(), G4KineticTrackVector::Boost(), G4KineticTrackVector::BoostBeam(), G4CollisionNN::CrossSection(), G4VElasticCollision::FinalState(), G4QGSMFragmentation::FragmentString(), G4KineticTrack(), G4LundStringFragmentation::Loop_toFragmentString(), G4ExcitedString::LorentzRotate(), G4ExcitedString::TransformToCenterOfMass(), and Update4Momentum().

SetActualWidth()

void G4KineticTrack::SetActualWidth ( G4double *  anActualWidth )

inlineprivate

Definition at line 342 of file G4KineticTrack.hh.

{
  theActualWidth = anActualWidth;
}

References theActualWidth.

SetCreatorModelID()

void G4KineticTrack::SetCreatorModelID ( G4int  id )

inline

Definition at line 430 of file G4KineticTrack.hh.

{
        theCreatorModel = id;
}

References theCreatorModel.

Referenced by Decay(), G4DecayKineticTracks::Decay(), G4GeneratorPrecompoundInterface::MakeCoalescence(), and G4QuasiElasticChannel::Scatter().

SetDefinition()

void G4KineticTrack::SetDefinition ( const G4ParticleDefinition *  aDefinition )

inline

Definition at line 218 of file G4KineticTrack.hh.

{
  theDefinition = aDefinition;
}

References theDefinition.

SetFormationTime()

void G4KineticTrack::SetFormationTime ( G4double  aFormationTime )

inline

Definition at line 228 of file G4KineticTrack.hh.

{
  theFormationTime = aFormationTime;
}

References theFormationTime.

Referenced by G4QGSMFragmentation::FragmentString(), and G4LundStringFragmentation::Loop_toFragmentString().

SetnChannels()

void G4KineticTrack::SetnChannels ( const G4int  aChannel )

inlineprivate

Definition at line 332 of file G4KineticTrack.hh.

{
  nChannels = numberOfChannels;
}

References nChannels.

SetNucleon()

void G4KineticTrack::SetNucleon ( G4Nucleon *  aN )

inline

Definition at line 105 of file G4KineticTrack.hh.

{theNucleon = aN;}

References theNucleon.

Referenced by G4BinaryCascade::BuildTargetList().

SetPosition()

void G4KineticTrack::SetPosition ( const G4ThreeVector  aPosition )

inline

Definition at line 238 of file G4KineticTrack.hh.

{
  thePosition = aPosition;
}

References thePosition.

Referenced by G4RKPropagation::FieldTransport(), G4QGSMFragmentation::FragmentString(), G4ExcitedStringDecay::FragmentStrings(), G4RKPropagation::FreeTransport(), G4RKFieldIntegrator::Integrate(), G4LundStringFragmentation::Loop_toFragmentString(), and G4KineticTrackVector::Shift().

SetProjectilePotential()

void G4KineticTrack::SetProjectilePotential ( const G4double  aPotential )

inline

Definition at line 419 of file G4KineticTrack.hh.

{
    theProjectilePotential = aPotential;
}

References theProjectilePotential.

Referenced by G4BinaryLightIonReaction::Interact().

SetState()

G4KineticTrack::CascadeState G4KineticTrack::SetState ( const CascadeState  new_state )

inline

Definition at line 411 of file G4KineticTrack.hh.

{
    CascadeState old_state=theStateToNucleus;
    theStateToNucleus=new_state;
    return old_state;
}

References theStateToNucleus.

Referenced by G4BinaryCascade::ApplyYourself(), G4BinaryCascade::BuildTargetList(), G4BinaryCascade::FindLateParticleCollision(), G4BinaryLightIonReaction::Interact(), and G4RKPropagation::Transport().

SetTrackingMomentum()

void G4KineticTrack::SetTrackingMomentum ( const G4LorentzVector &  a4Momentum )

inline

Definition at line 286 of file G4KineticTrack.hh.

{
//  set the4Momentum and update theTotal4Momentum, keep the mass of aMomentum
 
  the4Momentum = aMomentum;
  theTotal4Momentum=the4Momentum+theFermi3Momentum;
//     keep mass of aMomentum for the total momentum
  G4double mass2 = aMomentum.mag2();
  G4double p2=theTotal4Momentum.vect().mag2();
  theTotal4Momentum.setE(std::sqrt(mass2+p2));
}

References CLHEP::HepLorentzVector::mag2(), CLHEP::Hep3Vector::mag2(), CLHEP::HepLorentzVector::setE(), the4Momentum, theFermi3Momentum, theTotal4Momentum, and CLHEP::HepLorentzVector::vect().

Referenced by G4RKPropagation::FieldTransport(), G4RKPropagation::Transport(), and UpdateTrackingMomentum().

Update4Momentum() [1/2]

void G4KineticTrack::Update4Momentum ( const G4ThreeVector &  aMomentum )

inline

Definition at line 278 of file G4KineticTrack.hh.

{
// update the4Momentum with aMomentum at constant mass (the4Momentum.mag()  
//   updates theTotal4Momentum as well.
  G4double newE=std::sqrt(theTotal4Momentum.mag2() + aMomentum.mag2());
  Set4Momentum(G4LorentzVector(aMomentum, newE));
}

References CLHEP::HepLorentzVector::mag2(), CLHEP::Hep3Vector::mag2(), Set4Momentum(), and theTotal4Momentum.

Update4Momentum() [2/2]

void G4KineticTrack::Update4Momentum ( G4double  aEnergy )

inline

Definition at line 262 of file G4KineticTrack.hh.

{
// update the4Momentum with aEnergy at constant mass (the4Momentum.mag()  
//   updates theTotal4Momentum as well.
  G4double newP(0);
  G4double mass2=theTotal4Momentum.mag2();
  if ( sqr(aEnergy) > mass2 )
  {
      newP = std::sqrt(sqr(aEnergy) - mass2 );
  } else
  {
      aEnergy=std::sqrt(mass2);
  }
  Set4Momentum(G4LorentzVector(newP*the4Momentum.vect().unit(), aEnergy));
}

References CLHEP::HepLorentzVector::mag2(), Set4Momentum(), sqr(), the4Momentum, theTotal4Momentum, CLHEP::Hep3Vector::unit(), and CLHEP::HepLorentzVector::vect().

Referenced by G4BinaryCascade::CorrectShortlivedPrimaryForFermi().

UpdateTrackingMomentum() [1/2]

void G4KineticTrack::UpdateTrackingMomentum ( const G4ThreeVector &  aMomentum )

inline

Definition at line 314 of file G4KineticTrack.hh.

{
// update the4Momentum with aMomentum at constant mass (the4Momentum.mag()  
//   updates theTotal4Momentum as well.
  G4double newE=std::sqrt(theTotal4Momentum.mag2() + aMomentum.mag2());
  SetTrackingMomentum(G4LorentzVector(aMomentum, newE));
}

References CLHEP::HepLorentzVector::mag2(), CLHEP::Hep3Vector::mag2(), SetTrackingMomentum(), and theTotal4Momentum.

UpdateTrackingMomentum() [2/2]

void G4KineticTrack::UpdateTrackingMomentum ( G4double  aEnergy )

inline

Definition at line 298 of file G4KineticTrack.hh.

{
// update the4Momentum with aEnergy at constant mass (the4Momentum.mag()  
//   updates theTotal4Momentum as well.
  G4double newP(0);
  G4double mass2=theTotal4Momentum.mag2();
  if ( sqr(aEnergy) > mass2 )
  {
      newP = std::sqrt(sqr(aEnergy) - mass2 );
  } else
  {
      aEnergy=std::sqrt(mass2);
  }
  SetTrackingMomentum(G4LorentzVector(newP*the4Momentum.vect().unit(), aEnergy));
}

References CLHEP::HepLorentzVector::mag2(), SetTrackingMomentum(), sqr(), the4Momentum, theTotal4Momentum, CLHEP::Hep3Vector::unit(), and CLHEP::HepLorentzVector::vect().

Field Documentation

nChannels

G4int G4KineticTrack::nChannels

private

Definition at line 177 of file G4KineticTrack.hh.

Referenced by Decay(), EvaluateTotalActualWidth(), G4KineticTrack(), GetnChannels(), operator=(), and SetnChannels().

the4Momentum

G4LorentzVector G4KineticTrack::the4Momentum

private

Definition at line 171 of file G4KineticTrack.hh.

Referenced by G4KineticTrack(), GetActualMass(), GetTrackingMomentum(), operator=(), SampleResidualLifetime(), Set4Momentum(), SetTrackingMomentum(), Update4Momentum(), and UpdateTrackingMomentum().

theActualMass

G4double G4KineticTrack::theActualMass

private

Definition at line 179 of file G4KineticTrack.hh.

Referenced by G4KineticTrack(), IntegrandFunction1(), IntegrateCMMomentum(), and IntegrateCMMomentum2().

theActualWidth

G4double* G4KineticTrack::theActualWidth

private

Definition at line 181 of file G4KineticTrack.hh.

Referenced by Decay(), EvaluateTotalActualWidth(), G4KineticTrack(), GetActualWidth(), operator=(), SetActualWidth(), and ~G4KineticTrack().

theCreatorModel

G4int G4KineticTrack::theCreatorModel

private

Definition at line 192 of file G4KineticTrack.hh.

Referenced by G4KineticTrack(), GetCreatorModelID(), operator=(), and SetCreatorModelID().

theDaughterMass

G4double* G4KineticTrack::theDaughterMass

private

Definition at line 185 of file G4KineticTrack.hh.

Referenced by G4KineticTrack(), IntegrandFunction1(), IntegrandFunction2(), IntegrandFunction3(), IntegrandFunction4(), IntegrateCMMomentum(), and ~G4KineticTrack().

theDaughterWidth

G4double* G4KineticTrack::theDaughterWidth

private

Definition at line 186 of file G4KineticTrack.hh.

Referenced by G4KineticTrack(), IntegrandFunction1(), IntegrandFunction2(), IntegrandFunction3(), IntegrandFunction4(), and ~G4KineticTrack().

theDefinition

const G4ParticleDefinition* G4KineticTrack::theDefinition

private

Definition at line 165 of file G4KineticTrack.hh.

Referenced by Decay(), G4KineticTrack(), GetDefinition(), IntegrandFunction2(), operator=(), and SetDefinition().

theFermi3Momentum

G4LorentzVector G4KineticTrack::theFermi3Momentum

private

Definition at line 172 of file G4KineticTrack.hh.

Referenced by G4KineticTrack(), operator=(), Set4Momentum(), and SetTrackingMomentum().

theFormationTime

G4double G4KineticTrack::theFormationTime

private

Definition at line 167 of file G4KineticTrack.hh.

Referenced by G4KineticTrack(), GetFormationTime(), operator=(), and SetFormationTime().

theNucleon

G4Nucleon* G4KineticTrack::theNucleon

private

Definition at line 175 of file G4KineticTrack.hh.

Referenced by G4KineticTrack(), Hit(), IsParticipant(), operator=(), and SetNucleon().

thePosition

G4ThreeVector G4KineticTrack::thePosition

private

Definition at line 169 of file G4KineticTrack.hh.

Referenced by G4KineticTrack(), GetPosition(), and SetPosition().

theProjectilePotential

G4double G4KineticTrack::theProjectilePotential

private

Definition at line 190 of file G4KineticTrack.hh.

Referenced by G4KineticTrack(), GetProjectilePotential(), and SetProjectilePotential().

theStateToNucleus

CascadeState G4KineticTrack::theStateToNucleus

private

Definition at line 188 of file G4KineticTrack.hh.

Referenced by G4KineticTrack(), GetState(), operator=(), and SetState().

theTotal4Momentum

G4LorentzVector G4KineticTrack::theTotal4Momentum

private

Definition at line 173 of file G4KineticTrack.hh.

Referenced by G4KineticTrack(), Get4Momentum(), operator=(), Set4Momentum(), SetTrackingMomentum(), Update4Momentum(), and UpdateTrackingMomentum().

---

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

• source/processes/hadronic/util/include/G4KineticTrack.hh
• source/processes/hadronic/util/src/G4KineticTrack.cc