Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/cuts/src/G4PhysicsTableHelper.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/cuts/src/G4PhysicsTableHelper.cc (Version 11.3.0) and /processes/cuts/src/G4PhysicsTableHelper.cc (Version 9.1.p1)


  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 // G4PhysicsTableHelper class implementation   <<  26 // $Id: G4PhysicsTableHelper.cc,v 1.5 2006/06/29 19:30:12 gunter Exp $
                                                   >>  27 // GEANT4 tag $Name: geant4-09-01-patch-01 $
 27 //                                                 28 //
 28 // Author: H.Kurashige, 20 August 2004 - First <<  29 // 
 29 // ------------------------------------------- <<  30 // ------------------------------------------------------------
                                                   >>  31 //  GEANT 4 class header file 
                                                   >>  32 //
                                                   >>  33 // Class Description
                                                   >>  34 //  G4PhysicsTableHelper is a static utility class 
                                                   >>  35 //  for helping proceeses to build their physics table
                                                   >>  36 //
                                                   >>  37 // ------------------------------------------------------------
                                                   >>  38 //   First Implementation          20 Aug. 2004   H.Kurashige
                                                   >>  39 //
                                                   >>  40 // ------------------------------------------------------------
 30                                                    41 
 31 #include "G4PhysicsTableHelper.hh"                 42 #include "G4PhysicsTableHelper.hh" 
 32 #include "G4ProductionCutsTable.hh"            <<  43 #include  "G4ProductionCutsTable.hh"
 33 #include "G4MCCIndexConversionTable.hh"        << 
 34 #include "G4Threading.hh"                      << 
 35 #include "G4ios.hh"                            << 
 36                                                    44 
 37 G4int G4PhysicsTableHelper::verboseLevel = 1;      45 G4int G4PhysicsTableHelper::verboseLevel = 1; 
 38                                                    46 
 39 // ------------------------------------------- << 
 40 G4PhysicsTableHelper::G4PhysicsTableHelper()       47 G4PhysicsTableHelper::G4PhysicsTableHelper()
 41 {                                                  48 {
 42 }                                                  49 }
 43                                                    50 
 44 // ------------------------------------------- << 
 45 G4PhysicsTableHelper::~G4PhysicsTableHelper()      51 G4PhysicsTableHelper::~G4PhysicsTableHelper()
 46 {                                                  52 {
 47 }                                                  53 }
 48                                                    54 
 49 // ------------------------------------------- <<  55 G4PhysicsTableHelper::G4PhysicsTableHelper(const G4PhysicsTableHelper&)
 50 G4PhysicsTable*                                <<  56 {
 51 G4PhysicsTableHelper::PreparePhysicsTable(G4Ph <<  57 }
 52 {                                              <<  58 
 53   G4ProductionCutsTable* cutTable              <<  59 G4PhysicsTableHelper& G4PhysicsTableHelper::operator=(const G4PhysicsTableHelper&)
 54     = G4ProductionCutsTable::GetProductionCuts <<  60 {
 55   std::size_t numberOfMCC = cutTable->GetTable <<  61   return *this;
                                                   >>  62 }
                                                   >>  63 
 56                                                    64 
 57   if ( physTable != nullptr )                  <<  65 G4PhysicsTable* G4PhysicsTableHelper::PreparePhysicsTable(G4PhysicsTable* physTable)
 58   {                                            <<  66 {
                                                   >>  67   G4ProductionCutsTable* cutTable = G4ProductionCutsTable::GetProductionCutsTable();  
                                                   >>  68   size_t numberOfMCC = cutTable->GetTableSize(); 
                                                   >>  69 
                                                   >>  70   if ( physTable !=0) {
 59     // compare size of physics table and numbe     71     // compare size of physics table and number of material-cuts-couple
 60     if ( physTable->size() < numberOfMCC )     <<  72     if ( physTable->size() < numberOfMCC) {
 61     {                                          <<  73       // enlarge physcis table
                                                   >>  74       physTable->resize(numberOfMCC, (G4PhysicsVector*)(0));
                                                   >>  75     } else if ( physTable->size() > numberOfMCC){
                                                   >>  76       // ERROR: this situation should not occur  
                                                   >>  77       //  size of physics table is shorter than  number of material-cuts-couple
                                                   >>  78       physTable->resize(numberOfMCC);
 62 #ifdef G4VERBOSE                                   79 #ifdef G4VERBOSE  
 63       if (verboseLevel>2)                      <<  80       if (verboseLevel>0) {
 64       {                                        <<  81   G4cerr << "G4PhysicsTableHelper::PreparePhysicsTable  ";
 65         G4cout << "G4PhysicsTableHelper::Prepa <<  82   G4cerr << "Physics Table "<< physTable ;
 66                << " the table " << physTable < <<  83   G4cerr << " is longer than number of material-cuts-couple " << G4endl;
 67          << physTable->size()                  << 
 68                << " will be is resized to " << << 
 69       }                                            84       }
 70 #endif                                             85 #endif 
 71       // enlarge physics table                 << 
 72       physTable->resize(numberOfMCC, nullptr); << 
 73     }                                          << 
 74     else if ( physTable->size() > numberOfMCC  << 
 75     {                                          << 
 76       // ERROR: this situation should not occu << 
 77       // size of physics table is larger than  << 
 78       G4ExceptionDescription ed;               << 
 79       ed << "table " << physTable << " size="  << 
 80    << " is longer than number of material-cuts << 
 81       G4Exception( "G4PhysicsTableHelper::Prep << 
 82                    "ProcCuts001", FatalExcepti << 
 83     }                                              86     } 
 84   }                                            <<  87   } else {
 85   else                                         << 
 86   {                                            << 
 87     // create PhysicsTable is given poitner is     88     // create PhysicsTable is given poitner is null
 88     physTable = new G4PhysicsTable();          <<  89     physTable = new G4PhysicsTable(numberOfMCC);
 89     physTable->resize(numberOfMCC, nullptr);   <<  90     physTable->resize(numberOfMCC, (G4PhysicsVector*)(0));
                                                   >>  91 
 90   }                                                92   }
 91                                                    93 
 92 #ifdef G4VERBOSE                                   94 #ifdef G4VERBOSE  
 93   if (verboseLevel>2)                          <<  95   if (verboseLevel>2) {
 94   {                                            <<  96     if ( physTable !=0) { 
 95     G4cout << "G4PhysicsTableHelper::PreparePh <<  97       G4cerr << "Physics Table size "<< physTable->size();
 96      << " the table "<< physTable              <<  98     } else {
 97      << " size=" << numberOfMCC << G4endl;     <<  99       G4cerr << "Physics Table does not exist   ";
                                                   >> 100     }
                                                   >> 101     G4cerr << ": number of material-cuts-couple " << numberOfMCC << G4endl;
 98   }                                               102   }
 99 #endif                                            103 #endif 
100                                                   104 
101   // Reset recal-needed flag for all physics v    105   // Reset recal-needed flag for all physics vectors
102   physTable->ResetFlagArray();                    106   physTable->ResetFlagArray();
103                                                   107 
104   for (std::size_t idx = 0; idx <numberOfMCC;  << 108   for (size_t idx = 0; idx <numberOfMCC; idx +=1){
105   {                                            << 109     const G4MaterialCutsCouple* mcc = cutTable->GetMaterialCutsCouple(idx);
106     const G4MaterialCutsCouple* mcc = cutTable << 110     //check if re-calculation of the physics vector is needed 
107                                                << 
108     // check if re-calculation of the physics  << 
109     // MCC is not used                            111     // MCC is not used
110     if ( !mcc->IsUsed() ) physTable->ClearFlag    112     if ( !mcc->IsUsed() ) physTable->ClearFlag(idx);
111                                                   113 
112     // RecalcNeeded flag of MCC is not asserte    114     // RecalcNeeded flag of MCC is not asserted 
113     if ( !mcc->IsRecalcNeeded() ) physTable->C    115     if ( !mcc->IsRecalcNeeded() ) physTable->ClearFlag(idx);
114   }                                               116   }
115                                                   117   
116   return physTable;                               118   return physTable;
117 }                                                 119 }
118                                                   120 
119 // ------------------------------------------- << 121 
                                                   >> 122 
120 G4bool G4PhysicsTableHelper::RetrievePhysicsTa    123 G4bool G4PhysicsTableHelper::RetrievePhysicsTable(G4PhysicsTable* physTable,
121                                                << 124               const G4String& fileName,
122                                                << 125               G4bool ascii              )
123 {                                                 126 {
124   if (physTable == nullptr ) return false;     << 127   if (physTable == 0) return false;
125                                                   128   
126   // retrieve physics table from the given fil    129   // retrieve physics table from the given file
127   G4PhysicsTable* tempTable = new G4PhysicsTab    130   G4PhysicsTable* tempTable = new G4PhysicsTable();
128   if (! tempTable->RetrievePhysicsTable(fileNa << 131   if (! tempTable->RetrievePhysicsTable(fileName,ascii) ){
129   {                                            << 132 #ifdef G4VERBOSE  
130     G4ExceptionDescription ed;                 << 133     if (verboseLevel>1) {
131     ed << "Cannot retrieve physics table from  << 134       G4cerr << "G4PhysicsTableHelper::RetrievePhysicsTable  ";
132     G4Exception( "G4ProductionCutsTable::Retri << 135       G4cerr << "Fail to retreive from "<< fileName << G4endl;
133                  "ProcCuts105", JustWarning, e << 136     }
134     delete tempTable;                          << 137 #endif 
135     return false;                                 138     return false;
136   }                                               139   } 
137                                                   140 
138   G4ProductionCutsTable* cutTable              << 141   G4ProductionCutsTable* cutTable = G4ProductionCutsTable::GetProductionCutsTable();  
139     = G4ProductionCutsTable::GetProductionCuts << 142   const G4MCCIndexConversionTable* converter = cutTable->GetMCCIndexConversionTable();
140   const G4MCCIndexConversionTable* converter   << 
141     = cutTable->GetMCCIndexConversionTable();  << 
142                                                   143 
143   // check physics table size                     144   // check physics table size
144   if ( tempTable->size() != converter->size()) << 145   if ( tempTable->size() != converter->size()){
145   {                                            << 146 #ifdef G4VERBOSE  
146     G4ExceptionDescription ed;                 << 147     if (verboseLevel>0) {
147     ed << "Physics table in " << fileName      << 148       G4cerr << "G4PhysicsTableHelper::RetrievePhysicsTable  ";
148        << "\n   size=" << tempTable->size() << << 149       G4cerr << "Size of the physics table in "<< fileName;
149        << " is inconsistent with material-cut- << 150       G4cerr << "( size =" << tempTable->size() << ")";
150        << "size=" << converter->size() << " th << 151       G4cerr << " is inconsistent with material-cut info";
151     G4Exception("G4ProductionCutsTable::Retrie << 152       G4cerr << "( size =" << converter->size() << ")";
152                 "ProcCuts106", JustWarning, ed << 153       G4cerr << G4endl;
153     delete tempTable;                          << 154     }
                                                   >> 155 #endif
154     return false;                                 156     return false;
155   }                                               157   }
156                                                   158   
157   // fill the given physics table with retriev << 159   // fill the given physics table with retrived physics vectors 
158   for (std::size_t idx=0; idx<converter->size( << 160   for (size_t idx=0; idx<converter->size(); idx++){
159   {                                            << 161     if (converter->IsUsed(idx)){
160     if (converter->IsUsed(idx))                << 162       size_t i = converter->GetIndex(idx);
161     {                                          << 
162       G4int i = converter->GetIndex(idx);      << 
163       if(i < 0)                                << 
164       {                                        << 
165         tempTable->clearAndDestroy();          << 
166   delete tempTable;                            << 
167   return false;                                << 
168       }                                        << 
169       G4PhysicsVector* vec = (*physTable)[i];     163       G4PhysicsVector* vec = (*physTable)[i];
170       if (vec != nullptr ) delete vec;         << 164       if (vec !=0 ) delete vec;
171       (*physTable)[i] = (*tempTable)[idx];     << 165       (*physTable)[i] =  (*tempTable)[idx];
172       physTable->ClearFlag(i);                    166       physTable->ClearFlag(i);
173     }                                             167     }
174   }                                               168   }
175   tempTable->clear();                             169   tempTable->clear();
176   delete tempTable;                               170   delete tempTable;
177                                                   171 
178   return true;                                    172   return true;
179 }                                                 173 }
180                                                   174 
181 // ------------------------------------------- << 175 
182 void G4PhysicsTableHelper::SetPhysicsVector(G4    176 void G4PhysicsTableHelper::SetPhysicsVector(G4PhysicsTable* physTable,
183                                             st << 177               size_t idx,
184                                             G4 << 178               G4PhysicsVector* vec)
185 {                                                 179 {
186   if ( physTable == nullptr) {  return;  }     << 180   if ( physTable ==0) {  return;  }
187                                                   181 
188   if ( physTable->size() <= idx)               << 182   if ( physTable->size() <= idx) {
189   {                                            << 183 #ifdef G4VERBOSE  
190     G4ExceptionDescription ed;                 << 184     if (verboseLevel>0) {
191     ed << "Given index (" << idx << ")  exceed << 185       G4cerr << "G4PhysicsTableHelper::SetPhysicsVector   ";
192        << "the size of the physics table "     << 186       G4cerr << "Given index (" << idx << ")  exceeds ";
193        << "( size =" << physTable->size() << " << 187       G4cerr << "size of the physics table ";
194     G4Exception("G4ProductionCutsTable::SetPhy << 188       G4cerr << "( size =" << physTable->size()<< ")";
195                 "ProcCuts107",                 << 189       G4cerr << G4endl;
196                 JustWarning, ed);              << 190     }
                                                   >> 191 #endif
197     return;                                       192     return;
198   }                                               193   } 
199                                                   194 
200   // set physics vector                           195   // set physics vector 
201   (*physTable)[idx] = vec;                        196   (*physTable)[idx] = vec;
202   // clear flag                                   197   // clear flag
203   physTable->ClearFlag(idx);                      198   physTable->ClearFlag(idx);
204 }                                              << 199  
205                                                   200 
206 // ------------------------------------------- << 
207 void G4PhysicsTableHelper::SetVerboseLevel(G4i << 
208 {                                              << 
209   if( !G4Threading::IsWorkerThread() ) verbose << 
210 }                                                 201 }
211                                                   202 
212 // ------------------------------------------- << 203 
213 G4int G4PhysicsTableHelper::GetVerboseLevel()  << 204 
214 {                                              << 205 
215   return verboseLevel;                         << 
216 }                                              << 
217                                                   206