G4KineticTrack Class Reference

#include <G4KineticTrack.hh>

Inheritance diagram for G4KineticTrack:

Collaboration 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)
G4int	operator== (const G4KineticTrack &right) const
G4int	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)
int	operator== (const G4VKineticNucleon &right) const
int	operator!= (const G4VKineticNucleon &right) const

Detailed Description

Definition at line 57 of file G4KineticTrack.hh.

Member Enumeration Documentation

enum G4KineticTrack::CascadeState

Enumerator
undefined
outside
going_in
inside
going_out
gone_out
captured
miss_nucleus

Definition at line 119 of file G4KineticTrack.hh.

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

Constructor & Destructor Documentation

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::G4KineticTrack

(

const G4KineticTrack &

right

)

Definition at line 100 of file G4KineticTrack.cc.

                                                          : G4VKineticNucleon()
{
 G4int i;
 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 (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;
*/
}

Here is the call graph for this function:

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)
{
  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];
          G4int n;
          for (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;
 */

}

Here is the call graph for this function:

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)
{
    theFermi3Momentum.setE(0);
    Set4Momentum(a4Momentum);
}

Here is the call graph for this function:

G4KineticTrack::~G4KineticTrack

(

)

Definition at line 438 of file G4KineticTrack.cc.

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

Member Function Documentation

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

inline

Definition at line 379 of file G4KineticTrack.hh.

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

G4KineticTrackVector * G4KineticTrack::Decay ( )

virtual

Reimplemented from G4VKineticNucleon.

Definition at line 486 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 definiton 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 {       

       G4int index;
       G4double theSumActualWidth = 0.0;
       G4double* theCumActualWidth = new G4double[nChannels];
       for (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 (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[index];
       //     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(getenv("DecayEnergyBalanceCheck"))
       std::cout << "DEBUGGING energy balance in cms and lab, charge baryon balance : "
                 << momentumBalanceCMS << " " 
             <<energyMomentumBalance << " " 
             <<chargeBalance<<" "
             <<baryonBalance<<" "
             <<G4endl;
     return theDecayProductList;
    }
 else
    {
     return 0;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

const G4LorentzVector & G4KineticTrack::Get4Momentum ( ) const

inlinevirtual

Implements G4VKineticNucleon.

Definition at line 240 of file G4KineticTrack.hh.

{
  return theTotal4Momentum;
}

Here is the caller graph for this function:

G4double G4KineticTrack::GetActualMass ( ) const

inline

Definition at line 319 of file G4KineticTrack.hh.

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

Here is the call graph for this function:

Here is the caller graph for this function:

G4double * G4KineticTrack::GetActualWidth ( ) const

inline

Definition at line 334 of file G4KineticTrack.hh.

{
  return theActualWidth;
}

const G4ParticleDefinition * G4KineticTrack::GetDefinition ( ) const

inlinevirtual

Implements G4VKineticNucleon.

Definition at line 210 of file G4KineticTrack.hh.

{
  return theDefinition;
}

Here is the caller graph for this function:

G4double G4KineticTrack::GetFormationTime ( ) const

inline

Definition at line 220 of file G4KineticTrack.hh.

{
  return theFormationTime;
}

Here is the caller graph for this function:

G4int G4KineticTrack::GetnChannels ( ) const

inline

Definition at line 324 of file G4KineticTrack.hh.

{
  return nChannels;
}

Here is the caller graph for this function:

const G4ThreeVector & G4KineticTrack::GetPosition ( void  ) const

inlinevirtual

Implements G4VKineticNucleon.

Definition at line 230 of file G4KineticTrack.hh.

{
  return thePosition;
}

Here is the caller graph for this function:

G4double G4KineticTrack::GetProjectilePotential ( ) const

inline

Definition at line 421 of file G4KineticTrack.hh.

{
    return theProjectilePotential;
}

Here is the caller graph for this function:

G4KineticTrack::CascadeState G4KineticTrack::GetState ( ) const

inline

Definition at line 402 of file G4KineticTrack.hh.

{
    return theStateToNucleus;
}

Here is the caller graph for this function:

const G4LorentzVector & G4KineticTrack::GetTrackingMomentum ( ) const

inline

Definition at line 245 of file G4KineticTrack.hh.

{
   return the4Momentum;
}

Here is the caller graph for this function:

void G4KineticTrack::Hit ( )

inline

Definition at line 386 of file G4KineticTrack.hh.

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

Here is the call graph for this function:

G4bool G4KineticTrack::IsParticipant ( ) const

inline

Definition at line 395 of file G4KineticTrack.hh.

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

Here is the call graph for this function:

G4int G4KineticTrack::operator!=

(

const G4KineticTrack &

right

)

const

Definition at line 479 of file G4KineticTrack.cc.

{
 return (this != & right);
}

G4KineticTrack & G4KineticTrack::operator=

(

const G4KineticTrack &

right

)

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

Here is the call graph for this function:

G4int G4KineticTrack::operator==

(

const G4KineticTrack &

right

)

const

Definition at line 472 of file G4KineticTrack.cc.

{
 return (this == & right);
}

G4double G4KineticTrack::SampleResidualLifetime ( )

inline

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4KineticTrack::Set4Momentum ( const G4LorentzVector &  a4Momentum )

inline

Definition at line 250 of file G4KineticTrack.hh.

{
//  set the4Momentum and update theTotal4Momentum

  theTotal4Momentum=a4Momentum;
  the4Momentum = theTotal4Momentum;
  theFermi3Momentum=G4LorentzVector(0);
}

Here is the caller graph for this function:

void G4KineticTrack::SetDefinition ( const G4ParticleDefinition *  aDefinition )

inline

Definition at line 215 of file G4KineticTrack.hh.

{
  theDefinition = aDefinition;
}

void G4KineticTrack::SetFormationTime ( G4double  aFormationTime )

inline

Definition at line 225 of file G4KineticTrack.hh.

{
  theFormationTime = aFormationTime;
}

Here is the caller graph for this function:

void G4KineticTrack::SetNucleon ( G4Nucleon *  aN )

inline

Definition at line 106 of file G4KineticTrack.hh.

{theNucleon = aN;}

void G4KineticTrack::SetPosition ( const G4ThreeVector  aPosition )

inline

Definition at line 235 of file G4KineticTrack.hh.

{
  thePosition = aPosition;
}

Here is the caller graph for this function:

void G4KineticTrack::SetProjectilePotential ( const G4double  aPotential )

inline

Definition at line 416 of file G4KineticTrack.hh.

{
    theProjectilePotential = aPotential;
}

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

inline

Definition at line 408 of file G4KineticTrack.hh.

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

Here is the caller graph for this function:

void G4KineticTrack::SetTrackingMomentum ( const G4LorentzVector &  a4Momentum )

inline

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4KineticTrack::Update4Momentum ( G4double  aEnergy )

inline

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

Here is the call graph for this function:

void G4KineticTrack::Update4Momentum ( const G4ThreeVector &  aMomentum )

inline

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

Here is the call graph for this function:

void G4KineticTrack::UpdateTrackingMomentum ( G4double  aEnergy )

inline

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

Here is the call graph for this function:

void G4KineticTrack::UpdateTrackingMomentum ( const G4ThreeVector &  aMomentum )

inline

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

Here is the call graph for this function:

---

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

• source/geant4.10.03.p03/source/processes/hadronic/models/util/include/G4KineticTrack.hh
• source/geant4.10.03.p03/source/processes/hadronic/models/util/src/G4KineticTrack.cc