Import Geant4 0.0.0 source tree

2016-06-01 15:25:35 +02:00
parent 54d6b71f95
commit b97f8d0df7
3237 changed files with 807095 additions and 0 deletions
@@ -0,0 +1,326 @@
+// This code implementation is the intellectual property of
+// the RD44 GEANT4 collaboration.
+//
+// By copying, distributing or modifying the Program (or any work
+// based on the Program) you indicate your acceptance of this statement,
+// and all its terms.
+//
+// $Id: G4DynamicParticle.hh,v 2.2 1998/11/13 17:01:08 kurasige Exp $
+// GEANT4 tag $Name: geant4-00 $
+//
+// 
+// ------------------------------------------------------------
+//	GEANT 4 class header file 
+//
+//	For information related to this code contact:
+//	CERN, CN Division, ASD group
+//	History: first implementation, based on object model of
+//	2nd December 1995, G.Cosmo
+//      ---------------- G4DynamicParticle  ----------------
+//      first implementation by Makoto Asai, 29 January 1996
+//      revised by G.Cosmo, 29 February 1996
+//      revised by Hisaya Kurashige, 24 July 1996
+//         modify thePreAssignedDecayProducts
+//         add   void SetMomentum(G4ThreeVector &momentum)
+//         add   void Set4Momentum(G4LorentzVector &momentum)
+//         add   G4LorentzVector   Get4Momentum()
+//         add   G4DynamicParticle(G4ParticleDefinition * aParticleDefinition,
+//                                 G4LorentzVector &p4vector)
+//      revised by Hisaya Kurashige, 19 Oct 1996
+//         add    theKillProcess
+//         add    theProperTime
+//      revised by Hisaya Kurashige, 19 Feb 1997
+//      revised by Hisaya Kurashige, 5  June 1998
+//         remove    theKillProcess
+// ------------------------------------------------------------
+
+#ifndef G4DynamicParticle_h
+#define G4DynamicParticle_h 1
+
+
+#include "globals.hh"
+#include "G4ios.hh"
+
+#include "G4ParticleDefinition.hh"
+#include "G4Allocator.hh"
+#include "G4ParticleMomentum.hh"
+#include "G4LorentzVector.hh"
+
+class  G4VProcess;
+class  G4DecayProducts;
+
+
+class G4DynamicParticle 
+{
+  //  The dynamic particle is a class which contains the purely
+  //  dynamic aspects of a moving particle. It also has a
+  //  pointer to a G4ParticleDefinition object, which holds
+  //  all the static information.
+
+  public:
+     G4DynamicParticle();
+
+     G4DynamicParticle(G4ParticleDefinition * aParticleDefinition,
+                        const G4ParticleMomentum& aMomentumDirection,
+                        G4double aKineticEnergy);
+     G4DynamicParticle(G4ParticleDefinition * aParticleDefinition,
+                        const G4ThreeVector& aParticleMomentum);
+     G4DynamicParticle(G4ParticleDefinition * aParticleDefinition,
+                        const G4LorentzVector    &aParticleMomentum);
+     G4DynamicParticle(G4ParticleDefinition * aParticleDefinition,
+			G4double aTotalEnergy,
+                        const G4ThreeVector &aParticleMomentum);
+
+     G4DynamicParticle(const G4DynamicParticle &right);
+
+     ~G4DynamicParticle();
+
+     G4DynamicParticle & operator=(const G4DynamicParticle &right);
+     G4int operator==(const G4DynamicParticle &right) const;
+     G4int operator!=(const G4DynamicParticle &right) const;
+
+     inline void *operator new(size_t);
+     inline void operator delete(void *aDynamicParticle);
+
+     void DumpInfo() const;
+
+     G4double GetMass() const;
+     void     SetMass(G4double mass);
+     // set/get dynamical mass
+     // the dynamical mass is set to PDG mass in default
+
+     const G4ParticleMomentum& GetMomentumDirection() const;
+      //  Returns the normalized direction of the momentum
+
+     void SetMomentumDirection(const G4ParticleMomentum &aDirection);
+      //  Sets the normalized direction of the momentum
+
+     void SetMomentumDirection(G4double px, G4double py, G4double pz);
+      //  Sets the normalized direction of the momentum by coordinates
+
+     G4ThreeVector GetMomentum() const;
+      //  Returns the current particle momentum vector
+     void SetMomentum( const G4ThreeVector &momentum);
+      //  set the current particle momentum vector
+
+     G4LorentzVector Get4Momentum() const;
+      //  Returns the current particle energy-momentum 4vector
+     void Set4Momentum( const G4LorentzVector &momentum);
+      //  Set the current particle energy-momentum 4vector
+
+     G4double GetProperTime() const;
+      //  Returns the current particle proper time
+     void SetProperTime( G4double );
+      //  Set the current particle Proper Time
+
+     G4ParticleDefinition* GetDefinition() const;
+
+     void SetDefinition(G4ParticleDefinition * aParticleDefinition);
+
+     G4double GetTotalMomentum() const;
+      //  Returns the module of the momentum vector
+
+     G4double GetTotalEnergy() const;
+      //  Returns the total energy of the particle
+
+     const G4ThreeVector& GetPolarization() const;
+
+     void SetPolarization(G4double polX, G4double polY, G4double polZ);
+
+     G4double GetKineticEnergy() const;
+      //  Returns the kinetic energy of a particle
+
+     void SetKineticEnergy(G4double aEnergy);
+      //  Sets the kinetic energy of a particle
+
+     G4DecayProducts *GetPreAssignedDecayProducts() const;
+     void SetPreAssignedDecayProducts(G4DecayProducts *aDecayProducts);
+
+  private:
+     G4double           theDynamicalMass;
+
+     G4ParticleMomentum theMomentumDirection;
+      //  The normalized momentum vector
+
+     G4ParticleDefinition *theParticleDefinition;
+      //  Contains the static information of this particle.
+
+     G4ThreeVector thePolarization;
+
+     G4double theKineticEnergy;
+
+     G4double theProperTime;
+
+     G4DecayProducts *thePreAssignedDecayProducts;
+
+ private:
+   G4int verboseLevel;
+   // controle flag for output message
+   //  0: Silent
+   //  1: Warning message
+   //  2: More
+
+ public:
+   void  SetVerboseLevel(G4int value);
+   G4int GetVerboseLevel() const;
+
+
+};
+
+extern G4Allocator<G4DynamicParticle> aDynamicParticleAllocator;
+
+// ------------------------
+// Inlined operators
+// ------------------------
+
+inline void * G4DynamicParticle::operator new(size_t)
+{
+  void * aDynamicParticle;
+  aDynamicParticle = (void *) aDynamicParticleAllocator.MallocSingle();
+  return aDynamicParticle;
+}
+
+inline void G4DynamicParticle::operator delete(void * aDynamicParticle)
+{
+  aDynamicParticleAllocator.FreeSingle((G4DynamicParticle *) aDynamicParticle);
+}
+
+// ------------------------
+// Inlined functions
+// ------------------------
+inline G4double G4DynamicParticle::GetMass() const
+{
+  return theDynamicalMass;
+}
+
+inline void G4DynamicParticle::SetMass(G4double newMass)
+{
+  theDynamicalMass = newMass;
+}
+
+inline const G4ParticleMomentum& G4DynamicParticle::GetMomentumDirection() const
+{
+  return theMomentumDirection;
+}
+
+inline G4ThreeVector G4DynamicParticle::GetMomentum() const
+{
+  G4double pModule = sqrt(theKineticEnergy*theKineticEnergy +
+                        2*theKineticEnergy*theDynamicalMass);
+  G4ThreeVector pMomentum(theMomentumDirection.x()*pModule,
+                          theMomentumDirection.y()*pModule,
+                          theMomentumDirection.z()*pModule);
+  return pMomentum;
+}
+
+inline  G4LorentzVector  G4DynamicParticle::Get4Momentum() const
+{       
+  G4double mass      = theDynamicalMass;
+  G4double energy    = theKineticEnergy;
+  G4double momentum  = 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 sqrt((theKineticEnergy + 2.*theDynamicalMass)* theKineticEnergy);
+}
+
+inline G4ParticleDefinition* G4DynamicParticle::GetDefinition() 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 void G4DynamicParticle::SetMomentumDirection(const G4ParticleMomentum &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::SetDefinition(G4ParticleDefinition * aParticleDefinition)
+{
+  theParticleDefinition = aParticleDefinition;
+  theDynamicalMass = theParticleDefinition->GetPDGMass();
+}
+
+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)
+{
+  theKineticEnergy = aEnergy;
+}
+
+inline void G4DynamicParticle::SetProperTime(G4double atime)
+{
+  theProperTime = atime;
+}
+
+inline G4DecayProducts* G4DynamicParticle::GetPreAssignedDecayProducts() const
+{ 
+  return thePreAssignedDecayProducts;
+}
+
+inline void G4DynamicParticle::SetPreAssignedDecayProducts(G4DecayProducts* aDecayProducts)
+{
+ thePreAssignedDecayProducts = aDecayProducts;
+}
+
+inline 
+void G4DynamicParticle::SetVerboseLevel(G4int value)
+{
+   verboseLevel = value;
+}
+
+inline 
+G4int G4DynamicParticle::GetVerboseLevel() const
+{
+   return verboseLevel;
+}
+
+#endif
+
+
+
+
+
+
+
+
+
+