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 (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
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 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(), and GetTrackingMomentum().

                                                          : 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(), G4VDecayChannel::GetBR(), G4VDecayChannel::GetDaughter(), G4DecayTable::GetDecayChannel(), G4ParticleDefinition::GetDecayTable(), G4SampleResonance::GetMinimumMass(), G4VDecayChannel::GetNumberOfDaughters(), G4ParticleDefinition::GetPDGMass(), G4ParticleDefinition::GetPDGWidth(), G4ParticleDefinition::IsShortLived(), G4KaonZero::KaonZero(), G4KaonZeroLong::KaonZeroLong(), G4KaonZeroShort::KaonZeroShort(), and 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(), and CLHEP::HepLorentzVector::setE().

  :     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, Get4Momentum(), G4DynamicParticle::Get4Momentum(), GetActualMass(), G4ParticleDefinition::GetBaryonNumber(), G4VDecayChannel::GetDaughter(), G4VDecayChannel::GetDaughterName(), G4DecayTable::GetDecayChannel(), G4ParticleDefinition::GetDecayTable(), GetDefinition(), G4DynamicParticle::GetDefinition(), G4SampleResonance::GetMinimumMass(), G4VDecayChannel::GetNumberOfDaughters(), G4VDecayChannel::GetParentName(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), GetPosition(), G4ParticleDefinition::IsShortLived(), G4DecayProducts::PopProducts(), and G4SampleResonance::SampleMass().

Referenced by G4QMDCollision::CalKinematicsOfBinaryCollisions(), G4DecayKineticTracks::Decay(), 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

inlinevirtual

Implements G4VKineticNucleon.

Definition at line 248 of file G4KineticTrack.hh.

Referenced by G4CollisionManager::AddCollision(), G4KineticTrackVector::Boost(), G4KineticTrackVector::BoostBeam(), G4XpimNTotal::CrossSection(), G4XpipNTotal::CrossSection(), G4XNNTotalLowE::CrossSection(), G4XNNElasticLowE::CrossSection(), G4CollisionNN::CrossSection(), G4XResonance::CrossSection(), G4CrossSectionPatch::CrossSection(), G4XAnnihilationChannel::CrossSection(), G4XMesonBaryonElastic::CrossSection(), G4XnpTotalLowE::CrossSection(), G4CrossSectionComposite::CrossSection(), G4XnpElasticLowE::CrossSection(), G4CrossSectionBuffer::CrossSection(), G4XPDGElastic::CrossSection(), G4XPDGTotal::CrossSection(), Decay(), G4VXResonance::DetailedBalance(), G4VElasticCollision::FinalState(), G4VAnnihilationCollision::FinalState(), G4VScatteringCollision::FinalState(), G4Absorber::FindProducts(), G4QGSMFragmentation::FragmentString(), G4LundStringFragmentation::FragmentString(), G4MesonAbsorption::GetFinalState(), G4Scatterer::GetTimeToInteraction(), G4VCrossSectionSource::PrintAll(), G4IntraNucleiCascader::processSecondary(), G4DecayStrongResonances::Propagate(), G4CascadeInterface::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.

References CLHEP::HepLorentzVector::mag2().

Referenced by G4CollisionNN::CrossSection(), Decay(), G4VElasticCollision::FinalState(), G4VScatteringCollision::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

inlinevirtual

Implements G4VKineticNucleon.

Definition at line 213 of file G4KineticTrack.hh.

Referenced by G4CollisionManager::AddCollision(), G4KineticTrackVector::BoostBeam(), G4XAqmTotal::CrossSection(), G4CollisionNN::CrossSection(), G4XResonance::CrossSection(), G4XAnnihilationChannel::CrossSection(), G4XnpElasticLowE::CrossSection(), G4XnpTotalLowE::CrossSection(), G4CollisionComposite::CrossSection(), G4XPDGElastic::CrossSection(), G4XPDGTotal::CrossSection(), G4DecayKineticTracks::Decay(), Decay(), G4VXResonance::DegeneracyFactor(), G4VXResonance::DetailedBalance(), G4VElasticCollision::FinalState(), G4VScatteringCollision::FinalState(), G4Absorber::FindAbsorbers(), G4VCrossSectionSource::FindKeyParticle(), G4VCrossSectionSource::FindLightParticle(), G4Absorber::FindProducts(), G4KineticTrack(), G4BCDecay::GetCollisions(), G4MesonAbsorption::GetFinalState(), G4ParticleTypeConverter::GetGenericType(), G4ConcreteMesonBaryonToResonance::GetOutgoingParticle(), G4Scatterer::GetTimeToInteraction(), G4GeneralNNCollision::IsInCharge(), G4CollisionMesonBaryonElastic::IsInCharge(), G4CollisionNNElastic::IsInCharge(), G4CollisionnpElastic::IsInCharge(), G4ConcreteNNTwoBodyResonance::IsInCharge(), G4VXResonance::IsospinCorrection(), operator=(), G4CollisionManager::Print(), G4CollisionInitialState::Print(), G4IntraNucleiCascader::processSecondary(), G4DecayStrongResonances::Propagate(), G4CascadeInterface::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(), G4QGSMFragmentation::FragmentString(), G4LundStringFragmentation::FragmentString(), G4ExcitedString::G4ExcitedString(), G4KineticTrack(), G4BCLateParticle::GetCollisions(), operator=(), and G4CascadeInterface::Propagate().

{
  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 ( void  ) const

inlinevirtual

Implements G4VKineticNucleon.

Definition at line 237 of file G4KineticTrack.hh.

Referenced by G4XMesonBaryonElastic::CrossSection(), Decay(), G4VAnnihilationCollision::FinalState(), G4VScatteringCollision::FinalState(), G4Absorber::FindAbsorbers(), G4Absorber::FindProducts(), G4QGSMFragmentation::FragmentString(), G4LundStringFragmentation::FragmentString(), G4ExcitedString::G4ExcitedString(), G4KineticTrack(), G4RKPropagation::GetSphereIntersectionTimes(), G4Scatterer::GetTimeToInteraction(), G4IntraNucleiCascader::processSecondary(), G4CascadeInterface::Propagate(), G4KineticTrackVector::Shift(), 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(), and GetTrackingMomentum().

{
 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, and CLHEP::HepLorentzVector::gamma().

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 G4KineticTrackVector::Boost(), G4KineticTrackVector::BoostBeam(), G4CollisionNN::CrossSection(), G4VElasticCollision::FinalState(), G4QGSMFragmentation::FragmentString(), G4LundStringFragmentation::FragmentString(), 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.

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

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

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

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

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

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 ( G4double  aEnergy )

inline

Definition at line 267 of file G4KineticTrack.hh.

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

{
// 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::Update4Momentum ( const G4ThreeVector &  aMomentum )

inline

Definition at line 283 of file G4KineticTrack.hh.

References CLHEP::Hep3Vector::mag2(), CLHEP::HepLorentzVector::mag2(), and 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::UpdateTrackingMomentum ( G4double  aEnergy )

inline

Definition at line 303 of file G4KineticTrack.hh.

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

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

void G4KineticTrack::UpdateTrackingMomentum ( const G4ThreeVector &  aMomentum )

inline

Definition at line 319 of file G4KineticTrack.hh.

References CLHEP::Hep3Vector::mag2(), CLHEP::HepLorentzVector::mag2(), and 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));
}

---

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

• G4KineticTrack.hh
• G4KineticTrack.cc