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
	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)
	~G4KineticTrack ()
G4KineticTrack &	operator= (const G4KineticTrack &right)
G4bool	operator== (const G4KineticTrack &right) const
G4bool	operator!= (const G4KineticTrack &right) const
const G4ParticleDefinition *	GetDefinition () const
void	SetDefinition (const G4ParticleDefinition *aDefinition)
G4double	GetFormationTime () const
void	SetFormationTime (G4double aFormationTime)
const G4ThreeVector &	GetPosition () const
void	SetPosition (const G4ThreeVector aPosition)
const G4LorentzVector &	Get4Momentum () const
void	Set4Momentum (const G4LorentzVector &a4Momentum)
void	Update4Momentum (G4double aEnergy)
void	Update4Momentum (const G4ThreeVector &aMomentum)
void	SetTrackingMomentum (const G4LorentzVector &a4Momentum)
void	UpdateTrackingMomentum (G4double aEnergy)
void	UpdateTrackingMomentum (const G4ThreeVector &aMomentum)
const G4LorentzVector &	GetTrackingMomentum () const
G4double	SampleResidualLifetime ()
void	Hit ()
void	SetNucleon (G4Nucleon *aN)
G4bool	IsParticipant () const
G4KineticTrackVector *	Decay ()
G4double *	GetActualWidth () const
G4double	GetActualMass () const
G4int	GetnChannels () const
CascadeState	SetState (const CascadeState new_state)
CascadeState	GetState () const
void	SetProjectilePotential (const G4double aPotential)
G4double	GetProjectilePotential () const
void	SetCreatorModelID (G4int id)
G4int	GetCreatorModelID () const
const G4ParticleDefinition *	GetParentResonanceDef () const
void	SetParentResonanceDef (const G4ParticleDefinition *parent)
G4int	GetParentResonanceID () const
void	SetParentResonanceID (const G4int parentID)
G4double	BrWig (const G4double Gamma, const G4double rmass, const G4double mass) const
Public Member Functions inherited from G4VKineticNucleon
	G4VKineticNucleon ()
	G4VKineticNucleon (const G4VKineticNucleon &right)
virtual	~G4VKineticNucleon ()
const G4VKineticNucleon &	operator= (const G4VKineticNucleon &right)
G4bool	operator== (const G4VKineticNucleon &right) const
G4bool	operator!= (const G4VKineticNucleon &right) const

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),
                theParentResonanceDef(nullptr),
                theParentResonanceID(0)
{
////////////////
//    DEBUG   //
////////////////
 
/*
 G4cerr << G4endl << G4endl << G4endl;
 G4cerr << "   G4KineticTrack default constructor invoked! \n";
 G4cerr << "   =========================================== \n" << G4endl;
*/
}

Referenced by Decay().

G4KineticTrack() [2/4]

G4KineticTrack::G4KineticTrack

(

const G4KineticTrack &

right

)

Definition at line 103 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();
 theParentResonanceDef = right.GetParentResonanceDef();
 theParentResonanceID = right.GetParentResonanceID();
 
////////////////
//    DEBUG   //
////////////////
 
/*
 G4cerr << G4endl << G4endl << G4endl;
 G4cerr << "   G4KineticTrack copy constructor invoked! \n";
 G4cerr << "   ======================================== \n" <<G4endl;
*/
}

G4KineticTrack() [3/4]

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

Definition at line 143 of file G4KineticTrack.cc.

                                                                  :
                theDefinition(aDefinition),
        theFormationTime(aFormationTime),
                thePosition(aPosition),
                the4Momentum(a4Momentum),
        theFermi3Momentum(0),
        theTotal4Momentum(a4Momentum),
        theNucleon(0),
        theStateToNucleus(undefined),
        theProjectilePotential(0),
                theCreatorModel(-1),
                theParentResonanceDef(nullptr),
                theParentResonanceID(0)
{
  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;
 */
 
}

G4KineticTrack() [4/4]

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

Definition at line 423 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),
        theParentResonanceDef(nullptr),
        theParentResonanceID(0) 
{
    theFermi3Momentum.setE(0);
    Set4Momentum(a4Momentum);
}

~G4KineticTrack()

G4KineticTrack::~G4KineticTrack

(

)

Definition at line 448 of file G4KineticTrack.cc.

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

Member Function Documentation

BrWig()

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

inline

Definition at line 390 of file G4KineticTrack.hh.

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

Decay()

G4KineticTrackVector * G4KineticTrack::Decay ( )

virtual

Reimplemented from G4VKineticNucleon.

Definition at line 496 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;
     // Use the integer round mass in keV to get an unique ID for the parent resonance
     G4int uniqueID = static_cast< G4int >( round( Get4Momentum().mag() / CLHEP::keV ) );
     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());
             aDaughter->SetParentResonanceDef(GetDefinition());
             aDaughter->SetParentResonanceID(uniqueID);
           }
         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;
    }
}

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

Get4Momentum()

const G4LorentzVector & G4KineticTrack::Get4Momentum ( ) const

inlinevirtual

Implements G4VKineticNucleon.

Definition at line 251 of file G4KineticTrack.hh.

{
  return theTotal4Momentum;
}

Referenced by G4CollisionManager::AddCollision(), G4KineticTrackVector::Boost(), G4KineticTrackVector::BoostBeam(), 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(), G4DecayKineticTracks::Decay(), Decay(), G4VXResonance::DetailedBalance(), G4VAnnihilationCollision::FinalState(), G4VElasticCollision::FinalState(), G4VScatteringCollision::FinalState(), G4Absorber::FindProducts(), G4QGSMFragmentation::FragmentString(), G4ExcitedString::Get4Momentum(), G4MesonAbsorption::GetFinalState(), G4Scatterer::GetTimeToInteraction(), G4ExcitedString::LorentzRotate(), G4GeneratorPrecompoundInterface::MakeCoalescence(), G4VCrossSectionSource::PrintAll(), G4IntraNucleiCascader::processSecondary(), G4CascadeInterface::Propagate(), G4DecayStrongResonances::Propagate(), G4IntraNucleiCascader::releaseSecondary(), G4Scatterer::Scatter(), G4CrossSectionPatch::Transition(), and G4Absorber::WillBeAbsorbed().

GetActualMass()

G4double G4KineticTrack::GetActualMass ( ) const

inline

Definition at line 330 of file G4KineticTrack.hh.

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

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

GetActualWidth()

G4double * G4KineticTrack::GetActualWidth ( ) const

inline

Definition at line 345 of file G4KineticTrack.hh.

{
  return theActualWidth;
}

GetCreatorModelID()

G4int G4KineticTrack::GetCreatorModelID ( ) const

inline

Definition at line 443 of file G4KineticTrack.hh.

{
       return theCreatorModel;
}

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

GetDefinition()

const G4ParticleDefinition * G4KineticTrack::GetDefinition ( ) const

inlinevirtual

Implements G4VKineticNucleon.

Definition at line 221 of file G4KineticTrack.hh.

{
  return theDefinition;
}

Referenced by G4CollisionManager::AddCollision(), G4KineticTrackVector::BoostBeam(), G4CollisionComposite::CrossSection(), G4CollisionNN::CrossSection(), G4XAnnihilationChannel::CrossSection(), G4XAqmTotal::CrossSection(), G4XnpElasticLowE::CrossSection(), G4XnpTotalLowE::CrossSection(), G4XPDGElastic::CrossSection(), G4XPDGTotal::CrossSection(), G4XResonance::CrossSection(), G4DecayKineticTracks::Decay(), Decay(), G4VXResonance::DegeneracyFactor(), G4VXResonance::DetailedBalance(), G4VElasticCollision::FinalState(), G4VScatteringCollision::FinalState(), G4Absorber::FindAbsorbers(), G4VCrossSectionSource::FindKeyParticle(), G4VCrossSectionSource::FindLightParticle(), G4Absorber::FindProducts(), G4QGSMFragmentation::FragmentString(), G4ExcitedStringDecay::FragmentStrings(), G4KineticTrack(), G4BCDecay::GetCollisions(), G4MesonAbsorption::GetFinalState(), G4ParticleTypeConverter::GetGenericType(), G4ConcreteMesonBaryonToResonance::GetOutgoingParticle(), G4Scatterer::GetTimeToInteraction(), G4CollisionMesonBaryonElastic::IsInCharge(), G4CollisionNNElastic::IsInCharge(), G4CollisionnpElastic::IsInCharge(), G4ConcreteNNTwoBodyResonance::IsInCharge(), G4GeneralNNCollision::IsInCharge(), G4VXResonance::IsospinCorrection(), G4GeneratorPrecompoundInterface::MakeCoalescence(), operator=(), G4CollisionInitialState::Print(), G4CollisionManager::Print(), G4IntraNucleiCascader::processSecondary(), G4CascadeInterface::Propagate(), G4DecayStrongResonances::Propagate(), G4IntraNucleiCascader::releaseSecondary(), G4Scatterer::Scatter(), G4RKPropagation::Transport(), and G4Absorber::WillBeAbsorbed().

GetFormationTime()

G4double G4KineticTrack::GetFormationTime ( ) const

inline

Definition at line 231 of file G4KineticTrack.hh.

{
  return theFormationTime;
}

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

GetnChannels()

G4int G4KineticTrack::GetnChannels ( ) const

inline

Definition at line 335 of file G4KineticTrack.hh.

{
  return nChannels;
}

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

GetParentResonanceDef()

const G4ParticleDefinition * G4KineticTrack::GetParentResonanceDef ( ) const

inline

Definition at line 449 of file G4KineticTrack.hh.

{
        return theParentResonanceDef;
}

Referenced by G4KineticTrack(), operator=(), and G4DecayStrongResonances::Propagate().

GetParentResonanceID()

G4int G4KineticTrack::GetParentResonanceID ( ) const

inline

Definition at line 461 of file G4KineticTrack.hh.

{
        return theParentResonanceID;
}

Referenced by G4KineticTrack(), operator=(), and G4DecayStrongResonances::Propagate().

GetPosition()

const G4ThreeVector & G4KineticTrack::GetPosition ( ) const

inlinevirtual

Implements G4VKineticNucleon.

Definition at line 241 of file G4KineticTrack.hh.

{
  return thePosition;
}

Referenced by G4XMesonBaryonElastic::CrossSection(), Decay(), G4VAnnihilationCollision::FinalState(), G4VScatteringCollision::FinalState(), G4Absorber::FindAbsorbers(), G4Absorber::FindProducts(), G4QGSMFragmentation::FragmentString(), G4ExcitedString::G4ExcitedString(), G4KineticTrack(), G4RKPropagation::GetSphereIntersectionTimes(), G4Scatterer::GetTimeToInteraction(), G4GeneratorPrecompoundInterface::MakeCoalescence(), G4IntraNucleiCascader::processSecondary(), G4CascadeInterface::Propagate(), G4KineticTrackVector::Shift(), and G4RKPropagation::Transport().

GetProjectilePotential()

G4double G4KineticTrack::GetProjectilePotential ( ) const

inline

Definition at line 432 of file G4KineticTrack.hh.

{
    return theProjectilePotential;
}

Referenced by G4RKPropagation::Transport().

GetState()

G4KineticTrack::CascadeState G4KineticTrack::GetState ( ) const

inline

Definition at line 413 of file G4KineticTrack.hh.

{
    return theStateToNucleus;
}

Referenced by G4RKPropagation::Transport().

GetTrackingMomentum()

const G4LorentzVector & G4KineticTrack::GetTrackingMomentum ( ) const

inline

Definition at line 256 of file G4KineticTrack.hh.

{
   return the4Momentum;
}

Referenced by G4KineticTrack(), G4RKPropagation::GetSphereIntersectionTimes(), G4Scatterer::GetTimeToInteraction(), operator=(), and G4RKPropagation::Transport().

Hit()

void G4KineticTrack::Hit ( )

inline

Definition at line 397 of file G4KineticTrack.hh.

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

IsParticipant()

G4bool G4KineticTrack::IsParticipant ( ) const

inline

Definition at line 406 of file G4KineticTrack.hh.

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

operator!=()

G4bool G4KineticTrack::operator!=

(

const G4KineticTrack &

right

)

const

Definition at line 489 of file G4KineticTrack.cc.

{
 return (this != & right);
}

operator=()

G4KineticTrack & G4KineticTrack::operator=

(

const G4KineticTrack &

right

)

Definition at line 457 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();
     theParentResonanceDef = right.GetParentResonanceDef();
     theParentResonanceID = right.GetParentResonanceID();
    }
 return *this;
}

operator==()

G4bool G4KineticTrack::operator==

(

const G4KineticTrack &

right

)

const

Definition at line 482 of file G4KineticTrack.cc.

{
 return (this == & right);
}

SampleResidualLifetime()

G4double G4KineticTrack::SampleResidualLifetime ( )

inline

Definition at line 368 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();
}

Referenced by G4BCDecay::GetCollisions().

Set4Momentum()

void G4KineticTrack::Set4Momentum ( const G4LorentzVector & a4Momentum )

inline

Definition at line 261 of file G4KineticTrack.hh.

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

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

SetCreatorModelID()

void G4KineticTrack::SetCreatorModelID ( G4int id )

inline

Definition at line 438 of file G4KineticTrack.hh.

{
        theCreatorModel = id;
}

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

SetDefinition()

void G4KineticTrack::SetDefinition ( const G4ParticleDefinition * aDefinition )

inline

Definition at line 226 of file G4KineticTrack.hh.

{
  theDefinition = aDefinition;
}

SetFormationTime()

void G4KineticTrack::SetFormationTime ( G4double aFormationTime )

inline

Definition at line 236 of file G4KineticTrack.hh.

{
  theFormationTime = aFormationTime;
}

Referenced by G4QGSMFragmentation::FragmentString().

SetNucleon()

void G4KineticTrack::SetNucleon ( G4Nucleon * aN )

inline

Definition at line 105 of file G4KineticTrack.hh.

{theNucleon = aN;}

SetParentResonanceDef()

void G4KineticTrack::SetParentResonanceDef ( const G4ParticleDefinition * parent )

inline

Definition at line 455 of file G4KineticTrack.hh.

{
        theParentResonanceDef = parentDef;
}

Referenced by G4DecayKineticTracks::Decay(), and Decay().

SetParentResonanceID()

void G4KineticTrack::SetParentResonanceID ( const G4int parentID )

inline

Definition at line 467 of file G4KineticTrack.hh.

{
        theParentResonanceID = parentID;
}

Referenced by G4DecayKineticTracks::Decay(), and Decay().

SetPosition()

void G4KineticTrack::SetPosition ( const G4ThreeVector aPosition )

inline

Definition at line 246 of file G4KineticTrack.hh.

{
  thePosition = aPosition;
}

Referenced by G4QGSMFragmentation::FragmentString(), G4ExcitedStringDecay::FragmentStrings(), and G4KineticTrackVector::Shift().

SetProjectilePotential()

void G4KineticTrack::SetProjectilePotential ( const G4double aPotential )

inline

Definition at line 427 of file G4KineticTrack.hh.

{
    theProjectilePotential = aPotential;
}

SetState()

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

inline

Definition at line 419 of file G4KineticTrack.hh.

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

Referenced by G4BinaryCascade::ApplyYourself(), and G4RKPropagation::Transport().

SetTrackingMomentum()

void G4KineticTrack::SetTrackingMomentum ( const G4LorentzVector & a4Momentum )

inline

Definition at line 294 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));
}

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

Update4Momentum() [1/2]

void G4KineticTrack::Update4Momentum ( const G4ThreeVector & aMomentum )

inline

Definition at line 286 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));
}

Update4Momentum() [2/2]

void G4KineticTrack::Update4Momentum ( G4double aEnergy )

inline

Definition at line 270 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));
}

UpdateTrackingMomentum() [1/2]

void G4KineticTrack::UpdateTrackingMomentum ( const G4ThreeVector & aMomentum )

inline

Definition at line 322 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));
}

UpdateTrackingMomentum() [2/2]

void G4KineticTrack::UpdateTrackingMomentum ( G4double aEnergy )

inline

Definition at line 306 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));
}

---

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

• G4KineticTrack.hh
• G4KineticTrack.cc