G4KineticTrack Class Reference

#include <G4KineticTrack.hh>

Inheritance diagram for G4KineticTrack:

Public Types
	undefined
	outside
	going_in
	inside
	going_out
	gone_out
	captured
	miss_nucleus
enum	CascadeState {   undefined, outside, going_in, inside,   going_out, gone_out, captured, miss_nucleus }
Public Member Functions
	G4KineticTrack ()
	G4KineticTrack (const G4KineticTrack &right)
	G4KineticTrack (G4ParticleDefinition *aDefinition, G4double aFormationTime, G4ThreeVector aPosition, G4LorentzVector &a4Momentum)
	G4KineticTrack (G4Nucleon *nucleon, G4ThreeVector aPosition, G4LorentzVector &a4Momentum)
	~G4KineticTrack ()
G4KineticTrack &	operator= (const G4KineticTrack &right)
G4int	operator== (const G4KineticTrack &right) const
G4int	operator!= (const G4KineticTrack &right) const
G4ParticleDefinition *	GetDefinition () const
void	SetDefinition (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

---

Detailed Description

Definition at line 60 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 122 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.

References GetActualMass(), GetDefinition(), GetFormationTime(), GetnChannels(), GetPosition(), GetTrackingMomentum(), theActualWidth, theFermi3Momentum, theNucleon, theProjectilePotential, theStateToNucleus, and theTotal4Momentum.

                                                          : 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;
*/
}

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

Definition at line 138 of file G4KineticTrack.cc.

References G4AntiKaonZero::AntiKaonZero(), G4DecayTable::entries(), G4SwapObj(), G4UniformRand, GetActualMass(), G4DecayTable::GetDecayChannel(), G4ParticleDefinition::GetDecayTable(), G4SampleResonance::GetMinimumMass(), G4ParticleDefinition::GetPDGMass(), G4ParticleDefinition::GetPDGWidth(), G4ParticleDefinition::IsShortLived(), G4KaonZero::KaonZero(), G4KaonZeroLong::KaonZeroLong(), G4KaonZeroShort::KaonZeroShort(), and CLHEP::detail::n.

                                                            :
                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;
          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)
            {
              
              int 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");
//              }     
              
            }
          
          G4double l=0;
          //if(nDaughters<3) theChannel->GetAngularMomentum(); 
          G4double theMassRatio = thePoleMass / theActualMass;
          G4double theMomRatio = theActualMom / thePoleMom;
          theActualWidth[index] = thePoleWidth * theMassRatio *
                                  std::pow(theMomRatio, (2 * l + 1)) *
                                  (1.2 / (1+ 0.2*std::pow(theMomRatio, (2 * l))));
          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::G4KineticTrack	(	G4Nucleon *	nucleon,
		G4ThreeVector	aPosition,
		G4LorentzVector &	a4Momentum
	)

Definition at line 413 of file G4KineticTrack.cc.

References Set4Momentum().

  :     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

(

)

Definition at line 435 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 398 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 483 of file G4KineticTrack.cc.

References G4GeneralPhaseSpaceDecay::DecayIt(), G4DecayProducts::entries(), G4cerr, G4endl, G4lrint(), G4UniformRand, G4DynamicParticle::Get4Momentum(), Get4Momentum(), GetActualMass(), G4ParticleDefinition::GetBaryonNumber(), G4VDecayChannel::GetDaughter(), G4VDecayChannel::GetDaughterName(), G4DecayTable::GetDecayChannel(), G4ParticleDefinition::GetDecayTable(), G4DynamicParticle::GetDefinition(), GetDefinition(), G4SampleResonance::GetMinimumMass(), G4VDecayChannel::GetNumberOfDaughters(), G4VDecayChannel::GetParentName(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), GetPosition(), G4DecayProducts::PopProducts(), position, and G4SampleResonance::SampleMass().

Referenced by G4QMDCollision::CalKinematicsOfBinaryCollisions(), and G4BCDecay::GetFinalState().

{
//
//   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;
*/
  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)
    {
     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);
     G4int 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;
     }
     G4String theParentName = theDecayChannel->GetParentName();
     G4double theParentMass = this->GetActualMass();
     G4double theBR = theActualWidth[index];
     //     cout << "**BR*** DECAYNEW  " << theBR << G4endl;
     G4int theNumberOfDaughters = theDecayChannel->GetNumberOfDaughters();
     G4String theDaughtersName1 = "";
     G4String theDaughtersName2 = "";
     G4String theDaughtersName3 = "";
     
     G4double masses[3]={0.,0.,0.};
     G4int shortlivedDaughters[3];
     G4int numberOfShortliveds(0);
     G4double SumLongLivedMass(0);
     for (G4int aD=0; aD < theNumberOfDaughters ; aD++)
     {
        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 = "";
            break;
         case 2:    
            theDaughtersName1 = theDecayChannel->GetDaughterName(0);        
            theDaughtersName2 = theDecayChannel->GetDaughterName(1);
            theDaughtersName3 = "";
            if (  numberOfShortliveds == 1) 
            {   G4SampleResonance aSampler;
                G4double massmax=theParentMass - SumLongLivedMass;
                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]));
                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;              
         default:    
            theDaughtersName1 = theDecayChannel->GetDaughterName(0);
            theDaughtersName2 = theDecayChannel->GetDaughterName(1);
            theDaughtersName3 = theDecayChannel->GetDaughterName(2);
            if (  numberOfShortliveds == 1) 
            {   G4SampleResonance aSampler;
                G4double massmax=theParentMass - SumLongLivedMass;
                G4ParticleDefinition * aDaughter=theDecayChannel->GetDaughter(shortlivedDaughters[0]);      
                masses[shortlivedDaughters[0]]= aSampler.SampleMass(aDaughter,massmax);
            }
            break;
        }

//      
//      Get the decay products List
//
     
     G4GeneralPhaseSpaceDecay thePhaseSpaceDecayChannel(theParentName,
                                                        theParentMass,
                                                        theBR,
                                                        theNumberOfDaughters,
                                                        theDaughtersName1,                  
                                                        theDaughtersName2,
                                                        theDaughtersName3,
                                                        masses);
     G4DecayProducts* theDecayProducts = thePhaseSpaceDecayChannel.DecayIt();
     if(!theDecayProducts)
     {
       G4cerr << "Error condition encountered in G4KineticTrack::Decay()"<<G4endl;
       G4cerr << "  phase-space decay failed."<<G4endl;
       G4cerr << "  particle was "<<thisDefinition->GetParticleName()<<G4endl;
       G4cerr << "  channel index "<< chosench << "of "<<nChannels<<"channels"<<G4endl;
       G4cerr << "  "<<theNumberOfDaughters<< " Daughter particles: "
              << theDaughtersName1<<" "<<theDaughtersName2<<" "<<theDaughtersName3<<G4endl;
       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();
     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;
    }
}

const G4LorentzVector & G4KineticTrack::Get4Momentum

(

)

const [inline, virtual]

Implements G4VKineticNucleon.

Definition at line 248 of file G4KineticTrack.hh.

Referenced by G4CollisionManager::AddCollision(), G4XResonance::CrossSection(), G4XpipNTotal::CrossSection(), G4XpimNTotal::CrossSection(), G4XPDGTotal::CrossSection(), G4XPDGElastic::CrossSection(), G4XnpTotalLowE::CrossSection(), G4XnpElasticLowE::CrossSection(), G4XNNTotalLowE::CrossSection(), G4XNNElasticLowE::CrossSection(), G4XMesonBaryonElastic::CrossSection(), G4XAnnihilationChannel::CrossSection(), G4CrossSectionPatch::CrossSection(), G4CrossSectionComposite::CrossSection(), G4CrossSectionBuffer::CrossSection(), G4CollisionNN::CrossSection(), Decay(), G4VXResonance::DetailedBalance(), G4VScatteringCollision::FinalState(), G4VElasticCollision::FinalState(), G4VAnnihilationCollision::FinalState(), G4Absorber::FindProducts(), G4MesonAbsorption::GetFinalState(), G4Scatterer::GetTimeToInteraction(), G4VCrossSectionSource::PrintAll(), G4IntraNucleiCascader::processSecondary(), G4StringChipsParticleLevelInterface::Propagate(), G4QStringChipsParticleLevelInterface::Propagate(), G4IntraNucleiCascader::releaseSecondary(), G4Scatterer::Scatter(), G4CrossSectionPatch::Transition(), and G4Absorber::WillBeAbsorbed().

{
  return theTotal4Momentum;
}

G4double G4KineticTrack::GetActualMass

(

)

const [inline]

Definition at line 330 of file G4KineticTrack.hh.

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

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

G4double * G4KineticTrack::GetActualWidth

(

)

const [inline]

Definition at line 349 of file G4KineticTrack.hh.

{
  return theActualWidth;
}

G4ParticleDefinition * G4KineticTrack::GetDefinition

(

)

const [inline, virtual]

Implements G4VKineticNucleon.

Definition at line 213 of file G4KineticTrack.hh.

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

{
  return theDefinition;
}

G4double G4KineticTrack::GetFormationTime

(

)

const [inline]

Definition at line 225 of file G4KineticTrack.hh.

Referenced by G4XMesonBaryonElastic::CrossSection(), G4ExcitedString::G4ExcitedString(), G4KineticTrack(), G4BCLateParticle::GetCollisions(), and operator=().

{
  return theFormationTime;
}

G4int G4KineticTrack::GetnChannels

(

)

const [inline]

Definition at line 337 of file G4KineticTrack.hh.

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

{
  return nChannels;
}

const G4ThreeVector & G4KineticTrack::GetPosition

(

)

const [inline, virtual]

Implements G4VKineticNucleon.

Definition at line 237 of file G4KineticTrack.hh.

Referenced by G4XMesonBaryonElastic::CrossSection(), Decay(), G4VScatteringCollision::FinalState(), G4VAnnihilationCollision::FinalState(), G4Absorber::FindAbsorbers(), G4Absorber::FindProducts(), G4ExcitedString::G4ExcitedString(), G4KineticTrack(), G4RKPropagation::GetSphereIntersectionTimes(), G4Scatterer::GetTimeToInteraction(), G4IntraNucleiCascader::processSecondary(), and G4RKPropagation::Transport().

{
  return thePosition;
}

G4double G4KineticTrack::GetProjectilePotential

(

)

const [inline]

Definition at line 440 of file G4KineticTrack.hh.

Referenced by G4RKPropagation::Transport().

{
        return theProjectilePotential;
}

G4KineticTrack::CascadeState G4KineticTrack::GetState

(

)

const [inline]

Definition at line 421 of file G4KineticTrack.hh.

Referenced by G4RKPropagation::Transport().

{
        return theStateToNucleus;
}

const G4LorentzVector & G4KineticTrack::GetTrackingMomentum

(

)

const [inline]

Definition at line 253 of file G4KineticTrack.hh.

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

{
   return the4Momentum;
}

void G4KineticTrack::Hit

(

)

[inline]

Definition at line 405 of file G4KineticTrack.hh.

References G4Nucleon::Hit().

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

G4bool G4KineticTrack::IsParticipant

(

)

const [inline]

Definition at line 414 of file G4KineticTrack.hh.

References G4Nucleon::AreYouHit().

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

G4int G4KineticTrack::operator!=

(

const G4KineticTrack &

right

)

const

Definition at line 476 of file G4KineticTrack.cc.

{
 return (this != & right);
}

G4KineticTrack & G4KineticTrack::operator=

(

const G4KineticTrack &

right

)

Definition at line 444 of file G4KineticTrack.cc.

References GetDefinition(), GetFormationTime(), GetnChannels(), GetTrackingMomentum(), the4Momentum, theActualWidth, theFermi3Momentum, theNucleon, theStateToNucleus, and theTotal4Momentum.

{
 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;
}

G4int G4KineticTrack::operator==

(

const G4KineticTrack &

right

)

const

Definition at line 469 of file G4KineticTrack.cc.

{
 return (this == & right);
}

G4double G4KineticTrack::SampleResidualLifetime

(

)

[inline]

Definition at line 374 of file G4KineticTrack.hh.

References G4UniformRand.

Referenced by G4BCDecay::GetCollisions().

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

void G4KineticTrack::Set4Momentum

(

const G4LorentzVector &

a4Momentum

)

[inline]

Definition at line 258 of file G4KineticTrack.hh.

Referenced by G4CollisionNN::CrossSection(), G4VElasticCollision::FinalState(), G4KineticTrack(), and Update4Momentum().

{
//  set the4Momentum and update theTotal4Momentum

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

void G4KineticTrack::SetDefinition

(

G4ParticleDefinition *

aDefinition

)

[inline]

Definition at line 218 of file G4KineticTrack.hh.

{
  theDefinition = aDefinition;
}

void G4KineticTrack::SetFormationTime

(

G4double

aFormationTime

)

[inline]

Definition at line 230 of file G4KineticTrack.hh.

{
  theFormationTime = aFormationTime;
}

void G4KineticTrack::SetNucleon

(

G4Nucleon *

aN

)

[inline]

Definition at line 109 of file G4KineticTrack.hh.

{theNucleon = aN;}

void G4KineticTrack::SetPosition

(

const G4ThreeVector

aPosition

)

[inline]

Definition at line 242 of file G4KineticTrack.hh.

{
  thePosition = aPosition;
}

void G4KineticTrack::SetProjectilePotential

(

const G4double

aPotential

)

[inline]

Definition at line 435 of file G4KineticTrack.hh.

{
        theProjectilePotential = aPotential;
}

G4KineticTrack::CascadeState G4KineticTrack::SetState

(

const CascadeState

new_state

)

[inline]

Definition at line 427 of file G4KineticTrack.hh.

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

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

void G4KineticTrack::SetTrackingMomentum

(

const G4LorentzVector &

a4Momentum

)

[inline]

Definition at line 291 of file G4KineticTrack.hh.

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

{
//  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));
}

void G4KineticTrack::Update4Momentum

(

const G4ThreeVector &

aMomentum

)

[inline]

Definition at line 283 of file G4KineticTrack.hh.

References Set4Momentum().

{
// 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));
}

void G4KineticTrack::Update4Momentum

(

G4double

aEnergy

)

[inline]

Definition at line 267 of file G4KineticTrack.hh.

References Set4Momentum(), and sqr().

{
// 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));
}

void G4KineticTrack::UpdateTrackingMomentum

(

const G4ThreeVector &

aMomentum

)

[inline]

Definition at line 319 of file G4KineticTrack.hh.

References SetTrackingMomentum().

{
// 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));
}

void G4KineticTrack::UpdateTrackingMomentum

(

G4double

aEnergy

)

[inline]

Definition at line 303 of file G4KineticTrack.hh.

References SetTrackingMomentum(), and sqr().

{
// 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

---