Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/hadronic/management/src/G4EnergyRangeManager.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /processes/hadronic/management/src/G4EnergyRangeManager.cc (Version 11.3.0) and /processes/hadronic/management/src/G4EnergyRangeManager.cc (Version 9.2.p4)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
 26 //                                                 26 //
                                                   >>  27 // $Id: G4EnergyRangeManager.cc,v 1.15 2006/06/29 19:58:21 gunter Exp $
                                                   >>  28 // GEANT4 tag $Name: geant4-09-02-patch-04 $
                                                   >>  29 //
 27  // Hadronic Process: Energy Range Manager         30  // Hadronic Process: Energy Range Manager
 28  // original by H.P. Wellisch                      31  // original by H.P. Wellisch
 29  // modified by J.L. Chuma, TRIUMF, 22-Nov-199     32  // modified by J.L. Chuma, TRIUMF, 22-Nov-1996
 30  // Last modified: 24-Mar-1997                     33  // Last modified: 24-Mar-1997
 31  // fix in the counter-hndling: H.P. Wellisch      34  // fix in the counter-hndling: H.P. Wellisch 04-Apr-97
 32  // throw an exception if no model found:  J.L     35  // throw an exception if no model found:  J.L. Chuma  04-Apr-97
 33                                                    36  
 34 #include "G4EnergyRangeManager.hh"                 37 #include "G4EnergyRangeManager.hh"
 35 #include "Randomize.hh"                            38 #include "Randomize.hh"
 36 #include "G4HadronicException.hh"                  39 #include "G4HadronicException.hh"
 37 #include "G4SystemOfUnits.hh"                  << 
 38                                                    40 
 39 G4EnergyRangeManager::G4EnergyRangeManager()   <<  41  G4EnergyRangeManager::G4EnergyRangeManager(
 40  : theHadronicInteractionCounter(0)            <<  42   const G4EnergyRangeManager &right )
 41 {}                                             <<  43   {
 42                                                <<  44     if( this != &right )
 43 G4EnergyRangeManager::~G4EnergyRangeManager()  <<  45     {
 44 {}                                             <<  46       for( G4int i=0; i<theHadronicInteractionCounter; ++i )
 45                                                <<  47         theHadronicInteraction[i] = right.theHadronicInteraction[i];
 46 void G4EnergyRangeManager::RegisterMe(G4Hadron <<  48       theHadronicInteractionCounter = right.theHadronicInteractionCounter;
 47 {                                              << 
 48   if(!a) { return; }                           << 
 49   if(0 < theHadronicInteractionCounter) {      << 
 50     for(G4int i=0; i<theHadronicInteractionCou << 
 51       if(a == theHadronicInteraction[i]) { ret << 
 52     }                                              49     }
 53   }                                                50   }
 54   theHadronicInteraction.push_back(a);         <<  51  
 55   ++theHadronicInteractionCounter;             <<  52  G4EnergyRangeManager &
 56 }                                              <<  53   G4EnergyRangeManager::operator=(
 57                                                <<  54    const G4EnergyRangeManager &right )
 58 G4HadronicInteraction*                         <<  55   {
 59 G4EnergyRangeManager::GetHadronicInteraction(c <<  56     if( this != &right )
 60                                              G <<  57     {
 61                                              c <<  58       for( G4int i=0; i<theHadronicInteractionCounter; ++i )
 62                                              c <<  59         theHadronicInteraction[i] =
 63 {                                              <<  60           right.theHadronicInteraction[i];
 64   // VI shortcut: if only one interaction is r <<  61       theHadronicInteractionCounter =
 65   if(1 == theHadronicInteractionCounter) { ret <<  62         right.theHadronicInteractionCounter;
 66   else if(0 == theHadronicInteractionCounter)  <<  63     }
 67     G4cout << "G4EnergyRangeManager::GetHadron <<  64     return *this;
 68      << "no models defined for a process" << G << 
 69     return nullptr;                            << 
 70   }                                                65   }
 71                                                <<  66  
 72   G4double kineticEnergy = aHadProjectile.GetK <<  67  void
 73   // For ions, get kinetic energy per nucleon  <<  68   G4EnergyRangeManager::RegisterMe(
 74   if ( std::abs( aHadProjectile.GetDefinition( <<  69    G4HadronicInteraction *a )
 75     kineticEnergy /= static_cast< G4double >(  <<  70   {
                                                   >>  71     if( theHadronicInteractionCounter+1 > MAX_NUMBER_OF_MODELS )
                                                   >>  72     {
                                                   >>  73       throw G4HadronicException(__FILE__, __LINE__,"RegisterMe: TOO MANY MODELS");
                                                   >>  74     }
                                                   >>  75     theHadronicInteraction[ theHadronicInteractionCounter++ ] = a;
 76   }                                                76   }
 77                                                <<  77  
 78   G4int cou = 0, memory = 0, memor2 = 0;       <<  78  G4HadronicInteraction *
 79   G4double emi1 = 0.0, ema1 = 0.0, emi2 = 0.0, <<  79   G4EnergyRangeManager::GetHadronicInteraction(
 80                                                <<  80    const G4double kineticEnergy,
 81   for (G4int i = 0; i<theHadronicInteractionCo <<  81    const G4Material *aMaterial,
 82     if ( theHadronicInteraction[i]->IsApplicab <<  82    const G4Element *anElement ) const
                                                   >>  83   {
                                                   >>  84     G4int counter = GetHadronicInteractionCounter();
                                                   >>  85     if( counter == 0 )
                                                   >>  86       throw G4HadronicException(__FILE__, __LINE__,
                                                   >>  87                                "GetHadronicInteraction: NO MODELS STORED");
                                                   >>  88 
                                                   >>  89     G4int cou = 0, memory = 0, memor2 = 0;
                                                   >>  90     G4double emi1 = 0.0, ema1 = 0.0, emi2 = 0.0, ema2 = 0.0;
                                                   >>  91     for( G4int i=0; i<counter; i++ )
                                                   >>  92     {
 83       G4double low  = theHadronicInteraction[i     93       G4double low  = theHadronicInteraction[i]->GetMinEnergy( aMaterial, anElement );
                                                   >>  94       // Work-around for particles with 0 kinetic energy, which still
                                                   >>  95       // require a model to return a ParticleChange
                                                   >>  96       if (low == 0.) low = -DBL_MIN;
 84       G4double high = theHadronicInteraction[i     97       G4double high = theHadronicInteraction[i]->GetMaxEnergy( aMaterial, anElement );
 85       if (low <= kineticEnergy && high >= kine <<  98       if( low < kineticEnergy && high >= kineticEnergy )
                                                   >>  99       {
 86         ++cou;                                    100         ++cou;
 87         emi2 = emi1;                              101         emi2 = emi1;
 88         ema2 = ema1;                              102         ema2 = ema1;
 89         emi1 = low;                               103         emi1 = low;
 90         ema1 = high;                              104         ema1 = high;
 91         memor2 = memory;                          105         memor2 = memory;
 92         memory = i;                               106         memory = i;
 93       }                                           107       }
 94     }                                             108     }
 95   }                                            << 109     G4int m=-1;
 96                                                << 110     G4double rand;
 97   G4HadronicInteraction* hi = nullptr;         << 111     switch ( cou )
 98   switch (cou) {                               << 112     {
 99     case 0:                                    << 113      case 0:
100       G4cout << "No model found out of " << th << 114        G4cout<<"G4EnergyRangeManager:GetHadronicInteraction: counter="<<counter<<", Ek="
101       for( G4int j=0; j<theHadronicInteraction << 115              <<kineticEnergy<<", Material = "<<aMaterial->GetName()<<", Element = "
102   G4HadronicInteraction* hint=theHadronicInter << 116              <<anElement->GetName()<<G4endl;
103   G4cout << "   "<< j << ".  Elow= " << hint-> << 117        for( G4int j=0; j<counter; j++ )
104          <<", Ehigh= " << hint->GetMaxEnergy(a << 118        {
105          <<"   " << hint->GetModelName() << G4 << 119          G4HadronicInteraction* HInt=theHadronicInteraction[j];
106       }                                        << 120          G4cout<<"*"<<j<<"* low=" <<HInt->GetMinEnergy(aMaterial,anElement)
107       break;                                   << 121                <<", high="<<HInt->GetMaxEnergy(aMaterial,anElement)<<G4endl;
108                                                << 122        }
109     case 1:                                    << 123        throw G4HadronicException(__FILE__, __LINE__,
110       hi = theHadronicInteraction[memory];     << 124           "GetHadronicInteraction: No Model found");
111       break;                                   << 125        return 0;
112                                                << 126      case 1:
113     case 2:                                    << 127        m = memory;
114       if( (emi2<=emi1 && ema2>=ema1) || (emi2> << 128        break;
115   G4cout << "Energy ranges of two models fully << 129      case 2:
116   for( G4int j=0; j<theHadronicInteractionCoun << 130        if( (emi2<=emi1 && ema2>=ema1) || (emi2>=emi1 && ema2<=ema1) )
117     G4HadronicInteraction* hint=theHadronicInt << 131        {
118     G4cout << "   "<< j << ".  Elow= " << hint << 132          G4cout<<"G4EnergyRangeManager:GetHadronicInteraction: counter="<<counter<<", Ek="
119      <<", Ehigh= " << hint->GetMaxEnergy(aMate << 133                <<kineticEnergy<<", Material = "<<aMaterial->GetName()<<", Element = "
120      <<"   " << hint->GetModelName() << G4endl << 134                <<anElement->GetName()<<G4endl;
121   }                                            << 135          if(counter) for( G4int j=0; j<counter; j++ )
122       } else {                                 << 136          {
123   G4double rand = G4UniformRand();             << 137            G4HadronicInteraction* HInt=theHadronicInteraction[j];
124   G4int mem;                                   << 138            G4cout<<"*"<<j<<"* low=" <<HInt->GetMinEnergy(aMaterial,anElement)
125   if( emi1 < emi2 ) {                          << 139                <<", high="<<HInt->GetMaxEnergy(aMaterial,anElement)<<G4endl;
126     if( (ema1-kineticEnergy) < rand*(ema1-emi2 << 140          }
127       mem = memor2;                            << 141          throw G4HadronicException(__FILE__, __LINE__,
128     } else {                                   << 142                "GetHadronicInteraction: Energy ranges of two models fully overlapping");
129       mem = memory;                            << 143        }
130     }                                          << 144        rand = G4UniformRand();
131   } else {                                     << 145        if( emi1 < emi2 )
132     if( (ema2-kineticEnergy) < rand*(ema2-emi1 << 146        {
133       mem = memory;                            << 147          if( (ema1-kineticEnergy)/(ema1-emi2)<rand )
134     } else {                                   << 148            m = memor2;
135       mem = memor2;                            << 149          else
136     }                                          << 150            m = memory;
137   }                                            << 151        } else {
138   hi = theHadronicInteraction[mem];            << 152          if( (ema2-kineticEnergy)/(ema2-emi1)<rand )
139       }                                        << 153            m = memory;
140       break;                                   << 154          else
141                                                << 155            m = memor2;
142     default:                                   << 156        }
143       G4cout << "More than two competing model << 157        break;
144       for( G4int j=0; j<theHadronicInteraction << 158      default:
145   G4HadronicInteraction* hint=theHadronicInter << 159       throw G4HadronicException(__FILE__, __LINE__,
146   G4cout << "   "<< j << ".  Elow= " << hint-> << 160         "GetHadronicInteraction: More than two competing models in this energy range");
147          <<", Ehigh= " << hint->GetMaxEnergy(a << 
148          <<"   " << hint->GetModelName() << G4 << 
149       }                                        << 
150       break;                                   << 
151   }                                            << 
152   return hi;                                   << 
153 }                                              << 
154                                                << 
155 std::vector<G4HadronicInteraction*>&           << 
156 G4EnergyRangeManager::GetHadronicInteractionLi << 
157 {                                              << 
158   return theHadronicInteraction;               << 
159 }                                              << 
160                                                << 
161 void G4EnergyRangeManager::Dump( G4int verbose << 
162 {                                              << 
163   G4cout << "G4EnergyRangeManager " << this << << 
164   for (G4int i = 0 ; i < theHadronicInteractio << 
165     G4cout << "   HadronicModel " << i <<":"   << 
166            << theHadronicInteraction[i]->GetMo << 
167     if (verbose > 0) {                         << 
168       G4cout << "      Minimum Energy "        << 
169        << theHadronicInteraction[i]->GetMinEne << 
170              << "Maximum Energy "              << 
171        << theHadronicInteraction[i]->GetMaxEne << 
172              << G4endl;                        << 
173     }                                             161     }
174   }                                            << 162     return theHadronicInteraction[m];
175 }                                              << 163   } 
176                                                << 164  
177 void                                           << 165  /* end of file */
178 G4EnergyRangeManager::BuildPhysicsTable(const  << 
179 {                                              << 
180   for (auto & hadi : theHadronicInteraction) { << 
181     hadi->BuildPhysicsTable( aParticleType );  << 
182   }                                            << 
183 }                                              << 
184                                                << 
185                                                   166  
186                                                   167