Gabriele Cosmo
335 lines
9.0 KiB
Plaintext
335 lines
9.0 KiB
Plaintext
//
|
|
// ********************************************************************
|
|
// * License and Disclaimer *
|
|
// * *
|
|
// * The Geant4 software is copyright of the Copyright Holders of *
|
|
// * the Geant4 Collaboration. It is provided under the terms and *
|
|
// * conditions of the Geant4 Software License, included in the file *
|
|
// * LICENSE and available at http://cern.ch/geant4/license . These *
|
|
// * include a list of copyright holders. *
|
|
// * *
|
|
// * Neither the authors of this software system, nor their employing *
|
|
// * institutes,nor the agencies providing financial support for this *
|
|
// * work make any representation or warranty, express or implied, *
|
|
// * regarding this software system or assume any liability for its *
|
|
// * use. Please see the license in the file LICENSE and URL above *
|
|
// * for the full disclaimer and the limitation of liability. *
|
|
// * *
|
|
// * This code implementation is the result of the scientific and *
|
|
// * technical work of the GEANT4 collaboration. *
|
|
// * By using, copying, modifying or distributing the software (or *
|
|
// * any work based on the software) you agree to acknowledge its *
|
|
// * use in resulting scientific publications, and indicate your *
|
|
// * acceptance of all terms of the Geant4 Software license. *
|
|
// ********************************************************************
|
|
//
|
|
// G4DynamicParticle inline implementation
|
|
//
|
|
// 17.08.1999 - H.Kurashige
|
|
// --------------------------------------------------------------------
|
|
|
|
extern G4PART_DLL G4Allocator<G4DynamicParticle>*& pDynamicParticleAllocator();
|
|
|
|
// ------------------------
|
|
// Inlined operators
|
|
// ------------------------
|
|
|
|
inline void * G4DynamicParticle::operator new(size_t)
|
|
{
|
|
if (pDynamicParticleAllocator() == nullptr)
|
|
{
|
|
pDynamicParticleAllocator() = new G4Allocator<G4DynamicParticle>;
|
|
}
|
|
return pDynamicParticleAllocator()->MallocSingle();
|
|
}
|
|
|
|
inline void G4DynamicParticle::operator delete(void * aDynamicParticle)
|
|
{
|
|
pDynamicParticleAllocator()
|
|
->FreeSingle((G4DynamicParticle *) aDynamicParticle);
|
|
}
|
|
|
|
// ------------------------
|
|
// Inlined functions
|
|
// ------------------------
|
|
|
|
inline const G4ElectronOccupancy*
|
|
G4DynamicParticle::GetElectronOccupancy() const
|
|
{
|
|
return theElectronOccupancy;
|
|
}
|
|
|
|
inline G4int G4DynamicParticle::GetTotalOccupancy() const
|
|
{
|
|
return (theElectronOccupancy) ? theElectronOccupancy->GetTotalOccupancy() : 0;
|
|
}
|
|
|
|
inline G4int G4DynamicParticle::GetOccupancy(G4int orbit) const
|
|
{
|
|
return (theElectronOccupancy) ? theElectronOccupancy->GetOccupancy(orbit) : 0;
|
|
}
|
|
|
|
inline void G4DynamicParticle::AddElectron(G4int orbit, G4int number)
|
|
{
|
|
if (theElectronOccupancy == nullptr) { AllocateElectronOccupancy(); }
|
|
if (theElectronOccupancy != nullptr)
|
|
{
|
|
G4int n = theElectronOccupancy->AddElectron(orbit, number);
|
|
theDynamicalCharge -= CLHEP::eplus * n;
|
|
theDynamicalMass += CLHEP::electron_mass_c2 * n;
|
|
}
|
|
}
|
|
|
|
inline void G4DynamicParticle::RemoveElectron(G4int orbit, G4int number)
|
|
{
|
|
if (theElectronOccupancy == nullptr) { AllocateElectronOccupancy(); }
|
|
if (theElectronOccupancy != nullptr)
|
|
{
|
|
G4int n = theElectronOccupancy->RemoveElectron(orbit, number);
|
|
theDynamicalCharge += CLHEP::eplus * n;
|
|
theDynamicalMass -= CLHEP::electron_mass_c2 * n;
|
|
}
|
|
}
|
|
|
|
inline G4double G4DynamicParticle::GetCharge() const
|
|
{
|
|
return theDynamicalCharge;
|
|
}
|
|
|
|
inline void G4DynamicParticle::SetCharge(G4double newCharge)
|
|
{
|
|
theDynamicalCharge = newCharge;
|
|
}
|
|
|
|
inline void G4DynamicParticle::SetCharge(G4int newCharge)
|
|
{
|
|
theDynamicalCharge = newCharge*CLHEP::eplus;
|
|
}
|
|
|
|
inline G4double G4DynamicParticle::GetMass() const
|
|
{
|
|
return theDynamicalMass;
|
|
}
|
|
|
|
inline void G4DynamicParticle::SetMass(G4double newMass)
|
|
{
|
|
if(theDynamicalMass != newMass)
|
|
{
|
|
theDynamicalMass = std::max(newMass, 0.0);
|
|
theBeta = -1.0;
|
|
}
|
|
}
|
|
|
|
inline G4double G4DynamicParticle::GetSpin() const
|
|
{
|
|
return theDynamicalSpin;
|
|
}
|
|
|
|
inline void G4DynamicParticle::SetSpin(G4double spin)
|
|
{
|
|
theDynamicalSpin = spin;
|
|
}
|
|
|
|
inline void G4DynamicParticle::SetSpin(G4int spinInUnitOfHalfInteger)
|
|
{
|
|
theDynamicalSpin = spinInUnitOfHalfInteger * 0.5;
|
|
}
|
|
|
|
inline G4double G4DynamicParticle::GetMagneticMoment() const
|
|
{
|
|
return theDynamicalMagneticMoment;
|
|
}
|
|
|
|
inline void G4DynamicParticle::SetMagneticMoment(G4double magneticMoment)
|
|
{
|
|
theDynamicalMagneticMoment = magneticMoment;
|
|
}
|
|
|
|
inline const G4ThreeVector& G4DynamicParticle::GetMomentumDirection() const
|
|
{
|
|
return theMomentumDirection;
|
|
}
|
|
|
|
inline G4ThreeVector G4DynamicParticle::GetMomentum() const
|
|
{
|
|
G4double pModule = std::sqrt(theKineticEnergy*theKineticEnergy
|
|
+ 2*theKineticEnergy*theDynamicalMass);
|
|
G4ThreeVector pMomentum(theMomentumDirection.x()*pModule,
|
|
theMomentumDirection.y()*pModule,
|
|
theMomentumDirection.z()*pModule);
|
|
return pMomentum;
|
|
}
|
|
|
|
inline G4LorentzVector G4DynamicParticle::Get4Momentum() const
|
|
{
|
|
const G4double mass = theDynamicalMass;
|
|
const G4double energy = theKineticEnergy;
|
|
const G4double momentum = std::sqrt(energy*energy+2.0*mass*energy);
|
|
G4LorentzVector p4( theMomentumDirection.x()*momentum,
|
|
theMomentumDirection.y()*momentum,
|
|
theMomentumDirection.z()*momentum,
|
|
energy+mass );
|
|
return p4;
|
|
}
|
|
|
|
inline G4double G4DynamicParticle::GetTotalMomentum() const
|
|
{
|
|
// The momentum is returned in energy equivalent
|
|
//
|
|
return std::sqrt((theKineticEnergy + 2.*theDynamicalMass)* theKineticEnergy);
|
|
}
|
|
|
|
inline G4ParticleDefinition* G4DynamicParticle::GetDefinition() const
|
|
{
|
|
return const_cast<G4ParticleDefinition*>(theParticleDefinition);
|
|
}
|
|
|
|
inline const G4ParticleDefinition*
|
|
G4DynamicParticle::GetParticleDefinition() const
|
|
{
|
|
return theParticleDefinition;
|
|
}
|
|
|
|
inline const G4ThreeVector& G4DynamicParticle::GetPolarization() const
|
|
{
|
|
return thePolarization;
|
|
}
|
|
|
|
inline G4double G4DynamicParticle::GetProperTime() const
|
|
{
|
|
return theProperTime;
|
|
}
|
|
|
|
inline G4double G4DynamicParticle::GetTotalEnergy() const
|
|
{
|
|
return (theKineticEnergy+theDynamicalMass);
|
|
}
|
|
|
|
inline G4double G4DynamicParticle::GetKineticEnergy() const
|
|
{
|
|
return theKineticEnergy;
|
|
}
|
|
|
|
inline G4double G4DynamicParticle::GetLogKineticEnergy() const
|
|
{
|
|
if (theLogKineticEnergy == DBL_MAX)
|
|
{
|
|
theLogKineticEnergy = (theKineticEnergy > 0.)
|
|
? G4Log(theKineticEnergy) : LOG_EKIN_MIN;
|
|
}
|
|
return theLogKineticEnergy;
|
|
}
|
|
|
|
inline void
|
|
G4DynamicParticle::SetMomentumDirection(const G4ThreeVector& aDirection)
|
|
{
|
|
theMomentumDirection = aDirection;
|
|
}
|
|
|
|
inline void
|
|
G4DynamicParticle::SetMomentumDirection(G4double px, G4double py, G4double pz)
|
|
{
|
|
theMomentumDirection.setX(px);
|
|
theMomentumDirection.setY(py);
|
|
theMomentumDirection.setZ(pz);
|
|
}
|
|
|
|
inline void G4DynamicParticle::SetPolarization(const G4ThreeVector& vp)
|
|
{
|
|
thePolarization = vp;
|
|
}
|
|
|
|
inline void
|
|
G4DynamicParticle::SetPolarization(G4double polX, G4double polY, G4double polZ)
|
|
{
|
|
thePolarization.setX(polX);
|
|
thePolarization.setY(polY);
|
|
thePolarization.setZ(polZ);
|
|
}
|
|
|
|
inline void G4DynamicParticle::SetKineticEnergy(G4double aEnergy)
|
|
{
|
|
if(aEnergy != theKineticEnergy) {
|
|
theLogKineticEnergy = DBL_MAX;
|
|
theKineticEnergy = aEnergy;
|
|
theBeta = -1.0;
|
|
}
|
|
}
|
|
|
|
inline void G4DynamicParticle::SetProperTime(G4double atime)
|
|
{
|
|
theProperTime = atime;
|
|
}
|
|
|
|
inline const G4DecayProducts*
|
|
G4DynamicParticle::GetPreAssignedDecayProducts() const
|
|
{
|
|
return thePreAssignedDecayProducts;
|
|
}
|
|
|
|
inline void
|
|
G4DynamicParticle::SetPreAssignedDecayProducts(G4DecayProducts* aDecayProducts)
|
|
{
|
|
thePreAssignedDecayProducts = aDecayProducts;
|
|
}
|
|
|
|
inline G4double G4DynamicParticle::GetPreAssignedDecayProperTime() const
|
|
{
|
|
return thePreAssignedDecayTime;
|
|
}
|
|
|
|
inline void G4DynamicParticle::SetPreAssignedDecayProperTime(G4double aTime)
|
|
{
|
|
thePreAssignedDecayTime = aTime;
|
|
}
|
|
|
|
inline void G4DynamicParticle::SetVerboseLevel(G4int value)
|
|
{
|
|
verboseLevel = value;
|
|
}
|
|
|
|
inline G4int G4DynamicParticle::GetVerboseLevel() const
|
|
{
|
|
return verboseLevel;
|
|
}
|
|
|
|
inline void G4DynamicParticle::SetPrimaryParticle(G4PrimaryParticle* p)
|
|
{
|
|
primaryParticle = p;
|
|
}
|
|
|
|
inline G4PrimaryParticle* G4DynamicParticle::GetPrimaryParticle() const
|
|
{
|
|
return primaryParticle;
|
|
}
|
|
|
|
inline G4int G4DynamicParticle::GetPDGcode() const
|
|
{
|
|
G4int code = theParticleDefinition->GetPDGEncoding();
|
|
return (code == 0) ? thePDGcode : code;
|
|
}
|
|
|
|
inline void G4DynamicParticle::SetPDGcode(G4int c)
|
|
{
|
|
thePDGcode = c;
|
|
}
|
|
|
|
inline void G4DynamicParticle::ComputeBeta() const
|
|
{
|
|
// ultra relativistic particles and particles with mass zero
|
|
theBeta = 1.0;
|
|
|
|
// other particles
|
|
if(theDynamicalMass > 0.0 && theKineticEnergy < 1000*theDynamicalMass)
|
|
{
|
|
const G4double T = theKineticEnergy/theDynamicalMass;
|
|
theBeta = std::sqrt(T*(T+2.))/(T+1.0);
|
|
}
|
|
}
|
|
|
|
inline G4double G4DynamicParticle::GetBeta() const
|
|
{
|
|
if(theBeta < 0.0) { ComputeBeta(); }
|
|
return theBeta;
|
|
}
|