Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/persistency/mctruth/src/G4PersistencyCenter.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 /persistency/mctruth/src/G4PersistencyCenter.cc (Version 11.3.0) and /persistency/mctruth/src/G4PersistencyCenter.cc (Version 9.2.p1)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
 26 // G4PersistencyCenter implementation          <<  26 // File: G4PersistencyCenter.cc
 27 //                                                 27 //
 28 // Author: Youhei Morita, 10.08.2001           <<  28 // History:
 29 // ------------------------------------------- <<  29 //   '01.08.10  Youhei Morita  Initial creation (with "fadsclass3")
 30                                                    30 
 31 #include "G4PersistencyCenter.hh"                  31 #include "G4PersistencyCenter.hh"
                                                   >>  32 
                                                   >>  33 // Forward Declarations:
 32 #include "G4PersistencyCenterMessenger.hh"         34 #include "G4PersistencyCenterMessenger.hh"
 33                                                    35 
                                                   >>  36 // Addtional Include:
 34 #include "G4UImanager.hh"                          37 #include "G4UImanager.hh"
 35 #include "G4PersistencyManager.hh"                 38 #include "G4PersistencyManager.hh"
 36 #include "G4VHCIOentry.hh"                     << 
 37 #include "G4VDCIOentry.hh"                     << 
 38                                                    39 
 39 G4ThreadLocal G4PersistencyCenter* G4Persisten <<  40 G4PersistencyCenter* G4PersistencyCenter::f_thePointer=G4PersistencyCenter::GetPersistencyCenter();
 40                                                    41 
 41 // ------------------------------------------- <<  42 // Implementation of Constructor #1
 42 G4PersistencyCenter::G4PersistencyCenter()         43 G4PersistencyCenter::G4PersistencyCenter()
                                                   >>  44  : m_verbose(0)
 43 {                                                  45 {
 44   f_wrObj[0] = "HepMC";                            46   f_wrObj[0] = "HepMC";
 45   f_wrObj[1] = "MCTruth";                          47   f_wrObj[1] = "MCTruth";
 46   f_wrObj[2] = "Hits";                             48   f_wrObj[2] = "Hits";
 47   f_wrObj[3] = "Digits";                           49   f_wrObj[3] = "Digits";
 48                                                    50 
 49   f_rdObj[0] = "Hits";                             51   f_rdObj[0] = "Hits";
 50   f_rdObj[1] = "HitsBG";                           52   f_rdObj[1] = "HitsBG";
 51                                                    53 
 52   for(auto itr = f_wrObj.cbegin(); itr != f_wr <<  54   ObjMap::iterator itr;
 53   {                                            <<  55 
                                                   >>  56   for ( itr = f_wrObj.begin(); itr != f_wrObj.end(); itr++ ) {
 54     f_writeFileName[(*itr).second] = "G4defaul     57     f_writeFileName[(*itr).second] = "G4defaultOutput";
 55   }                                                58   }
 56                                                    59 
 57   for(auto itr = f_rdObj.cbegin(); itr != f_rd <<  60   for ( itr = f_rdObj.begin(); itr != f_rdObj.end(); itr++ ) {
 58   {                                            << 
 59     f_readFileName[(*itr).second] = "G4default     61     f_readFileName[(*itr).second] = "G4defaultInput";
 60   }                                                62   }
 61                                                    63 
 62   f_writeFileMode["HepMC"]   = kRecycle;           64   f_writeFileMode["HepMC"]   = kRecycle;
 63   f_writeFileMode["MCTruth"] = kOn;                65   f_writeFileMode["MCTruth"] = kOn;
 64   f_writeFileMode["Hits"]    = kOn;                66   f_writeFileMode["Hits"]    = kOn;
 65   f_writeFileMode["Digits"]  = kOff;               67   f_writeFileMode["Digits"]  = kOff;
 66                                                    68 
 67   f_readFileMode["Hits"]   = false;                69   f_readFileMode["Hits"]   = false;
 68   f_readFileMode["HitsBG"] = false;                70   f_readFileMode["HitsBG"] = false;
 69                                                    71 
 70   f_theMessenger   = new G4PersistencyCenterMe <<  72   f_theMessenger = new G4PersistencyCenterMessenger(this);
 71   f_currentManager = new G4PersistencyManager(     73   f_currentManager = new G4PersistencyManager(this, "Default");
 72 }                                                  74 }
 73                                                    75 
 74 // ------------------------------------------- <<  76 // Implementation of Constructor #2
                                                   >>  77 G4PersistencyCenter::G4PersistencyCenter(const G4PersistencyCenter&)
                                                   >>  78 {}
                                                   >>  79 
                                                   >>  80 // Implementation of Destructor #1
 75 G4PersistencyCenter::~G4PersistencyCenter()        81 G4PersistencyCenter::~G4PersistencyCenter()
 76 {                                                  82 {
 77   delete f_theMessenger;                           83   delete f_theMessenger;
 78   delete f_currentManager;                         84   delete f_currentManager;
 79 }                                                  85 }
 80                                                    86 
 81 // ------------------------------------------- <<  87 // Implementation of GetPersistencyCenter
 82 G4PersistencyCenter* G4PersistencyCenter::GetP     88 G4PersistencyCenter* G4PersistencyCenter::GetPersistencyCenter()
 83 {                                                  89 {
 84   if(f_thePointer == nullptr)                  <<  90   if ( f_thePointer == 0 ) f_thePointer = new G4PersistencyCenter;
 85     f_thePointer = new G4PersistencyCenter;    << 
 86   return f_thePointer;                             91   return f_thePointer;
 87 }                                                  92 }
 88                                                    93 
 89 // ------------------------------------------- <<  94 
 90 void G4PersistencyCenter::SelectSystem(const G <<  95 // Implementation of SelectSystem
                                                   >>  96 void G4PersistencyCenter::SelectSystem(std::string systemName)
 91 {                                                  97 {
 92   G4int st = 0;                                <<  98   int st = 0;
 93                                                    99 
 94   if(f_currentManager != nullptr)              << 100   if (f_currentManager!=0) delete f_currentManager;
 95     delete f_currentManager;                   << 
 96                                                   101 
 97   G4PersistencyManager* pm = nullptr;          << 102   G4PersistencyManager* pm = 0;
 98                                                   103 
 99   if(systemName == "ROOT")                     << 104   if (systemName=="None")
100   {                                               105   {
101     G4cout << " G4PersistencyCenter: \"ROOT\"  << 106     G4cout<<" G4PersistencyCenter: Default is selected."<< G4endl;
102            << G4endl;                          << 107     pm = new G4PersistencyManager(this, "Default");
                                                   >> 108   }
                                                   >> 109   else if (systemName=="ROOT")
                                                   >> 110   {
                                                   >> 111     G4cout<<" G4PersistencyCenter: \"ROOT\" Persistency Package is selected."
                                                   >> 112           <<G4endl;
103     // G4UImanager *man=G4UImanager::GetUIpoin    113     // G4UImanager *man=G4UImanager::GetUIpointer();
104     // std::string libs="Cint:Core:Tree:Rint:M    114     // std::string libs="Cint:Core:Tree:Rint:Matrix:Physics:fadsROOT";
105     // st = man->ApplyCommand("/load "+libs);     115     // st = man->ApplyCommand("/load "+libs);
106     if(st == 0)                                << 116     if ( st == 0 ) {
107     {                                          << 
108       pm = GetPersistencyManager("ROOT");         117       pm = GetPersistencyManager("ROOT");
109     }                                             118     }
110   }                                               119   }
111   else if(systemName == "ODBMS")               << 120   else if (systemName=="ODBMS")
112   {                                               121   {
113     G4cout << " G4PersistencyCenter: \"ODBMS\" << 122     G4cout<<" G4PersistencyCenter: \"ODBMS\" package is selected."<<G4endl;
114     // G4UImanager *man=G4UImanager::GetUIpoin    123     // G4UImanager *man=G4UImanager::GetUIpointer();
115     // std::string libs="fadsODBMS";              124     // std::string libs="fadsODBMS";
116     // st = man->ApplyCommand("/load "+libs);     125     // st = man->ApplyCommand("/load "+libs);
117     if(st == 0)                                << 126     if ( st == 0 ) {
118     {                                          << 
119       pm = GetPersistencyManager("ODBMS");        127       pm = GetPersistencyManager("ODBMS");
120     }                                             128     }
121   }                                               129   }
122   else                                         << 130   if ( st == 0 ) {
123   {                                            << 
124     G4cout << " G4PersistencyCenter: Default i << 
125     pm = new G4PersistencyManager(this, "Defau << 
126   }                                            << 
127                                                << 
128   if(st == 0)                                  << 
129   {                                            << 
130     f_currentManager = pm->Create();              131     f_currentManager = pm->Create();
131     if(f_currentManager != nullptr)            << 132     if (f_currentManager!=0) f_currentManager->SetVerboseLevel(m_verbose);
132       f_currentManager->SetVerboseLevel(m_verb << 
133     f_currentSystemName = systemName;             133     f_currentSystemName = systemName;
134   }                                               134   }
135 }                                                 135 }
136                                                   136 
137 // ------------------------------------------- << 137 // Implementation of SetHepMCObjyReaderFile
138 void G4PersistencyCenter::SetHepMCObjyReaderFi << 138 void G4PersistencyCenter::SetHepMCObjyReaderFile(std::string file)
139 {                                                 139 {
140   if(SetReadFile("HepMC", file))               << 140   if ( SetReadFile("HepMC", file) ) {
141   {                                            << 
142     SetRetrieveMode("HepMC", true);               141     SetRetrieveMode("HepMC", true);
143   }                                               142   }
144 }                                                 143 }
145                                                   144 
146 // ------------------------------------------- << 145 // Implementation of CurrentHepMCObjyReaderFile
147 G4String G4PersistencyCenter::CurrentHepMCObjy << 146 std::string G4PersistencyCenter::CurrentHepMCObjyReaderFile()
148 {                                                 147 {
149   if(CurrentRetrieveMode("HepMC"))             << 148   if ( CurrentRetrieveMode("HepMC") ) {
150   {                                            << 
151     return CurrentReadFile("HepMC");              149     return CurrentReadFile("HepMC");
152   }                                            << 150   } else {
153   else                                         << 
154   {                                            << 
155     return "";                                    151     return "";
156   }                                               152   }
157 }                                                 153 }
158                                                   154 
159 // ------------------------------------------- << 155 // Implementation of SetStoreMode
160 void G4PersistencyCenter::SetStoreMode(const G << 156 void G4PersistencyCenter::SetStoreMode(std::string objName, StoreMode mode)
161 {                                                 157 {
162   if((*(f_writeFileName.find(objName))).second << 158   if ( (*(f_writeFileName.find(objName))).second != "" ) {
163   {                                            << 
164     f_writeFileMode[objName] = mode;              159     f_writeFileMode[objName] = mode;
165   }                                            << 160   } else {
166   else                                         << 161     G4cerr << "!! unknown object type " << objName << " for output."
167   {                                            << 162            << G4endl;
168     G4cerr << "!! unknown object type " << obj << 
169   }                                               163   }
170 }                                                 164 }
171                                                   165 
172 // ------------------------------------------- << 166 // Implementation of SetRetrieveMode
173 void G4PersistencyCenter::SetRetrieveMode(cons << 167 void G4PersistencyCenter::SetRetrieveMode(std::string objName, G4bool mode)
174 {                                                 168 {
175   if((*(f_readFileName.find(objName))).second  << 169   if ( (*(f_readFileName.find(objName))).second != "" ) {
176   {                                            << 
177     f_readFileMode[objName] = mode;               170     f_readFileMode[objName] = mode;
178   }                                            << 171   } else {
179   else                                         << 172     G4cerr << "!! unknown object type " << objName << " for input."
180   {                                            << 173            << G4endl;
181     G4cerr << "!! unknown object type " << obj << 
182   }                                               174   }
183 }                                                 175 }
184                                                   176 
185 // ------------------------------------------- << 177 // Implementation of CurrentStoreMode
186 StoreMode G4PersistencyCenter::CurrentStoreMod << 178 StoreMode G4PersistencyCenter::CurrentStoreMode(std::string objName)
187 {                                                 179 {
188   if((*(f_writeFileName.find(objName))).second << 180 
189   {                                            << 181 
                                                   >> 182   if ( (*(f_writeFileName.find(objName))).second != "" ) {
190     return f_writeFileMode[objName];              183     return f_writeFileMode[objName];
191   }                                            << 184   } else {
192   else                                         << 
193   {                                            << 
194     return kOff;                                  185     return kOff;
195   }                                               186   }
196 }                                                 187 }
197                                                   188 
198 // ------------------------------------------- << 189 // Implementation of CurrentRetrieveMode
199 G4bool G4PersistencyCenter::CurrentRetrieveMod << 190 G4bool G4PersistencyCenter::CurrentRetrieveMode(std::string objName)
200 {                                                 191 {
201   if((*(f_readFileName.find(objName))).second  << 192   if ( (*(f_readFileName.find(objName))).second != "" ) {
202   {                                            << 
203     return f_readFileMode[objName];               193     return f_readFileMode[objName];
204   }                                            << 194   } else {
205   else                                         << 
206   {                                            << 
207     return false;                                 195     return false;
208   }                                               196   }
209 }                                                 197 }
210                                                   198 
211 // ------------------------------------------- << 199 // Implementation of SetWriteFile
212 G4bool G4PersistencyCenter::SetWriteFile(const << 200 G4bool G4PersistencyCenter::SetWriteFile(std::string objName, std::string writeFileName)
213                                          const << 
214 {                                                 201 {
215   if((*(f_writeFileName.find(objName))).second << 202   if ( (*(f_writeFileName.find(objName))).second != "" ) {
216   {                                            << 
217     f_writeFileName[objName] = writeFileName;     203     f_writeFileName[objName] = writeFileName;
218   }                                            << 204   } else {
219   else                                         << 205     G4cerr << "!! unknown object type " << objName << " for output."
220   {                                            << 206            << G4endl;
221     G4cerr << "!! unknown object type " << obj << 
222     return false;                                 207     return false;
223   }                                               208   }
224   return true;                                    209   return true;
225 }                                                 210 }
226                                                   211 
227 // ------------------------------------------- << 212 // Implementation of SetReadFile
228 G4bool G4PersistencyCenter::SetReadFile(const  << 213 G4bool G4PersistencyCenter::SetReadFile(std::string objName, std::string readFileName)
229                                         const  << 
230 {                                                 214 {
231 #ifndef WIN32                                     215 #ifndef WIN32
232   if(f_ut.FileExists(readFileName))            << 216   if ( f_ut.FileExists(readFileName) )
233   {                                               217   {
234     f_readFileName[objName] = readFileName;       218     f_readFileName[objName] = readFileName;
235   }                                               219   }
236   else                                            220   else
237   {                                               221   {
238     G4cerr << "!! File \"" << objName << "\" d << 222     G4cerr << "!! File \"" << objName << "\" does not exist."
                                                   >> 223            << G4endl;
239     return false;                                 224     return false;
240   }                                               225   }
241 #endif                                            226 #endif
242   return true;                                    227   return true;
243 }                                                 228 }
244                                                   229 
245 // ------------------------------------------- << 230 // Implementation of CurrentWriteFile
246 G4String G4PersistencyCenter::CurrentWriteFile << 231 std::string G4PersistencyCenter::CurrentWriteFile(std::string objName)
247 {                                                 232 {
248   if((*(f_writeFileName.find(objName))).second << 233   if ( (*(f_writeFileName.find(objName))).second != "" ) {
249   {                                            << 
250     return f_writeFileName[objName];              234     return f_writeFileName[objName];
251   }                                            << 235   } else {
252   else                                         << 
253   {                                            << 
254     return "?????";                               236     return "?????";
255   }                                               237   }
256 }                                                 238 }
257                                                   239 
258 // ------------------------------------------- << 240 // Implementation of CurrentReadFile
259 G4String G4PersistencyCenter::CurrentReadFile( << 241 std::string G4PersistencyCenter::CurrentReadFile(std::string objName)
260 {                                                 242 {
261   if((*(f_readFileName.find(objName))).second  << 243   if ( (*(f_readFileName.find(objName))).second != "" ) {
262   {                                            << 
263     return f_readFileName[objName];               244     return f_readFileName[objName];
264   }                                            << 245   } else {
265   else                                         << 
266   {                                            << 
267     return "?????";                               246     return "?????";
268   }                                               247   }
269 }                                                 248 }
270                                                   249 
271 // ------------------------------------------- << 250 // Implementation of CurrentObject
272 G4String G4PersistencyCenter::CurrentObject(co << 251 std::string G4PersistencyCenter::CurrentObject(std::string file)
273 {                                                 252 {
274   for(auto itr = f_readFileName.cbegin(); itr  << 253   FileMap::iterator itr;
275   {                                            << 254   for ( itr = f_readFileName.begin(); itr != f_readFileName.end(); itr++ ) {
276     if(file == (*itr).second)                  << 255     if ( file == (*itr).second ) return (*itr).first;
277       return (*itr).first;                     << 
278   }                                               256   }
279   for(auto itr = f_writeFileName.cbegin(); itr << 257   for ( itr = f_writeFileName.begin(); itr != f_writeFileName.end(); itr++ ) {
280   {                                            << 258     if ( file == (*itr).second ) return (*itr).first;
281     if(file == (*itr).second)                  << 
282       return (*itr).first;                     << 
283   }                                               259   }
284   return "?????";                                 260   return "?????";
285 }                                                 261 }
286                                                   262 
287 // ------------------------------------------- << 263 // Implementation of AddHCIOmanager
288 void G4PersistencyCenter::AddHCIOmanager(const << 264 void G4PersistencyCenter::AddHCIOmanager(std::string detName, std::string colName)
289                                          const << 
290 {                                                 265 {
291   G4HCIOcatalog* ioc = G4HCIOcatalog::GetHCIOc    266   G4HCIOcatalog* ioc = G4HCIOcatalog::GetHCIOcatalog();
292                                                   267 
293   G4VHCIOentry* ioe = ioc->GetEntry(detName);     268   G4VHCIOentry* ioe = ioc->GetEntry(detName);
294   if(ioe != nullptr)                           << 269   if ( ioe != 0 ) {
295   {                                            << 
296     ioe->CreateHCIOmanager(detName, colName);     270     ioe->CreateHCIOmanager(detName, colName);
297   }                                            << 271   } else {
298   else                                         << 
299   {                                            << 
300     G4cerr << "Error! -- HCIO assignment faile    272     G4cerr << "Error! -- HCIO assignment failed for detector " << detName
301            << ", collection " << colName << G4 << 273               << ", collection " << colName << G4endl;
302   }                                               274   }
303 }                                                 275 }
304                                                   276 
305 // ------------------------------------------- << 277 // Implementation of CurrentHCIOmanager
306 G4String G4PersistencyCenter::CurrentHCIOmanag << 278 std::string G4PersistencyCenter::CurrentHCIOmanager()
307 {                                                 279 {
308   G4HCIOcatalog* ioc = G4HCIOcatalog::GetHCIOc    280   G4HCIOcatalog* ioc = G4HCIOcatalog::GetHCIOcatalog();
309   return ioc->CurrentHCIOmanager();               281   return ioc->CurrentHCIOmanager();
310 }                                                 282 }
311                                                   283 
312 // ------------------------------------------- << 284 // Implementation of AddDCIOmanager
313 void G4PersistencyCenter::AddDCIOmanager(const << 285 void G4PersistencyCenter::AddDCIOmanager(std::string detName)
314 {                                                 286 {
315   G4DCIOcatalog* ioc = G4DCIOcatalog::GetDCIOc    287   G4DCIOcatalog* ioc = G4DCIOcatalog::GetDCIOcatalog();
316                                                   288 
317   G4String colName = "";                       << 289   std::string colName = "";
318   G4VDCIOentry* ioe = ioc->GetEntry(detName);     290   G4VDCIOentry* ioe = ioc->GetEntry(detName);
319   if(ioe != nullptr)                           << 291   if ( ioe != 0 ) {
320   {                                            << 
321     ioe->CreateDCIOmanager(detName, colName);     292     ioe->CreateDCIOmanager(detName, colName);
322   }                                            << 293   } else {
323   else                                         << 
324   {                                            << 
325     G4cerr << "Error! -- DCIO assignment faile    294     G4cerr << "Error! -- DCIO assignment failed for detector " << detName
326            << ", collection " << colName << G4 << 295               << ", collection " << colName << G4endl;
327   }                                               296   }
328 }                                                 297 }
329                                                   298 
330 // ------------------------------------------- << 299 // Implementation of CurrentDCIOmanager
331 G4String G4PersistencyCenter::CurrentDCIOmanag << 300 std::string G4PersistencyCenter::CurrentDCIOmanager()
332 {                                                 301 {
333   G4DCIOcatalog* ioc = G4DCIOcatalog::GetDCIOc    302   G4DCIOcatalog* ioc = G4DCIOcatalog::GetDCIOcatalog();
334   return ioc->CurrentDCIOmanager();               303   return ioc->CurrentDCIOmanager();
335 }                                                 304 }
336                                                   305 
337 // ------------------------------------------- << 306 // Implementation of PrintAll
338 void G4PersistencyCenter::PrintAll()              307 void G4PersistencyCenter::PrintAll()
339 {                                                 308 {
340   G4cout << "Persistency Package: " << Current    309   G4cout << "Persistency Package: " << CurrentSystem() << G4endl;
341   G4cout << G4endl;                               310   G4cout << G4endl;
342                                                   311 
343   G4String name, file;                         << 312   ObjMap::iterator itr;
344   StoreMode mode;                              << 313   std::string name;
                                                   >> 314   std::string file;
                                                   >> 315   StoreMode   mode;
345                                                   316 
346   G4cout << "Output object types and file name    317   G4cout << "Output object types and file names:" << G4endl;
347   for(auto itr = f_wrObj.cbegin(); itr != f_wr << 318   for ( itr = f_wrObj.begin(); itr != f_wrObj.end(); itr++ ) {
348   {                                            << 
349     name = (*itr).second;                         319     name = (*itr).second;
350     // disabled HepMC and MCTruth for now         320     // disabled HepMC and MCTruth for now
351     if(name != "HepMC" && name != "MCTruth")   << 321     if ( name != "HepMC" && name != "MCTruth" ) {
352     {                                          << 
353       G4cout << "  Object: " << PadString(name    322       G4cout << "  Object: " << PadString(name, 9);
354       mode = CurrentStoreMode(name);              323       mode = CurrentStoreMode(name);
355       if(mode == kOn)                          << 324       if ( mode == kOn ) {
356       {                                        << 
357         G4cout << " <on>    ";                    325         G4cout << " <on>    ";
358       }                                        << 326       } else if ( mode == kOff ) {
359       else if(mode == kOff)                    << 
360       {                                        << 
361         G4cout << " <off>   ";                    327         G4cout << " <off>   ";
362       }                                        << 328       } else if ( mode == kRecycle ) {
363       else if(mode == kRecycle)                << 
364       {                                        << 
365         G4cout << "<recycle>";                    329         G4cout << "<recycle>";
366       }                                           330       }
367       file = CurrentWriteFile(name);              331       file = CurrentWriteFile(name);
368       if(file == "")                           << 332       if ( file == "" ) file = "   <N/A>";
369         file = "   <N/A>";                     << 
370       G4cout << " File: " << file << G4endl;      333       G4cout << " File: " << file << G4endl;
371     }                                             334     }
372   }                                               335   }
373   G4cout << G4endl;                               336   G4cout << G4endl;
374                                                   337 
375   G4cout << "Input object types and file names    338   G4cout << "Input object types and file names:" << G4endl;
376   for(auto itr = f_rdObj.cbegin(); itr != f_rd << 339   for ( itr = f_rdObj.begin(); itr != f_rdObj.end(); itr++ ) {
377   {                                            << 
378     name = (*itr).second;                         340     name = (*itr).second;
379     // disabled HepMC and MCTruth for now         341     // disabled HepMC and MCTruth for now
380     if(name != "HepMC" && name != "MCTruth")   << 342     if ( name != "HepMC" && name != "MCTruth" ) {
381     {                                          << 
382       G4cout << "  Object: " << PadString(name    343       G4cout << "  Object: " << PadString(name, 9);
383       if(CurrentRetrieveMode(name))            << 344       if ( CurrentRetrieveMode(name) ) {
384       {                                        << 
385         G4cout << " <on>    ";                    345         G4cout << " <on>    ";
386       }                                        << 346       } else {
387       else                                     << 
388       {                                        << 
389         G4cout << " <off>   ";                    347         G4cout << " <off>   ";
390       }                                           348       }
391       file = CurrentReadFile(name);               349       file = CurrentReadFile(name);
392       if(file == "")                           << 350       if ( file == "" ) file = "   <N/A>";
393         file = "   <N/A>";                     << 
394       G4cout << " File: " << CurrentReadFile(n    351       G4cout << " File: " << CurrentReadFile(name) << G4endl;
395     }                                             352     }
396   }                                               353   }
397   G4cout << G4endl;                               354   G4cout << G4endl;
398                                                   355 
399   G4HCIOcatalog* hioc = G4HCIOcatalog::GetHCIO    356   G4HCIOcatalog* hioc = G4HCIOcatalog::GetHCIOcatalog();
400   if(hioc != nullptr)                          << 357   if ( hioc != 0 ) {
401   {                                            << 
402     G4cout << "Hit IO Managers:" << G4endl;       358     G4cout << "Hit IO Managers:" << G4endl;
403     hioc->PrintEntries();                         359     hioc->PrintEntries();
404     hioc->PrintHCIOmanager();                     360     hioc->PrintHCIOmanager();
405     G4cout << G4endl;                             361     G4cout << G4endl;
406   }                                            << 362   } else {
407   else                                         << 
408   {                                            << 
409     G4cout << "Hit IO Manager catalog is not r    363     G4cout << "Hit IO Manager catalog is not registered." << G4endl;
410   }                                               364   }
411                                                   365 
412   G4DCIOcatalog* dioc = G4DCIOcatalog::GetDCIO    366   G4DCIOcatalog* dioc = G4DCIOcatalog::GetDCIOcatalog();
413   if(dioc != nullptr)                          << 367   if ( dioc != 0 ) {
414   {                                            << 
415     G4cout << "Digit IO Managers:" << G4endl;     368     G4cout << "Digit IO Managers:" << G4endl;
416     dioc->PrintEntries();                         369     dioc->PrintEntries();
417     dioc->PrintDCIOmanager();                     370     dioc->PrintDCIOmanager();
418     G4cout << G4endl;                             371     G4cout << G4endl;
419   }                                            << 372   } else {
420   else                                         << 
421   {                                            << 
422     G4cout << "Digit IO Manager catalog is not    373     G4cout << "Digit IO Manager catalog is not registered." << G4endl;
423   }                                               374   }
424 }                                                 375 }
425                                                   376 
426 // ------------------------------------------- << 377 // Implementation of SetPersistencyManager
427 void G4PersistencyCenter::SetPersistencyManage    378 void G4PersistencyCenter::SetPersistencyManager(G4PersistencyManager* pm,
428                                                << 379                                                   std::string name)
429 {                                                 380 {
430   f_currentManager    = pm;                    << 381   f_currentManager=pm;
431   f_currentSystemName = name;                  << 382   f_currentSystemName=name;
432 }                                                 383 }
433                                                   384 
434 // ------------------------------------------- << 385 // Implementation of GetPersistencyManager
435 G4PersistencyManager*                          << 386 G4PersistencyManager* G4PersistencyCenter::GetPersistencyManager(std::string nam)
436 G4PersistencyCenter::GetPersistencyManager(con << 
437 {                                                 387 {
438   if(f_theCatalog.find(nam) != f_theCatalog.ce << 388   if (f_theCatalog.find(nam)!=f_theCatalog.end())
439     return f_theCatalog[nam];                     389     return f_theCatalog[nam];
440   return nullptr;                              << 390   return 0;
441 }                                                 391 }
442                                                   392 
443 // ------------------------------------------- << 393 // Implementation of RegisterPersistencyManager
444 void G4PersistencyCenter::RegisterPersistencyM    394 void G4PersistencyCenter::RegisterPersistencyManager(G4PersistencyManager* pm)
445 {                                                 395 {
446   f_theCatalog[pm->GetName()] = pm;            << 396   f_theCatalog[pm->GetName()]=pm;
447 }                                                 397 }
448                                                   398 
449 // ------------------------------------------- << 399 // Implementation of DeletePersistencyManager
450 void G4PersistencyCenter::DeletePersistencyMan    400 void G4PersistencyCenter::DeletePersistencyManager()
451 {                                                 401 {
452   if(f_currentManager != nullptr)              << 402   if (f_currentManager!=0) delete f_currentManager;
453     delete f_currentManager;                   << 403   f_currentManager=0;
454   f_currentManager = nullptr;                  << 
455 }                                                 404 }
456                                                   405 
457 // ------------------------------------------- << 406 // Implementation of SetVerboseLevel
458 void G4PersistencyCenter::SetVerboseLevel(G4in << 407 void G4PersistencyCenter::SetVerboseLevel(int v)
459 {                                                 408 {
460   m_verbose = v;                                  409   m_verbose = v;
461   if(f_currentManager != nullptr)              << 410   if ( f_currentManager != 0 ) f_currentManager->SetVerboseLevel(m_verbose);
462     f_currentManager->SetVerboseLevel(m_verbos << 
463 }                                                 411 }
464                                                   412 
465 // ------------------------------------------- << 413 // Implementation of PadString
466 G4String G4PersistencyCenter::PadString(const  << 414 std::string G4PersistencyCenter::PadString(std::string name, unsigned int width)
467                                         unsign << 
468 {                                                 415 {
469   if(name.length() > width)                    << 416   if ( name.length() > width ) {
470   {                                            << 417     return name.substr(0,width-1) + "#";
471     return name.substr(0, width - 1) + "#";    << 418   } else {
472   }                                            << 419     std::string wname = name;
473   else                                         << 420     for ( unsigned int i=0; i < width-name.length(); i++) wname = wname + " ";
474   {                                            << 
475     G4String wname = name;                     << 
476     for(unsigned int i = 0; i < width - name.l << 
477       wname = wname + " ";                     << 
478     return wname;                                 421     return wname;
479   }                                               422   }
480 }                                                 423 }
                                                   >> 424 
                                                   >> 425 // End of G4PersistencyCenter.cc
                                                   >> 426 
481                                                   427