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
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
virtual G4KineticTrackVector *	Decay ()
virtual const G4LorentzVector &	Get4Momentum () const =0
virtual const G4ParticleDefinition *	GetDefinition () const =0
virtual const G4ThreeVector &	GetPosition () const =0

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

G4KineticTrack() [2/4]

G4KineticTrack::G4KineticTrack

(

const G4KineticTrack &

right

)

Definition at line 100 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;
 
////////////////
//    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 137 of file G4KineticTrack.cc.

                                                                  :
                theDefinition(aDefinition),
        theFormationTime(aFormationTime),
                thePosition(aPosition),
                the4Momentum(a4Momentum),
        theFermi3Momentum(0),
        theTotal4Momentum(a4Momentum),
        theNucleon(0),
        theStateToNucleus(undefined),
        theProjectilePotential(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 414 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)
{
    theFermi3Momentum.setE(0);
    Set4Momentum(a4Momentum);
}

~G4KineticTrack()

G4KineticTrack::~G4KineticTrack

(

)

Definition at line 436 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 378 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 481 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
//
     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;
         theDecayProductList->push_back(new G4KineticTrack (aProduct,
                                                         formationTime,
                                                         position,
                                                         momentum));
         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(), G4QMDCollision::CalKinematicsOfBinaryCollisions(), G4DecayKineticTracks::Decay(), G4NeutrinoNucleusModel::FinalBarion(), G4NeutrinoNucleusModel::FinalMeson(), and G4BCDecay::GetFinalState().

Get4Momentum()

const G4LorentzVector & G4KineticTrack::Get4Momentum ( ) const

inlinevirtual

Implements G4VKineticNucleon.

Definition at line 239 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(), 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(), G4DecayStrongResonances::Propagate(), G4CascadeInterface::Propagate(), G4IntraNucleiCascader::releaseSecondary(), G4Scatterer::Scatter(), G4CrossSectionPatch::Transition(), and G4Absorber::WillBeAbsorbed().

GetActualMass()

G4double G4KineticTrack::GetActualMass ( ) const

inline

Definition at line 318 of file G4KineticTrack.hh.

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

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

GetActualWidth()

G4double * G4KineticTrack::GetActualWidth ( ) const

inline

Definition at line 333 of file G4KineticTrack.hh.

{
  return theActualWidth;
}

GetDefinition()

const G4ParticleDefinition * G4KineticTrack::GetDefinition ( ) const

inlinevirtual

Implements G4VKineticNucleon.

Definition at line 209 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(), Decay(), G4DecayKineticTracks::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=(), G4CollisionManager::Print(), G4CollisionInitialState::Print(), G4IntraNucleiCascader::processSecondary(), G4DecayStrongResonances::Propagate(), G4CascadeInterface::Propagate(), G4IntraNucleiCascader::releaseSecondary(), G4Scatterer::Scatter(), G4RKPropagation::Transport(), and G4Absorber::WillBeAbsorbed().

GetFormationTime()

G4double G4KineticTrack::GetFormationTime ( ) const

inline

Definition at line 219 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 323 of file G4KineticTrack.hh.

{
  return nChannels;
}

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

GetPosition()

const G4ThreeVector & G4KineticTrack::GetPosition ( ) const

inlinevirtual

Implements G4VKineticNucleon.

Definition at line 229 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 420 of file G4KineticTrack.hh.

{
    return theProjectilePotential;
}

Referenced by G4RKPropagation::Transport().

GetState()

G4KineticTrack::CascadeState G4KineticTrack::GetState ( ) const

inline

Definition at line 401 of file G4KineticTrack.hh.

{
    return theStateToNucleus;
}

Referenced by G4RKPropagation::Transport().

GetTrackingMomentum()

const G4LorentzVector & G4KineticTrack::GetTrackingMomentum ( ) const

inline

Definition at line 244 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 385 of file G4KineticTrack.hh.

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

IsParticipant()

G4bool G4KineticTrack::IsParticipant ( ) const

inline

Definition at line 394 of file G4KineticTrack.hh.

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

operator!=()

G4bool G4KineticTrack::operator!=

(

const G4KineticTrack &

right

)

const

Definition at line 474 of file G4KineticTrack.cc.

{
 return (this != & right);
}

operator=()

G4KineticTrack & G4KineticTrack::operator=

(

const G4KineticTrack &

right

)

Definition at line 445 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];
    }
 return *this;
}

operator==()

G4bool G4KineticTrack::operator==

(

const G4KineticTrack &

right

)

const

Definition at line 467 of file G4KineticTrack.cc.

{
 return (this == & right);
}

SampleResidualLifetime()

G4double G4KineticTrack::SampleResidualLifetime ( )

inline

Definition at line 356 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 249 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(), and Update4Momentum().

SetDefinition()

void G4KineticTrack::SetDefinition ( const G4ParticleDefinition *  aDefinition )

inline

Definition at line 214 of file G4KineticTrack.hh.

{
  theDefinition = aDefinition;
}

SetFormationTime()

void G4KineticTrack::SetFormationTime ( G4double  aFormationTime )

inline

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

SetPosition()

void G4KineticTrack::SetPosition ( const G4ThreeVector  aPosition )

inline

Definition at line 234 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 415 of file G4KineticTrack.hh.

{
    theProjectilePotential = aPotential;
}

SetState()

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

inline

Definition at line 407 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 282 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(), and UpdateTrackingMomentum().

Update4Momentum() [1/2]

void G4KineticTrack::Update4Momentum ( const G4ThreeVector &  aMomentum )

inline

Definition at line 274 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 258 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 310 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 294 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