Import Geant4 9.6.0 source tree

source/processes/hadronic/models/binary_cascade/include/G4Absorber.hh

@@ -44,6 +44,13 @@ public:
   G4bool FindAbsorbers(G4KineticTrack & kt, G4KineticTrackVector & tgt);
   G4bool FindProducts(G4KineticTrack & kt);
 
+private:
+  // hide copy ctor, =, == and != operators
+  G4Absorber(const  G4Absorber &right);
+  const G4Absorber & operator=(const G4Absorber & right);
+  int operator==(const G4Absorber & right) const;
+  int operator!=(const G4Absorber & right) const;
+
 
 private:
   G4double theCutOnP;

source/processes/hadronic/models/binary_cascade/include/G4AntiProtonField.hh

@@ -39,14 +39,15 @@
 #ifndef G4AntiProtonField_h
 #define  G4AntiProtonField_h 1
 
-//#include "globals.hh"
+#include <CLHEP/Units/SystemOfUnits.h>
+
 #include "G4VNuclearField.hh"
 #include "G4V3DNucleus.hh"
 
 class G4AntiProtonField: public G4VNuclearField
 {
 public:
-  G4AntiProtonField(G4V3DNucleus * nucleus, G4double coeff = 1.53*fermi);
+  G4AntiProtonField(G4V3DNucleus * nucleus, G4double coeff = 1.53*CLHEP::fermi);
   virtual ~G4AntiProtonField();
 
 private:

source/processes/hadronic/models/binary_cascade/include/G4BCLateParticle.hh

@@ -25,13 +25,13 @@
 //
 #ifndef G4BCLateParticle_h
 #define G4BCLateParticle_h 1
+
+#include <vector>
+
 #include "G4BCAction.hh"
 #include "G4CollisionInitialState.hh"
 #include "G4KineticTrack.hh"
 #include "G4KineticTrackVector.hh"
-#include <vector>
-
-//#define debug_BCLateParticle 1
 
 class G4BCLateParticle : public G4BCAction
 {
@@ -51,17 +51,7 @@ class G4BCLateParticle : public G4BCAction
     G4CollisionInitialState * aLate = 
             new G4CollisionInitialState(ctime,
 	    				 aProjectile, noTarget, this);
-    theColl.push_back(aLate);
-
-#ifdef debug_BCLateParticle
-  G4cout << "Particle starting late " << aProjectile << " "  
-         <<  aProjectile->GetDefinition()->GetParticleName() << " "
-	 <<  1/MeV*aProjectile->Get4Momentum() << " " 
-	 <<  1/fermi*aProjectile->GetPosition() << " " 
-	 <<  aProjectile->GetFormationTime() 
-	 << G4endl;
-#endif	 
-    
+    theColl.push_back(aLate);    
     return theColl;
   }
 

source/processes/hadronic/models/binary_cascade/include/G4BinaryCascade.hh

@@ -29,11 +29,14 @@
 //      GEANT4 Class file
 //
 //
-//      File name:    G4BinaryCascade.hh 
+//      File name:    G4BinaryCascade.hh
+//
+//      Authors: Alessandro Brunengo (Alessandro.Brunengo@ge.infn.it)
+//               Hans-Peter Wellisch
+//               Gunter Folger
 //
-//      Author: Alessandro Brunengo (Alessandro.Brunengo@ge.infn.it)       
-// 
 //      Creation date: 8 June 2000
+//
 // -----------------------------------------------------------------------------
 
 #ifndef G4BinaryCascade_hh
@@ -68,24 +71,68 @@ class G4BinaryCascade : public G4VIntraNuclearTransportModel
 {
 public:
 
-  G4BinaryCascade();
-  G4BinaryCascade(const G4BinaryCascade & right);
+  G4BinaryCascade(G4VPreCompoundModel* ptr = 0);
 
   virtual ~G4BinaryCascade();
 
-  const G4BinaryCascade& operator=(G4BinaryCascade & right);
-  G4int operator==(G4BinaryCascade& right) {return (this == &right);}
-  G4int operator!=(G4BinaryCascade& right) {return (this != &right);}
-
-  G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack, 
+  G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
                                               G4Nucleus& theNucleus);
   virtual G4ReactionProductVector * Propagate(G4KineticTrackVector *,
 					      G4V3DNucleus *);
 
   virtual void ModelDescription(std::ostream&) const;
+  virtual void PropagateModelDescription(std::ostream&) const;
 
 private:
 
+  G4BinaryCascade(const G4BinaryCascade & right);
+  const G4BinaryCascade& operator=(G4BinaryCascade & right);
+  G4int operator==(G4BinaryCascade& right) {return (this == &right);}
+  G4int operator!=(G4BinaryCascade& right) {return (this != &right);}
+
+// Implementation
+  void PrintWelcomeMessage();
+  void BuildTargetList();
+  G4bool  BuildLateParticleCollisions(G4KineticTrackVector * secondaries);
+  void FindCollisions(G4KineticTrackVector *);
+  void FindDecayCollision(G4KineticTrack *);
+  void FindLateParticleCollision(G4KineticTrack *);
+
+//  void PropagateInit();
+//  void Cascade();
+  G4ReactionProductVector * DeExcite();
+  G4ReactionProductVector *  DecayVoidNucleus();
+  G4ReactionProductVector * ProductsAddFinalState (G4ReactionProductVector * products, G4KineticTrackVector & finalState  );
+  G4ReactionProductVector * ProductsAddPrecompound(G4ReactionProductVector * products ,G4ReactionProductVector * preco );
+
+  G4bool ApplyCollision(G4CollisionInitialState *);
+  G4bool Capture(G4bool verbose=false);
+  G4bool Absorb();
+  G4bool CheckPauliPrinciple(G4KineticTrackVector *);
+  G4double GetExcitationEnergy();
+  void CorrectFinalPandE();
+
+  G4double CorrectShortlivedPrimaryForFermi(
+      G4KineticTrack* primary,G4KineticTrackVector target_collection);
+  G4bool CorrectShortlivedFinalsForFermi(
+        G4KineticTrackVector * products, G4double initial_Efermi);
+
+  void UpdateTracksAndCollisions(G4KineticTrackVector * oldSecondaries,
+             G4KineticTrackVector * oldTarget,
+             G4KineticTrackVector * newSecondaries);
+  G4bool DoTimeStep(G4double timeStep);
+  G4KineticTrackVector* CorrectBarionsOnBoundary(G4KineticTrackVector *in,
+                                               G4KineticTrackVector *out);
+  G4Fragment * FindFragments();
+  void StepParticlesOut();
+
+  G4LorentzVector GetFinal4Momentum();
+  G4LorentzVector GetFinalNucleusMomentum();
+
+  G4ReactionProductVector * Propagate1H1(G4KineticTrackVector *,
+                G4V3DNucleus *);
+  G4double GetIonMass(G4int Z, G4int A);
+
   G4int GetTotalCharge(std::vector<G4KineticTrack *> & aV)
   {
     G4int result = 0;
@@ -102,59 +149,36 @@ private:
     std::vector<G4KineticTrack *>::iterator i;
     for(i = aV.begin(); i != aV.end(); ++i)
     {
-       if ( (*i)->GetDefinition()->GetBaryonNumber() != 0 ){ 
+       if ( (*i)->GetDefinition()->GetBaryonNumber() != 0 ){
              result += G4lrint((*i)->GetDefinition()->GetPDGCharge());
        }
     }
     return result;
   }
-  void PrintWelcomeMessage();
-  void BuildTargetList();
-  void FindCollisions(G4KineticTrackVector *);
-  void FindDecayCollision(G4KineticTrack *);
-  void FindLateParticleCollision(G4KineticTrack *);
-  G4bool ApplyCollision(G4CollisionInitialState *);
-  G4bool Capture(G4bool verbose=false);
-  G4bool Absorb();
-  G4bool CheckPauliPrinciple(G4KineticTrackVector *);
-  G4double GetExcitationEnergy();
-  G4bool CheckDecay(G4KineticTrackVector *);
-  void CorrectFinalPandE();
-  G4double CorrectShortlivedPrimaryForFermi(
-  		G4KineticTrack* primary,G4KineticTrackVector target_collection);
-  G4bool CorrectShortlivedFinalsForFermi(
-		  G4KineticTrackVector * products, G4double initial_Efermi);
-  void UpdateTracksAndCollisions(G4KineticTrackVector * oldSecondaries,
-				 G4KineticTrackVector * oldTarget,
-				 G4KineticTrackVector * newSecondaries);
-  G4bool DoTimeStep(G4double timeStep);
-  G4KineticTrackVector* CorrectBarionsOnBoundary(G4KineticTrackVector *in, 
-                                               G4KineticTrackVector *out);
-  G4Fragment * FindFragments();
-  void StepParticlesOut();
-  G4LorentzVector GetFinal4Momentum();
-  G4LorentzVector GetFinalNucleusMomentum();
-  G4ReactionProductVector * Propagate1H1(G4KineticTrackVector *,
-					 G4V3DNucleus *);
-  G4double GetIonMass(G4int Z, G4int A);
-  
+
   G4ReactionProductVector * HighEnergyModelFSProducts(G4ReactionProductVector *,
-		  	  	  	 G4KineticTrackVector * secondaries);
-  G4ReactionProductVector * FillVoidNucleusProducts(G4ReactionProductVector * );
+		  	  	  	 G4KineticTrackVector * secondaries);                                // add secondaries of string model to G4RPV
+  G4ReactionProductVector * FillVoidNucleusProducts(G4ReactionProductVector * );    // nucleus destroyed, add secondaries to G4RPV
 // utility methods
+
   G4ThreeVector GetSpherePoint(G4double r, const G4LorentzVector & momentumdirection);
+
   void ClearAndDestroy(G4KineticTrackVector * ktv);
   void ClearAndDestroy(G4ReactionProductVector * rpv);
 
 // for debugging purpose
+
+  G4ReactionProductVector * ProductsAddFakeGamma(G4ReactionProductVector * products );
+
   void PrintKTVector(G4KineticTrackVector * ktv, std::string comment=std::string(""));
   void PrintKTVector(G4KineticTrack* kt, std::string comment=std::string(""));
   void DebugApplyCollisionFail(G4CollisionInitialState * collision,
 		  	  	  	  	   G4KineticTrackVector * products);
-  void DebugApplyCollision(G4CollisionInitialState * collision, 
+  void DebugApplyCollision(G4CollisionInitialState * collision,
                            G4KineticTrackVector *products);
-  void DebugEpConservation(const G4HadProjectile & aTrack, G4ReactionProductVector* products);			   
-			   
+  G4bool DebugEpConservation(const G4HadProjectile & aTrack, G4ReactionProductVector* products);
+  G4bool CheckChargeAndBaryonNumber(G4String where);
+
 private:
   G4KineticTrackVector theProjectileList;	// replaced by theProjectile4Momentum
   G4KineticTrackVector theTargetList;		// list of nucleons in Nucleus
@@ -167,7 +191,7 @@ private:
   G4CollisionManager * theCollisionMgr;
 
   G4Scatterer * theH1Scatterer;
-  
+
   std::vector<G4BCAction *> theImR;
   G4BCDecay * theDecay;
   G4BCLateParticle * theLateParticle;
@@ -180,8 +204,8 @@ private:
   G4double theCutOnPAbsorb;
   G4LorentzVector theInitial4Mom;   // suppress?
   G4LorentzVector theProjectile4Momentum;
-  G4int currentA, currentZ;
-  G4int initialZ, initialA;
+  G4int currentA, currentZ, lateA, lateZ;
+  G4int initialZ, initialA,projectileA,projectileZ;
   G4double massInNucleus, initial_nuclear_mass;
   G4double currentInitialEnergy;   // for debugging
   G4LorentzRotation precompoundLorentzboost;
@@ -189,8 +213,8 @@ private:
   G4bool thePrimaryEscape;
   G4ParticleDefinition * thePrimaryType;
   G4ThreeVector theMomentumTransfer;
-  
-  
+
+
 
 };
 

source/processes/hadronic/models/binary_cascade/include/G4BinaryLightIonReaction.hh

@@ -24,40 +24,57 @@
 // ********************************************************************
 //
 #ifndef G4BinaryLightIonReaction_h
-#define G4BinaryLightIonReaction_h
+#define G4BinaryLightIonReaction_h 1
 
 #include "G4BinaryCascade.hh"
 #include "G4PreCompoundModel.hh"
 #include "G4HadFinalState.hh"
 #include "G4ExcitationHandler.hh"
 
-class G4BinaryLightIonReaction : public G4HadronicInteraction 
+class G4BinaryLightIonReaction : public G4HadronicInteraction
 {
   public:
-    G4BinaryLightIonReaction();
-    virtual ~G4BinaryLightIonReaction(){}
-    G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack, 
+    G4BinaryLightIonReaction(G4VPreCompoundModel* ptr = 0);
+    virtual ~G4BinaryLightIonReaction();
+    G4HadFinalState* ApplyYourself(const G4HadProjectile& aTrack,
                                               G4Nucleus& theNucleus);
-    void SetPrecompound(G4VPreCompoundModel* const  value);
-    void SetDeExcitation(G4ExcitationHandler* const  value);
+    inline void SetPrecompound(G4VPreCompoundModel* ptr);
+    inline void SetDeExcitation(G4ExcitationHandler* ptr);
+
+    virtual void ModelDescription(std::ostream&) const ;
 
   private:
-    G4BinaryCascade theModel;
+    G4bool EnergyAndMomentumCorrector(G4ReactionProductVector* products,
+               G4LorentzVector& TotalCollisionMom);
+    G4bool SetLighterAsProjectile(G4LorentzVector & mom,const G4LorentzRotation & toBreit);
+    G4ReactionProductVector * FuseNucleiAndPrompound(const G4LorentzVector & mom);
+    G4ReactionProductVector * Interact(G4LorentzVector & mom, const G4LorentzRotation & );
+    G4double GetProjectileExcitation();
+    void DeExciteSpectatorNucleus(G4ReactionProductVector * spectators, G4ReactionProductVector * cascaders,
+                           G4double theStatisticalExEnergy, G4LorentzVector & momentum);
+    G4LorentzVector SortResult(G4ReactionProductVector * result,G4ReactionProductVector * spectators,G4ReactionProductVector * cascaders);
+
+    G4BinaryCascade* theModel;
     G4ExcitationHandler* theHandler;
     G4VPreCompoundModel* theProjectileFragmentation;
     G4HadFinalState theResult;
-    G4bool EnergyAndMomentumCorrector(G4ReactionProductVector* products,
-    				G4LorentzVector& TotalCollisionMom);
+    G4int pA, pZ, tA, tZ,spectatorA,spectatorZ;
+    G4Fancy3DNucleus * projectile3dNucleus, * target3dNucleus;
+    G4FermiMomentum theFermi;
+    G4LorentzVector pInitialState, pFinalState;
+
+    G4bool debug_G4BinaryLightIonReactionResults;
+
 };
-inline void G4BinaryLightIonReaction::SetPrecompound(G4VPreCompoundModel* const  value)
+inline void G4BinaryLightIonReaction::SetPrecompound(G4VPreCompoundModel* ptr)
 {
-   if (theProjectileFragmentation) delete theProjectileFragmentation; 
-   theProjectileFragmentation = value;
+  if(ptr) { theProjectileFragmentation = ptr; }
+  theHandler = theProjectileFragmentation->GetExcitationHandler();
 }
-inline void G4BinaryLightIonReaction::SetDeExcitation(G4ExcitationHandler* const  value)
+inline void G4BinaryLightIonReaction::SetDeExcitation(G4ExcitationHandler* ptr)
 {
-   if (theHandler) delete theHandler; 
-   theHandler = value;
+  theProjectileFragmentation->SetExcitationHandler(ptr);
+  theHandler = ptr;
 }
 
 #endif

source/processes/hadronic/models/binary_cascade/include/G4FieldPropagation.hh

@@ -34,15 +34,15 @@ public:
    G4FieldPropagation() {}
    G4FieldPropagation(const G4FieldPropagation &) {}
 
-   virtual ~G4FieldPropagation() {}
+   virtual ~G4FieldPropagation();
 
-   // Operators
+private:   // Operators
    const G4FieldPropagation & operator=(const G4FieldPropagation &right);
 
    int operator==(const G4FieldPropagation &right) const;
    int operator!=(const G4FieldPropagation &right) const;
 
-    // Methods
+public:    // Methods
 
    // only theActive are propagated, nothing else
    // only theSpectators define the field, nothing else

source/processes/hadronic/models/binary_cascade/include/G4GeneratorPrecompoundInterface.hh

@@ -24,14 +24,13 @@
 // ********************************************************************
 //
 //
-// $Id: G4GeneratorPrecompoundInterface.hh,v 1.6 2010-08-31 16:16:51 vnivanch Exp $
-// GEANT4 tag $Name: not supported by cvs2svn $
+// $Id$
 //
 // -----------------------------------------------------------------------------
 //      GEANT 4 class header file
 //
 //      History: first implementation
-//      HPW, 10DEC 98, the decay part originally written by Gunter Folger 
+//      HPW, 10DEC 98, the decay part originally written by Gunter Folger
 //                in his FTF-test-program.
 //
 //
@@ -39,7 +38,7 @@
 //
 // Class Description
 // Trivial implementation of an intra-nuclear transport. It pworvides coupling
-// of high energy generators with pre equilibrium decay models. 
+// of high energy generators with pre equilibrium decay models.
 // To be used in your physics list in case you need this physics.
 // Class Description - End
 
@@ -56,21 +55,23 @@ class G4KineticTrackVector;
 class G4V3DNucleus;
 class G4ParticleDefinition;
 
-class G4GeneratorPrecompoundInterface : public G4VIntraNuclearTransportModel 
+class G4GeneratorPrecompoundInterface : public G4VIntraNuclearTransportModel
 {
 public:
 
-  G4GeneratorPrecompoundInterface(G4VPreCompoundModel* p = 0);    
+  G4GeneratorPrecompoundInterface(G4VPreCompoundModel* p = 0);
   virtual ~G4GeneratorPrecompoundInterface();
 
-  virtual G4HadFinalState* 
+  virtual G4HadFinalState*
   ApplyYourself(const G4HadProjectile &aTrack, G4Nucleus &targetNucleus );
 
-  virtual G4ReactionProductVector* 
+  virtual G4ReactionProductVector*
   Propagate(G4KineticTrackVector* theSecondaries, G4V3DNucleus* theNucleus);
- 
+
   inline void SetCaptureThreshold(G4double);
 
+  virtual void PropagateModelDescription(std::ostream&) const;
+
 private:
 
   G4GeneratorPrecompoundInterface(const G4GeneratorPrecompoundInterface& right);
@@ -83,7 +84,7 @@ private:
   const G4ParticleDefinition* neutron;
 };
 
-inline 
+inline
 void G4GeneratorPrecompoundInterface::SetCaptureThreshold(G4double value)
 {
   CaptureThreshold=value;

source/processes/hadronic/models/binary_cascade/include/G4KaonMinusField.hh

@@ -39,13 +39,15 @@
 #ifndef G4KaonMinusField_h
 #define  G4KaonMinusField_h 1
 
+#include <CLHEP/Units/SystemOfUnits.h>
+
 #include "G4VNuclearField.hh"
 #include "G4V3DNucleus.hh"
 
 class G4KaonMinusField: public G4VNuclearField
 {
 public:
-  G4KaonMinusField(G4V3DNucleus * nucleus, G4double coeff = 0.35*fermi);
+  G4KaonMinusField(G4V3DNucleus * nucleus, G4double coeff = 0.35*CLHEP::fermi);
   virtual ~G4KaonMinusField();
 
 private:

source/processes/hadronic/models/binary_cascade/include/G4KaonPlusField.hh

@@ -39,13 +39,15 @@
 #ifndef G4KaonPlusField_h
 #define  G4KaonPlusField_h 1
 
+#include <CLHEP/Units/SystemOfUnits.h>
+
 #include "G4VNuclearField.hh"
 #include "G4V3DNucleus.hh"
 
 class G4KaonPlusField: public G4VNuclearField
 {
 public:
-  G4KaonPlusField(G4V3DNucleus * nucleus, G4double coeff = 0.35*fermi);
+  G4KaonPlusField(G4V3DNucleus * nucleus, G4double coeff = 0.35*CLHEP::fermi);
   virtual ~G4KaonPlusField();
 
 private:

source/processes/hadronic/models/binary_cascade/include/G4KaonZeroField.hh

@@ -39,12 +39,14 @@
 #ifndef G4KaonZeroField_h
 #define  G4KaonZeroField_h 1
 
+#include <CLHEP/Units/SystemOfUnits.h>
+
 #include "G4VNuclearField.hh"
 
 class G4KaonZeroField: public G4VNuclearField
 {
 public:
-  G4KaonZeroField(G4V3DNucleus * nucleus, G4double coeff = 0.35*fermi);
+  G4KaonZeroField(G4V3DNucleus * nucleus, G4double coeff = 0.35*CLHEP::fermi);
   virtual ~G4KaonZeroField();
 
 private:

source/processes/hadronic/models/binary_cascade/include/G4PionMinusField.hh

@@ -39,6 +39,8 @@
 #ifndef G4PionMinusField_h
 #define  G4PionMinusField_h 1
 
+#include <CLHEP/Units/SystemOfUnits.h>
+
 #include "G4VNuclearField.hh"
 #include "G4V3DNucleus.hh"
 
@@ -46,11 +48,10 @@ class G4PionMinusField: public G4VNuclearField
 {
 public:
 
-  G4PionMinusField(G4V3DNucleus * nucleus, G4double coeff = 0.042*fermi);
+  G4PionMinusField(G4V3DNucleus * nucleus, G4double coeff = 0.042*CLHEP::fermi);
   virtual ~G4PionMinusField();
 
 private:
-
   G4PionMinusField(const  G4PionMinusField &right);
   const G4PionMinusField & operator=(const G4PionMinusField & right);
   int operator==(const G4PionMinusField & right) const;

source/processes/hadronic/models/binary_cascade/include/G4PionPlusField.hh

@@ -39,13 +39,15 @@
 #ifndef G4PionPlusField_hh
 #define G4PionPlusField_hh
 
+#include <CLHEP/Units/SystemOfUnits.h>
+
 #include "G4VNuclearField.hh"
 #include "G4V3DNucleus.hh"
 
 class G4PionPlusField: public G4VNuclearField
 {
 public:
-  G4PionPlusField(G4V3DNucleus * nucleus, G4double coeff = 0.042*fermi);
+  G4PionPlusField(G4V3DNucleus * nucleus, G4double coeff = 0.042*CLHEP::fermi);
   virtual ~G4PionPlusField();
 
 private:

source/processes/hadronic/models/binary_cascade/include/G4PionZeroField.hh

@@ -39,13 +39,15 @@
 #ifndef G4PionZeroField_h
 #define  G4PionZeroField_h 1
 
+#include <CLHEP/Units/SystemOfUnits.h>
+
 #include "G4VNuclearField.hh"
 #include "G4V3DNucleus.hh"
 
 class G4PionZeroField: public G4VNuclearField
 {
 public:
-  G4PionZeroField(G4V3DNucleus * nucleus, G4double coeff = 0.042*fermi);
+  G4PionZeroField(G4V3DNucleus * nucleus, G4double coeff = 0.042*CLHEP::fermi);
   virtual ~G4PionZeroField();
 
 private:

source/processes/hadronic/models/binary_cascade/include/G4ProtonField.hh

@@ -53,7 +53,6 @@ public:
   virtual ~G4ProtonField();
 
 private:
-
   G4ProtonField(const  G4ProtonField &right);
   const G4ProtonField & operator=(const G4ProtonField & right);
   int operator==(const G4ProtonField & right) const;

source/processes/hadronic/models/binary_cascade/include/G4SigmaMinusField.hh

@@ -39,12 +39,14 @@
 #ifndef G4SigmaMinusField_h
 #define  G4SigmaMinusField_h 1
 
+#include <CLHEP/Units/SystemOfUnits.h>
+
 #include "G4VNuclearField.hh"
 
 class G4SigmaMinusField: public G4VNuclearField
 {
 public:
-  G4SigmaMinusField(G4V3DNucleus * nucleus, G4double coeff = 0.36*fermi);
+  G4SigmaMinusField(G4V3DNucleus * nucleus, G4double coeff = 0.36*CLHEP::fermi);
   virtual ~G4SigmaMinusField();
 
 private:

source/processes/hadronic/models/binary_cascade/include/G4SigmaPlusField.hh

@@ -28,12 +28,14 @@
 #ifndef G4SigmaPlusField_h
 #define  G4SigmaPlusField_h 1
 
+#include <CLHEP/Units/SystemOfUnits.h>
+
 #include "G4VNuclearField.hh"
 
 class G4SigmaPlusField: public G4VNuclearField
 {
 public:
-  G4SigmaPlusField(G4V3DNucleus * nucleus, G4double coeff = 0.36*fermi);
+  G4SigmaPlusField(G4V3DNucleus * nucleus, G4double coeff = 0.36*CLHEP::fermi);
   virtual ~G4SigmaPlusField();
 
 private:

source/processes/hadronic/models/binary_cascade/include/G4SigmaZeroField.hh

@@ -39,12 +39,14 @@
 #ifndef G4SigmaZeroField_h
 #define  G4SigmaZeroField_h 1
 
+#include <CLHEP/Units/SystemOfUnits.h>
+
 #include "G4VNuclearField.hh"
 
 class G4SigmaZeroField: public G4VNuclearField
 {
 public:
-  G4SigmaZeroField(G4V3DNucleus * nucleus, G4double coeff = 0.36*fermi);
+  G4SigmaZeroField(G4V3DNucleus * nucleus, G4double coeff = 0.36*CLHEP::fermi);
   virtual ~G4SigmaZeroField();
 
 private: