Ignore:
Timestamp:
Apr 20, 2009, 5:54:05 PM (15 years ago)
Author:
garnier
Message:

update to geant4.9.2

Location:
trunk/source/processes/hadronic/models/management
Files:
19 edited

Legend:

Unmodified
Added
Removed

  • trunk/source/processes/hadronic/models/management/History

    r962 r1007  
    1515     ---------------------------------------------------------------
    1616
    17 25 February 2009 - V.Ivanchenko (hadr-modman-V09-02-03)
    18 ------------------------------------------------------
    19 -  G4HadronicInteractionRegistry - added protection to the Clean method
    20 
    21 14 February 2009 - V.Ivanchenko (hadr-modman-V09-02-02)
    22 ------------------------------------------------------
    23 -  G4HadronicInteractionRegistry - added Clean method
    24 
    25 06 February 2009 - V.Ivanchenko (hadr-modman-V09-02-01)
    26 ------------------------------------------------------
    27 
    28 23 January 2009 - V.Ivanchenko (hadr-modman-V09-02-00)
    29 ------------------------------------------------------
    30 -  G4HadronicInteractionRegistry - make it as real singleton
    31 -  G4HadronicInteraction, G4InelasticInteraction - move constructor,
    32        destructor and some header files from header to source
    33 
    341719 June 2008 - G.Cosmo  (hadr-modman-V09-01-03)
    3518-----------------------------------------------
    3619-  included change introduced in hadr-modman-V09-01-01 and
    37    discarded by mistake in the last tag ...
     20   discarded by imstake in the last tag ...
    3821
    392219 June 2008 - V.Ivanchenko (hadr-modman-V09-01-02)

  • trunk/source/processes/hadronic/models/management/include/G4HadronicInteraction.hh

    r962 r1007  
    2525//
    2626//
    27 // $Id: G4HadronicInteraction.hh,v 1.9 2009/01/24 11:56:27 vnivanch Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
    29 //
    30 // Hadronic Interaction  abstract base class
    31 // This class is the base class for the model classes.
    32 // It sorts out the energy-range for the models and provides
    33 // class utilities.
    34 // original by H.P. Wellisch
    35 // Modified by J.L.Chuma, TRIUMF, 21-Mar-1997
    36 // Last modified: 3-Apr-1997
    37 // Added units to energy initialization: J.L. Chuma  04-Apr-97
    38 // Modified by J.L.Chuma, 05-May-97  to Initialize theBlockedCounter
    39 // Modified by J.L.Chuma, 08-Jul-97 to implement the Nucleus changes
    40 // Adding a registry for memory management of hadronic models, HPW 22-Mar-99
    41 // 23-Jan-2009 V.Ivanchenko move constructor and destructor to the body
    42 //                          and reorder methods in the header
     27// $Id: G4HadronicInteraction.hh,v 1.8 2007/01/11 05:30:01 dennis Exp $
     28// GEANT4 tag $Name: geant4-09-02 $
     29//
     30 // Hadronic Interaction  abstract base class
     31 // This class is the base class for the model classes.
     32 // It sorts out the energy-range for the models and provides
     33 // class utilities.
     34 // original by H.P. Wellisch
     35 // Modified by J.L.Chuma, TRIUMF, 21-Mar-1997
     36 // Last modified: 3-Apr-1997
     37 // Added units to energy initialization: J.L. Chuma  04-Apr-97
     38 // Modified by J.L.Chuma, 05-May-97  to Initialize theBlockedCounter
     39 // Modified by J.L.Chuma, 08-Jul-97 to implement the Nucleus changes
     40 // Adding a registry for memory management of hadronic models, HPW 22-Mar-99
    4341
    4442// Class Description
    4543// This is the base class for all hadronic interaction models in geant4.
    46 // If you want to implement a new way of producing a final state, please,
    47 //  inherit from here.
     44// If you want to implement a new way of producing a final state, please inherit
     45// from here.
    4846// Class Description - End
    4947 
    … …  
    5250 
    5351#include "G4HadFinalState.hh"
     52#include "G4DynamicParticle.hh"
    5453#include "G4ReactionDynamics.hh"
    5554#include "G4Material.hh"
    … …  
    5756#include "G4Track.hh"
    5857#include "G4HadProjectile.hh"
    59 
    60 class G4HadronicInteraction
    61 {
     58#include "G4HadronicInteractionRegistry.hh"
     59#include "G4HadronicException.hh"
     60
     61 class G4HadronicInteraction
     62 {
     63 public:
     64   
     65    G4HadronicInteraction(const G4String& modelName = "HadronicModel") :
     66      verboseLevel(0), theMinEnergy(0.0*GeV), theMaxEnergy(25.0*GeV),
     67      isBlocked(false), theModelName(modelName)
     68    {
     69      G4HadronicInteractionRegistry::RegisterMe(this);
     70    }
     71   
     72    virtual ~G4HadronicInteraction()
     73    {
     74      G4HadronicInteractionRegistry::RemoveMe(this);
     75    }
     76   
     77 private:
     78   
     79    inline G4HadronicInteraction(
     80     const G4HadronicInteraction &right )
     81    { *this = right; }
     82   
     83    inline const G4HadronicInteraction & operator=(
     84     const G4HadronicInteraction &right )
     85    {
     86     G4String text = "unintended use of G4HadronicInteraction::operator=";
     87     throw G4HadronicException(__FILE__, __LINE__, text);
     88     return right;
     89    }
     90   
     91 public:
     92   
     93    inline G4bool operator==(
     94     const G4HadronicInteraction &right ) const
     95    { return ( this == (G4HadronicInteraction *) &right ); }
     96   
     97    inline G4bool operator!=(
     98     const G4HadronicInteraction &right ) const
     99    { return ( this != (G4HadronicInteraction *) &right ); }
     100   
     101    inline G4double GetMinEnergy() const
     102    { return theMinEnergy; }
     103   
     104    virtual G4double GetMinEnergy( const G4Material *aMaterial,
     105                                  const G4Element *anElement ) const;
     106   
     107    inline void SetMinEnergy( const G4double anEnergy )
     108    { theMinEnergy = anEnergy; }
     109   
     110    virtual void SetMinEnergy( G4double anEnergy, G4Element *anElement );
     111   
     112    virtual void SetMinEnergy( G4double anEnergy, G4Material *aMaterial );
     113   
     114    inline G4double GetMaxEnergy() const
     115    { return theMaxEnergy; }
     116   
     117    virtual G4double GetMaxEnergy( const G4Material *aMaterial,
     118                                  const G4Element *anElement ) const;
     119   
     120    inline void SetMaxEnergy( const G4double anEnergy )
     121    { theMaxEnergy = anEnergy; }
     122   
     123    virtual void SetMaxEnergy( G4double anEnergy, G4Element *anElement );
     124   
     125    virtual void SetMaxEnergy( G4double anEnergy, G4Material *aMaterial );
     126 
     127    inline const G4HadronicInteraction *GetMyPointer() const
     128    { return this; }
     129
     130    inline G4int GetVerboseLevel() const
     131    { return verboseLevel; }
     132
     133    inline void SetVerboseLevel( G4int value )
     134    { verboseLevel = value; }
     135
     136    inline const G4String& GetModelName() const
     137    { return theModelName; }
     138
    62139public: // With description
    63 
    64    
    65   G4HadronicInteraction(const G4String& modelName = "HadronicModel");
    66    
    67   virtual ~G4HadronicInteraction();
    68    
    69   virtual G4HadFinalState *ApplyYourself(const G4HadProjectile &aTrack,
    70                                          G4Nucleus & targetNucleus ) = 0;
    71   // This is the interface to implement for final state production code.
    72    
    73   virtual G4bool IsApplicable(const G4HadProjectile &/*aTrack*/,
    74                               G4Nucleus & /*targetNucleus*/)
    75   {  return true;}
    76  
    77   inline G4double GetMinEnergy() const
    78   { return theMinEnergy; }
    79    
    80   virtual G4double GetMinEnergy( const G4Material *aMaterial,
    81                                  const G4Element *anElement ) const;
    82    
    83   inline void SetMinEnergy( const G4double anEnergy )
    84   { theMinEnergy = anEnergy; }
    85    
    86   virtual void SetMinEnergy( G4double anEnergy, G4Element *anElement );
    87    
    88   virtual void SetMinEnergy( G4double anEnergy, G4Material *aMaterial );
    89    
    90   inline G4double GetMaxEnergy() const
    91   { return theMaxEnergy; }
    92    
    93   virtual G4double GetMaxEnergy( const G4Material *aMaterial,
    94                                  const G4Element *anElement ) const;
    95    
    96   inline void SetMaxEnergy( const G4double anEnergy )
    97   { theMaxEnergy = anEnergy; }
    98    
    99   virtual void SetMaxEnergy( G4double anEnergy, G4Element *anElement );
    100    
    101   virtual void SetMaxEnergy( G4double anEnergy, G4Material *aMaterial );
    102  
    103   inline const G4HadronicInteraction *GetMyPointer() const
    104   { return this; }
    105 
    106   inline G4int GetVerboseLevel() const
    107   { return verboseLevel; }
    108 
    109   inline void SetVerboseLevel( G4int value )
    110   { verboseLevel = value; }
    111 
    112   inline const G4String& GetModelName() const
    113   { return theModelName; }
     140    // This is the interface to implement for final state production code.
     141   
     142    virtual G4HadFinalState *ApplyYourself(
     143            const G4HadProjectile &aTrack, G4Nucleus & targetNucleus ) = 0;
    114144   
    115145public: // Without description
    116146
    117   virtual void DeActivateFor( G4Material *aMaterial );
    118    
    119   virtual void ActivateFor( G4Material *aMaterial )
    120   {
    121     Block();
    122     SetMaxEnergy(GetMaxEnergy(), aMaterial);
    123     SetMinEnergy(GetMinEnergy(), aMaterial);
    124   }
    125 
    126   virtual void DeActivateFor( G4Element *anElement );
    127   virtual void ActivateFor( G4Element *anElement )
    128   {
    129     Block();
    130     SetMaxEnergy(GetMaxEnergy(), anElement);
    131     SetMinEnergy(GetMinEnergy(), anElement);
    132   }
    133 
    134   virtual G4bool IsBlocked( const G4Material *aMaterial ) const;
    135 
    136   virtual G4bool IsBlocked( const G4Element *anElement) const;
    137 
    138   inline G4bool operator==(const G4HadronicInteraction &right ) const
    139   { return ( this == (G4HadronicInteraction *) &right ); }
    140    
    141   inline G4bool operator!=(const G4HadronicInteraction &right ) const
    142   { return ( this != (G4HadronicInteraction *) &right ); }
    143    
    144 private:
    145    
    146   G4HadronicInteraction(const G4HadronicInteraction &right );
    147    
    148   const G4HadronicInteraction& operator=(const G4HadronicInteraction &right);
    149 
    150 protected:
    151 
    152   inline G4bool IsBlocked() const { return isBlocked;}
    153   inline void Block() { isBlocked = true; }
    154    
    155   G4HadFinalState theParticleChange;
    156   // the G4HadFinalState object which is modified and returned
    157   // by address by the ApplyYourself method,
    158   // (instead of aParticleChange as found in G4VProcess)
    159    
    160   G4int verboseLevel;
    161   // control flag for output messages
    162   // 0: silent
    163   // 1: warning messages
    164   // 2: more
    165   // (instead of verboseLevel as found in G4VProcess)
    166    
    167   G4ReactionDynamics theReactionDynamics;
    168    
    169   // these two have global validity
    170   // units are assumed to be MeV
    171    
    172   G4double theMinEnergy;
    173   G4double theMaxEnergy;
    174    
    175   G4bool isBlocked;
    176 
    177   G4String theModelName;
    178    
    179 private:
     147    virtual void DeActivateFor( G4Material *aMaterial );
     148   
     149    virtual void ActivateFor( G4Material *aMaterial )
     150    {
     151      Block();
     152      SetMaxEnergy(GetMaxEnergy(), aMaterial);
     153      SetMinEnergy(GetMinEnergy(), aMaterial);
     154    }
     155
     156    virtual void DeActivateFor( G4Element *anElement );
     157    virtual void ActivateFor( G4Element *anElement )
     158    {
     159      Block();
     160      SetMaxEnergy(GetMaxEnergy(), anElement);
     161      SetMinEnergy(GetMinEnergy(), anElement);
     162    }
     163
     164    virtual G4bool IsBlocked( const G4Material *aMaterial ) const;
     165
     166    virtual G4bool IsBlocked( const G4Element *anElement) const;
     167   
     168    virtual G4bool IsApplicable(const G4HadProjectile &/*aTrack*/,
     169                               G4Nucleus & /*targetNucleus*/){  return true;}
     170 protected:
     171   
     172    G4HadFinalState theParticleChange;
     173    // the G4HadFinalState object which is modified and returned
     174    // by address by the ApplyYourself method,
     175    // (instead of aParticleChange as found in G4VProcess)
     176   
     177    G4int verboseLevel;
     178    // control flag for output messages
     179    // 0: silent
     180    // 1: warning messages
     181    // 2: more
     182    // (instead of verboseLevel as found in G4VProcess)
     183   
     184    G4ReactionDynamics theReactionDynamics;
     185   
     186    // these two have global validity
     187    // units are assumed to be MeV
     188   
     189    G4double theMinEnergy;
     190    G4double theMaxEnergy;
     191   
     192    G4bool IsBlocked() const { return isBlocked;}
     193    void Block() { isBlocked = true; }
     194    G4bool isBlocked;
     195
     196    G4String theModelName;
     197   
     198 private:
    180199       
    181    std::vector<std::pair<G4double, G4Material *> > theMinEnergyList;
    182    std::vector<std::pair<G4double, G4Material *> > theMaxEnergyList;
    183    std::vector<std::pair<G4double, G4Element *> > theMinEnergyListElements;
    184    std::vector<std::pair<G4double, G4Element *> > theMaxEnergyListElements;
    185    std::vector<G4Material *> theBlockedList;
    186    std::vector<G4Element *> theBlockedListElements;
    187 };
     200    std::vector<std::pair<G4double, G4Material *> > theMinEnergyList;
     201    std::vector<std::pair<G4double, G4Material *> > theMaxEnergyList;
     202    std::vector<std::pair<G4double, G4Element *> > theMinEnergyListElements;
     203    std::vector<std::pair<G4double, G4Element *> > theMaxEnergyListElements;
     204    std::vector<G4Material *> theBlockedList;
     205    std::vector<G4Element *> theBlockedListElements;
     206 };
    188207 
    189208#endif

  • trunk/source/processes/hadronic/models/management/include/G4HadronicInteractionRegistry.hh

    r962 r1007  
    2424// ********************************************************************
    2525//
    26 // $Id: G4HadronicInteractionRegistry.hh,v 1.4 2009/02/14 19:24:52 vnivanch Exp $
    27 // GEANT4 tag $Name: geant4-09-02-ref-02 $
    28 //
    29 // 23-Jan-2009 V.Ivanchenko make the class to be a singleton
    30 
    31 // Class Description
    32 // This is the a singleton class to store all hadronic interactions
    33 // Class Description - End
    34 
    3526#ifndef G4HadronicInteractionRegistry_h
    3627#define G4HadronicInteractionRegistry_h 1
    … …  
    3829#include <vector>
    3930#include "globals.hh"
    40 
    4131class G4HadronicInteraction;
    4232
    4333class G4HadronicInteractionRegistry
    4434{
    45 public:
    46 
    47   static G4HadronicInteractionRegistry* Instance();
    48   // access
     35  public:
    4936 
    5037  ~G4HadronicInteractionRegistry();
     38 
     39  static void RegisterMe(G4HadronicInteraction * aModel);
     40  static void RemoveMe(G4HadronicInteraction * aModel);
     41   
     42  protected:
    5143
    52   void Clean();
    53   //delete models
    54  
    55   void RegisterMe(G4HadronicInteraction * aModel);
    56   //register new model
     44  G4HadronicInteractionRegistry(G4String );
     45  static G4HadronicInteractionRegistry & theRegistry();
    5746
    58   void RemoveMe(G4HadronicInteraction * aModel);
    59   //deregister model
    60    
    61 private:
     47  private:
    6248
    63   G4HadronicInteractionRegistry();
     49  //  !!!  can not use "copy constructor" nor "default constructor" !!!!
     50       G4HadronicInteractionRegistry(const G4HadronicInteractionRegistry &right)
     51       { nModels = right.nModels; }
     52       G4HadronicInteractionRegistry() {nModels = 0;}
    6453
    65   static G4HadronicInteractionRegistry* theInstance;
     54  //  !!!  Assignment operation is forbidden !!!
     55      const G4HadronicInteractionRegistry & operator=(const G4HadronicInteractionRegistry &)
     56      { return *this;}
     57
     58  void AddModel(G4HadronicInteraction * aModel);
    6659 
    6760  G4int nModels;

  • trunk/source/processes/hadronic/models/management/include/G4InelasticInteraction.hh

    r962 r1007  
    2525//
    2626//
    27 // $Id: G4InelasticInteraction.hh,v 1.6 2009/01/24 11:56:27 vnivanch Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4InelasticInteraction.hh,v 1.5 2007/01/11 05:30:12 dennis Exp $
     28// GEANT4 tag $Name: geant4-09-02 $
    2929//
    30 // Hadronic Process: Inelastic Interaction
    31 // This class is an abstract base class, since the pure virtual
    32 // function ApplyYourself has not been defined yet.
    33 // original by H.P. Wellisch
    34 // Modified by J.L. Chuma, TRIUMF, 22-Nov-1996
    35 // Modified by J.L. Chuma  27-Mar-1997
    36 // Modified by J.L. Chuma  30-Apr-1997
    37 // Modified by J.L. Chuma  05-Aug-1997  to pass the original incident particle to
    38 //                                      CalculateMomenta
    39 // Modified by J.L. Chuma  05-Jun-1998  to include quasiElastic flag to allow for
    40 //                                      TwoBody to be called directly, bypassing
    41 //                                      TwoCluster, and allowing TwoCluster to be
    42 //                                      called with no secondaries
    43 // 23-Jan-2009 V.Ivanchenko move constructor and destructor to the body
     30 // Hadronic Process: Inelastic Interaction
     31 // This class is an abstract base class, since the pure virtual
     32 // function ApplyYourself has not been defined yet.
     33 // original by H.P. Wellisch
     34 // Modified by J.L. Chuma, TRIUMF, 22-Nov-1996
     35 // Modified by J.L. Chuma  27-Mar-1997
     36 // Modified by J.L. Chuma  30-Apr-1997
     37 // Modified by J.L. Chuma  05-Aug-1997  to pass the original incident particle to
     38 //                                      CalculateMomenta
     39 // Modified by J.L. Chuma  05-Jun-1998  to include quasiElastic flag to allow for
     40 //                                      TwoBody to be called directly, bypassing
     41 //                                      TwoCluster, and allowing TwoCluster to be
     42 //                                      called with no secondaries
    4443 
    4544#ifndef G4InelasticInteraction_h
    … …  
    5453#include "G4ReactionDynamics.hh"
    5554
    56 class G4InelasticInteraction : public G4HadronicInteraction
    57 {
    58 public:
     55 class G4InelasticInteraction : public G4HadronicInteraction
     56 {
     57 public:
    5958   
    60     G4InelasticInteraction(const G4String& modelName = "LEInelastic");
     59    G4InelasticInteraction(const G4String& modelName = "LEInelastic")
     60     : G4HadronicInteraction(modelName)
     61    { cache = 0.0;}
    6162   
    62     virtual ~G4InelasticInteraction();
     63    virtual ~G4InelasticInteraction()
     64    { }
    6365   
    64 protected:
     66 protected:
    6567   
    6668    G4double Pmltpc( G4int np, G4int nm, G4int nz, G4int n,
    … …  
    98100                      G4ReactionProduct &targetParticle,
    99101                      G4bool &incidentHasChanged );
    100 private:
     102   private:
    101103   
    102104      G4double cache;
    103105      G4ThreeVector what;
    104106
    105 };
     107 };
    106108 
    107109#endif

  • trunk/source/processes/hadronic/models/management/include/G4V3DNucleus.hh

    r962 r1007  
    2626//
    2727// $Id: G4V3DNucleus.hh,v 1.6 2008/05/16 14:02:37 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     28// GEANT4 tag $Name: geant4-09-02 $
    2929//
    3030#ifndef G4V3DNucleus_h

  • trunk/source/processes/hadronic/models/management/include/G4VHighEnergyGenerator.hh

    r962 r1007  
    2626//
    2727// $Id: G4VHighEnergyGenerator.hh,v 1.4 2006/06/29 20:45:41 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     28// GEANT4 tag $Name: geant4-09-02 $
    2929//
    3030#ifndef G4VHighEnergyGenerator_h

  • trunk/source/processes/hadronic/models/management/include/G4VIntraNuclearTransportModel.hh

    r962 r1007  
    2626//
    2727// $Id: G4VIntraNuclearTransportModel.hh,v 1.4 2007/01/11 05:29:46 dennis Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     28// GEANT4 tag $Name: geant4-09-02 $
    2929//
    3030// $Id: G4IntraNuclearTransportMode.hh,v 1.0 1998/06/30

  • trunk/source/processes/hadronic/models/management/include/G4VKineticNucleon.hh

    r962 r1007  
    2626//
    2727// $Id: G4VKineticNucleon.hh,v 1.4 2006/06/29 20:45:47 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     28// GEANT4 tag $Name: geant4-09-02 $
    2929//
    3030#ifndef G4VKineticNucleon_h

  • trunk/source/processes/hadronic/models/management/include/G4VNuclearDensity.hh

    r962 r1007  
    2626//
    2727// $Id: G4VNuclearDensity.hh,v 1.4 2006/06/29 20:45:49 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     28// GEANT4 tag $Name: geant4-09-02 $
    2929//
    3030#ifndef G4VNuclearDensity_h

  • trunk/source/processes/hadronic/models/management/include/G4VPreCompoundModel.hh

    r962 r1007  
    2626//
    2727// $Id: G4VPreCompoundModel.hh,v 1.5 2007/01/11 05:29:34 dennis Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     28// GEANT4 tag $Name: geant4-09-02 $
    2929//
    3030

  • trunk/source/processes/hadronic/models/management/src/G4HadronicInteraction.cc

    r962 r1007  
    2424// ********************************************************************
    2525//
    26 // $Id: G4HadronicInteraction.cc,v 1.4 2009/01/24 11:56:27 vnivanch Exp $
    27 // GEANT4 tag $Name: geant4-09-02-ref-02 $
    2826//
    29 // Hadronic Interaction  base class
    30 // original by H.P. Wellisch
    31 // modified by J.L. Chuma, TRIUMF, 21-Mar-1997
    32 // Last modified: 04-Apr-1997
    33 // reimplemented 1.11.2003 JPW.
    34 // 23-Jan-2009 V.Ivanchenko move constructor and destructor to the body
    35 
     27 // Hadronic Interaction  base class
     28 // original by H.P. Wellisch
     29 // modified by J.L. Chuma, TRIUMF, 21-Mar-1997
     30 // Last modified: 04-Apr-1997
     31 // reimplemented 1.11.2003 JPW.
     32 
    3633#include "G4HadronicInteraction.hh"
    37 #include "G4HadronicInteractionRegistry.hh"
    38 #include "G4HadronicException.hh"
    39 
    40 G4HadronicInteraction::G4HadronicInteraction(const G4String& modelName) :
    41   verboseLevel(0), theMinEnergy(0.0*GeV), theMaxEnergy(25.0*GeV),
    42   isBlocked(false), theModelName(modelName)
    43 {
    44   G4HadronicInteractionRegistry::Instance()->RegisterMe(this);
    45 }
    46    
    47 G4HadronicInteraction::~G4HadronicInteraction()
    48 {
    49   G4HadronicInteractionRegistry::Instance()->RemoveMe(this);
    50 }
    51  
    52 G4double G4HadronicInteraction::GetMinEnergy(
     34 
     35 G4double
     36  G4HadronicInteraction::GetMinEnergy(
    5337   const G4Material *aMaterial, const G4Element *anElement ) const
    54 {
    55   size_t i;
    56   if( IsBlocked(aMaterial) )return 0.*GeV;
    57   if( IsBlocked(anElement) )return 0.*GeV;
    58   for( i=0; i<theMinEnergyListElements.size(); ++i )
    59     {
    60       if( anElement == theMinEnergyListElements[i].second )
    61         return theMinEnergyListElements[i].first;
     38  {
     39    size_t i;
     40    if( IsBlocked(aMaterial) )return 0.*GeV;
     41    if( IsBlocked(anElement) )return 0.*GeV;
     42    for( i=0; i<theMinEnergyListElements.size(); ++i )
     43    {
     44      if( anElement == theMinEnergyListElements[i].second )return theMinEnergyListElements[i].first;
    6245    }
    6346    for( i=0; i<theMinEnergyList.size(); ++i )
    6447    {
    65       if( aMaterial == theMinEnergyList[i].second )
    66         return theMinEnergyList[i].first;
     48      if( aMaterial == theMinEnergyList[i].second )return theMinEnergyList[i].first;
    6749    }
    6850    if(IsBlocked()) return 0.*GeV;
    … …  
    7254           << " not found in min energy List" << G4endl;
    7355    return theMinEnergy;
    74 }
    75  
    76 void G4HadronicInteraction::SetMinEnergy(G4double anEnergy,
    77                                          G4Element *anElement )
    78 {
    79   if( IsBlocked(anElement) )
    80     G4cout << "*** Warning from HadronicInteraction::SetMinEnergy" << G4endl
     56  }
     57 
     58 void
     59  G4HadronicInteraction::SetMinEnergy(
     60   G4double anEnergy,
     61   G4Element *anElement )
     62  {
     63    if( IsBlocked(anElement) )
     64      G4cout << "*** Warning from HadronicInteraction::SetMinEnergy" << G4endl
    8165           << "    The model is not active for the Element  "
    8266           << anElement->GetName() << "." << G4endl;
    8367   
    84   for( size_t i=0; i<theMinEnergyListElements.size(); ++i )
     68    for( size_t i=0; i<theMinEnergyListElements.size(); ++i )
    8569    {
    8670      if( anElement == theMinEnergyListElements[i].second )
    … …  
    9074      }
    9175    }
    92   theMinEnergyListElements.push_back(std::pair<G4double, G4Element *>(anEnergy, anElement));
    93 }
    94  
    95 void G4HadronicInteraction::SetMinEnergy(G4double anEnergy,
    96                                          G4Material *aMaterial )
    97 {
    98   if( IsBlocked(aMaterial) )
    99     G4cout << "*** Warning from HadronicInteraction::SetMinEnergy" << G4endl
     76    theMinEnergyListElements.push_back(std::pair<G4double, G4Element *>(anEnergy, anElement));
     77  }
     78 
     79 void
     80  G4HadronicInteraction::SetMinEnergy(
     81   G4double anEnergy,
     82   G4Material *aMaterial )
     83  {
     84    if( IsBlocked(aMaterial) )
     85      G4cout << "*** Warning from HadronicInteraction::SetMinEnergy" << G4endl
    10086           << "    The model is not active for the Material "
    10187           << aMaterial->GetName() << "." << G4endl;
    10288   
    103   for( size_t i=0; i<theMinEnergyList.size(); ++i )
     89    for( size_t i=0; i<theMinEnergyList.size(); ++i )
    10490    {
    10591      if( aMaterial == theMinEnergyList[i].second )
    106         {
    107           theMinEnergyList[i].first = anEnergy;
    108           return;
    109         }
    110     }
    111   theMinEnergyList.push_back(std::pair<G4double, G4Material *>(anEnergy, aMaterial));
    112 }
    113  
    114 G4double G4HadronicInteraction::GetMaxEnergy(const G4Material *aMaterial,
    115                                              const G4Element *anElement ) const
    116 {
    117   size_t i;
    118   if( IsBlocked(aMaterial) )return 0.0*GeV;
    119   if( IsBlocked(anElement) )return 0.0*GeV;
    120   for( i=0; i<theMaxEnergyListElements.size(); ++i )
    121     {
    122       if( anElement == theMaxEnergyListElements[i].second )
    123         return theMaxEnergyListElements[i].first;
     92      {
     93        theMinEnergyList[i].first = anEnergy;
     94        return;
     95      }
     96    }
     97    theMinEnergyList.push_back(std::pair<G4double, G4Material *>(anEnergy, aMaterial));
     98  }
     99 
     100 G4double
     101  G4HadronicInteraction::GetMaxEnergy(
     102   const G4Material *aMaterial, const G4Element *anElement ) const
     103  {
     104    size_t i;
     105    if( IsBlocked(aMaterial) )return 0.0*GeV;
     106    if( IsBlocked(anElement) )return 0.0*GeV;
     107    for( i=0; i<theMaxEnergyListElements.size(); ++i )
     108    {
     109      if( anElement == theMaxEnergyListElements[i].second )return theMaxEnergyListElements[i].first;
    124110    }
    125111    for( i=0; i<theMaxEnergyList.size(); ++i )
    126112    {
    127       if( aMaterial == theMaxEnergyList[i].second )
    128         return theMaxEnergyList[i].first;
     113      if( aMaterial == theMaxEnergyList[i].second )return theMaxEnergyList[i].first;
    129114    }
    130115    if(IsBlocked()) return 0.*GeV;
    131116    if( verboseLevel > 0 )
    132117      G4cout << "*** Warning from HadronicInteraction::GetMaxEnergy" << G4endl
    133              << "    material " << aMaterial->GetName()
    134              << " not found in min energy List" << G4endl;
     118           << "    material " << aMaterial->GetName()
     119           << " not found in min energy List" << G4endl;
    135120   
    136121    return theMaxEnergy;
    137 }
    138  
    139 void G4HadronicInteraction::SetMaxEnergy(G4double anEnergy,
    140                                          G4Element *anElement )
    141 {
    142   if( IsBlocked(anElement) )
    143     G4cout << "*** Warning from HadronicInteraction::SetMaxEnergy" << G4endl
     122  }
     123 
     124 void
     125  G4HadronicInteraction::SetMaxEnergy(
     126   G4double anEnergy,
     127   G4Element *anElement )
     128  {
     129    if( IsBlocked(anElement) )
     130      G4cout << "*** Warning from HadronicInteraction::SetMaxEnergy" << G4endl
    144131           << "Warning: The model is not active for the Element  "
    145132           << anElement->GetName() << "." << G4endl;
    146133   
    147   for( size_t i=0; i<theMaxEnergyListElements.size(); ++i )
     134    for( size_t i=0; i<theMaxEnergyListElements.size(); ++i )
    148135    {
    149136      if( anElement == theMaxEnergyListElements[i].second )
    … …  
    153140      }
    154141    }
    155   theMaxEnergyListElements.push_back(std::pair<G4double, G4Element *>(anEnergy, anElement));
    156 }
    157 
    158 void G4HadronicInteraction::SetMaxEnergy(G4double anEnergy,
    159                                          G4Material *aMaterial )
    160 {
    161   if( IsBlocked(aMaterial) )
    162     G4cout << "*** Warning from HadronicInteraction::SetMaxEnergy" << G4endl
     142    theMaxEnergyListElements.push_back(std::pair<G4double, G4Element *>(anEnergy, anElement));
     143  }
     144
     145 void
     146  G4HadronicInteraction::SetMaxEnergy(
     147   G4double anEnergy,
     148   G4Material *aMaterial )
     149  {
     150    if( IsBlocked(aMaterial) )
     151      G4cout << "*** Warning from HadronicInteraction::SetMaxEnergy" << G4endl
    163152           << "Warning: The model is not active for the Material "
    164153           << aMaterial->GetName() << "." << G4endl;
    165154   
    166   for( size_t i=0; i<theMaxEnergyList.size(); ++i )
     155    for( size_t i=0; i<theMaxEnergyList.size(); ++i )
    167156    {
    168157      if( aMaterial == theMaxEnergyList[i].second )
    169         {
     158      {
    170159        theMaxEnergyList[i].first = anEnergy;
    171160        return;
    172         }
    173     }
    174   theMaxEnergyList.push_back(std::pair<G4double, G4Material *>(anEnergy, aMaterial));
    175 }
    176 
    177 void G4HadronicInteraction::DeActivateFor( G4Material *aMaterial )
    178 {
    179   theBlockedList.push_back(aMaterial);
    180 }
    181 
    182 void G4HadronicInteraction::DeActivateFor( G4Element *anElement )
    183 {
    184   theBlockedListElements.push_back(anElement);
    185 }
    186 
    187 G4bool G4HadronicInteraction::IsBlocked( const G4Material *aMaterial ) const
    188 {
    189   for( size_t i=0; i<theBlockedList.size(); ++i )
     161      }
     162    }
     163    theMaxEnergyList.push_back(std::pair<G4double, G4Material *>(anEnergy, aMaterial));
     164  }
     165
     166 void
     167  G4HadronicInteraction::DeActivateFor( G4Material *aMaterial )
     168  {
     169    theBlockedList.push_back(aMaterial);
     170  }
     171
     172 void
     173  G4HadronicInteraction::DeActivateFor( G4Element *anElement )
     174  {
     175    theBlockedListElements.push_back(anElement);
     176  }
     177
     178 G4bool
     179  G4HadronicInteraction::IsBlocked( const G4Material *aMaterial ) const
     180  {
     181    for( size_t i=0; i<theBlockedList.size(); ++i )
    190182    {
    191183      if( aMaterial == theBlockedList[i] )
    192         {
    193           return true;
    194         }
    195     }
    196   return false;
    197 }
    198  
    199 G4bool G4HadronicInteraction::IsBlocked( const G4Element *anElement ) const
    200 {
    201   for( size_t i=0; i<theBlockedListElements.size(); ++i )
     184      {
     185        return true;
     186      }
     187    }
     188    return false;
     189  }
     190 
     191 G4bool
     192  G4HadronicInteraction::IsBlocked( const G4Element *anElement ) const
     193  {
     194    for( size_t i=0; i<theBlockedListElements.size(); ++i )
    202195    {
    203196      if( anElement == theBlockedListElements[i] )
    204         {
    205           return true;
    206         }
    207     }
    208   return false;
    209 }
    210 
    211 G4HadronicInteraction::G4HadronicInteraction(const G4HadronicInteraction &right )
    212 {
    213   *this = right;
    214 }
    215    
    216 const G4HadronicInteraction&
    217 G4HadronicInteraction::operator=(const G4HadronicInteraction &right )
    218 {
    219   G4String text = "unintended use of G4HadronicInteraction::operator=";
    220   throw G4HadronicException(__FILE__, __LINE__, text);
    221   return right;
    222 }
    223  
    224 /* end of file */
    225  
     197      {
     198        return true;
     199      }
     200    }
     201    return false;
     202  }
     203 
     204 /* end of file */
     205 

  • trunk/source/processes/hadronic/models/management/src/G4HadronicInteractionRegistry.cc

    r962 r1007  
    2424// ********************************************************************
    2525//
    26 // $Id: G4HadronicInteractionRegistry.cc,v 1.7 2009/02/25 16:30:18 vnivanch Exp $
    27 // GEANT4 tag $Name: geant4-09-02-ref-02 $
    28 //
    29 // 23-Jan-2009 V.Ivanchenko make the class to be a singleton
    30 
    3126#include "G4HadronicInteractionRegistry.hh"
    3227#include "G4HadronicInteraction.hh"
    3328
    34 G4HadronicInteractionRegistry* G4HadronicInteractionRegistry::theInstance = 0;
    35 
    36 G4HadronicInteractionRegistry* G4HadronicInteractionRegistry::Instance()
     29G4HadronicInteractionRegistry & G4HadronicInteractionRegistry::theRegistry()
    3730{
    38   if(0 == theInstance) {
    39     static G4HadronicInteractionRegistry manager;
    40     theInstance = &manager;
    41   }
    42   return theInstance;
    43 }
    44 
    45 G4HadronicInteractionRegistry::G4HadronicInteractionRegistry()
    46 {
    47   nModels = 0;
    48 }
    49 
    50 G4HadronicInteractionRegistry::~G4HadronicInteractionRegistry()
    51 {
    52   Clean();
    53 }
    54 
    55 void G4HadronicInteractionRegistry::Clean()
    56 {
    57   //G4cout << "G4HadronicInteractionRegistry::Clean() start " << nModels << G4endl;
    58   if(0 < nModels) {
    59     for (G4int i=0; i<nModels; i++) {
    60       if( allModels[i] ) {
    61         //G4cout << "delete " << i << G4endl;
    62         //G4cout << allModels[i]->GetModelName() << G4endl;
    63         delete allModels[i];
    64         allModels[i] = 0;
    65       }
    66     }
    67   }
    68   //G4cout << "G4HadronicInteractionRegistry::Clean() is done " << G4endl;
    69   nModels = 0;
     31  static G4HadronicInteractionRegistry theRegistryInstance;
     32  return theRegistryInstance;
    7033}
    7134
    … …  
    7336RegisterMe(G4HadronicInteraction * aModel)
    7437{
    75   if(nModels > 0) {
    76     for (G4int i=0; i<nModels; i++) {
    77       if( aModel == allModels[i] ) return;
    78     }
    79   }
    80   //G4cout << "Register model <" << aModel->GetModelName()
    81   //<< ">  " << nModels << G4endl;
    82   allModels.push_back(aModel);
    83   nModels++;
     38  theRegistry().AddModel(aModel);
    8439}
    8540
    … …  
    8742RemoveMe(G4HadronicInteraction * aModel)
    8843{
    89   if(nModels > 0) {
    90     for (G4int i=0; i<nModels; i++) {
    91       if( aModel == allModels[i] ) {
    92         //G4cout << "DeRegister model <" << aModel->GetModelName()
    93         //<< ">  " << i << G4endl;
    94         allModels[i] = 0;
    95         return;
    96       }
     44  theRegistry().allModels.erase(std::find(theRegistry().allModels.begin(),
     45                                          theRegistry().allModels.end(), aModel));
     46  theRegistry().nModels = theRegistry().allModels.size();
     47}
     48
     49G4HadronicInteractionRegistry::~G4HadronicInteractionRegistry()
     50{
     51  /*
     52  while(allModels.size()!=0)
     53  {
     54    delete allModels.front();
     55  }
     56  */
     57}
     58
     59void G4HadronicInteractionRegistry::
     60AddModel(G4HadronicInteraction * aModel)
     61{
     62  G4bool alreadyThere = false;
     63  for(G4int i=0; i<nModels; i++)
     64  {
     65    if(allModels[i]==aModel)
     66    {
     67      alreadyThere = true;
     68      break;
    9769    }
    9870  }
     71  if(!alreadyThere)
     72  {
     73    nModels++;
     74    allModels.push_back(aModel);
     75  }
    9976}

  • trunk/source/processes/hadronic/models/management/src/G4InelasticInteraction.cc

    r962 r1007  
    2424// ********************************************************************
    2525//
    26 // $Id: G4InelasticInteraction.cc,v 1.12 2009/01/24 11:56:27 vnivanch Exp $
    27 // GEANT4 tag $Name: geant4-09-02-ref-02 $
    2826//
    29 // Hadronic Process: Inelastic Interaction
    30 // original by H.P. Wellisch
    31 // modified by J.L. Chuma, TRIUMF, 22-Nov-1996
    32 // Last modified: 27-Mar-1997
    33 // J.P. Wellisch: 23-Apr-97: throw G4HadronicException(__FILE__, __LINE__,  removed
    34 // J.P. Wellisch: 24-Apr-97: correction for SetUpPions
    35 // Modified by J.L. Chuma, 30-Apr-97: added originalTarget to CalculateMomenta
    36 //                                    since TwoBody needed to reset the target particle
    37 // J.L. Chuma, 20-Jun-97: Modified CalculateMomenta to correct the decision process
    38 //                        for whether to use GenerateXandPt or TwoCluster
    39 // J.L. Chuma, 06-Aug-97: added original incident particle, before Fermi motion and
    40 //                        evaporation effects are included, needed for calculating
    41 //                        self absorption and corrections for single particle spectra
    42 // HPW removed misunderstanding of LocalEnergyDeposit, 11.04.98.
    43 // 23-Jan-2009 V.Ivanchenko move constructor and destructor to the body
     27//
     28 // Hadronic Process: Inelastic Interaction
     29 // original by H.P. Wellisch
     30 // modified by J.L. Chuma, TRIUMF, 22-Nov-1996
     31 // Last modified: 27-Mar-1997
     32 // J.P. Wellisch: 23-Apr-97: throw G4HadronicException(__FILE__, __LINE__,  removed
     33 // J.P. Wellisch: 24-Apr-97: correction for SetUpPions
     34 // Modified by J.L. Chuma, 30-Apr-97: added originalTarget to CalculateMomenta
     35 //                                    since TwoBody needed to reset the target particle
     36 // J.L. Chuma, 20-Jun-97: Modified CalculateMomenta to correct the decision process
     37 //                        for whether to use GenerateXandPt or TwoCluster
     38 // J.L. Chuma, 06-Aug-97: added original incident particle, before Fermi motion and
     39 //                        evaporation effects are included, needed for calculating
     40 //                        self absorption and corrections for single particle spectra
     41 // HPW removed misunderstanding of LocalEnergyDeposit, 11.04.98.
    4442 
    4543#include "G4InelasticInteraction.hh"
    4644#include "Randomize.hh"
    4745#include "G4HadReentrentException.hh"
    48 
    49 G4InelasticInteraction::G4InelasticInteraction(const G4String& modelName)
    50   : G4HadronicInteraction(modelName)
    51 { cache = 0.0;}
    52    
    53 G4InelasticInteraction::~G4InelasticInteraction()
    54 {}
    55  
    56 G4double
     46 
     47 G4double
    5748  G4InelasticInteraction::Pmltpc(      // used in Cascade functions
    5849   G4int np, G4int nm, G4int nz, G4int n, G4double b, G4double c )
    … …  
    7263  }
    7364
    74 G4bool
     65 G4bool
    7566  G4InelasticInteraction::MarkLeadingStrangeParticle(
    7667   const G4ReactionProduct &currentParticle,
    … …  
    10192  }
    10293 
    103 void
     94 void
    10495  G4InelasticInteraction::SetUpPions(
    10596   const G4int np,
    … …  
    135126  }
    136127 
    137 void
     128 void
    138129  G4InelasticInteraction::GetNormalizationConstant(
    139130   const G4double energy,  // MeV,  <0 means annihilation channels
    … …  
    179170  }
    180171 
    181 void
     172 void
    182173  G4InelasticInteraction::CalculateMomenta(
    183174   G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,
    … …  
    353344
    354345 
    355 void G4InelasticInteraction::
     346 void G4InelasticInteraction::
    356347 Rotate(G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec, G4int &vecLen)
    357348 {
    … …  
    367358 }     
    368359
    369 void
     360 void
    370361  G4InelasticInteraction::SetUpChange(
    371362   G4FastVector<G4ReactionProduct,GHADLISTSIZE> &vec,

  • trunk/source/processes/hadronic/models/management/src/G4V3DNucleus.cc

    r962 r1007  
    2626//
    2727// $Id: G4V3DNucleus.cc,v 1.5 2006/06/29 20:45:59 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     28// GEANT4 tag $Name: geant4-09-02 $
    2929//
    3030#include "G4V3DNucleus.hh"

  • trunk/source/processes/hadronic/models/management/src/G4VHighEnergyGenerator.cc

    r962 r1007  
    2626//
    2727// $Id: G4VHighEnergyGenerator.cc,v 1.5 2006/06/29 20:46:03 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     28// GEANT4 tag $Name: geant4-09-02 $
    2929//
    3030// G4VHighEnergyGenerator

  • trunk/source/processes/hadronic/models/management/src/G4VIntraNuclearTransportModel.cc

    r962 r1007  
    2626//
    2727// $Id: G4VIntraNuclearTransportModel.cc,v 1.5 2007/01/11 05:28:56 dennis Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     28// GEANT4 tag $Name: geant4-09-02 $
    2929//
    3030// $Id: G4VIntraNuclearTransportModel.cc,v 1.0 1998/06/30

  • trunk/source/processes/hadronic/models/management/src/G4VKineticNucleon.cc

    r962 r1007  
    2626//
    2727// $Id: G4VKineticNucleon.cc,v 1.3 2006/06/29 20:46:07 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     28// GEANT4 tag $Name: geant4-09-02 $
    2929//
    3030#include "G4VKineticNucleon.hh"

  • trunk/source/processes/hadronic/models/management/src/G4VNuclearDensity.cc

    r962 r1007  
    2626//
    2727// $Id: G4VNuclearDensity.cc,v 1.3 2006/06/29 20:46:09 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     28// GEANT4 tag $Name: geant4-09-02 $
    2929//
    3030

  • trunk/source/processes/hadronic/models/management/src/G4VPreCompoundModel.cc

    r962 r1007  
    2626//
    2727// $Id: G4VPreCompoundModel.cc,v 1.6 2007/01/11 05:29:10 dennis Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     28// GEANT4 tag $Name: geant4-09-02 $
    2929//
    3030
Note: See TracChangeset for help on using the changeset viewer.