Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/management/src/G4ProcessTable.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/management/src/G4ProcessTable.cc (Version 11.3.0) and /processes/management/src/G4ProcessTable.cc (Version 4.0)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                    <<   3 // * DISCLAIMER                                                       *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th <<   5 // * The following disclaimer summarizes all the specific disclaimers *
  6 // * the Geant4 Collaboration.  It is provided <<   6 // * of contributors to this software. The specific disclaimers,which *
  7 // * conditions of the Geant4 Software License <<   7 // * govern, are listed with their locations in:                      *
  8 // * LICENSE and available at  http://cern.ch/ <<   8 // *   http://cern.ch/geant4/license                                  *
  9 // * include a list of copyright holders.      << 
 10 // *                                                9 // *                                                                  *
 11 // * Neither the authors of this software syst     10 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     11 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     12 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     13 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file  <<  14 // * use.                                                             *
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                               15 // *                                                                  *
 18 // * This  code  implementation is the result  <<  16 // * This  code  implementation is the  intellectual property  of the *
 19 // * technical work of the GEANT4 collaboratio <<  17 // * GEANT4 collaboration.                                            *
 20 // * By using,  copying,  modifying or  distri <<  18 // * By copying,  distributing  or modifying the Program (or any work *
 21 // * any work based  on the software)  you  ag <<  19 // * based  on  the Program)  you indicate  your  acceptance of  this *
 22 // * use  in  resulting  scientific  publicati <<  20 // * statement, and all its terms.                                    *
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // *******************************************     21 // ********************************************************************
 25 //                                                 22 //
 26 // G4ProcessTable class implementation         << 
 27 //                                                 23 //
 28 // Author: H.Kurashige, 4 August 1998          <<  24 // $Id: G4ProcessTable.cc,v 1.8 2001/07/11 10:08:20 gunter Exp $
 29 // ------------------------------------------- <<  25 // GEANT4 tag $Name: geant4-04-00 $
                                                   >>  26 //
                                                   >>  27 // 
                                                   >>  28 // ------------------------------------------------------------
                                                   >>  29 //  GEANT 4 class header file 
                                                   >>  30 //
                                                   >>  31 //  History: first implementation, based on object model of
                                                   >>  32 //  4th Aug 1998, H.Kurashige
                                                   >>  33 // ------------------------------------------------------------
                                                   >>  34 //  History:
                                                   >>  35 //   Use STL vector instead of RW vector    1. Mar 00 H.Kurashige
                                                   >>  36 //
 30                                                    37 
 31 #include "G4ProcessTableMessenger.hh"              38 #include "G4ProcessTableMessenger.hh"
 32 #include "G4ProcessTable.hh"                       39 #include "G4ProcessTable.hh"
 33 #include "G4ParticleTable.hh"                  << 
 34 #include "G4ios.hh"                            << 
 35                                                << 
 36 // ------------------------------------------- << 
 37 // Static class variable: ptr to single instan << 
 38 G4ThreadLocal G4ProcessTable* G4ProcessTable:: << 
 39                                                    40 
 40 // ------------------------------------------- <<  41 //  constructor //////////////////////////
 41 // Default constructor                         <<  42 G4ProcessTable::G4ProcessTable():verboseLevel(1)
 42 //                                             << 
 43 G4ProcessTable::G4ProcessTable()               << 
 44 {                                                  43 {
 45 #ifdef G4VERBOSE                                   44 #ifdef G4VERBOSE
 46   if (verboseLevel>1)                          <<  45   if (verboseLevel>1){
 47   {                                            << 
 48     G4cout << "--  G4ProcessTable constructor      46     G4cout << "--  G4ProcessTable constructor  --" << G4endl;
 49   }                                                47   }
 50 #endif                                             48 #endif
 51   fProcTblVector  = new  G4ProcTableVector();      49   fProcTblVector  = new  G4ProcTableVector();
 52   fProcNameVector = new  G4ProcNameVector();       50   fProcNameVector = new  G4ProcNameVector();
 53   tmpTblVector    = new  G4ProcTableVector();      51   tmpTblVector    = new  G4ProcTableVector();
 54   fProcTblMessenger = new G4ProcessTableMessen <<  52   fProcTblMessenger = 0;
 55 }                                                  53 }
 56                                                    54 
 57 // ------------------------------------------- <<  55 // copy constructor //////////////////////////
 58 // Destructor                                  <<  56 G4ProcessTable::G4ProcessTable(const G4ProcessTable &right)
 59 //                                             <<  57 {
                                                   >>  58 #ifdef G4VERBOSE
                                                   >>  59   if (verboseLevel>0){
                                                   >>  60     G4cout << "--  G4ProcessTable copy constructor  --" << G4endl;
                                                   >>  61   }
                                                   >>  62 #endif
                                                   >>  63 }
                                                   >>  64 
                                                   >>  65 // destructor //////////////////////////
 60 G4ProcessTable::~G4ProcessTable()                  66 G4ProcessTable::~G4ProcessTable()
 61 {                                                  67 {
 62   if ( tmpTblVector != nullptr )               <<  68 #ifdef G4VERBOSE
 63   {                                            <<  69   if (verboseLevel>1){
                                                   >>  70     G4cout << "--  G4ProcessTable destructor  --" << G4endl;
                                                   >>  71   }
                                                   >>  72 
                                                   >>  73 #endif
                                                   >>  74   if ( tmpTblVector != 0) {
 64     tmpTblVector ->clear();                        75     tmpTblVector ->clear();
 65     delete tmpTblVector;                           76     delete tmpTblVector;
 66     tmpTblVector = nullptr;                    << 
 67   }                                                77   }
 68                                                    78 
 69   if ( fProcTblVector != nullptr )             <<  79   if ( fProcTblVector != 0) {
 70   {                                            <<  80     // G4ProcTableVector::iterator idx;
 71     for (auto elem : *fProcTblVector)          <<  81     
 72     {                                          <<  82     // destruction of processes has moved to G4VUserPhysicsList
 73       delete elem;                             <<  83     // for (idx=fProcTblVector->begin(); idx!=fProcTblVector->end(); ++idx) {
 74     }                                          <<  84       // delete all processes
                                                   >>  85       // delete (*idx)->GetProcess();
                                                   >>  86       // delete (*idx);
                                                   >>  87     //}  
 75     fProcTblVector ->clear();                      88     fProcTblVector ->clear();
 76     delete fProcTblVector;                         89     delete fProcTblVector;
 77     fProcTblVector = nullptr;                  << 
 78   }                                                90   }
 79                                                    91 
 80   // delete all process except transportation  <<  92   if ( fProcNameVector != 0) {
 81   for(auto proc : fListProcesses)              <<  93     fProcNameVector ->clear();
 82   {                                            <<  94     delete fProcNameVector;
 83     if ( proc != nullptr )                     << 
 84     {                                          << 
 85       G4ProcessType type = proc->GetProcessTyp << 
 86       if (type != fTransportation && type != f << 
 87        && type != fParameterisation)           << 
 88       {                                        << 
 89         delete proc;                           << 
 90       }                                        << 
 91     }                                          << 
 92   }                                                95   }
                                                   >>  96 }
 93                                                    97 
 94   fListProcesses.clear();                      <<  98 /////////////////////////
                                                   >>  99 G4UImessenger* G4ProcessTable::CreateMessenger()
                                                   >> 100 {
                                                   >> 101   if (fProcTblMessenger == 0) {
                                                   >> 102     fProcTblMessenger = new G4ProcessTableMessenger(this);
                                                   >> 103   }
                                                   >> 104   return     fProcTblMessenger;
                                                   >> 105 }
 95                                                   106 
 96   if ( fProcNameVector != nullptr )            << 107 /////////////////////////
 97   {                                            << 108 void  G4ProcessTable::DeleteMessenger()
 98     fProcNameVector ->clear();                 << 109 {
 99     delete fProcNameVector;                    << 110   if (fProcTblMessenger != 0) {
100     fProcNameVector = nullptr;                 << 111     delete fProcTblMessenger;
101   }                                               112   }
102   fProcessTable = nullptr;                     << 
103   delete fProcTblMessenger;                    << 
104 }                                                 113 }
105                                                   114 
106 // ------------------------------------------- << 115 
107 //                                             << 116 //////////////////////////
108 G4ProcessTable* G4ProcessTable::GetProcessTabl << 117 G4ProcessTable & G4ProcessTable::operator=(const G4ProcessTable &right)
109 {                                                 118 {
110   if(fProcessTable == nullptr)                 << 119 #ifdef G4VERBOSE
111   {                                            << 120   if (verboseLevel>0){
112     static G4ThreadLocalSingleton<G4ProcessTab << 121     G4cout << "--  G4ProcessTable assignment operator  --" << G4endl;
113     fProcessTable = inst.Instance();           << 
114   }                                               122   }
115   return fProcessTable;                        << 123 #endif
                                                   >> 124   if (&right == this) return *this;
                                                   >> 125   else return *this;
116 }                                                 126 }
117                                                   127 
118 // ------------------------------------------- << 128 //////////////////////////
119 //                                             << 129 G4int G4ProcessTable::operator==(const G4ProcessTable &right) const
120 G4int G4ProcessTable::Insert(G4VProcess* aProc << 130 {
121                              G4ProcessManager* << 131   return (this == &right);
                                                   >> 132 }
                                                   >> 133 
                                                   >> 134 //////////////////////////
                                                   >> 135 G4int G4ProcessTable::operator!=(const G4ProcessTable &right) const
                                                   >> 136 {
                                                   >> 137   return (this != &right);
                                                   >> 138 }
                                                   >> 139 
                                                   >> 140 // Static class variable: ptr to single instance of class
                                                   >> 141 G4ProcessTable* G4ProcessTable::fProcessTable =0;
                                                   >> 142 
                                                   >> 143 
                                                   >> 144 //////////////////////////
                                                   >> 145 G4ProcessTable* G4ProcessTable::GetProcessTable()
                                                   >> 146 {
                                                   >> 147     static G4ProcessTable theProcessTable;
                                                   >> 148     if (!fProcessTable){
                                                   >> 149       fProcessTable =  &theProcessTable;
                                                   >> 150     }
                                                   >> 151     return fProcessTable;
                                                   >> 152 }
                                                   >> 153 
                                                   >> 154 //////////////////////////
                                                   >> 155 G4int   G4ProcessTable::Insert(G4VProcess* aProcess, 
                                                   >> 156              G4ProcessManager* aProcMgr)
122 {                                                 157 {
123   if ( (aProcess == nullptr) || ( aProcMgr ==  << 158   if ( (aProcess == 0) || ( aProcMgr == 0 ) ){
124   {                                            << 
125 #ifdef G4VERBOSE                                  159 #ifdef G4VERBOSE
126     if (verboseLevel>0)                        << 160     if (verboseLevel>0){
127     {                                          << 161       G4cout << "G4ProcessTable::Insert : arguments are 0 pointer "<<G4endl;
128       G4cout << "G4ProcessTable::Insert() - ar << 
129              << aProcess << "," << aProcMgr << << 
130     }                                             162     }
131 #endif                                            163 #endif
132     return -1;                                    164     return -1;
133   }                                               165   }
134                                                   166     
135 #ifdef G4VERBOSE                                  167 #ifdef G4VERBOSE
136   if (verboseLevel>1)                          << 168   if (verboseLevel>1){
137   {                                            << 169     G4cout << "G4ProcessTable::Insert ";
138     G4cout << "G4ProcessTable::Insert() -";    << 
139     G4cout << " Process["  << aProcess->GetPro    170     G4cout << " Process["  << aProcess->GetProcessName() << "]";
140     G4cout << " Particle["  << aProcMgr->GetPa << 171     G4cout << " Particle["  << aProcMgr->GetParticleType()->GetParticleName() << "]";
141            << "]" << G4endl;                   << 172     G4cout << G4endl;
142   }                                               173   }
143 #endif                                            174 #endif
144                                                   175 
145   G4int idxTbl = 0;                            << 176   G4ProcTableVector::iterator itr; 
146   G4int nidx = (G4int)fProcTblVector->size();  << 177   G4int idxTbl=0;
147   G4ProcTblElement* anElement = nullptr;       << 178   G4ProcTblElement* anElement;
                                                   >> 179   G4bool isFoundInTbl = false;
148   // loop over all elements                       180   // loop over all elements
149   for (; idxTbl < nidx; ++idxTbl)              << 181   for (itr=fProcTblVector->begin(); itr!=fProcTblVector->end(); ++itr, ++idxTbl) {
150   {                                            << 182     anElement = (*itr);
151     anElement = (*fProcTblVector)[idxTbl];     << 
152     if(!anElement) { continue; }               << 
153     // check if this process is included          183     // check if this process is included
154     if (aProcess == anElement->GetProcess())   << 184     if (aProcess == anElement->GetProcess()) {
155     {                                          << 185       isFoundInTbl = true;
                                                   >> 186 
156       // add the process manager into the elem    187       // add the process manager into the element 
157       // unless  this process manager is inclu << 188       //  unless  this process manager is included
158       if (!anElement->Contains(aProcMgr))      << 189       if (!anElement->Contains(aProcMgr)) {
159       {                                        << 190   anElement->Insert(aProcMgr);
160         anElement->Insert(aProcMgr);           << 191 #ifdef G4VERBOSE
161 #ifdef G4VERBOSE                               << 192   if (verboseLevel>2){
162         if (verboseLevel>2)                    << 193     G4cout << " This Process Manager is registered !! " << G4endl;
163         {                                      << 194   }
164           G4cout << " This Process Manager is  << 
165         }                                      << 
166 #endif                                            195 #endif
167       }                                           196       }
168       return idxTbl;                           << 197       break;
169     }                                             198     }
170   }                                               199   }
171   // add this process into the table by creati    200   // add this process into the table by creating a new element
172   if (verboseLevel>2)                          << 201   if (!isFoundInTbl) {
173   {                                            << 202     G4ProcTblElement* newElement = new G4ProcTblElement(aProcess);
174     G4cout << " New element is created !! " << << 203     newElement->Insert(aProcMgr);
175   }                                            << 204     fProcTblVector->push_back(newElement);
176   anElement = new G4ProcTblElement(aProcess);  << 205     // add into name vector     
177   anElement->Insert(aProcMgr);                 << 206     G4ProcNameVector::iterator ip;
178   fProcTblVector->push_back(anElement);        << 207     G4bool isFound = false;
179   fProcNameVector->push_back(aProcess->GetProc << 208     for (ip=fProcNameVector->begin(); ip!=fProcNameVector->end(); ++ip) {
180   return nidx;                                 << 209       isFound |= (aProcess->GetProcessName() == (*ip));
                                                   >> 210     }
                                                   >> 211     if (!isFound) {
                                                   >> 212       fProcNameVector->push_back(aProcess->GetProcessName() );
                                                   >> 213 #ifdef G4VERBOSE
                                                   >> 214       if (verboseLevel>2){
                                                   >> 215   G4cout << " This Process is registered !! " << G4endl;
                                                   >> 216       }
                                                   >> 217 #endif
                                                   >> 218     }
                                                   >> 219   }
                                                   >> 220   return idxTbl;
181 }                                                 221 }
182                                                   222 
183 // ------------------------------------------- << 223 //////////////////////////
184 //                                             << 224 G4int  G4ProcessTable::Remove( G4VProcess* aProcess, 
185 G4int G4ProcessTable::Remove( G4VProcess* aPro << 225              G4ProcessManager* aProcMgr)
186                               G4ProcessManager << 
187 {                                                 226 {
188   if ( (aProcess == nullptr) || ( aProcMgr ==  << 227   if ( (aProcess == 0) || ( aProcMgr == 0 ) ){
189   {                                            << 
190 #ifdef G4VERBOSE                                  228 #ifdef G4VERBOSE
191     if (verboseLevel>0)                        << 229     if (verboseLevel>0){
192     {                                          << 230       G4cout << "G4ProcessTable::Remove : arguments are 0 pointer "<< G4endl;
193       G4cout << "G4ProcessTable::Remove() - ar << 
194              << G4endl;                        << 
195     }                                             231     }
196 #endif                                            232 #endif
197     return -1;                                    233     return -1;
198   }                                               234   }
199                                                   235     
200 #ifdef G4VERBOSE                                  236 #ifdef G4VERBOSE
201   if (verboseLevel>1)                          << 237   if (verboseLevel>1){
202   {                                            << 238     G4cout << "G4ProcessTable::Remove ";
203     G4cout << "G4ProcessTable::Remove() -";    << 
204     G4cout << " Process["  << aProcess->GetPro    239     G4cout << " Process["  << aProcess->GetProcessName() << "]";
205     G4cout << " Particle[" << aProcMgr->GetPar << 240     G4cout << " Particle[" << aProcMgr->GetParticleType()->GetParticleName() << "]" << G4endl;
206            << "]" << G4endl;                   << 
207   }                                               241   }
208 #endif                                            242 #endif
209                                                   243 
210   G4int idxTbl = 0;                            << 244   G4ProcTableVector::iterator itr; 
211   G4int nidx = (G4int)fProcTblVector->size();  << 245   G4int idxTbl=0;
212   G4ProcTblElement* anElement =nullptr;        << 246   G4ProcTblElement* anElement=0;
                                                   >> 247   G4bool isFound = false;
213   // loop over all elements                       248   // loop over all elements
214   for (; idxTbl < nidx; ++idxTbl)              << 249   for (itr=fProcTblVector->begin(); itr!=fProcTblVector->end(); ++itr, ++idxTbl) {
215   {                                            << 250     anElement = (*itr);
216     anElement = (*fProcTblVector)[idxTbl];     << 
217     if(!anElement) { continue; }               << 
218                                                   251 
219     // check if this process is included          252     // check if this process is included
220     if (aProcess == anElement->GetProcess())   << 253     if (aProcess == anElement->GetProcess()) {
221     {                                          << 254       isFound = anElement->Contains(aProcMgr);
222       if(anElement->Contains(aProcMgr))        << 255       // remove the process manager from the element
223       {                                        << 256       anElement->Remove(aProcMgr);
224         // remove the process manager from the << 257 #ifdef G4VERBOSE
225         anElement->Remove(aProcMgr);           << 258       if (verboseLevel>2){
226 #ifdef G4VERBOSE                               << 259   G4cout << " This Process Manager is removed !! " << G4endl;
227         if (verboseLevel>2)                    << 
228         {                                      << 
229           G4cout << " This Process Manager is  << 
230         }                                      << 
231 #endif                                         << 
232         if(anElement->Length() == 0)           << 
233         {                                      << 
234           delete anElement;                    << 
235           (*fProcTblVector)[idxTbl] = nullptr; << 
236 #ifdef G4VERBOSE                               << 
237           if (verboseLevel>1)                  << 
238           {                                    << 
239             G4cout << " This Process is remove << 
240           }                                    << 
241 #endif                                         << 
242         }                                      << 
243         return idxTbl;                         << 
244       }                                           260       }
                                                   >> 261 #endif
                                                   >> 262       break;
245     }                                             263     }
246   }                                               264   }
                                                   >> 265   // 
                                                   >> 266   if (!isFound) {
247 #ifdef G4VERBOSE                                  267 #ifdef G4VERBOSE
248   if (verboseLevel>1)                          << 268     if (verboseLevel>0){
249   {                                            << 269       G4cout << " This Process Manager is not registered !! " << G4endl;
250     G4cout << " This Process Manager is not re << 270     }
251            << G4endl;                          << 
252   }                                            << 
253 #endif                                            271 #endif
254   return -1;                                   << 272     return -1;
255 }                                              << 
256                                                << 
257 // ------------------------------------------- << 
258 //                                             << 
259 void G4ProcessTable::RegisterProcess(G4VProces << 
260 {                                              << 
261   for(auto proc : fListProcesses)              << 
262   {                                            << 
263     if(ptr == proc) { return; }                << 
264   }                                               273   }
265   fListProcesses.push_back(ptr);               << 274   // remove the element if it has no entry
266 }                                              << 275   if (anElement->Length() == 0){
267                                                << 276     fProcTblVector->erase(itr);
268 // ------------------------------------------- << 277     delete anElement;
269 //                                             << 278     // check other prcesses with same name exist or not
270 void G4ProcessTable::DeRegisterProcess(G4VProc << 279     G4bool isSameName = false;
271 {                                              << 280     for (itr=fProcTblVector->begin(); itr!=fProcTblVector->end(); ++itr) {
272   std::size_t nn = fListProcesses.size();      << 281       anElement = (*itr);
273   for(std::size_t i=0; i<nn; ++i)              << 282       if (anElement->GetProcessName() == aProcess->GetProcessName()) {
274   {                                            << 283   isSameName = true;
275     if(ptr == fListProcesses[i])               << 284   break;
276     {                                          << 285       }
277       fListProcesses[i] = nullptr;             << 
278       return;                                  << 
279     }                                             286     }
280   }                                            << 287     // remove from name vector
281 }                                              << 288     if (!isSameName ) {
282                                                << 289       G4ProcNameVector::iterator i; 
283 // ------------------------------------------- << 290       for (i=fProcNameVector->begin(); i!=fProcNameVector->end(); ++i) {
284 //                                             << 291   if ( *i == aProcess->GetProcessName() ) {
285 G4VProcess* G4ProcessTable::FindProcess(const  << 292     fProcNameVector->erase(i);
286                                         const  << 293     break;
287 {                                              << 294   }
288   return FindProcess(processName,              << 295       }
289           G4ParticleTable::GetParticleTable()- << 
290 }                                              << 
291                                                << 
292 // ------------------------------------------- << 
293 //                                             << 
294 G4VProcess* G4ProcessTable::FindProcess(const  << 
295                                         const  << 
296                                         const  << 
297 {                                              << 
298   for (auto anElement : *fProcTblVector)       << 
299   {                                            << 
300     // check name and if the processManage is  << 
301     if (anElement && anElement->GetProcessName << 
302         && anElement->Contains(processManager) << 
303     {                                          << 
304       return anElement->GetProcess();          << 
305     }                                             296     }
306   }                                            << 
307 #ifdef G4VERBOSE                                  297 #ifdef G4VERBOSE
308   if (verboseLevel > 1)                        << 298     if (verboseLevel>1){
309   {                                            << 299       G4cout << " This Process is removed !! " << G4endl;
310     G4cout << " G4ProcessTable::FindProcess()  << 
311     G4cout << " The Process[" << processName < << 
312     G4cout << " for [" << processManager->GetP << 
313            << "]" << G4endl;                   << 
314   }                                            << 
315 #endif                                         << 
316   return nullptr;                              << 
317 }                                              << 
318                                                << 
319 // ------------------------------------------- << 
320 //                                             << 
321 G4VProcess*                                    << 
322 G4ProcessTable::FindProcess(G4ProcessType proc << 
323                             const G4ParticleDe << 
324 {                                              << 
325   // find the first process of given type for  << 
326                                                << 
327   const G4ProcessManager* processManager = par << 
328   for (auto anElement : *fProcTblVector)       << 
329   {                                            << 
330     if (anElement && anElement->GetProcess()-> << 
331         && anElement->Contains(processManager) << 
332     {                                          << 
333       return anElement->GetProcess();          << 
334     }                                             300     }
335   }                                            << 
336 #ifdef G4VERBOSE                               << 
337   if (verboseLevel > 1)                        << 
338   {                                            << 
339     G4cout << " G4ProcessTable::FindProcess()  << 
340     G4cout << " The Process Type " << processT << 
341     G4cout << " for [" << particle->GetParticl << 
342   }                                            << 
343 #endif                                            301 #endif
344   return nullptr;                              << 302   }
                                                   >> 303   return idxTbl;
345 }                                                 304 }
346                                                   305 
347 // ------------------------------------------- << 306 //////////////////////////
348 //                                             << 307 G4VProcess* G4ProcessTable::FindProcess(const G4String& processName, 
349 G4VProcess*                                    << 308                       const G4ProcessManager* processManager)
350 G4ProcessTable::FindProcess(G4int procSubType, << 309                                         const
351                             const G4ParticleDe << 
352 {                                                 310 {
353   // find the first process of given type for  << 311   G4ProcTableVector::iterator itr;   
354                                                << 312   G4int idxTbl = 0;
355   const G4ProcessManager* processManager = par << 313   G4bool isFound = false;
356   for (auto anElement : *fProcTblVector)       << 314   G4ProcTblElement* anElement=0;
357   {                                            << 315   for (itr=fProcTblVector->begin(); itr!=fProcTblVector->end(); ++itr, ++idxTbl) {
358     if ( anElement != nullptr                  << 316     anElement = (*itr);
359       && anElement->GetProcess()->GetProcessSu << 317     // check name
360       && anElement->Contains(processManager) ) << 318     if ( anElement->GetProcessName() == processName ) {
361     {                                          << 319       // check if the processManage is included
362       return anElement->GetProcess();          << 320       if ( anElement->Contains(processManager) ) {
                                                   >> 321   isFound = true;
                                                   >> 322   break;
                                                   >> 323       }
363     }                                             324     }
364   }                                               325   }
365 #ifdef G4VERBOSE                                  326 #ifdef G4VERBOSE
366   if (verboseLevel > 1)                        << 327   if (!isFound && verboseLevel>1){
367   {                                            << 328     G4cout << " G4ProcessTable::FindProcess :" ;
368     G4cout << " G4ProcessTable::FindProcess()  << 329     G4cout << " The Process[" << processName << "] is not found  ";
369     G4cout << " The Process SubType " << procS << 330     G4cout << " for " << processManager->GetParticleType()->GetParticleName() << G4endl;
370     G4cout << " for [" << particle->GetParticl << 
371   }                                               331   }
372 #endif                                            332 #endif
373   return nullptr;                              << 333   
                                                   >> 334   if (isFound) return anElement->GetProcess();
                                                   >> 335   else         return 0;
374 }                                                 336 }
375                                                   337 
376 // ------------------------------------------- << 338 ///////////////
377 //                                             << 339 G4ProcessTable::G4ProcTableVector* G4ProcessTable::Find( 
378 G4ProcessTable::G4ProcTableVector*             << 340            G4ProcTableVector* procTblVector,
379 G4ProcessTable::Find(const G4String& processNa << 341            const G4String& processName )
380 {                                                 342 {
381   tmpTblVector->clear();                          343   tmpTblVector->clear();
382                                                   344 
                                                   >> 345   G4ProcTableVector::iterator itr; 
383   G4bool isFound = false;                         346   G4bool isFound = false;
384   G4ProcTblElement* anElement = nullptr;       << 347   G4ProcTblElement* anElement;
385   for (auto itr=fProcTblVector->cbegin(); itr! << 348   for (itr=fProcTblVector->begin(); itr!=fProcTblVector->end(); ++itr) {
386   {                                            << 
387     anElement = (*itr);                           349     anElement = (*itr);
388     // check name                                 350     // check name
389     if ( anElement != nullptr && anElement->Ge << 351     if ( anElement->GetProcessName() == processName ) {
390     {                                          << 
391       isFound = true;                             352       isFound = true;
392       tmpTblVector->push_back(anElement);         353       tmpTblVector->push_back(anElement);
393     }                                             354     }
394   }                                               355   }
395                                                   356 
396   if (!isFound && verboseLevel>0)              << 
397   {                                            << 
398 #ifdef G4VERBOSE                                  357 #ifdef G4VERBOSE
399     G4cout << " G4ProcessTable::Find() -" ;    << 358   if (!isFound && verboseLevel>0){
                                                   >> 359     G4cout << " G4ProcessTable::Find :" ;
400     G4cout << " The Process[" << processName <    360     G4cout << " The Process[" << processName << "] is not found  " << G4endl;
401 #endif                                         << 
402   }                                               361   }
403                                                << 362 #endif
                                                   >> 363   
404   return tmpTblVector;                            364   return tmpTblVector;
405 }                                              << 
406                                                   365 
407 // ------------------------------------------- << 366 }     
408 //                                             << 367 ///////////////
409 G4ProcessTable::G4ProcTableVector*             << 368 G4ProcessTable::G4ProcTableVector* G4ProcessTable::Find( 
410 G4ProcessTable::Find(G4ProcessType processType << 369            G4ProcTableVector* procTblVector,
                                                   >> 370            G4ProcessType   processType )
411 {                                                 371 {
412   tmpTblVector->clear();                          372   tmpTblVector->clear();
413                                                   373 
                                                   >> 374   G4ProcTableVector::iterator itr; 
414   G4bool isFound = false;                         375   G4bool isFound = false;
415   G4ProcTblElement* anElement = nullptr;       << 376   G4ProcTblElement* anElement;
416   for (auto itr=fProcTblVector->cbegin(); itr! << 377   for (itr=fProcTblVector->begin(); itr!=fProcTblVector->end(); ++itr) {
417   {                                            << 
418     anElement = (*itr);                           378     anElement = (*itr);
419     // check name                                 379     // check name
420     if ( anElement != nullptr && anElement->Ge << 380     if ( anElement->GetProcess()->GetProcessType() == processType ) {
421     {                                          << 
422       isFound = true;                             381       isFound = true;
423       tmpTblVector->push_back(anElement);         382       tmpTblVector->push_back(anElement);
424     }                                             383     }
425   }                                               384   }
426                                                   385 
427   if (!isFound && verboseLevel>0)              << 
428   {                                            << 
429 #ifdef G4VERBOSE                                  386 #ifdef G4VERBOSE
430     G4cout << " G4ProcessTable::Find() -" ;    << 387   if (!isFound && verboseLevel>0){
431     G4cout << " The ProcessType[" << processTy << 388     G4cout << " G4ProcessTable::Find :" ;
432            << G4endl;                          << 389     G4cout << " The Process[" << anElement->GetProcessName() << "] is not found  " << G4endl;
433 #endif                                         << 
434   }                                               390   }
435                                                << 391 #endif
                                                   >> 392   
436   return tmpTblVector;                            393   return tmpTblVector;
                                                   >> 394 
437 }                                                 395 }     
438                                                   396 
439 // ------------------------------------------- << 397 ///////////////
440 //                                             << 398 G4ProcessVector* G4ProcessTable::ExtractProcesses( G4ProcTableVector* procTblVector)
441 G4ProcessVector*                               << 
442 G4ProcessTable::ExtractProcesses(G4ProcTableVe << 
443 {                                                 399 {
444   G4ProcessVector* procList = new G4ProcessVec    400   G4ProcessVector* procList = new G4ProcessVector();
                                                   >> 401   G4ProcTableVector::iterator itr; 
445   // loop over all elements                       402   // loop over all elements
446   for (auto itr=procTblVector->cbegin(); itr!= << 403   for (itr=procTblVector->begin(); itr!=procTblVector->end(); ++itr) {
447   {                                            << 
448     G4ProcTblElement* anElement = (*itr);         404     G4ProcTblElement* anElement = (*itr);
449     if ( anElement != nullptr) procList->inser << 405     procList->insert( anElement->GetProcess() );
450   }                                               406   }
451   return procList;                                407   return procList;
452 }                                                 408 }
453                                                   409 
454 // ------------------------------------------- << 410 ///////////////
455 //                                             << 411 G4ProcessVector* G4ProcessTable::FindProcesses()
456 void G4ProcessTable::SetProcessActivation(cons << 
457                                           cons << 
458                                                << 
459 {                                                 412 {
460   if (particleName == "ALL" )                  << 413   return ExtractProcesses(fProcTblVector);
461   {                                            << 
462     SetProcessActivation( processName, fActive << 
463   }                                            << 
464   else                                         << 
465   {                                            << 
466     SetProcessActivation(processName,          << 
467         G4ParticleTable::GetParticleTable()->F << 
468         fActive );                             << 
469   }                                            << 
470 }                                                 414 }
471                                                   415 
472 // ------------------------------------------- << 416 ///////////////
473 //                                             << 417 G4ProcessVector* G4ProcessTable::FindProcesses( const G4ProcessManager* pManager )
474 void G4ProcessTable::SetProcessActivation(G4Pr << 
475                                           cons << 
476                                                << 
477 {                                                 418 {
478   if ((particleName == "ALL" ) || (particleNam << 419   G4ProcessVector* procList = pManager->GetProcessList();
479   {                                            << 420   return new G4ProcessVector(*procList);
480     SetProcessActivation( processType, fActive << 
481   }                                            << 
482   else                                         << 
483   {                                            << 
484     SetProcessActivation(processType,          << 
485         G4ParticleTable::GetParticleTable()->F << 
486         fActive );                             << 
487   }                                            << 
488 }                                                 421 }
489                                                   422 
490 // ------------------------------------------- << 423 ///////////////
491 //                                             << 424 G4ProcessVector* G4ProcessTable::FindProcesses( const G4String& processName )
                                                   >> 425 {
                                                   >> 426   G4ProcTableVector* pTblVector =  Find(fProcTblVector, processName);
                                                   >> 427   return ExtractProcesses(pTblVector);
                                                   >> 428 }
                                                   >> 429 
                                                   >> 430 ///////////////
                                                   >> 431 G4ProcessVector* G4ProcessTable::FindProcesses( G4ProcessType processType)
                                                   >> 432 {
                                                   >> 433   G4ProcTableVector* pTblVector =  Find(fProcTblVector, processType);
                                                   >> 434   return ExtractProcesses(pTblVector);
                                                   >> 435 }
                                                   >> 436 
                                                   >> 437 ///////////////
492 void G4ProcessTable::SetProcessActivation( con    438 void G4ProcessTable::SetProcessActivation( const G4String& processName, 
493                                            G4b << 439                          G4bool          fActive  )
494 {                                                 440 {
495 #ifdef G4VERBOSE                                  441 #ifdef G4VERBOSE
496   if (verboseLevel>1)                          << 442   if (verboseLevel>1){
497   {                                            << 443     G4cout << " G4ProcessTable::SetProcessActivation:" ;
498     G4cout << " G4ProcessTable::SetProcessActi << 
499     G4cout << " The Process[" << processName <    444     G4cout << " The Process[" << processName << "] "<< G4endl;
500   }                                               445   }
501 #endif                                            446 #endif
502                                                   447 
503   G4ProcTableVector* pTblVector =  Find(proces << 448   G4ProcTableVector* pTblVector =  Find(fProcTblVector, processName);
                                                   >> 449   G4ProcTableVector::iterator itr; 
504   G4ProcTblElement* anElement;                    450   G4ProcTblElement* anElement;  
505    // loop over all elements                      451    // loop over all elements
506   for (auto itr=pTblVector->cbegin(); itr!=pTb << 452   for (itr=pTblVector->begin(); itr!=pTblVector->end(); ++itr) {
507   {                                            << 
508     anElement = (*itr);                           453     anElement = (*itr);
509     if ( anElement == nullptr ) continue;      << 
510     G4VProcess* process = anElement->GetProces    454     G4VProcess* process = anElement->GetProcess();
511     for (G4int idx = 0 ; idx < anElement->Leng << 455     for (G4int idx = 0 ; idx < anElement->Length(); idx++) {
512     {                                          << 
513       G4ProcessManager* manager = anElement->G    456       G4ProcessManager* manager = anElement->GetProcessManager(idx);
514       manager->SetProcessActivation(process, f    457       manager->SetProcessActivation(process, fActive);
515 #ifdef G4VERBOSE                                  458 #ifdef G4VERBOSE
516       if (verboseLevel>1)                      << 459       if (verboseLevel>1){
517       {                                        << 
518         G4cout << "  for " << manager->GetPart    460         G4cout << "  for " << manager->GetParticleType()->GetParticleName();
519         G4cout << "  Index = " << manager->Get << 461   G4cout << "  Index = " << manager->GetProcessIndex(process); 
520         G4cout << G4endl;                         462         G4cout << G4endl;
521       }                                           463       }
522 #endif                                            464 #endif
523     }                                             465     }
524   }                                               466   }
525 }                                                 467 }
526                                                   468 
527 // ------------------------------------------- << 469 ///////////////
528 //                                             << 470 void G4ProcessTable::SetProcessActivation( 
529 void G4ProcessTable::SetProcessActivation(cons << 471          const G4String& processName, 
530                                           G4Pr << 472                G4ProcessManager* processManager, 
531                                           G4bo << 473          G4bool          fActive  )
532 {                                                 474 {
533 #ifdef G4VERBOSE                                  475 #ifdef G4VERBOSE
534   if (verboseLevel>1)                          << 476   if (verboseLevel>1){
535   {                                            << 477     G4cout << " G4ProcessTable::SetProcessActivation:" ;
536     G4cout << " G4ProcessTable::SetProcessActi << 
537     G4cout << " The Process[" << processName <    478     G4cout << " The Process[" << processName << "] "<< G4endl;
538   }                                               479   }
539 #endif                                            480 #endif
540                                                   481   
541   G4VProcess* process = FindProcess( processNa    482   G4VProcess* process = FindProcess( processName,  processManager);
542   if ( process != nullptr)                     << 483   if ( process != 0) {
543   {                                            << 
544     processManager->SetProcessActivation(proce    484     processManager->SetProcessActivation(process, fActive);
545 #ifdef G4VERBOSE                                  485 #ifdef G4VERBOSE
546     if (verboseLevel>1)                        << 486     if (verboseLevel>1){
547     {                                          << 487       G4cout << "  for " << processManager->GetParticleType()->GetParticleName();
548       G4cout << "  for "                       << 488       G4cout << "  Index = " << processManager->GetProcessIndex(process) << G4endl;
549              << processManager->GetParticleTyp << 
550       G4cout << "  Index = "                   << 
551              << processManager->GetProcessInde << 
552     }                                             489     }
553 #endif                                            490 #endif
554   }                                               491   } 
555 }                                                 492 }
556                                                   493 
557 // ------------------------------------------- << 494 
558 //                                             << 495 ///////////////
559 void G4ProcessTable::SetProcessActivation( G4P << 496 void G4ProcessTable::SetProcessActivation( G4ProcessType   processType, 
560                                            G4b << 497                          G4bool          fActive  )
561 {                                                 498 {
562 #ifdef G4VERBOSE                                  499 #ifdef G4VERBOSE
563   if (verboseLevel>1)                          << 500   if (verboseLevel>1){
564   {                                            << 501     G4cout << " G4ProcessTable::SetProcessActivation:" ;
565     G4cout << " G4ProcessTable::SetProcessActi << 
566     G4cout << " The ProcessType[" << G4int(pro    502     G4cout << " The ProcessType[" << G4int(processType) << "] "<< G4endl;
567   }                                               503   }
568 #endif                                            504 #endif
569                                                   505 
570   G4ProcTableVector* pTblVector = Find(process << 506   G4ProcTableVector* pTblVector =  Find(fProcTblVector, processType);
                                                   >> 507   G4ProcTableVector::iterator itr; 
571   G4ProcTblElement* anElement;                    508   G4ProcTblElement* anElement;  
572   // loop over all elements                       509   // loop over all elements
573   for (auto itr=pTblVector->cbegin(); itr!=pTb << 510   for (itr=pTblVector->begin(); itr!=pTblVector->end(); ++itr) {
574   {                                            << 
575     anElement = (*itr);                           511     anElement = (*itr);
576     if ( anElement == nullptr ) continue;      << 
577     G4VProcess* process = anElement->GetProces    512     G4VProcess* process = anElement->GetProcess();
578 #ifdef G4VERBOSE                                  513 #ifdef G4VERBOSE
579     if (verboseLevel>1)                        << 514     if (verboseLevel>1){
580     {                                          << 
581       G4cout << " The Process[" << process->Ge    515       G4cout << " The Process[" << process->GetProcessName()<< "] "<< G4endl;
582     }                                             516     }
583 #endif                                            517 #endif
584     for (G4int idx = 0 ; idx < anElement->Leng << 518     for (G4int idx = 0 ; idx < anElement->Length(); idx++) {
585     {                                          << 
586       G4ProcessManager* manager = anElement->G    519       G4ProcessManager* manager = anElement->GetProcessManager(idx);
587       manager->SetProcessActivation(process, f    520       manager->SetProcessActivation(process, fActive);
588 #ifdef G4VERBOSE                                  521 #ifdef G4VERBOSE
589       if (verboseLevel>1)                      << 522       if (verboseLevel>1){
590       {                                        << 
591         G4cout << "  for " << manager->GetPart    523         G4cout << "  for " << manager->GetParticleType()->GetParticleName();
592         G4cout << "  Index = " << manager->Get << 524   G4cout << "  Index = " << manager->GetProcessIndex(process) << G4endl;
593       }                                           525       }
594 #endif                                            526 #endif
595     }                                             527     }
596   }                                               528   }
597 }                                                 529 }
598                                                   530 
599 // ------------------------------------------- << 531 ///////////////
600 //                                             << 532 void G4ProcessTable::SetProcessActivation( 
601 void G4ProcessTable::SetProcessActivation( G4P << 533          G4ProcessType   processType, 
602                                            G4P << 534                G4ProcessManager* processManager, 
603                                            G4b << 535          G4bool          fActive  )
604 {                                                 536 {
605 #ifdef G4VERBOSE                                  537 #ifdef G4VERBOSE
606   if (verboseLevel>1)                          << 538   if (verboseLevel>1){
607   {                                            << 539     G4cout << " G4ProcessTable::SetProcessActivation:" ;
608     G4cout << " G4ProcessTable::SetProcessActi << 
609     G4cout << " The ProcessType[" << G4int(pro    540     G4cout << " The ProcessType[" << G4int(processType) << "] "<< G4endl;
610   }                                               541   }
611 #endif                                            542 #endif
612                                                   543   
613   G4ProcessVector* procList =  processManager-    544   G4ProcessVector* procList =  processManager->GetProcessList();
614   for (G4int idx = 0; idx < (G4int)procList->l << 545   for (G4int idx = 0; idx < procList->length(); idx++) {
615   {                                            << 
616     G4VProcess* process = (*procList)(idx);       546     G4VProcess* process = (*procList)(idx);
617     if ( process->GetProcessType() == processT << 547     if ( process->GetProcessType() == processType) {
618     {                                          << 
619       processManager->SetProcessActivation(pro    548       processManager->SetProcessActivation(process, fActive);
620 #ifdef G4VERBOSE                                  549 #ifdef G4VERBOSE
621       if (verboseLevel>1)                      << 550       if (verboseLevel>1){
622       {                                        << 
623         G4cout << " The Process[" << process->    551         G4cout << " The Process[" << process->GetProcessName()<< "] "<< G4endl;
624         G4cout << "  for "                     << 552   G4cout << "  for " << processManager->GetParticleType()->GetParticleName();
625                << processManager->GetParticleT << 553   G4cout << "  Index = " << idx << G4endl;
626         G4cout << "  Index = " << idx << G4end << 
627       }                                           554       }
628 #endif                                            555 #endif
629     }                                             556     }
630   }                                               557   }
631 }                                                 558 }
632                                                   559 
633 // ------------------------------------------- << 560 
634 //                                             << 561 /////////////
635 void G4ProcessTable::DumpInfo(G4VProcess* proc    562 void G4ProcessTable::DumpInfo(G4VProcess* process, 
636                               const G4Particle << 563             G4ParticleDefinition* particle)
637 {                                                 564 {
                                                   >> 565   G4ProcTableVector::iterator itr; 
638   G4int idxTbl=0;                                 566   G4int idxTbl=0;
639   G4ProcTblElement* anElement = nullptr;       << 567   G4ProcTblElement* anElement=0;
640   G4bool isFoundInTbl = false;                    568   G4bool isFoundInTbl = false;
641   G4ProcessManager* manager = nullptr;         << 569   G4ProcessManager* manager=0;
642   G4int idx;                                      570   G4int idx;
643   // loop over all elements                       571   // loop over all elements
644   for (auto itr=fProcTblVector->cbegin();      << 572   for (itr=fProcTblVector->begin(); itr!=fProcTblVector->end(); ++itr, ++idxTbl) {
645             itr!=fProcTblVector->cend(); ++itr << 
646   {                                            << 
647     anElement = (*itr);                           573     anElement = (*itr);
648     if ( anElement == nullptr ) continue;      << 574     if (process == anElement->GetProcess() ){
649     if (process == anElement->GetProcess() )   << 575       if (particle!=0) {
650     {                                          << 576   for (idx=0; idx<anElement->Length(); idx++){
651       if (particle != nullptr)                 << 577     manager = anElement->GetProcessManager(idx);
652       {                                        << 578     if (particle == manager->GetParticleType()) {
653         for (idx=0; idx<anElement->Length(); + << 579       isFoundInTbl = true;
654         {                                      << 580       break;
655           manager = anElement->GetProcessManag << 581     }
656           if (particle == manager->GetParticle << 582   }
657           {                                    << 583       } else {
658             isFoundInTbl = true;               << 584   isFoundInTbl = true;
659             break;                             << 
660           }                                    << 
661         }                                      << 
662       }                                        << 
663       else                                     << 
664       {                                        << 
665         isFoundInTbl = true;                   << 
666       }                                           585       }
667       break;                                      586       break;
668     }                                             587     }
669   }                                               588   }
670   if  (!isFoundInTbl ) return;                    589   if  (!isFoundInTbl ) return;
671                                                   590   
672   G4int tmpVerbose = process->GetVerboseLevel(    591   G4int tmpVerbose = process->GetVerboseLevel();
673   process->SetVerboseLevel(verboseLevel);         592   process->SetVerboseLevel(verboseLevel);
674   process->DumpInfo();                            593   process->DumpInfo();
675   process->SetVerboseLevel(tmpVerbose);           594   process->SetVerboseLevel(tmpVerbose);
676   if (particle == nullptr)                     << 595   if (particle==0) {
677   {                                            << 596     for (idx=0; idx<anElement->Length(); idx++){
678     for (idx=0; idx<anElement->Length(); ++idx << 
679     {                                          << 
680       manager = anElement->GetProcessManager(i    597       manager = anElement->GetProcessManager(idx);
681       G4cout << " for " << manager->GetParticl    598       G4cout << " for " << manager->GetParticleType()->GetParticleName();
682       G4cout << G4endl;                           599       G4cout << G4endl;
683 #ifdef G4VERBOSE                               << 600       if (verboseLevel >2) manager->DumpInfo();
684       if (verboseLevel >2)                     << 
685       {                                        << 
686         tmpVerbose = manager->GetVerboseLevel( << 
687         manager->SetVerboseLevel(verboseLevel) << 
688         manager->DumpInfo();                   << 
689         manager->SetVerboseLevel(tmpVerbose);  << 
690       }                                        << 
691 #endif                                         << 
692     }                                             601     }
693   }                                            << 602   } else {
694   else                                         << 
695   {                                            << 
696     G4cout << " for " << manager->GetParticleT    603     G4cout << " for " << manager->GetParticleType()->GetParticleName();
697     G4cout << G4endl;                             604     G4cout << G4endl;
698 #ifdef G4VERBOSE                               << 605     if (verboseLevel >2) manager->DumpInfo();
699     if (verboseLevel >2)                       << 
700     {                                          << 
701       tmpVerbose = manager->GetVerboseLevel(); << 
702       manager->SetVerboseLevel(verboseLevel);  << 
703       manager->DumpInfo();                     << 
704       manager->SetVerboseLevel(tmpVerbose);    << 
705     }                                          << 
706 #endif                                         << 
707   }                                               606   }
708 }                                                 607 }
                                                   >> 608 
                                                   >> 609 
                                                   >> 610 
                                                   >> 611 
                                                   >> 612 
                                                   >> 613 
709                                                   614