Geant4 Cross Reference

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


  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 // G4ProductionCutsTable class implementation  << 
 27 //                                                 26 //
 28 // Author: M.Asai, 5 October 2002 - First impl <<  27 //
 29 // Modifications: H.Kurashige, 2004-2008       <<  28 //
 30 // ------------------------------------------- <<  29 // --------------------------------------------------------------
                                                   >>  30 //      GEANT 4 class implementation file/  History:
                                                   >>  31 //    06/Oct. 2002, M.Asai : First implementation
                                                   >>  32 //    02/Mar. 2008, H.Kurashige : Add messenger
                                                   >>  33 // --------------------------------------------------------------
 31                                                    34 
 32 #include "G4ProductionCutsTable.hh"                35 #include "G4ProductionCutsTable.hh"
 33 #include "G4ProductionCuts.hh"                     36 #include "G4ProductionCuts.hh"
 34 #include "G4MCCIndexConversionTable.hh"            37 #include "G4MCCIndexConversionTable.hh"
 35 #include "G4ProductionCutsTableMessenger.hh"       38 #include "G4ProductionCutsTableMessenger.hh"
 36 #include "G4ParticleDefinition.hh"                 39 #include "G4ParticleDefinition.hh"
 37 #include "G4ParticleTable.hh"                      40 #include "G4ParticleTable.hh"
 38 #include "G4RegionStore.hh"                        41 #include "G4RegionStore.hh"
 39 #include "G4LogicalVolume.hh"                      42 #include "G4LogicalVolume.hh"
 40 #include "G4VPhysicalVolume.hh"                    43 #include "G4VPhysicalVolume.hh"
 41 #include "G4RToEConvForElectron.hh"                44 #include "G4RToEConvForElectron.hh"
 42 #include "G4RToEConvForGamma.hh"                   45 #include "G4RToEConvForGamma.hh"
 43 #include "G4RToEConvForPositron.hh"                46 #include "G4RToEConvForPositron.hh"
 44 #include "G4RToEConvForProton.hh"                  47 #include "G4RToEConvForProton.hh"
 45 #include "G4MaterialTable.hh"                      48 #include "G4MaterialTable.hh"
 46 #include "G4Material.hh"                           49 #include "G4Material.hh"
 47 #include "G4UnitsTable.hh"                         50 #include "G4UnitsTable.hh"
 48                                                    51 
 49 #include "G4Timer.hh"                              52 #include "G4Timer.hh"
 50 #include "G4SystemOfUnits.hh"                      53 #include "G4SystemOfUnits.hh"
 51 #include "G4ios.hh"                                54 #include "G4ios.hh"
 52 #include <iomanip>                                 55 #include <iomanip>                
 53 #include <fstream>                                 56 #include <fstream>       
 54                                                    57 
 55 G4ProductionCutsTable* G4ProductionCutsTable:: << 
 56                                                    58 
 57 // ------------------------------------------- <<  59 G4ProductionCutsTable* G4ProductionCutsTable::fG4ProductionCutsTable = 0;
                                                   >>  60 
                                                   >>  61 /////////////////////////////////////////////////////////////
 58 G4ProductionCutsTable* G4ProductionCutsTable::     62 G4ProductionCutsTable* G4ProductionCutsTable::GetProductionCutsTable()
 59 {                                                  63 { 
 60    static G4ProductionCutsTable theProductionC     64    static G4ProductionCutsTable theProductionCutsTable;
 61    if(fProductionCutsTable == nullptr)         <<  65    if(!fG4ProductionCutsTable){
 62    {                                           <<  66      fG4ProductionCutsTable = &theProductionCutsTable;
 63      fProductionCutsTable = &theProductionCuts << 
 64    }                                               67    }
 65   return fProductionCutsTable;                 <<  68   return fG4ProductionCutsTable;
 66 }                                                  69 }
 67                                                    70 
 68 // ------------------------------------------- <<  71 /////////////////////////////////////////////////////////////
 69 G4ProductionCutsTable::G4ProductionCutsTable()     72 G4ProductionCutsTable::G4ProductionCutsTable()
                                                   >>  73   : firstUse(true),verboseLevel(1),fMessenger(nullptr)
 70 {                                                  74 {
 71   for(std::size_t i=0; i< NumberOfG4CutIndex;  <<  75   for(size_t i=0;i< NumberOfG4CutIndex;i++)
 72   {                                                76   {
 73     rangeCutTable.push_back(new std::vector<G4 <<  77     rangeCutTable.push_back(new G4CutVectorForAParticle);
 74     energyCutTable.push_back(new std::vector<G <<  78     energyCutTable.push_back(new G4CutVectorForAParticle);
 75     rangeDoubleVector[i] = nullptr;                79     rangeDoubleVector[i] = nullptr;
 76     energyDoubleVector[i] = nullptr;               80     energyDoubleVector[i] = nullptr;
 77     converters[i] = nullptr;                       81     converters[i] = nullptr;
 78   }                                                82   }
 79   fG4RegionStore = G4RegionStore::GetInstance(     83   fG4RegionStore = G4RegionStore::GetInstance();
 80   defaultProductionCuts = new G4ProductionCuts     84   defaultProductionCuts = new G4ProductionCuts();
 81                                                    85 
 82   // add messenger for UI                          86   // add messenger for UI 
 83   fMessenger = new G4ProductionCutsTableMessen     87   fMessenger = new G4ProductionCutsTableMessenger(this);
 84 }                                                  88 }
 85                                                    89 
 86 // ------------------------------------------- <<  90 /////////////////////////////////////////////////////////////
                                                   >>  91 G4ProductionCutsTable::G4ProductionCutsTable(const G4ProductionCutsTable& )
                                                   >>  92 { 
                                                   >>  93   fMessenger = nullptr;
                                                   >>  94   defaultProductionCuts = nullptr; 
                                                   >>  95   fG4RegionStore = nullptr;
                                                   >>  96 }
                                                   >>  97 
                                                   >>  98 /////////////////////////////////////////////////////////////
 87 G4ProductionCutsTable::~G4ProductionCutsTable(     99 G4ProductionCutsTable::~G4ProductionCutsTable()
 88 {                                                 100 {
 89   delete defaultProductionCuts;                << 101   if (defaultProductionCuts != nullptr) {
 90   defaultProductionCuts = nullptr;             << 102     delete defaultProductionCuts;
                                                   >> 103     defaultProductionCuts =nullptr;
                                                   >> 104   }
 91                                                   105 
 92   for(auto itr=coupleTable.cbegin(); itr!=coup << 106   for(CoupleTableIterator itr=coupleTable.begin();itr!=coupleTable.end();itr++){
 93   {                                            << 
 94     delete (*itr);                                107     delete (*itr); 
 95   }                                               108   }
 96   coupleTable.clear();                            109   coupleTable.clear();
 97                                                   110 
 98   for(std::size_t i=0; i< NumberOfG4CutIndex;  << 111   for(size_t i=0;i< NumberOfG4CutIndex;i++){
 99   {                                            << 
100     delete rangeCutTable[i];                      112     delete rangeCutTable[i];
101     delete energyCutTable[i];                     113     delete energyCutTable[i];
102     delete converters[i];                         114     delete converters[i];
103     if(rangeDoubleVector[i] != nullptr) delete    115     if(rangeDoubleVector[i] != nullptr) delete [] rangeDoubleVector[i];
104     if(energyDoubleVector[i] != nullptr) delet    116     if(energyDoubleVector[i] != nullptr) delete [] energyDoubleVector[i];
105     rangeCutTable[i] = nullptr;                   117     rangeCutTable[i] = nullptr;
106     energyCutTable[i] = nullptr;                  118     energyCutTable[i] = nullptr;
107     converters[i] = nullptr;                      119     converters[i] = nullptr;
108     rangeDoubleVector[i] = nullptr;               120     rangeDoubleVector[i] = nullptr;
109     energyDoubleVector[i] = nullptr;              121     energyDoubleVector[i] = nullptr;
110     if(i < 4)                                  << 
111     {                                          << 
112       delete userEnergyCuts[i];                << 
113     }                                          << 
114   }                                               122   }
115   fProductionCutsTable = nullptr;              << 123   fG4ProductionCutsTable = nullptr;
116                                                   124 
117   delete fMessenger;                           << 125   if (fMessenger != nullptr) delete fMessenger;
118   fMessenger = nullptr;                           126   fMessenger = nullptr;
119 }                                                 127 }
120                                                   128 
121 // ------------------------------------------- << 129 void G4ProductionCutsTable::UpdateCoupleTable(G4VPhysicalVolume* /*currentWorld*/)
122 void G4ProductionCutsTable::SetEnergyCutVector << 
123                                                << 
124 {                                                 130 {
125   if (idx >= 4) {                              << 131   if(firstUse){
126     G4ExceptionDescription ed;                 << 132     if(G4ParticleTable::GetParticleTable()->FindParticle("gamma")){
127     ed << "Wrong index= " << idx << "; it shou << 133       converters[0] = new G4RToEConvForGamma(); 
128     G4Exception("G4ProductionCutsTable::SetEne << 134       converters[0]->SetVerboseLevel(GetVerboseLevel());
129     "CUTS0100", FatalException, ed);           << 135     }
130     return;                                    << 136     if(G4ParticleTable::GetParticleTable()->FindParticle("e-")){
                                                   >> 137       converters[1] = new G4RToEConvForElectron(); 
                                                   >> 138       converters[1]->SetVerboseLevel(GetVerboseLevel());
                                                   >> 139   }
                                                   >> 140     if(G4ParticleTable::GetParticleTable()->FindParticle("e+")){
                                                   >> 141       converters[2] = new G4RToEConvForPositron(); 
                                                   >> 142       converters[2]->SetVerboseLevel(GetVerboseLevel());
                                                   >> 143     }
                                                   >> 144     if(G4ParticleTable::GetParticleTable()->FindParticle("proton")){
                                                   >> 145       converters[3] = new G4RToEConvForProton(); 
                                                   >> 146       converters[3]->SetVerboseLevel(GetVerboseLevel());
                                                   >> 147     }
                                                   >> 148     firstUse = false;
131   }                                               149   }
132   userEnergyCuts[idx] = new std::vector<G4doub << 
133 }                                              << 
134                                                   150 
135 // ------------------------------------------- << 
136 void G4ProductionCutsTable::CreateCoupleTables << 
137 {                                              << 
138   // Reset "used" flags of all couples            151   // Reset "used" flags of all couples
139   for(auto CoupleItr=coupleTable.cbegin();     << 152   for(CoupleTableIterator CoupleItr=coupleTable.begin();
140            CoupleItr!=coupleTable.cend(); ++Co << 153         CoupleItr!=coupleTable.end();CoupleItr++) 
141   {                                               154   {
142     (*CoupleItr)->SetUseFlag(false);              155     (*CoupleItr)->SetUseFlag(false); 
143   }                                               156   }
144                                                   157 
145   // Update Material-Cut-Couple                   158   // Update Material-Cut-Couple
146   for(auto rItr=fG4RegionStore->cbegin(); rItr << 159   typedef std::vector<G4Region*>::iterator regionIterator;
                                                   >> 160   for(regionIterator rItr=fG4RegionStore->begin();
                                                   >> 161                 rItr!=fG4RegionStore->end();rItr++)
147   {                                               162   {
148     // Material scan is to be done only for th    163     // Material scan is to be done only for the regions appear in the 
149     // current tracking world.                    164     // current tracking world.
150     //    if((*rItr)->GetWorldPhysical()!=curr << 165 //    if((*rItr)->GetWorldPhysical()!=currentWorld) continue;
                                                   >> 166    if((*rItr)->IsInMassGeometry() || (*rItr)->IsInParallelGeometry())
                                                   >> 167    {
151                                                   168 
152     if( (*rItr)->IsInMassGeometry() || (*rItr) << 169     G4ProductionCuts* fProductionCut = (*rItr)->GetProductionCuts();
153     {                                          << 170     std::vector<G4Material*>::const_iterator mItr =
154       G4ProductionCuts* fProductionCut = (*rIt << 171       (*rItr)->GetMaterialIterator();
155       auto mItr = (*rItr)->GetMaterialIterator << 172     size_t nMaterial = (*rItr)->GetNumberOfMaterials();
156       std::size_t nMaterial = (*rItr)->GetNumb << 173     (*rItr)->ClearMap();
157       (*rItr)->ClearMap();                     << 174 
158                                                << 175     for(size_t iMate=0;iMate<nMaterial;iMate++){
159       for(std::size_t iMate=0; iMate<nMaterial << 176       //check if this material cut couple has already been made
160       {                                        << 177       G4bool coupleAlreadyDefined = false;
161         //check if this material cut couple ha << 178       G4MaterialCutsCouple* aCouple;
162         G4bool coupleAlreadyDefined = false;   << 179       for(CoupleTableIterator cItr=coupleTable.begin();
163         G4MaterialCutsCouple* aCouple;         << 180           cItr!=coupleTable.end();cItr++){
164         for(auto cItr=coupleTable.cbegin(); cI << 181         if( (*cItr)->GetMaterial()==(*mItr)    && 
165         {                                      << 182       (*cItr)->GetProductionCuts()==fProductionCut){ 
166           if( (*cItr)->GetMaterial()==(*mItr)  << 183           coupleAlreadyDefined = true;
167            && (*cItr)->GetProductionCuts()==fP << 184           aCouple = *cItr;
168           {                                    << 185           break;
169             coupleAlreadyDefined = true;       << 
170             aCouple = *cItr;                   << 
171             break;                             << 
172           }                                    << 
173         }                                         186         }
                                                   >> 187       }
174                                                   188       
175         // If this combination is new, cleate  << 189       // If this combination is new, cleate and register a couple
176         if(!coupleAlreadyDefined)              << 190       if(!coupleAlreadyDefined){
177         {                                      << 191         aCouple = new G4MaterialCutsCouple((*mItr),fProductionCut);
178           aCouple = new G4MaterialCutsCouple(( << 192         coupleTable.push_back(aCouple);
179           coupleTable.push_back(aCouple);      << 193         aCouple->SetIndex(coupleTable.size()-1);
180           aCouple->SetIndex(G4int(coupleTable. << 194       }
181         }                                      << 
182                                                << 
183         // Register this couple to the region  << 
184         (*rItr)->RegisterMaterialCouplePair((* << 
185                                                   195 
186         // Set the couple to the proper logica << 196       // Register this couple to the region
187         aCouple->SetUseFlag();                 << 197       (*rItr)->RegisterMaterialCouplePair((*mItr),aCouple);
188                                                   198 
189         auto rootLVItr = (*rItr)->GetRootLogic << 199       // Set the couple to the proper logical volumes in that region
190         std::size_t nRootLV = (*rItr)->GetNumb << 200       aCouple->SetUseFlag();
191         for(std::size_t iLV=0; iLV<nRootLV; ++ << 
192         {                                      << 
193           // Set the couple to the proper logi << 
194           G4LogicalVolume* aLV = *rootLVItr;   << 
195           G4Region* aR = *rItr;                << 
196                                                   201 
197           ScanAndSetCouple(aLV,aCouple,aR);    << 202       std::vector<G4LogicalVolume*>::iterator rootLVItr
                                                   >> 203                          = (*rItr)->GetRootLogicalVolumeIterator();
                                                   >> 204       size_t nRootLV = (*rItr)->GetNumberOfRootVolumes();
                                                   >> 205       for(size_t iLV=0;iLV<nRootLV;iLV++)      {
                                                   >> 206         //Set the couple to the proper logical volumes in that region
                                                   >> 207         G4LogicalVolume* aLV = *rootLVItr;
                                                   >> 208         G4Region* aR = *rItr;
198                                                   209 
199           // Proceed to the next root logical  << 210         ScanAndSetCouple(aLV,aCouple,aR);
200           ++rootLVItr;                         << 
201         }                                      << 
202                                                   211 
203         // Proceed to next material in this re << 212         // Proceed to the next root logical volume in this region
204         ++mItr;                                << 213         rootLVItr++;
205       }                                           214       }
                                                   >> 215 
                                                   >> 216       // Proceed to next material in this region
                                                   >> 217       mItr++;
206     }                                             218     }
                                                   >> 219    }
207   }                                               220   }
208                                                   221 
209   // Check if sizes of Range/Energy cuts table    222   // Check if sizes of Range/Energy cuts tables are equal to the size of
210   // the couple table. If new couples are made << 223   // the couple table
211   // nCouple becomes larger then nTable        << 224   // If new couples are made during the previous procedure, nCouple becomes
212                                                << 225   // larger then nTable
213   std::size_t nCouple = coupleTable.size();    << 226   size_t nCouple = coupleTable.size();
214   std::size_t nTable = energyCutTable[0]->size << 227   size_t nTable = energyCutTable[0]->size();
215   G4bool newCoupleAppears = nCouple>nTable;       228   G4bool newCoupleAppears = nCouple>nTable;
216   if(newCoupleAppears)                         << 229   if(newCoupleAppears) {
217   {                                            << 230     for(size_t n=nCouple-nTable;n>0;n--) {
218     for(std::size_t n=nCouple-nTable; n>0; --n << 231       for(size_t nn=0;nn< NumberOfG4CutIndex;nn++){
219     {                                          << 
220       for(std::size_t nn=0; nn< NumberOfG4CutI << 
221       {                                        << 
222         rangeCutTable[nn]->push_back(-1.);        232         rangeCutTable[nn]->push_back(-1.);
223         energyCutTable[nn]->push_back(-1.);       233         energyCutTable[nn]->push_back(-1.);
224       }                                           234       }
225     }                                             235     }
226   }                                               236   }
227                                                   237 
228   // resize Range/Energy cuts double vectors i << 
229   if(newCoupleAppears)                         << 
230   {                                            << 
231     for(std::size_t ix=0; ix<NumberOfG4CutInde << 
232     {                                          << 
233       G4double* rangeVOld = rangeDoubleVector[ << 
234       G4double* energyVOld = energyDoubleVecto << 
235       if(rangeVOld) delete [] rangeVOld;       << 
236       if(energyVOld) delete [] energyVOld;     << 
237       rangeDoubleVector[ix] = new G4double[(*( << 
238       energyDoubleVector[ix] = new G4double[(* << 
239     }                                          << 
240   }                                            << 
241 }                                              << 
242                                                << 
243 // ------------------------------------------- << 
244 void G4ProductionCutsTable::UpdateCoupleTable( << 
245 {                                              << 
246   CreateCoupleTables();                        << 
247                                                << 
248   if(firstUse)                                 << 
249   {                                            << 
250     if(G4ParticleTable::GetParticleTable()->Fi << 
251     {                                          << 
252       converters[0] = new G4RToEConvForGamma() << 
253       converters[0]->SetVerboseLevel(GetVerbos << 
254     }                                          << 
255     if(G4ParticleTable::GetParticleTable()->Fi << 
256     {                                          << 
257       converters[1] = new G4RToEConvForElectro << 
258       converters[1]->SetVerboseLevel(GetVerbos << 
259     }                                          << 
260     if(G4ParticleTable::GetParticleTable()->Fi << 
261     {                                          << 
262       converters[2] = new G4RToEConvForPositro << 
263       converters[2]->SetVerboseLevel(GetVerbos << 
264     }                                          << 
265     if(G4ParticleTable::GetParticleTable()->Fi << 
266     {                                          << 
267       converters[3] = new G4RToEConvForProton( << 
268       converters[3]->SetVerboseLevel(GetVerbos << 
269     }                                          << 
270     firstUse = false;                          << 
271   }                                            << 
272                                                << 
273   // Update RangeEnergy cuts tables               238   // Update RangeEnergy cuts tables
274   std::size_t idx = 0;                         << 239   size_t idx = 0;
275   G4Timer timer;                                  240   G4Timer timer;
276   if (verboseLevel>2)                          << 241   if (verboseLevel>2) {
277   {                                            << 
278     timer.Start();                                242     timer.Start();
279   }                                               243   }
280   for(auto cItr=coupleTable.cbegin(); cItr!=co << 244   for(CoupleTableIterator cItr=coupleTable.begin();
281   {                                            << 245       cItr!=coupleTable.end();cItr++){
282     G4ProductionCuts* aCut = (*cItr)->GetProdu    246     G4ProductionCuts* aCut = (*cItr)->GetProductionCuts();
283     const G4Material* aMat = (*cItr)->GetMater    247     const G4Material* aMat = (*cItr)->GetMaterial();
284     if((*cItr)->IsRecalcNeeded())              << 248     if((*cItr)->IsRecalcNeeded()) {
285     {                                          << 249       for(size_t ptcl=0;ptcl< NumberOfG4CutIndex;ptcl++){
286       for(std::size_t ptcl=0; ptcl< NumberOfG4 << 250         G4double rCut = aCut->GetProductionCut(ptcl);
287       {                                        << 
288         G4double rCut = aCut->GetProductionCut << 
289         (*(rangeCutTable[ptcl]))[idx] = rCut;     251         (*(rangeCutTable[ptcl]))[idx] = rCut;
290                                                << 252         // if(converters[ptcl] && (*cItr)->IsUsed())
291         if(nullptr != converters[ptcl])        << 253         if(converters[ptcl]) {
292         {                                      << 254           (*(energyCutTable[ptcl]))[idx] = converters[ptcl]->Convert(rCut,aMat);
293           // check user defined cut in energy  << 255         } else {
294           if(nullptr == userEnergyCuts[ptcl] | << 
295           {                                    << 
296             (*(energyCutTable[ptcl]))[idx] = c << 
297           }                                    << 
298           else                                 << 
299           {                                    << 
300             (*(energyCutTable[ptcl]))[idx] = ( << 
301           }                                    << 
302         }                                      << 
303         else                                   << 
304         {                                      << 
305           (*(energyCutTable[ptcl]))[idx] = -1.    256           (*(energyCutTable[ptcl]))[idx] = -1.; 
306         }                                         257         }
307       }                                           258       }
308     }                                             259     }
309     ++idx;                                     << 260     idx++;  
310   }                                               261   }
311   if (verboseLevel>2)                          << 262   if (verboseLevel>2) {
312   {                                            << 
313     timer.Stop();                                 263     timer.Stop();
314     G4cout << "G4ProductionCutsTable::UpdateCo << 264     G4cout << "G4ProductionCutsTable::UpdateCoupleTable "
315            << "Elapsed time for calculation of << 265         << "  elapsed time for calculation of  energy cuts " << G4endl;
316     G4cout << timer << G4endl;                 << 266     G4cout << timer <<G4endl;
                                                   >> 267   }
                                                   >> 268 
                                                   >> 269   // resize Range/Energy cuts double vectors if new couple is made
                                                   >> 270   if(newCoupleAppears){
                                                   >> 271     for(size_t ix=0;ix<NumberOfG4CutIndex;ix++){
                                                   >> 272       G4double* rangeVOld = rangeDoubleVector[ix];
                                                   >> 273       G4double* energyVOld = energyDoubleVector[ix];
                                                   >> 274       if(rangeVOld) delete [] rangeVOld;
                                                   >> 275       if(energyVOld) delete [] energyVOld;
                                                   >> 276       rangeDoubleVector[ix] = new G4double[(*(rangeCutTable[ix])).size()];
                                                   >> 277       energyDoubleVector[ix] = new G4double[(*(energyCutTable[ix])).size()];
                                                   >> 278     }
317   }                                               279   }
318                                                   280 
319   // Update Range/Energy cuts double vectors      281   // Update Range/Energy cuts double vectors
320   for(std::size_t ix=0; ix<NumberOfG4CutIndex; << 282   for(size_t ix=0;ix<NumberOfG4CutIndex;ix++) {
321   {                                            << 283     for(size_t ixx=0;ixx<(*(rangeCutTable[ix])).size();ixx++) {
322     for(std::size_t ixx=0; ixx<(*(rangeCutTabl << 
323     {                                          << 
324       rangeDoubleVector[ix][ixx] = (*(rangeCut    284       rangeDoubleVector[ix][ixx] = (*(rangeCutTable[ix]))[ixx];
325       energyDoubleVector[ix][ixx] = (*(energyC    285       energyDoubleVector[ix][ixx] = (*(energyCutTable[ix]))[ixx];
326     }                                             286     }
327   }                                               287   }
328 }                                                 288 }
329                                                   289 
330 // ------------------------------------------- << 290 
                                                   >> 291 /////////////////////////////////////////////////////////////
331 G4double G4ProductionCutsTable::ConvertRangeTo    292 G4double G4ProductionCutsTable::ConvertRangeToEnergy(
332                                   const G4Part << 293           const G4ParticleDefinition* particle,
333                                   const G4Mate << 294           const G4Material*           material, 
334                                   G4double     << 295           G4double                    range      
                                                   >> 296                  )
335 {                                                 297 {
336   // This method gives energy corresponding to    298   // This method gives energy corresponding to range value  
337                                                << 
338   // protection against premature call         << 
339   if(firstUse)                                 << 
340   {                                            << 
341 #ifdef G4VERBOSE                               << 
342     if(verboseLevel>0)                         << 
343     {                                          << 
344       G4ExceptionDescription ed;               << 
345       ed << "Invoked prematurely before it is  << 
346       G4Exception("G4ProductionCutsTable::Conv << 
347                   "CUTS0100", JustWarning, ed) << 
348     }                                          << 
349 #endif                                         << 
350     return -1.0;                               << 
351   }                                            << 
352                                                << 
353   // check material                               299   // check material
354   if (material == nullptr) return -1.0;        << 300   if (material ==nullptr) return -1.0;
355                                                   301 
356   // check range                                  302   // check range
357   if (range == 0.0) return 0.0;                << 303   if (range ==0.0) return 0.0;
358   if (range <0.0) return -1.0;                    304   if (range <0.0) return -1.0;
359                                                   305 
360   // check particle                               306   // check particle
361   G4int index = G4ProductionCuts::GetIndex(par    307   G4int index = G4ProductionCuts::GetIndex(particle);
362                                                   308 
363   if (index<0 || converters[index] == nullptr) << 309   if (index<0) {
364   {                                            << 310 #ifdef G4VERBOSE  
365 #ifdef G4VERBOSE                               << 311     if (verboseLevel >1) {
366     if(verboseLevel>0)                         << 312       G4cout << "G4ProductionCutsTable::ConvertRangeToEnergy" ;
367     {                                          << 313       G4cout << particle->GetParticleName() << " has no cut value " << G4endl;
368       G4ExceptionDescription ed;               << 314     }  
369       ed << "Invoked ";                        << 
370       if(particle != nullptr)                  << 
371       { ed << "for particle <" << particle->Ge << 
372       else                                     << 
373       { ed << "without valid particle pointer. << 
374       G4Exception("G4ProductionCutsTable::Conv << 
375                   "CUTS0101", JustWarning, ed) << 
376     }                                          << 
377 #endif                                            315 #endif
378     return -1.0;                                  316     return -1.0;
379   }                                               317   }
380                                                   318 
381   return converters[index]->Convert(range, mat    319   return converters[index]->Convert(range, material);
                                                   >> 320    
382 }                                                 321 }
383                                                   322 
384 // ------------------------------------------- << 323 /////////////////////////////////////////////////////////////
385 void G4ProductionCutsTable::ResetConverters()     324 void G4ProductionCutsTable::ResetConverters()
386 {}                                             << 325 {
                                                   >> 326   for(size_t i=0;i< NumberOfG4CutIndex;i++){
                                                   >> 327     if (converters[i]!=0) converters[i]->Reset();
                                                   >> 328   }
                                                   >> 329 }
387                                                   330 
388 // ------------------------------------------- << 331 
                                                   >> 332 /////////////////////////////////////////////////////////////
389 void G4ProductionCutsTable::SetEnergyRange(G4d    333 void G4ProductionCutsTable::SetEnergyRange(G4double lowedge, G4double highedge)
390 {                                                 334 {
391   G4VRangeToEnergyConverter::SetEnergyRange(lo    335   G4VRangeToEnergyConverter::SetEnergyRange(lowedge,highedge);
392 }                                                 336 }
393                                                   337 
394 // ------------------------------------------- << 338 /////////////////////////////////////////////////////////////
395 G4double  G4ProductionCutsTable::GetLowEdgeEne    339 G4double  G4ProductionCutsTable::GetLowEdgeEnergy() const
396 {                                                 340 {
397   return G4VRangeToEnergyConverter::GetLowEdge    341   return G4VRangeToEnergyConverter::GetLowEdgeEnergy();
398 }                                                 342 }
399                                                   343 
400 // ------------------------------------------- << 344 /////////////////////////////////////////////////////////////
401 G4double G4ProductionCutsTable::GetHighEdgeEne    345 G4double G4ProductionCutsTable::GetHighEdgeEnergy() const
402 {                                                 346 {
403   return G4VRangeToEnergyConverter::GetHighEdg    347   return G4VRangeToEnergyConverter::GetHighEdgeEnergy();
404 }                                                 348 }
405                                                   349  
406 // ------------------------------------------- << 350 
                                                   >> 351 /////////////////////////////////////////////////////////////
407 void G4ProductionCutsTable::ScanAndSetCouple(G    352 void G4ProductionCutsTable::ScanAndSetCouple(G4LogicalVolume* aLV,
408                                              G    353                                              G4MaterialCutsCouple* aCouple,
409                                              G    354                                              G4Region* aRegion)
410 {                                                 355 {
411   // Check whether or not this logical volume  << 356   //Check whether or not this logical volume belongs to the same region
412   if((aRegion!=nullptr) && aLV->GetRegion()!=a    357   if((aRegion!=nullptr) && aLV->GetRegion()!=aRegion) return;
413                                                   358 
414   // Check if this particular volume has a mat << 359   //Check if this particular volume has a material matched to the couple
415   if(aLV->GetMaterial()==aCouple->GetMaterial( << 360   if(aLV->GetMaterial()==aCouple->GetMaterial()) {
416   {                                            << 
417     aLV->SetMaterialCutsCouple(aCouple);          361     aLV->SetMaterialCutsCouple(aCouple);
418   }                                               362   }
419                                                   363 
420   std::size_t noDaughters = aLV->GetNoDaughter << 364   size_t noDaughters = aLV->GetNoDaughters();
421   if(noDaughters==0) return;                      365   if(noDaughters==0) return;
422                                                   366 
423   // Loop over daughters with same region      << 367   //Loop over daughters with same region
424   for(std::size_t i=0; i<noDaughters; ++i)     << 368   for(size_t i=0;i<noDaughters;i++){
425   {                                            << 
426     G4LogicalVolume* daughterLVol = aLV->GetDa    369     G4LogicalVolume* daughterLVol = aLV->GetDaughter(i)->GetLogicalVolume();
427     ScanAndSetCouple(daughterLVol,aCouple,aReg    370     ScanAndSetCouple(daughterLVol,aCouple,aRegion);
428   }                                               371   }
429 }                                                 372 }
430                                                   373 
431 // ------------------------------------------- << 374 /////////////////////////////////////////////////////////////
432 void G4ProductionCutsTable::DumpCouples() cons    375 void G4ProductionCutsTable::DumpCouples() const
433 {                                                 376 {
434   G4cout << G4endl;                               377   G4cout << G4endl;
435   G4cout << "========= Table of registered cou << 378   G4cout << "========= Table of registered couples =============================="
436          << G4endl;                               379          << G4endl;
437   for(auto cItr=coupleTable.cbegin(); cItr!=co << 380   for(CoupleTableIterator cItr=coupleTable.begin();
438   {                                            << 381       cItr!=coupleTable.end();cItr++) {
439     G4MaterialCutsCouple* aCouple = (*cItr);      382     G4MaterialCutsCouple* aCouple = (*cItr);
440     G4ProductionCuts* aCut = aCouple->GetProdu    383     G4ProductionCuts* aCut = aCouple->GetProductionCuts();
441     G4cout << G4endl;                             384     G4cout << G4endl;
442     G4cout << "Index : " << aCouple->GetIndex(    385     G4cout << "Index : " << aCouple->GetIndex() 
443            << "     used in the geometry : ";     386            << "     used in the geometry : ";
444     if(aCouple->IsUsed()) G4cout << "Yes";        387     if(aCouple->IsUsed()) G4cout << "Yes";
445     else                  G4cout << "No ";        388     else                  G4cout << "No ";
446 ////    G4cout << "     recalculation needed :    389 ////    G4cout << "     recalculation needed : ";
447 ////    if(aCouple->IsRecalcNeeded()) G4cout <    390 ////    if(aCouple->IsRecalcNeeded()) G4cout << "Yes";
448 ////    else                          G4cout <    391 ////    else                          G4cout << "No ";
449     G4cout << G4endl;                             392     G4cout << G4endl;
450     G4cout << " Material : " << aCouple->GetMa    393     G4cout << " Material : " << aCouple->GetMaterial()->GetName() << G4endl;
451     G4cout << " Range cuts        : "             394     G4cout << " Range cuts        : " 
452            << " gamma  " << G4BestUnit(aCut->G    395            << " gamma  " << G4BestUnit(aCut->GetProductionCut("gamma"),"Length")
453            << "    e-  " << G4BestUnit(aCut->G    396            << "    e-  " << G4BestUnit(aCut->GetProductionCut("e-"),"Length")
454            << "    e+  " << G4BestUnit(aCut->G    397            << "    e+  " << G4BestUnit(aCut->GetProductionCut("e+"),"Length")
455            << " proton " << G4BestUnit(aCut->G    398            << " proton " << G4BestUnit(aCut->GetProductionCut("proton"),"Length")
456            << G4endl;                             399            << G4endl;
457     G4cout << " Energy thresholds : " ;           400     G4cout << " Energy thresholds : " ;
458 ////    if(aCouple->IsRecalcNeeded()) {           401 ////    if(aCouple->IsRecalcNeeded()) {
459 ////      G4cout << " is not ready to print";     402 ////      G4cout << " is not ready to print";
460 ////    } else {                                  403 ////    } else {
461     G4cout << " gamma  " << G4BestUnit((*(ener << 404       G4cout << " gamma  " << G4BestUnit((*(energyCutTable[0]))[aCouple->GetIndex()],"Energy")
462            << "    e-  " << G4BestUnit((*(ener << 405              << "    e-  " << G4BestUnit((*(energyCutTable[1]))[aCouple->GetIndex()],"Energy")
463            << "    e+  " << G4BestUnit((*(ener << 406              << "    e+  " << G4BestUnit((*(energyCutTable[2]))[aCouple->GetIndex()],"Energy") 
464            << " proton " << G4BestUnit((*(ener << 407        << " proton " << G4BestUnit((*(energyCutTable[3]))[aCouple->GetIndex()],"Energy");
465 ////    }                                         408 ////    }
466     G4cout << G4endl;                             409     G4cout << G4endl;
467                                                   410 
468     if(aCouple->IsUsed())                      << 411     if(aCouple->IsUsed()) {
469     {                                          << 
470       G4cout << " Region(s) which use this cou    412       G4cout << " Region(s) which use this couple : " << G4endl;
471       for(auto rItr=fG4RegionStore->cbegin();  << 413       typedef std::vector<G4Region*>::iterator regionIterator;
472                rItr!=fG4RegionStore->cend(); + << 414       for(regionIterator rItr=fG4RegionStore->begin();
473       {                                        << 415           rItr!=fG4RegionStore->end();rItr++) {
474         if (IsCoupleUsedInTheRegion(aCouple, * << 416         if (IsCoupleUsedInTheRegion(aCouple, *rItr) ){
475         {                                      << 
476           G4cout << "    " << (*rItr)->GetName    417           G4cout << "    " << (*rItr)->GetName() << G4endl;
477         }                                         418         }
478       }                                           419       }
479     }                                             420     }
480   }                                               421   }
481   G4cout << G4endl;                               422   G4cout << G4endl;
482   G4cout << "================================= << 423   G4cout << "====================================================================" << G4endl;
483   G4cout << G4endl;                               424   G4cout << G4endl;
484 }                                                 425 }
485                                                   426            
486 // ------------------------------------------- << 427 
                                                   >> 428 /////////////////////////////////////////////////////////////
                                                   >> 429 // Store cuts and material information in files under the specified directory.
487 G4bool  G4ProductionCutsTable::StoreCutsTable(    430 G4bool  G4ProductionCutsTable::StoreCutsTable(const G4String& dir, 
488                                                << 431                                               G4bool          ascii)
489 {                                                 432 {
490   // Store cuts and material information in fi << 
491                                                << 
492   if (!StoreMaterialInfo(dir, ascii)) return f    433   if (!StoreMaterialInfo(dir, ascii)) return false;
493   if (!StoreMaterialCutsCoupleInfo(dir, ascii)    434   if (!StoreMaterialCutsCoupleInfo(dir, ascii)) return false;
494   if (!StoreCutsInfo(dir, ascii)) return false    435   if (!StoreCutsInfo(dir, ascii)) return false;
495                                                   436   
496 #ifdef G4VERBOSE                                  437 #ifdef G4VERBOSE  
497   if (verboseLevel >2)                         << 438   if (verboseLevel >2) {
498   {                                            << 439     G4cout << "G4ProductionCutsTable::StoreCutsTable " ;
499     G4cout << "G4ProductionCutsTable::StoreCut << 440     G4cout << " Material/Cuts information have been succesfully stored ";
500     G4cout << " Material/Cuts information have << 441     if (ascii) {
501     if (ascii)                                 << 
502     {                                          << 
503       G4cout << " in Ascii mode ";                442       G4cout << " in Ascii mode ";
504     }                                          << 443     }else{
505     else                                       << 
506     {                                          << 
507       G4cout << " in Binary mode ";               444       G4cout << " in Binary mode ";
508     }                                             445     }
509     G4cout << " under " << dir << G4endl;         446     G4cout << " under " << dir << G4endl;  
510   }                                               447   }  
511 #endif                                            448 #endif
512   return true;                                    449   return true;
513 }                                                 450 }
514                                                   451   
515 // ------------------------------------------- << 452 /////////////////////////////////////////////////////////////
516 G4bool  G4ProductionCutsTable::RetrieveCutsTab    453 G4bool  G4ProductionCutsTable::RetrieveCutsTable(const G4String& dir,
517                                                << 454                                                  G4bool          ascii)
518 {                                                 455 {
519   if (!CheckForRetrieveCutsTable(dir, ascii))     456   if (!CheckForRetrieveCutsTable(dir, ascii)) return false;
520   if (!RetrieveCutsInfo(dir, ascii)) return fa    457   if (!RetrieveCutsInfo(dir, ascii)) return false;
521 #ifdef G4VERBOSE                                  458 #ifdef G4VERBOSE  
522   if (verboseLevel >2)                         << 459   if (verboseLevel >2) {
523   {                                            << 460     G4cout << "G4ProductionCutsTable::RetrieveCutsTable " ;
524     G4cout << "G4ProductionCutsTable::Retrieve << 461     G4cout << " Material/Cuts information have been succesfully retreived ";
525     G4cout << " Material/Cuts information have << 462     if (ascii) {
526     if (ascii)                                 << 
527     {                                          << 
528       G4cout << " in Ascii mode ";                463       G4cout << " in Ascii mode ";
529     }                                          << 464     }else{
530     else                                       << 
531     {                                          << 
532       G4cout << " in Binary mode ";               465       G4cout << " in Binary mode ";
533     }                                             466     }
534     G4cout << " under " << dir << G4endl;         467     G4cout << " under " << dir << G4endl;  
535   }                                               468   }  
536 #endif                                            469 #endif
537   return true;                                    470   return true;
538 }                                                 471 }
539                                                   472 
540 // ------------------------------------------- << 473 /////////////////////////////////////////////////////////////
                                                   >> 474 // check stored material and cut values are consistent
                                                   >> 475 // with the current detector setup. 
                                                   >> 476 //
541 G4bool                                            477 G4bool
542 G4ProductionCutsTable::CheckForRetrieveCutsTab << 478  G4ProductionCutsTable::CheckForRetrieveCutsTable(const G4String& directory, 
543                                                << 479                                                   G4bool          ascii)
544 {                                                 480 {
545   // check stored material and cut values are  << 481   G4cerr << "G4ProductionCutsTable::CheckForRetrieveCutsTable!!"<< G4endl;
546   // with the current detector setup           << 
547                                                << 
548   G4cerr << "G4ProductionCutsTable::CheckForRe << 
549   //  isNeedForRestoreCoupleInfo = false;         482   //  isNeedForRestoreCoupleInfo = false;
550   if (!CheckMaterialInfo(directory, ascii)) re    483   if (!CheckMaterialInfo(directory, ascii)) return false;
551   if (verboseLevel >2)                         << 484   if (verboseLevel >2) {
552   {                                            << 485       G4cerr << "G4ProductionCutsTable::CheckMaterialInfo  passed !!"<< G4endl;
553       G4cerr << "G4ProductionCutsTable::CheckM << 
554   }                                               486   }
555   if (!CheckMaterialCutsCoupleInfo(directory,     487   if (!CheckMaterialCutsCoupleInfo(directory, ascii)) return false;
556   if (verboseLevel >2)                         << 488   if (verboseLevel >2) {
557   {                                            << 489     G4cerr << "G4ProductionCutsTable::CheckMaterialCutsCoupleInfo  passed !!"<< G4endl;
558     G4cerr << "G4ProductionCutsTable::CheckMat << 
559            << G4endl;                          << 
560   }                                               490   }
561   return true;                                    491   return true;
562 }                                                 492 }
563                                                   493   
564 // ------------------------------------------- << 494 /////////////////////////////////////////////////////////////
565 G4bool G4ProductionCutsTable::StoreMaterialInf << 495 // Store material information in files under the specified directory.
566                                                << 496 //
                                                   >> 497 G4bool  G4ProductionCutsTable::StoreMaterialInfo(const G4String& directory, 
                                                   >> 498                                                  G4bool          ascii)
567 {                                                 499 {
568   // Store material information in files under << 
569                                                << 
570   const G4String fileName = directory + "/" +     500   const G4String fileName = directory + "/" + "material.dat";
571   const G4String key = "MATERIAL-V3.0";           501   const G4String key = "MATERIAL-V3.0";
572   std::ofstream fOut;                             502   std::ofstream fOut;  
573                                                   503 
574   // open output file                          << 504   // open output file //
575   if (!ascii )  fOut.open(fileName,std::ios::o << 505   if (!ascii ) 
576   else          fOut.open(fileName,std::ios::o << 506     fOut.open(fileName,std::ios::out|std::ios::binary);
                                                   >> 507   else 
                                                   >> 508     fOut.open(fileName,std::ios::out);
577                                                   509 
                                                   >> 510   
578   // check if the file has been opened success    511   // check if the file has been opened successfully 
579   if (!fOut)                                   << 512   if (!fOut) {
580   {                                            << 
581 #ifdef G4VERBOSE                                  513 #ifdef G4VERBOSE
582     if (verboseLevel>0)                        << 514     if (verboseLevel>0) {
583     {                                          << 515       G4cerr << "G4ProductionCutsTable::StoreMaterialInfo  ";
584       G4cerr << "G4ProductionCutsTable::StoreM << 516       G4cerr << " Can not open file " << fileName << G4endl;
585       G4cerr << "Cannot open file: " << fileNa << 
586     }                                             517     }
587 #endif                                            518 #endif
588     G4Exception( "G4ProductionCutsTable::Store    519     G4Exception( "G4ProductionCutsTable::StoreMaterialInfo()",
589                  "ProcCuts102", JustWarning, " << 520      "ProcCuts102",
                                                   >> 521      JustWarning, "Can not open file ");
590     return false;                                 522     return false;
591   }                                               523   }
592                                                   524   
593   const G4MaterialTable* matTable = G4Material    525   const G4MaterialTable* matTable = G4Material::GetMaterialTable(); 
594   // number of materials in the table             526   // number of materials in the table
595   G4int numberOfMaterial = (G4int)matTable->si << 527   G4int numberOfMaterial = matTable->size();
596                                                   528 
597   if (ascii)                                   << 529  if (ascii) {
598   {                                            << 
599     /////////////// ASCII mode  //////////////    530     /////////////// ASCII mode  /////////////////
600     // key word                                   531     // key word
601     fOut  << key << G4endl;                       532     fOut  << key << G4endl;
602                                                   533     
603     // number of materials in the table           534     // number of materials in the table
604     fOut  << numberOfMaterial << G4endl;          535     fOut  << numberOfMaterial << G4endl;
605                                                   536     
606     fOut.setf(std::ios::scientific);              537     fOut.setf(std::ios::scientific);
607                                                   538   
608     // material name and density                  539     // material name and density
609     for (std::size_t idx=0; static_cast<G4int> << 540     for (size_t idx=0; static_cast<G4int>(idx)<numberOfMaterial; ++idx){
610     {                                          << 
611       fOut << std::setw(FixedStringLengthForSt    541       fOut << std::setw(FixedStringLengthForStore)
612            << ((*matTable)[idx])->GetName();      542            << ((*matTable)[idx])->GetName();
613       fOut << std::setw(FixedStringLengthForSt    543       fOut << std::setw(FixedStringLengthForStore)
614            << ((*matTable)[idx])->GetDensity()    544            << ((*matTable)[idx])->GetDensity()/(g/cm3) << G4endl;
615     }                                             545     }
616                                                   546     
617     fOut.unsetf(std::ios::scientific);            547     fOut.unsetf(std::ios::scientific);
618                                                   548 
619   }                                            << 549   } else {
620   else                                         << 
621   {                                            << 
622     /////////////// Binary mode  /////////////    550     /////////////// Binary mode  /////////////////
623     char temp[FixedStringLengthForStore];         551     char temp[FixedStringLengthForStore];
624     std::size_t i;                             << 552     size_t i;
625                                                   553 
626     // key word                                   554     // key word
627     for (i=0; i<FixedStringLengthForStore; ++i << 555     for (i=0; i<FixedStringLengthForStore; ++i){
628     {                                          << 
629       temp[i] = '\0';                             556       temp[i] = '\0'; 
630     }                                             557     }
631     for (i=0; i<key.length() && i<FixedStringL << 558     for (i=0; i<key.length() && i<FixedStringLengthForStore-1; ++i){
632     {                                          << 559       temp[i]=key[i];
633       temp[i]=key[(G4int)i];                   << 
634     }                                             560     }
635     fOut.write(temp, FixedStringLengthForStore    561     fOut.write(temp, FixedStringLengthForStore);
636                                                   562 
637     // number of materials in the table           563     // number of materials in the table
638     fOut.write( (char*)(&numberOfMaterial), si << 564     fOut.write( (char*)(&numberOfMaterial), sizeof (G4int));
639                                                   565     
640     // material name and density                  566     // material name and density
641     for (std::size_t imat=0; static_cast<G4int << 567     for (size_t imat=0; static_cast<G4int>(imat)<numberOfMaterial; ++imat){
642     {                                          << 
643       G4String name =  ((*matTable)[imat])->Ge    568       G4String name =  ((*matTable)[imat])->GetName();
644       G4double density = ((*matTable)[imat])->    569       G4double density = ((*matTable)[imat])->GetDensity();
645       for (i=0; i<FixedStringLengthForStore; + << 570       for (i=0; i<FixedStringLengthForStore; ++i) temp[i] = '\0'; 
646         temp[i] = '\0';                        << 
647       for (i=0; i<name.length() && i<FixedStri    571       for (i=0; i<name.length() && i<FixedStringLengthForStore-1; ++i)
648         temp[i]=name[(G4int)i];                << 572         temp[i]=name[i];
649       fOut.write(temp, FixedStringLengthForSto    573       fOut.write(temp, FixedStringLengthForStore);
650       fOut.write( (char*)(&density), sizeof(G4 << 574       fOut.write( (char*)(&density), sizeof (G4double));
651     }                                             575     }    
652   }                                            << 576    }    
653                                                   577 
654   fOut.close();                                   578   fOut.close();
655   return true;                                    579   return true;
656 }                                                 580 }
657                                                   581 
658 // ------------------------------------------- << 582 /////////////////////////////////////////////////////////////
659 G4bool G4ProductionCutsTable::CheckMaterialInf << 583 // check stored material is consistent with the current detector setup. 
660                                                << 584 G4bool  G4ProductionCutsTable::CheckMaterialInfo(const G4String& directory, 
                                                   >> 585                                                  G4bool          ascii)
661 {                                                 586 {
662   // Check stored material is consistent with  << 
663                                                << 
664   const G4String fileName = directory + "/" +     587   const G4String fileName = directory + "/" + "material.dat";
665   const G4String key = "MATERIAL-V3.0";           588   const G4String key = "MATERIAL-V3.0";
666   std::ifstream fIn;                              589   std::ifstream fIn;  
667                                                   590 
668   // open input file                           << 591   // open input file //
669   if (!ascii ) fIn.open(fileName,std::ios::in| << 592   if (!ascii )
670   else         fIn.open(fileName,std::ios::in) << 593     fIn.open(fileName,std::ios::in|std::ios::binary);
                                                   >> 594   else
                                                   >> 595     fIn.open(fileName,std::ios::in);
671                                                   596 
672   // check if the file has been opened success    597   // check if the file has been opened successfully 
673   if (!fIn)                                    << 598   if (!fIn) {
674   {                                            << 
675 #ifdef G4VERBOSE                                  599 #ifdef G4VERBOSE
676     if (verboseLevel >0)                       << 600     if (verboseLevel >0) {
677     {                                          << 601       G4cerr << "G4ProductionCutsTable::CheckMaterialInfo  ";
678       G4cerr << "G4ProductionCutsTable::CheckM << 602       G4cerr << " Can not open file " << fileName << G4endl;
679       G4cerr << "Cannot open file: " << fileNa << 
680     }                                             603     }
681 #endif                                            604 #endif
682     G4Exception( "G4ProductionCutsTable::Check    605     G4Exception( "G4ProductionCutsTable::CheckMaterialInfo()",
683                  "ProcCuts102", JustWarning, " << 606      "ProcCuts102",
                                                   >> 607      JustWarning, "Can not open file ");
684     return false;                                 608     return false;
685   }                                               609   }
686                                                   610   
687   char temp[FixedStringLengthForStore];           611   char temp[FixedStringLengthForStore];
688                                                   612 
689   // key word                                     613   // key word
690   G4String keyword;                               614   G4String keyword;    
691   if (ascii)                                   << 615   if (ascii) {
692   {                                            << 
693     fIn >> keyword;                               616     fIn >> keyword;
694   }                                            << 617   } else {
695   else                                         << 
696   {                                            << 
697     fIn.read(temp, FixedStringLengthForStore);    618     fIn.read(temp, FixedStringLengthForStore);
698     keyword = (const char*)(temp);                619     keyword = (const char*)(temp);
699   }                                               620   }
700   if (key!=keyword)                            << 621   if (key!=keyword) {
701   {                                            << 
702 #ifdef G4VERBOSE                                  622 #ifdef G4VERBOSE
703     if (verboseLevel >0)                       << 623     if (verboseLevel >0) {
704     {                                          << 624       G4cerr << "G4ProductionCutsTable::CheckMaterialInfo  ";
705       G4cerr << "G4ProductionCutsTable::CheckM << 625       G4cerr << " Key word in " << fileName << "= " << keyword ;
706       G4cerr << "Key word in " << fileName <<  << 
707       G4cerr <<"( should be   "<< key << ")" <    626       G4cerr <<"( should be   "<< key << ")" <<G4endl;
708     }                                             627     }
709 #endif                                            628 #endif
710     G4Exception( "G4ProductionCutsTable::Check    629     G4Exception( "G4ProductionCutsTable::CheckMaterialInfo()",
711                  "ProcCuts103", JustWarning, " << 630      "ProcCuts103",
                                                   >> 631      JustWarning, "Bad Data Format");
712     return false;                                 632     return false;
713   }                                               633   }
714                                                   634 
715   // number of materials in the table             635   // number of materials in the table
716   G4int nmat;                                     636   G4int nmat;
717   if (ascii)                                   << 637   if (ascii) {
718   {                                            << 
719     fIn >> nmat;                                  638     fIn >> nmat;
                                                   >> 639   } else {
                                                   >> 640     fIn.read( (char*)(&nmat), sizeof (G4int));
720   }                                               641   }
721   else                                         << 642   if ((nmat<=0) || (nmat >100000)){
722   {                                            << 
723     fIn.read( (char*)(&nmat), sizeof(G4int));  << 
724   }                                            << 
725   if ((nmat<=0) || (nmat >100000))             << 
726   {                                            << 
727     G4Exception( "G4ProductionCutsTable::Check    643     G4Exception( "G4ProductionCutsTable::CheckMaterialInfo()",
728                  "ProcCuts108", JustWarning,   << 644      "ProcCuts108",JustWarning, 
729                  "Number of materials is less  << 645      "Number of materials is less than zero or too big");
730     return false;                                 646     return false;
731   }                                               647   }
732                                                   648 
733   // list of material                             649   // list of material
734   for (G4int idx=0; idx<nmat ; ++idx)          << 650   for (G4int idx=0; idx<nmat ; ++idx){
735   {                                            << 
736     // check eof                                  651     // check eof
737     if(fIn.eof())                              << 652     if(fIn.eof()) {
738     {                                          << 
739 #ifdef G4VERBOSE                                  653 #ifdef G4VERBOSE
740       if (verboseLevel >0)                     << 654       if (verboseLevel >0) {
741       {                                        << 655         G4cout << "G4ProductionCutsTable::CheckMaterialInfo  ";
742         G4cout << "G4ProductionCutsTable::Chec << 656         G4cout << " encountered End of File " ;
743         G4cout << "Encountered End of File " ; << 
744         G4cout << " at " << idx+1 << "th  mate    657         G4cout << " at " << idx+1 << "th  material "<< G4endl;
745       }                                           658       }
746 #endif                                            659 #endif
747       fIn.close();                                660       fIn.close();
748       return false;                               661       return false;
749     }                                             662     }
750                                                   663 
751     // check material name and density            664     // check material name and density
752     char name[FixedStringLengthForStore];         665     char name[FixedStringLengthForStore];
753     G4double density;                          << 666     double density;
754     if (ascii)                                 << 667     if (ascii) {
755     {                                          << 
756       fIn >> name >> density;                     668       fIn >> name >> density;
757       density *= (g/cm3);                         669       density *= (g/cm3);
758                                                   670       
759     }                                          << 671     } else {
760     else                                       << 
761     {                                          << 
762       fIn.read(name, FixedStringLengthForStore    672       fIn.read(name, FixedStringLengthForStore);
763       fIn.read((char*)(&density), sizeof(G4dou << 673       fIn.read((char*)(&density), sizeof (G4double));
764     }                                             674     }
765     if (fIn.fail())                            << 675     if (fIn.fail()) {
766     {                                          << 
767 #ifdef G4VERBOSE                                  676 #ifdef G4VERBOSE
768       if (verboseLevel >0)                     << 677       if (verboseLevel >0) {
769       {                                        << 678         G4cerr << "G4ProductionCutsTable::CheckMaterialInfo  ";
770         G4cerr << "G4ProductionCutsTable::Chec << 679         G4cerr << " Bad data format ";
771         G4cerr << "Bad data format ";          << 
772         G4cerr << " at " << idx+1 << "th  mate    680         G4cerr << " at " << idx+1 << "th  material "<< G4endl;        
773       }                                           681       }
774 #endif                                            682 #endif
775       G4Exception( "G4ProductionCutsTable::Che    683       G4Exception( "G4ProductionCutsTable::CheckMaterialInfo()",
776                    "ProcCuts103", JustWarning, << 684        "ProcCuts103",
                                                   >> 685        JustWarning, "Bad Data Format");
777       fIn.close();                                686       fIn.close();
778       return false;                               687       return false;
779     }                                             688     }
780                                                   689 
781     G4Material* aMaterial = G4Material::GetMat    690     G4Material* aMaterial = G4Material::GetMaterial(name);
782     if (aMaterial == nullptr ) continue;          691     if (aMaterial == nullptr ) continue;
783                                                   692 
784     G4double ratio = std::fabs(density/aMateri    693     G4double ratio = std::fabs(density/aMaterial->GetDensity() );
785     if ((0.999>ratio) || (ratio>1.001) )       << 694     if ((0.999>ratio) || (ratio>1.001) ){
786     {                                          << 
787 #ifdef G4VERBOSE                                  695 #ifdef G4VERBOSE
788       if (verboseLevel >0)                     << 696       if (verboseLevel >0) {
789       {                                        << 697   G4cerr << "G4ProductionCutsTable::CheckMaterialInfo  ";
790         G4cerr << "G4ProductionCutsTable::Chec << 698   G4cerr << " Inconsistent material density" << G4endl;;
791         G4cerr << "Inconsistent material densi << 699   G4cerr << " at " << idx+1 << "th  material "<< G4endl;  
792         G4cerr << " at " << idx+1 << "th  mate << 700   G4cerr << "Name:   " << name << G4endl;
793         G4cerr << "Name:   " << name << G4endl << 701   G4cerr << "Density:" << std::setiosflags(std::ios::scientific) << density / (g/cm3) ;
794         G4cerr << "Density:" << std::setiosfla << 702   G4cerr << "(should be " << aMaterial->GetDensity()/(g/cm3)<< ")" << " [g/cm3]"<< G4endl;      
795                << density / (g/cm3) ;          << 703   G4cerr << std::resetiosflags(std::ios::scientific);
796         G4cerr << "(should be " << aMaterial-> << 
797                << " [g/cm3]"<< G4endl;         << 
798         G4cerr << std::resetiosflags(std::ios: << 
799       }                                           704       }
800 #endif                                            705 #endif
801       G4Exception( "G4ProductionCutsTable::Che    706       G4Exception( "G4ProductionCutsTable::CheckMaterialInfo()",
802                    "ProcCuts104", JustWarning, << 707        "ProcCuts104",
                                                   >> 708        JustWarning, "Inconsitent matrial density");
803       fIn.close();                                709       fIn.close();
804       return false;                               710       return false;
805     }                                             711     }
                                                   >> 712 
806   }                                               713   }
807                                                   714 
808   fIn.close();                                    715   fIn.close();
809   return true;                                    716   return true;
                                                   >> 717 
810 }                                                 718 }
                                                   >> 719 
811                                                   720   
812 // ------------------------------------------- << 721 /////////////////////////////////////////////////////////////
                                                   >> 722 // Store materialCutsCouple information in files under the specified directory.
                                                   >> 723 //
813 G4bool                                            724 G4bool
814 G4ProductionCutsTable::StoreMaterialCutsCouple << 725  G4ProductionCutsTable::StoreMaterialCutsCoupleInfo(const G4String& directory, 
815                                                << 726                 G4bool          ascii)
816 {                                                 727 {  
817   // Store materialCutsCouple information in f << 
818                                                << 
819   const G4String fileName = directory + "/" +     728   const G4String fileName = directory + "/" + "couple.dat";
820   const G4String key = "COUPLE-V3.0";             729   const G4String key = "COUPLE-V3.0";
821   std::ofstream fOut;                             730   std::ofstream fOut;  
822   char temp[FixedStringLengthForStore];           731   char temp[FixedStringLengthForStore];
823                                                   732 
824   // open output file                          << 733   // open output file //
825   if (!ascii ) fOut.open(fileName,std::ios::ou << 734   if (!ascii ) 
826   else         fOut.open(fileName,std::ios::ou << 735     fOut.open(fileName,std::ios::out|std::ios::binary);
                                                   >> 736   else 
                                                   >> 737     fOut.open(fileName,std::ios::out);
827                                                   738   
828                                                   739   
829   // check if the file has been opened success    740   // check if the file has been opened successfully 
830   if (!fOut)                                   << 741   if (!fOut) {
831   {                                            << 
832 #ifdef G4VERBOSE                                  742 #ifdef G4VERBOSE
833     if (verboseLevel >0)                       << 743     if (verboseLevel >0) {
834     {                                          << 744       G4cerr << "G4ProductionCutsTable::StoreMaterialCutsCoupleInfo  ";
835       G4cerr << "G4ProductionCutsTable::StoreM << 745       G4cerr << " Can not open file " << fileName << G4endl;
836       G4cerr << "Cannot open file: " << fileNa << 
837     }                                             746     }
838 #endif                                            747 #endif
839     G4Exception( "G4ProductionCutsTable::Store    748     G4Exception( "G4ProductionCutsTable::StoreMaterialCutsCoupleInfo()",
840                  "ProcCuts102",                << 749      "ProcCuts102",
841                  JustWarning, "Cannot open fil << 750      JustWarning, "Can not open file ");
842      return false;                                751      return false;
843   }                                               752   }
844   G4int numberOfCouples = (G4int)coupleTable.s << 753   G4int numberOfCouples = coupleTable.size();
845   if (ascii)                                   << 754   if (ascii) {
846   {                                            << 
847     /////////////// ASCII mode  //////////////    755     /////////////// ASCII mode  /////////////////
848     // key word                                   756     // key word
849     fOut << std::setw(FixedStringLengthForStor    757     fOut << std::setw(FixedStringLengthForStore) <<  key << G4endl;
850                                                   758     
851     // number of couples in the table             759     // number of couples in the table
852     fOut  << numberOfCouples << G4endl;           760     fOut  << numberOfCouples << G4endl;
853   }                                            << 761   } else {
854   else                                         << 
855   {                                            << 
856     /////////////// Binary mode  /////////////    762     /////////////// Binary mode  /////////////////
857     // key word                                   763     // key word
858     std::size_t i;                             << 764     size_t i;
859     for (i=0; i<FixedStringLengthForStore; ++i << 765     for (i=0; i<FixedStringLengthForStore; ++i) temp[i] = '\0'; 
860       temp[i] = '\0';                          << 
861     for (i=0; i<key.length() && i<FixedStringL    766     for (i=0; i<key.length() && i<FixedStringLengthForStore-1; ++i)
862       temp[i]=key[(G4int)i];                   << 767       temp[i]=key[i];
863     fOut.write(temp, FixedStringLengthForStore    768     fOut.write(temp, FixedStringLengthForStore);
864                                                   769     
865     // number of couples in the table             770     // number of couples in the table   
866     fOut.write( (char*)(&numberOfCouples), siz << 771     fOut.write( (char*)(&numberOfCouples), sizeof (G4int));
867   }                                               772   }
868                                                   773 
                                                   >> 774  
869   // Loop over all couples                        775   // Loop over all couples
870   for (auto cItr=coupleTable.cbegin(); cItr!=c << 776   CoupleTableIterator cItr;
871   {                                            << 777   for (cItr=coupleTable.begin();cItr!=coupleTable.end();cItr++){
872     G4MaterialCutsCouple* aCouple = (*cItr);      778     G4MaterialCutsCouple* aCouple = (*cItr);
873     G4int index = aCouple->GetIndex();            779     G4int index = aCouple->GetIndex(); 
874     // cut value                                  780     // cut value
875     G4ProductionCuts* aCut = aCouple->GetProdu    781     G4ProductionCuts* aCut = aCouple->GetProductionCuts();
876     G4double cutValues[NumberOfG4CutIndex];       782     G4double cutValues[NumberOfG4CutIndex];
877     for (std::size_t idx=0; idx <NumberOfG4Cut << 783     for (size_t idx=0; idx <NumberOfG4CutIndex; idx++) {
878     {                                          << 784       cutValues[idx] = aCut->GetProductionCut(idx);
879       cutValues[idx] = aCut->GetProductionCut( << 
880     }                                             785     }
881     // material/region info                       786     // material/region info
882     G4String materialName = aCouple->GetMateri    787     G4String materialName = aCouple->GetMaterial()->GetName();
883     G4String regionName = "NONE";                 788     G4String regionName = "NONE";
884     if (aCouple->IsUsed())                     << 789     if (aCouple->IsUsed()){
885     {                                          << 790       typedef std::vector<G4Region*>::iterator regionIterator;
886       for(auto rItr=fG4RegionStore->cbegin();  << 791       for(regionIterator rItr=fG4RegionStore->begin();
887                rItr!=fG4RegionStore->cend(); + << 792           rItr!=fG4RegionStore->end();rItr++){
888       {                                        << 793         if (IsCoupleUsedInTheRegion(aCouple, *rItr) ){
889         if (IsCoupleUsedInTheRegion(aCouple, * << 
890         {                                      << 
891           regionName = (*rItr)->GetName();        794           regionName = (*rItr)->GetName();
892           break;                                  795           break;
893         }                                         796         }
894       }                                           797       }
895     }                                             798     }
896                                                   799 
897     if (ascii)                                 << 800     if (ascii) {
898     {                                          << 
899       /////////////// ASCII mode  ////////////    801       /////////////// ASCII mode  /////////////////
900       // index number                             802       // index number
901       fOut  << index << G4endl;                   803       fOut  << index << G4endl; 
902                                                   804   
903       // material name                            805       // material name 
904       fOut << std::setw(FixedStringLengthForSt    806       fOut << std::setw(FixedStringLengthForStore) << materialName<< G4endl;
905                                                   807   
906       // region name                              808       // region name 
907       fOut << std::setw(FixedStringLengthForSt    809       fOut << std::setw(FixedStringLengthForStore) << regionName<< G4endl;
908                                                   810 
909       fOut.setf(std::ios::scientific);            811       fOut.setf(std::ios::scientific);
910       // cut values                               812       // cut values
911       for (std::size_t idx=0; idx< NumberOfG4C << 813       for (size_t idx=0; idx< NumberOfG4CutIndex; idx++) {
912       {                                        << 
913         fOut << std::setw(FixedStringLengthFor    814         fOut << std::setw(FixedStringLengthForStore) << cutValues[idx]/(mm)
914              << G4endl;                           815              << G4endl;
915       }                                           816       }
916       fOut.unsetf(std::ios::scientific);          817       fOut.unsetf(std::ios::scientific);
917                                                   818 
918     }                                          << 819     } else {
919     else                                       << 
920     {                                          << 
921       /////////////// Binary mode  ///////////    820       /////////////// Binary mode  /////////////////
922       // index                                    821       // index
923       fOut.write( (char*)(&index), sizeof(G4in << 822       fOut.write( (char*)(&index), sizeof (G4int));
924                                                   823     
925       // material name                            824       // material name
926       std::size_t i;                           << 825       size_t i;
927       for (i=0; i<FixedStringLengthForStore; + << 826       for (i=0; i<FixedStringLengthForStore; ++i) temp[i] = '\0'; 
928         temp[i] = '\0';                        << 827       for (i=0; i<materialName.length() && i<FixedStringLengthForStore-1; ++i) {
929       for (i=0; i<materialName.length() && i<F << 828         temp[i]=materialName[i];
930         temp[i]=materialName[(G4int)i];        << 829       }
931       fOut.write(temp, FixedStringLengthForSto    830       fOut.write(temp, FixedStringLengthForStore);
932                                                   831 
933       // region name                              832       // region name
934       for (i=0; i<FixedStringLengthForStore; + << 833       for (i=0; i<FixedStringLengthForStore; ++i) temp[i] = '\0'; 
935         temp[i] = '\0';                        << 834       for (i=0; i<regionName.length() && i<FixedStringLengthForStore-1; ++i) {
936       for (i=0; i<regionName.length() && i<Fix << 835         temp[i]=regionName[i];
937         temp[i]=regionName[(G4int)i];          << 836       }
938       fOut.write(temp, FixedStringLengthForSto    837       fOut.write(temp, FixedStringLengthForStore);
939                                                   838 
940       // cut values                               839       // cut values
941       for (std::size_t idx=0; idx< NumberOfG4C << 840       for (size_t idx=0; idx< NumberOfG4CutIndex; idx++) {
942       {                                        << 841          fOut.write( (char*)(&(cutValues[idx])), sizeof (G4double));
943          fOut.write( (char*)(&(cutValues[idx]) << 
944       }                                           842       }    
945     }                                             843     }
946   }                                            << 844    }    
                                                   >> 845 
947   fOut.close();                                   846   fOut.close();
948   return true;                                    847   return true;
949 }                                                 848 }
950                                                   849 
951 // ------------------------------------------- << 850 
                                                   >> 851 /////////////////////////////////////////////////////////////
                                                   >> 852 // check stored materialCutsCouple is consistent
                                                   >> 853 // with the current detector setup. 
                                                   >> 854 //
952 G4bool                                            855 G4bool
953 G4ProductionCutsTable::CheckMaterialCutsCouple    856 G4ProductionCutsTable::CheckMaterialCutsCoupleInfo(const G4String& directory,
954                                                << 857                                                    G4bool          ascii )
955 {                                                 858 {
956   // Check stored materialCutsCouple is consis << 
957   // with the current detector setup.          << 
958                                                << 
959   const G4String fileName = directory + "/" +     859   const G4String fileName = directory + "/" + "couple.dat";
960   const G4String key = "COUPLE-V3.0";             860   const G4String key = "COUPLE-V3.0";
961   std::ifstream fIn;                              861   std::ifstream fIn;  
962                                                   862 
963   // open input file                           << 863   // open input file //
964   if (!ascii ) fIn.open(fileName,std::ios::in| << 864   if (!ascii )
965   else         fIn.open(fileName,std::ios::in) << 865     fIn.open(fileName,std::ios::in|std::ios::binary);
                                                   >> 866   else
                                                   >> 867     fIn.open(fileName,std::ios::in);
966                                                   868 
967   // check if the file has been opened success    869   // check if the file has been opened successfully 
968   if (!fIn)                                    << 870   if (!fIn) {
969   {                                            << 
970 #ifdef G4VERBOSE                                  871 #ifdef G4VERBOSE
971     if (verboseLevel >0)                       << 872     if (verboseLevel >0) {
972     {                                          << 873       G4cerr << "G4ProductionCutTable::CheckMaterialCutsCoupleInfo  ";
973       G4cerr << "G4ProductionCutTable::CheckMa << 874       G4cerr << " Can not open file " << fileName << G4endl;
974       G4cerr << "Cannot open file!" << fileNam << 
975     }                                             875     }
976 #endif                                            876 #endif
977     G4Exception( "G4ProductionCutsTable::Check    877     G4Exception( "G4ProductionCutsTable::CheckMaterialCutsCoupleInfo()",
978                  "ProcCuts102", JustWarning, " << 878      "ProcCuts102",
                                                   >> 879      JustWarning, "Can not open file ");
979     return false;                                 880     return false;
980   }                                               881   }
981                                                   882   
982   char temp[FixedStringLengthForStore];           883   char temp[FixedStringLengthForStore];
983                                                   884 
984    // key word                                    885    // key word
985   G4String keyword;                               886   G4String keyword;    
986   if (ascii)                                   << 887   if (ascii) {
987   {                                            << 
988     fIn >> keyword;                               888     fIn >> keyword;
989   }                                            << 889   } else {
990   else                                         << 
991   {                                            << 
992     fIn.read(temp, FixedStringLengthForStore);    890     fIn.read(temp, FixedStringLengthForStore);
993     keyword = (const char*)(temp);                891     keyword = (const char*)(temp);
994   }                                               892   }
995   if (key!=keyword)                            << 893   if (key!=keyword) {
996   {                                            << 
997 #ifdef G4VERBOSE                                  894 #ifdef G4VERBOSE
998     if (verboseLevel >0)                       << 895     if (verboseLevel >0) {
999     {                                          << 896       G4cerr << "G4ProductionCutTable::CheckMaterialCutsCoupleInfo ";
1000       G4cerr << "G4ProductionCutTable::CheckM << 897       G4cerr << " Key word in " << fileName << "= " << keyword ;
1001       G4cerr << "Key word in " << fileName << << 898       G4cerr <<"( should be   "<< key << ")" <<G4endl;
1002       G4cerr <<"( should be   "<< key << ")"  << 
1003     }                                            899     }
1004 #endif                                           900 #endif
1005     G4Exception( "G4ProductionCutsTable::Chec    901     G4Exception( "G4ProductionCutsTable::CheckMaterialCutsCoupleInfo()",
1006                  "ProcCuts103", JustWarning,  << 902      "ProcCuts103",
                                                   >> 903      JustWarning, "Bad Data Format");
1007     fIn.close();                                 904     fIn.close();
1008     return false;                                905     return false;
1009   }                                              906   }
1010                                                  907 
1011   // numberOfCouples                             908   // numberOfCouples
1012   G4int numberOfCouples;                         909   G4int numberOfCouples;    
1013   if (ascii)                                  << 910   if (ascii) {
1014   {                                           << 
1015     fIn >> numberOfCouples;                      911     fIn >> numberOfCouples;
1016   }                                           << 912   } else {
1017   else                                        << 913     fIn.read( (char*)(&numberOfCouples), sizeof (G4int));
1018   {                                           << 
1019     fIn.read( (char*)(&numberOfCouples), size << 
1020   }                                              914   }
1021                                                  915 
1022   // Reset MCCIndexConversionTable               916   // Reset MCCIndexConversionTable
1023   mccConversionTable.Reset(numberOfCouples);     917   mccConversionTable.Reset(numberOfCouples);  
1024                                                  918 
1025   // Read in couple information                  919   // Read in couple information
1026   for (G4int idx=0; idx<numberOfCouples; ++id << 920   for (G4int idx=0; idx<numberOfCouples; idx+=1){
1027   {                                           << 
1028     // read in index                             921     // read in index
1029     G4int index;                                 922     G4int index; 
1030     if (ascii)                                << 923     if (ascii) {
1031     {                                         << 
1032       fIn >> index;                              924       fIn >> index;
1033     }                                         << 925     } else {
1034     else                                      << 926       fIn.read( (char*)(&index), sizeof (G4int));
1035     {                                         << 
1036       fIn.read( (char*)(&index), sizeof(G4int << 
1037     }                                            927     }
1038     // read in index material name               928     // read in index material name
1039     char mat_name[FixedStringLengthForStore];    929     char mat_name[FixedStringLengthForStore];
1040     if (ascii)                                << 930     if (ascii) {
1041     {                                         << 
1042       fIn >> mat_name;                           931       fIn >> mat_name;
1043     }                                         << 932     } else {
1044     else                                      << 
1045     {                                         << 
1046       fIn.read(mat_name, FixedStringLengthFor    933       fIn.read(mat_name, FixedStringLengthForStore);
1047     }                                            934     }
1048     // read in index and region name             935     // read in index and region name
1049     char region_name[FixedStringLengthForStor    936     char region_name[FixedStringLengthForStore];
1050     if (ascii)                                << 937     if (ascii) {
1051     {                                         << 
1052       fIn >> region_name;                        938       fIn >> region_name;
1053     }                                         << 939     } else {
1054     else                                      << 940      fIn.read(region_name, FixedStringLengthForStore);
1055     {                                         << 
1056       fIn.read(region_name, FixedStringLength << 
1057     }                                            941     }
1058     // cut value                                 942     // cut value
1059     G4double cutValues[NumberOfG4CutIndex];      943     G4double cutValues[NumberOfG4CutIndex];
1060     for (std::size_t i=0; i< NumberOfG4CutInd << 944     for (size_t i=0; i< NumberOfG4CutIndex; i++) {
1061     {                                         << 945       if (ascii) {
1062       if (ascii)                              << 
1063       {                                       << 
1064         fIn >>  cutValues[i];                    946         fIn >>  cutValues[i];
1065         cutValues[i] *= (mm);                    947         cutValues[i] *= (mm);
1066       }                                       << 948       } else {
1067       else                                    << 949         fIn.read( (char*)(&(cutValues[i])), sizeof (G4double));
1068       {                                       << 
1069         fIn.read( (char*)(&(cutValues[i])), s << 
1070       }                                          950       }
1071     }                                            951     }
1072                                                  952  
1073     // Loop over all couples                     953     // Loop over all couples
                                                   >> 954     CoupleTableIterator cItr;
1074     G4bool fOK = false;                          955     G4bool fOK = false;
1075     G4MaterialCutsCouple* aCouple = nullptr;     956     G4MaterialCutsCouple* aCouple = nullptr;
1076     for (auto cItr=coupleTable.cbegin(); cItr << 957     for (cItr=coupleTable.begin();cItr!=coupleTable.end();cItr++){
1077     {                                         << 
1078       aCouple = (*cItr);                         958       aCouple = (*cItr);
1079       // check material name                     959       // check material name
1080       if ( mat_name !=  aCouple->GetMaterial(    960       if ( mat_name !=  aCouple->GetMaterial()->GetName() ) continue;
1081       // check cut values                        961       // check cut values
1082       G4ProductionCuts* aCut = aCouple->GetPr    962       G4ProductionCuts* aCut = aCouple->GetProductionCuts();
1083       G4bool fRatio = true;                      963       G4bool fRatio = true;
1084       for (std::size_t j=0; j< NumberOfG4CutI << 964       for (size_t j=0; j< NumberOfG4CutIndex; j++) {
1085       {                                       << 
1086         // check ratio only if values are not    965         // check ratio only if values are not the same
1087         if (cutValues[j] != aCut->GetProducti << 966         if (cutValues[j] != aCut->GetProductionCut(j)) {  
1088         {                                     << 967           G4double ratio =  cutValues[j]/aCut->GetProductionCut(j);
1089           G4double ratio =  cutValues[j]/aCut << 
1090           fRatio = fRatio && (0.999<ratio) &&    968           fRatio = fRatio && (0.999<ratio) && (ratio<1.001) ;
1091         }                                        969         }
1092       }                                          970       } 
1093       if (!fRatio) continue;                     971       if (!fRatio) continue; 
1094       // MCC matched                             972       // MCC matched 
1095       fOK = true;                                973       fOK = true;
1096       mccConversionTable.SetNewIndex(index, a    974       mccConversionTable.SetNewIndex(index, aCouple->GetIndex()); 
1097       break;                                     975       break;
1098     }                                            976     }
1099                                                  977 
1100     if (fOK)                                  << 978     if (fOK) {
1101     {                                         << 
1102 #ifdef G4VERBOSE                                 979 #ifdef G4VERBOSE
1103       // debug information                       980       // debug information 
1104       if (verboseLevel >1)                    << 981       if (verboseLevel >1) {
1105       {                                       << 982   G4String regionname(region_name);
1106         G4String regionname(region_name);     << 983   G4Region* fRegion = nullptr;
1107         G4Region* fRegion = nullptr;          << 984   if ( regionname != "NONE" ) {
1108         if ( regionname != "NONE" )           << 985     fRegion = fG4RegionStore->GetRegion(region_name);
1109         {                                     << 986     if (fRegion == nullptr) {
1110           fRegion = fG4RegionStore->GetRegion << 987       G4cout << "G4ProductionCutTable::CheckMaterialCutsCoupleInfo ";
1111           if (fRegion == nullptr)             << 988       G4cout << "Region " << regionname << " is not found ";      
1112           {                                   << 989       G4cout << index << ": in " << fileName  << G4endl;
1113             G4cout << "G4ProductionCutTable:: << 990     } 
1114             G4cout << "Region " << regionname << 991   }
1115             G4cout << index << ": in " << fil << 992   if ( ( (regionname == "NONE") && (aCouple->IsUsed()) )  ||
1116           }                                   << 993        ( (fRegion != nullptr) && !IsCoupleUsedInTheRegion(aCouple, fRegion) ) ) {
1117         }                                     << 994     G4cout << "G4ProductionCutTable::CheckMaterialCutsCoupleInfo ";
1118         if  (((regionname == "NONE") && (aCou << 995     G4cout << "A Couple is used differnt region in the current setup  ";
1119          || ((fRegion!=nullptr) && !IsCoupleU << 996     G4cout << index << ": in " << fileName  << G4endl;
1120         {                                     << 997     G4cout << " material: " << mat_name ;
1121           G4cout << "G4ProductionCutTable::Ch << 998     G4cout << " region: " << region_name << G4endl;
1122                  << G4endl;                   << 999     for (size_t ii=0; ii< NumberOfG4CutIndex; ii++) {
1123           G4cout << "A Couple is used differe << 1000       G4cout << "cut[" << ii << "]=" << cutValues[ii]/mm;
1124           G4cout << index << ": in " << fileN << 1001       G4cout << " mm   :  ";
1125           G4cout << " material: " << mat_name << 1002     } 
1126           G4cout << " region: " << region_nam << 1003     G4cout << G4endl;
1127           for (std::size_t ii=0; ii< NumberOf << 1004   } else if ( index !=  aCouple->GetIndex() ) {
1128           {                                   << 1005     G4cout << "G4ProductionCutTable::CheckMaterialCutsCoupleInfo ";
1129             G4cout << "cut[" << ii << "]=" << << 1006     G4cout << "Index of couples was modified "<< G4endl;
1130             G4cout << " mm   :  ";            << 1007     G4cout << aCouple->GetIndex() << ":"  <<aCouple->GetMaterial()->GetName();
1131           }                                   << 1008     G4cout <<" is defined as " ;
1132           G4cout << G4endl;                   << 1009     G4cout << index << ":"  << mat_name << " in " << fileName << G4endl;
1133         }                                     << 1010   } else {
1134         else if ( index !=  aCouple->GetIndex << 1011     G4cout << "G4ProductionCutTable::CheckMaterialCutsCoupleInfo ";
1135         {                                     << 1012     G4cout << index << ":"  << mat_name << " in " << fileName ;
1136           G4cout << "G4ProductionCutTable::Ch << 1013     G4cout << " is consistent with current setup" << G4endl;
1137           G4cout << "Index of couples was mod << 1014   }
1138           G4cout << aCouple->GetIndex() << ": << 
1139                  << aCouple->GetMaterial()->G << 
1140           G4cout <<" is defined as " ;        << 
1141           G4cout << index << ":"  << mat_name << 
1142         }                                     << 
1143         else                                  << 
1144         {                                     << 
1145           G4cout << "G4ProductionCutTable::Ch << 
1146           G4cout << index << ":"  << mat_name << 
1147           G4cout << " is consistent with curr << 
1148         }                                     << 
1149       }                                          1015       }
1150 #endif                                           1016 #endif
1151     }                                         << 1017     } else {
1152     else                                      << 
1153     {                                         << 
1154 #ifdef G4VERBOSE                                 1018 #ifdef G4VERBOSE
1155       if (verboseLevel >0)                    << 1019       if (verboseLevel >0) {
1156       {                                       << 1020         G4cout << "G4ProductionCutTable::CheckMaterialCutsCoupleInfo ";
1157         G4cout << "G4ProductionCutTable::Chec << 1021         G4cout << "Couples is not defined in the current detector setup  ";
1158                << G4endl;                     << 
1159         G4cout << "Couples are not defined in << 
1160         G4cout << index << ": in " << fileNam    1022         G4cout << index << ": in " << fileName  << G4endl;
1161         G4cout << " material: " << mat_name ;    1023         G4cout << " material: " << mat_name ;
1162         G4cout << " region: " << region_name     1024         G4cout << " region: " << region_name << G4endl;
1163         for (std::size_t ii=0; ii< NumberOfG4 << 1025         for (size_t ii=0; ii< NumberOfG4CutIndex; ii++) {
1164         {                                     << 1026     G4cout << "cut[" << ii << "]=" << cutValues[ii]/mm;
1165           G4cout << "cut[" << ii << "]=" << c << 1027     G4cout << " mm   :  ";
1166           G4cout << " mm   :  ";              << 
1167         }                                        1028         }
1168         G4cout << G4endl;                        1029         G4cout << G4endl;
1169       }                                          1030       }
1170 #endif                                           1031 #endif
1171     }                                            1032     }
                                                   >> 1033 
1172   }                                              1034   }
1173   fIn.close();                                   1035   fIn.close();
1174   return true;                                   1036   return true;
1175 }                                                1037 }
1176                                                  1038 
1177 // ------------------------------------------ << 
1178 G4bool G4ProductionCutsTable::StoreCutsInfo(c << 
1179                                             G << 
1180 {                                             << 
1181   // Store cut values information in files un << 
1182                                                  1039 
                                                   >> 1040 /////////////////////////////////////////////////////////////
                                                   >> 1041 // Store cut values information in files under the specified directory.
                                                   >> 1042 //
                                                   >> 1043 G4bool   G4ProductionCutsTable::StoreCutsInfo(const G4String& directory, 
                                                   >> 1044                                               G4bool          ascii)
                                                   >> 1045 {
1183   const G4String fileName = directory + "/" +    1046   const G4String fileName = directory + "/" + "cut.dat";
1184   const G4String key = "CUT-V3.0";               1047   const G4String key = "CUT-V3.0";
1185   std::ofstream fOut;                            1048   std::ofstream fOut;  
1186   char temp[FixedStringLengthForStore];          1049   char temp[FixedStringLengthForStore];
1187                                                  1050   
1188   // open output file                         << 1051   // open output file //
1189   if (!ascii ) fOut.open(fileName,std::ios::o << 1052   if (!ascii ) 
1190   else         fOut.open(fileName,std::ios::o << 1053     fOut.open(fileName,std::ios::out|std::ios::binary);
1191                                               << 1054   else 
                                                   >> 1055     fOut.open(fileName,std::ios::out);
                                                   >> 1056   
                                                   >> 1057   
1192   // check if the file has been opened succes    1058   // check if the file has been opened successfully 
1193   if (!fOut)                                  << 1059   if (!fOut) {
1194   {                                           << 1060     if(verboseLevel>0) {         
1195     if(verboseLevel>0)                        << 1061       G4cerr << "G4ProductionCutsTable::StoreCutsInfo  ";
1196     {                                         << 1062       G4cerr << " Can not open file " << fileName << G4endl;
1197       G4cerr << "G4ProductionCutsTable::Store << 
1198       G4cerr << "Cannot open file: " << fileN << 
1199     }                                            1063     }
1200     G4Exception( "G4ProductionCutsTable::Stor    1064     G4Exception( "G4ProductionCutsTable::StoreCutsInfo()",
1201                  "ProcCuts102", JustWarning,  << 1065      "ProcCuts102",
                                                   >> 1066      JustWarning, "Can not open file");
1202     return false;                                1067     return false;
1203   }                                              1068   }
1204                                                  1069 
1205   G4int numberOfCouples = (G4int)coupleTable. << 1070   G4int numberOfCouples = coupleTable.size();
1206   if (ascii)                                  << 1071   if (ascii) {
1207   {                                           << 
1208     /////////////// ASCII mode  /////////////    1072     /////////////// ASCII mode  /////////////////
1209     // key word                                  1073     // key word
1210     fOut << key << G4endl;                    << 1074     fOut  << key << G4endl;
1211                                                  1075     
1212     // number of couples in the table            1076     // number of couples in the table
1213     fOut << numberOfCouples << G4endl;        << 1077     fOut  << numberOfCouples << G4endl;
1214   }                                           << 1078   } else {
1215   else                                        << 
1216   {                                           << 
1217     /////////////// Binary mode  ////////////    1079     /////////////// Binary mode  /////////////////
1218     // key word                                  1080     // key word
1219     std::size_t i;                            << 1081     size_t i;
1220     for (i=0; i<FixedStringLengthForStore; ++ << 1082     for (i=0; i<FixedStringLengthForStore; ++i) temp[i] = '\0'; 
1221       temp[i] = '\0';                         << 
1222     for (i=0; i<key.length() && i<FixedString    1083     for (i=0; i<key.length() && i<FixedStringLengthForStore-1; ++i)
1223       temp[i]=key[(G4int)i];                  << 1084       temp[i]=key[i];
1224     fOut.write(temp, FixedStringLengthForStor    1085     fOut.write(temp, FixedStringLengthForStore);
1225                                                  1086     
1226     // number of couples in the table            1087     // number of couples in the table   
1227     fOut.write( (char*)(&numberOfCouples), si << 1088     fOut.write( (char*)(&numberOfCouples), sizeof (G4int));
1228   }                                              1089   }
1229                                                  1090 
1230   for (std::size_t idx=0; idx <NumberOfG4CutI << 1091   
1231   {                                           << 1092   for (size_t idx=0; idx <NumberOfG4CutIndex; idx++) {
1232     const std::vector<G4double>* fRange  = Ge    1093     const std::vector<G4double>* fRange  = GetRangeCutsVector(idx);
1233     const std::vector<G4double>* fEnergy = Ge    1094     const std::vector<G4double>* fEnergy = GetEnergyCutsVector(idx);
1234     std::size_t i=0;                          << 1095     size_t i=0;
1235     // Loop over all couples                     1096     // Loop over all couples
1236     for (auto cItr=coupleTable.cbegin();cItr! << 1097     CoupleTableIterator cItr;
1237     {                                         << 1098     for (cItr=coupleTable.begin();cItr!=coupleTable.end();cItr++, i++){      
1238       if (ascii)                              << 1099       if (ascii) {
1239       {                                       << 
1240         /////////////// ASCII mode  /////////    1100         /////////////// ASCII mode  /////////////////
1241         fOut.setf(std::ios::scientific);         1101         fOut.setf(std::ios::scientific);
1242         fOut << std::setw(20) << (*fRange)[i]    1102         fOut << std::setw(20) << (*fRange)[i]/mm  ;
1243         fOut << std::setw(20) << (*fEnergy)[i    1103         fOut << std::setw(20) << (*fEnergy)[i]/keV << G4endl;
1244         fOut.unsetf(std::ios::scientific);       1104         fOut.unsetf(std::ios::scientific);
1245       }                                       << 1105       } else {
1246       else                                    << 
1247       {                                       << 
1248         /////////////// Binary mode  ////////    1106         /////////////// Binary mode  /////////////////
1249         G4double cut =  (*fRange)[i];            1107         G4double cut =  (*fRange)[i];
1250         fOut.write((char*)(&cut), sizeof(G4do << 1108         fOut.write((char*)(&cut), sizeof (G4double));
1251         cut =  (*fEnergy)[i];                    1109         cut =  (*fEnergy)[i];
1252         fOut.write((char*)(&cut), sizeof(G4do << 1110         fOut.write((char*)(&cut), sizeof (G4double));
1253       }                                          1111       }
1254     }                                            1112     }
1255   }                                              1113   }
1256   fOut.close();                                  1114   fOut.close();
1257   return true;                                   1115   return true;
1258 }                                                1116 }
1259                                                  1117   
1260 // ------------------------------------------ << 1118 /////////////////////////////////////////////////////////////
1261 G4bool G4ProductionCutsTable::RetrieveCutsInf << 1119 // Retrieve cut values information in files under the specified directory.
1262                                               << 1120 //
                                                   >> 1121 G4bool   G4ProductionCutsTable::RetrieveCutsInfo(const G4String& directory,
                                                   >> 1122                                                  G4bool          ascii)
1263 {                                                1123 {
1264   // Retrieve cut values information in files << 
1265                                               << 
1266   const G4String fileName = directory + "/" +    1124   const G4String fileName = directory + "/" + "cut.dat";
1267   const G4String key = "CUT-V3.0";               1125   const G4String key = "CUT-V3.0";
1268   std::ifstream fIn;                             1126   std::ifstream fIn;  
1269                                                  1127 
1270   // open input file                          << 1128   // open input file //
1271   if (!ascii ) fIn.open(fileName,std::ios::in << 1129   if (!ascii )
1272   else         fIn.open(fileName,std::ios::in << 1130     fIn.open(fileName,std::ios::in|std::ios::binary);
                                                   >> 1131   else
                                                   >> 1132     fIn.open(fileName,std::ios::in);
1273                                                  1133 
1274   // check if the file has been opened succes    1134   // check if the file has been opened successfully 
1275   if (!fIn)                                   << 1135   if (!fIn) {
1276   {                                           << 1136     if (verboseLevel >0) {
1277     if (verboseLevel >0)                      << 1137       G4cerr << "G4ProductionCutTable::RetrieveCutsInfo  ";
1278     {                                         << 1138       G4cerr << " Can not open file " << fileName << G4endl;
1279       G4cerr << "G4ProductionCutTable::Retrie << 
1280       G4cerr << "Cannot open file: " << fileN << 
1281     }                                            1139     }
1282     G4Exception( "G4ProductionCutsTable::Retr    1140     G4Exception( "G4ProductionCutsTable::RetrieveCutsInfo()",
1283                  "ProcCuts102", JustWarning,  << 1141      "ProcCuts102",
                                                   >> 1142      JustWarning, "Can not open file");
1284     return false;                                1143     return false;
1285   }                                              1144   }
1286                                                  1145   
1287   char temp[FixedStringLengthForStore];          1146   char temp[FixedStringLengthForStore];
1288                                                  1147 
1289    // key word                                   1148    // key word
1290   G4String keyword;                              1149   G4String keyword;    
1291   if (ascii)                                  << 1150   if (ascii) {
1292   {                                           << 
1293     fIn >> keyword;                              1151     fIn >> keyword;
1294   }                                           << 1152   } else {
1295   else                                        << 
1296   {                                           << 
1297     fIn.read(temp, FixedStringLengthForStore)    1153     fIn.read(temp, FixedStringLengthForStore);
1298     keyword = (const char*)(temp);               1154     keyword = (const char*)(temp);
1299   }                                              1155   }
1300   if (key!=keyword)                           << 1156   if (key!=keyword) {
1301   {                                           << 1157     if (verboseLevel >0) {
1302     if (verboseLevel >0)                      << 1158       G4cerr << "G4ProductionCutTable::RetrieveCutsInfo ";
1303     {                                         << 1159       G4cerr << " Key word in " << fileName << "= " << keyword ;
1304       G4cerr << "G4ProductionCutTable::Retrie << 1160       G4cerr <<"( should be   "<< key << ")" <<G4endl;
1305       G4cerr << "Key word in " << fileName << << 
1306       G4cerr <<"( should be   "<< key << ")"  << 
1307     }                                            1161     }
1308     G4Exception( "G4ProductionCutsTable::Retr    1162     G4Exception( "G4ProductionCutsTable::RetrieveCutsInfo()",
1309                  "ProcCuts103", JustWarning,  << 1163      "ProcCuts103",
                                                   >> 1164      JustWarning, "Bad Data Format");
1310     return false;                                1165     return false;
1311   }                                              1166   }
1312                                                  1167 
1313   // numberOfCouples                             1168   // numberOfCouples
1314   G4int numberOfCouples;                         1169   G4int numberOfCouples;    
1315   if (ascii)                                  << 1170   if (ascii) {
1316   {                                           << 
1317     fIn >> numberOfCouples;                      1171     fIn >> numberOfCouples;
1318     if (fIn.fail())                           << 1172     if (fIn.fail()) {
1319     {                                         << 
1320       G4Exception( "G4ProductionCutsTable::Re    1173       G4Exception( "G4ProductionCutsTable::RetrieveCutsInfo()",
1321                    "ProcCuts103", JustWarning << 1174        "ProcCuts103",
                                                   >> 1175        JustWarning, "Bad Data Format");
1322       return false;                              1176       return false;
1323     }                                            1177     }
1324   }                                           << 1178   } else {
1325   else                                        << 1179     fIn.read( (char*)(&numberOfCouples), sizeof (G4int));
1326   {                                           << 
1327     fIn.read( (char*)(&numberOfCouples), size << 
1328   }                                              1180   }
1329                                                  1181 
1330   if (numberOfCouples > static_cast<G4int>(mc << 1182   if (numberOfCouples > static_cast<G4int>(mccConversionTable.size()) ){
1331   {                                           << 
1332     G4Exception( "G4ProductionCutsTable::Retr    1183     G4Exception( "G4ProductionCutsTable::RetrieveCutsInfo()",
1333                  "ProcCuts109", JustWarning,  << 1184      "ProcCuts109", JustWarning, 
1334                  "Number of Couples in the fi << 1185      "Number of Couples in the file exceeds defined couples ");
1335   }                                              1186   }
1336   numberOfCouples = (G4int)mccConversionTable << 1187   numberOfCouples = mccConversionTable.size();
1337                                                  1188   
1338   for (std::size_t idx=0; static_cast<G4int>( << 1189   for (size_t idx=0; static_cast<G4int>(idx) <NumberOfG4CutIndex; idx++) {
1339   {                                           << 1190     G4CutVectorForAParticle* fRange  = rangeCutTable[idx];
1340     std::vector<G4double>* fRange  = rangeCut << 1191     G4CutVectorForAParticle* fEnergy = energyCutTable[idx];
1341     std::vector<G4double>* fEnergy = energyCu << 
1342     fRange->clear();                             1192     fRange->clear();
1343     fEnergy->clear();                            1193     fEnergy->clear();
1344                                                  1194 
1345     // Loop over all couples                     1195     // Loop over all couples
1346     for (std::size_t i=0; static_cast<G4int>( << 1196     for (size_t i=0; static_cast<G4int>(i)< numberOfCouples; i++){      
1347     {                                         << 
1348       G4double rcut, ecut;                       1197       G4double rcut, ecut;
1349       if (ascii)                              << 1198       if (ascii) {
1350       {                                       << 
1351         fIn >> rcut >> ecut;                     1199         fIn >> rcut >> ecut;
1352         if (fIn.fail())                       << 1200   if (fIn.fail()) {
1353         {                                     << 1201     G4Exception( "G4ProductionCutsTable::RetrieveCutsInfo()",
1354           G4Exception( "G4ProductionCutsTable << 1202            "ProcCuts103",
1355                        "ProcCuts103", JustWar << 1203            JustWarning, "Bad Data Format");
1356           return false;                       << 1204     return false;
1357         }                                     << 1205   }
1358         rcut *= mm;                              1206         rcut *= mm;
1359         ecut *= keV;                             1207         ecut *= keV;
                                                   >> 1208       } else {
                                                   >> 1209         fIn.read((char*)(&rcut), sizeof (G4double));
                                                   >> 1210         fIn.read((char*)(&ecut), sizeof (G4double));
1360       }                                          1211       }
1361       else                                    << 1212      if (!mccConversionTable.IsUsed(i)) continue;
1362       {                                       << 1213       size_t new_index = mccConversionTable.GetIndex(i);
1363         fIn.read((char*)(&rcut), sizeof(G4dou << 
1364         fIn.read((char*)(&ecut), sizeof(G4dou << 
1365       }                                       << 
1366       if (!mccConversionTable.IsUsed(i)) cont << 
1367       std::size_t new_index = mccConversionTa << 
1368       (*fRange)[new_index]  = rcut;              1214       (*fRange)[new_index]  = rcut;
1369       (*fEnergy)[new_index] = ecut;              1215       (*fEnergy)[new_index] = ecut;
1370     }                                            1216     }
1371   }                                              1217   }
1372   return true;                                   1218   return true;
1373 }                                                1219 }
1374                                                  1220 
1375 // ------------------------------------------ << 1221 /////////////////////////////////////////////////////////////
1376 void G4ProductionCutsTable::SetVerboseLevel(G << 1222 // Set Verbose Level 
                                                   >> 1223 //   set same verbosity to all registered RangeToEnergyConverters  
                                                   >> 1224  void G4ProductionCutsTable::SetVerboseLevel(G4int value)
1377 {                                                1225 {
1378   // Set same verbosity to all registered Ran << 
1379                                               << 
1380   verboseLevel = value;                          1226   verboseLevel = value;
1381   for (G4int ip=0; ip< NumberOfG4CutIndex; ++ << 1227   for (int ip=0; ip< NumberOfG4CutIndex; ip++) {
1382   {                                           << 1228     if (converters[ip] !=0 ){
1383     if (converters[ip] != nullptr )           << 
1384     {                                         << 
1385       converters[ip]->SetVerboseLevel(value);    1229       converters[ip]->SetVerboseLevel(value);
1386     }                                            1230     }
1387   }                                              1231   }
1388 }                                                1232 }
1389                                                  1233 
1390 // ------------------------------------------ << 1234 /////////////////////////////////////////////////////////////
1391 G4double G4ProductionCutsTable::GetMaxEnergyC    1235 G4double G4ProductionCutsTable::GetMaxEnergyCut()
1392 {                                                1236 {
1393   return G4VRangeToEnergyConverter::GetMaxEne    1237   return G4VRangeToEnergyConverter::GetMaxEnergyCut();
1394 }                                                1238 }
1395                                                  1239 
1396 // ------------------------------------------ << 1240 
                                                   >> 1241 /////////////////////////////////////////////////////////////  
1397 void G4ProductionCutsTable::SetMaxEnergyCut(G    1242 void G4ProductionCutsTable::SetMaxEnergyCut(G4double value)
1398 {                                                1243 {
1399   G4VRangeToEnergyConverter::SetMaxEnergyCut(    1244   G4VRangeToEnergyConverter::SetMaxEnergyCut(value);
1400 }                                                1245 }
1401                                                  1246