Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/analysis/management/src/G4HnManager.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 /analysis/management/src/G4HnManager.cc (Version 11.3.0) and /analysis/management/src/G4HnManager.cc (Version 10.0.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 // $Id: G4HnManager.cc 70604 2013-06-03 11:27:06Z ihrivnac $
 26                                                    27 
 27 // Author: Ivana Hrivnacova, 18/06/2013  (ivan     28 // Author: Ivana Hrivnacova, 18/06/2013  (ivana@ipno.in2p3.fr)
 28                                                    29 
 29 #include "G4HnManager.hh"                          30 #include "G4HnManager.hh"
 30 #include "G4HnMessenger.hh"                    << 
 31                                                << 
 32 #include "G4AnalysisUtilities.hh"              << 
 33 #include "G4VFileManager.hh"                   << 
 34                                                << 
 35 #include <utility>                             << 
 36                                                << 
 37 using namespace G4Analysis;                    << 
 38 using std::to_string;                          << 
 39                                                << 
 40 //____________________________________________ << 
 41 G4HnManager::G4HnManager(G4String hnType, cons << 
 42   : G4BaseAnalysisManager(state), fHnType(std: << 
 43 {}                                             << 
 44                                                << 
 45 //____________________________________________ << 
 46 G4HnManager::~G4HnManager()                    << 
 47 {                                              << 
 48   for ( auto info : fHnVector ) {              << 
 49     delete info;                               << 
 50   }                                            << 
 51 }                                              << 
 52                                                << 
 53 //                                             << 
 54 // private methods                             << 
 55 //                                             << 
 56                                                    31 
 57 //____________________________________________     32 //_____________________________________________________________________________
 58 void  G4HnManager::SetActivation(G4HnInformati <<  33 G4HnManager::G4HnManager(const G4String& hnType,
                                                   >>  34                          const G4AnalysisManagerState& state)
                                                   >>  35   : G4BaseAnalysisManager(state),
                                                   >>  36     fHnType(hnType),
                                                   >>  37     fNofActiveObjects(0),
                                                   >>  38     fNofAsciiObjects(0),
                                                   >>  39     fHnVector()
 59 {                                                  40 {
 60 // Set activation to a given object            << 
 61                                                << 
 62   // Do nothing if activation does not change  << 
 63   if ( info->GetActivation() == activation ) r << 
 64                                                << 
 65   // Change activation and account it in fNofA << 
 66   info->SetActivation(activation);             << 
 67   if (activation) {                            << 
 68     fNofActiveObjects++;                       << 
 69   }                                            << 
 70   else {                                       << 
 71     fNofActiveObjects--;                       << 
 72   }                                            << 
 73 }                                                  41 }
 74                                                    42 
 75 //____________________________________________     43 //_____________________________________________________________________________
 76 void  G4HnManager::SetPlotting(G4HnInformation <<  44 G4HnManager::~G4HnManager()
 77 {                                                  45 {
 78   // Do nothing if ascii does not change       <<  46   std::vector<G4HnInformation*>::iterator it;
 79   if ( info->GetPlotting() == plotting ) retur <<  47   for (it = fHnVector.begin(); it != fHnVector.end(); it++ ) {
 80                                                <<  48     delete (*it);
 81   // Change Plotting and account it in fNofPlo <<  49   }  
 82   info->SetPlotting(plotting);                 << 
 83   if (plotting) {                              << 
 84     fNofPlottingObjects++;                     << 
 85   }                                            << 
 86   else {                                       << 
 87     fNofPlottingObjects--;                     << 
 88   }                                            << 
 89 }                                                  50 }
 90                                                    51 
 91 //____________________________________________ <<  52 // 
 92 void  G4HnManager::SetFileName(G4HnInformation << 
 93 {                                              << 
 94   // Do nothing if file name does not change   << 
 95   if ( info->GetFileName() == fileName ) retur << 
 96                                                << 
 97   auto hnFileName = fileName;                  << 
 98   auto extension = GetExtension(fileName);     << 
 99   if (extension.size() != 0u) {                << 
100     // Check if valid extension (if present)   << 
101     auto output = G4Analysis::GetOutput(extens << 
102     if ( output == G4AnalysisOutput::kNone ) { << 
103       Warn("The file extension " + extension + << 
104         fkClass, "SetFileName");               << 
105       return;                                  << 
106     }                                          << 
107   }                                            << 
108   else {                                       << 
109     if (fDefaultFileType.size() != 0u) {       << 
110       //add extension if missing and file type << 
111       hnFileName = fileName + "." + fDefaultFi << 
112     }                                          << 
113   }                                            << 
114                                                << 
115   // Save the info and account a new file name << 
116   info->SetFileName(hnFileName);               << 
117   if (fFileManager) {                          << 
118     fFileManager->AddFileName(hnFileName);     << 
119   } else {                                     << 
120     Warn("Failed to set fileName " + fileName  << 
121          " for object " + info->GetName() + ". << 
122          fkClass, "SetFileName");              << 
123     return;                                    << 
124   }                                            << 
125                                                << 
126   if ( hnFileName != "" ) {                    << 
127     fNofFileNameObjects++;                     << 
128   } else {                                     << 
129     fNofFileNameObjects--;                     << 
130   }                                            << 
131 }                                              << 
132                                                << 
133 //                                             << 
134 // public methods                                  53 // public methods
135 //                                                 54 //
136                                                    55 
137 //____________________________________________     56 //_____________________________________________________________________________
138 void G4HnManager::CreateMessenger()            <<  57 void G4HnManager::AddH1Information(const G4String& name,
139 {                                              <<  58                                    const G4String& unitName,
140   fMessenger = std::make_unique<G4HnMessenger> <<  59                                    const G4String& fcnName,
141 }                                              <<  60                                    G4double unit, G4Fcn fcn,
142                                                <<  61                                    G4BinScheme binScheme)
143 //____________________________________________ <<  62 {
144 void G4HnManager::AddHnInformation(G4HnInforma <<  63   fHnVector.push_back(
145 {                                              <<  64     new G4HnInformation(name, unitName, unitName, fcnName, fcnName,
146   // Add new information                       <<  65                         unit, unit, fcn, fcn, binScheme, binScheme));
147                                                << 
148   fHnVector.push_back(info);                   << 
149   ++fNofActiveObjects;                             66   ++fNofActiveObjects;
150 }                                              <<  67 }  
151                                                    68 
152 //____________________________________________     69 //_____________________________________________________________________________
153 void G4HnManager::AddHnInformation(G4HnInforma <<  70 void  G4HnManager::AddH2Information(const G4String& name,
154 {                                              <<  71                                     const G4String& xunitName, 
155   // Replace the information at 'index' positi <<  72                                     const G4String& yunitName,
156   // Update new information with the previous  <<  73                                     const G4String& xfcnName,
157   // previous histogram was deleted with 'keep <<  74                                     const G4String& yfcnName,
158                                                <<  75                                     G4double xunit, G4double yunit,
159   auto previousInfo = fHnVector[index];        <<  76                                     G4Fcn xfcn, G4Fcn yfcn, 
160   if (previousInfo->GetDeletedPair().second) { <<  77                                     G4BinScheme xBinScheme, G4BinScheme yBinScheme)
161     info->Update(*previousInfo);               <<  78 {
162   }                                            <<  79   fHnVector.push_back(
163   delete previousInfo;                         <<  80     new G4HnInformation(name, xunitName, yunitName, xfcnName, yfcnName,
164                                                <<  81                         xunit, yunit, xfcn, yfcn, xBinScheme, yBinScheme));
165   fHnVector[index] = info;                     <<  82   ++fNofActiveObjects;
166                                                <<  83 }  
167   if (info->GetActivation()) { ++fNofActiveObj << 
168   if (info->GetAscii())      { ++fNofAsciiObje << 
169   if (info->GetPlotting())   { ++fNofPlottingO << 
170   if (! info->GetFileName().empty()) { ++fNofF << 
171 }                                              << 
172                                                << 
173 //____________________________________________ << 
174 void G4HnManager::SetHnDeleted(G4HnInformation << 
175 {                                              << 
176   info->SetDeleted(true, keepSetting);         << 
177                                                << 
178   if (info->GetActivation()) { --fNofActiveObj << 
179   if (info->GetAscii())      { --fNofAsciiObje << 
180   if (info->GetPlotting())   { --fNofPlottingO << 
181   if (! info->GetFileName().empty()) { --fNofF << 
182 }                                              << 
183                                                << 
184 //____________________________________________ << 
185 void G4HnManager::ClearData()                  << 
186 {                                              << 
187   for ( auto info : fHnVector ) {              << 
188     delete info;                               << 
189   }                                            << 
190   fHnVector.clear();                           << 
191   SetLockFirstId(false);                       << 
192 }                                              << 
193                                                    84 
194 //____________________________________________     85 //_____________________________________________________________________________
195 G4HnInformation* G4HnManager::GetHnInformation <<  86 G4HnInformation* G4HnManager::GetHnInformation(G4int id, 
196                                  std::string_v <<  87                                  G4String functionName, G4bool warn) const
197 {                                                  88 {
198   G4int index = id - fFirstId;                     89   G4int index = id - fFirstId;
199   if ( index < 0 || index >= G4int(fHnVector.s     90   if ( index < 0 || index >= G4int(fHnVector.size()) ) {
200     if ( warn ) {                                  91     if ( warn ) {
201       Warn(fHnType + " histogram " + to_string <<  92       G4String inFunction = "G4HnManager::";
202         fkClass, functionName);                <<  93       if ( functionName.size() )
203     }                                          <<  94         inFunction += functionName;
204     return nullptr;                            <<  95       else
                                                   >>  96         inFunction += "GetHnInformation"; 
                                                   >>  97       G4ExceptionDescription description;
                                                   >>  98       description << "      " << fHnType << " histogram " << id 
                                                   >>  99                   << " does not exist.";
                                                   >> 100       G4Exception(inFunction, "Analysis_W007", JustWarning, description);
                                                   >> 101     }  
                                                   >> 102     return 0;         
205   }                                               103   }
206   return fHnVector[index];                        104   return fHnVector[index];
207 }                                              << 105 }    
208                                                << 
209 //____________________________________________ << 
210 G4HnDimensionInformation* G4HnManager::GetHnDi << 
211                                 G4int dimensio << 
212                                 std::string_vi << 
213 {                                              << 
214   auto info = GetHnInformation(id, functionNam << 
215   if (info == nullptr) return nullptr;         << 
216                                                << 
217   return info->GetHnDimensionInformation(dimen << 
218 }                                              << 
219                                                   106 
220 //____________________________________________    107 //_____________________________________________________________________________
221 G4bool G4HnManager::IsActive() const              108 G4bool G4HnManager::IsActive() const
222 {                                                 109 {
223   return ( fNofActiveObjects > 0 );               110   return ( fNofActiveObjects > 0 );
224 }                                              << 111 }  
225                                                   112 
226 //____________________________________________    113 //_____________________________________________________________________________
227 G4bool G4HnManager::IsAscii() const               114 G4bool G4HnManager::IsAscii() const
228 {                                                 115 {
229   return ( fNofAsciiObjects > 0 );                116   return ( fNofAsciiObjects > 0 );
230 }                                              << 117 }  
231                                                << 
232 //____________________________________________ << 
233 G4bool G4HnManager::IsPlotting() const         << 
234 {                                              << 
235   return ( fNofPlottingObjects > 0 );          << 
236 }                                              << 
237                                                << 
238 //____________________________________________ << 
239 G4bool G4HnManager::IsFileName() const         << 
240 {                                              << 
241   return ( fNofFileNameObjects > 0 );          << 
242 }                                              << 
243                                                   118 
244 //____________________________________________    119 //_____________________________________________________________________________
245 void  G4HnManager::SetActivation(G4int id, G4b    120 void  G4HnManager::SetActivation(G4int id, G4bool activation)
246 {                                                 121 {
247 // Set activation to a given object               122 // Set activation to a given object
248                                                   123 
249   auto info = GetHnInformation(id, "SetActivat << 124   G4HnInformation* info = GetHnInformation(id, "SetActivation");
250                                                   125 
251   if (info == nullptr) return;                 << 126   if ( ! info ) return;
252                                                   127 
253   SetActivation(info, activation);             << 128   // Do nothing if activation does not change
254 }                                              << 129   if ( info->fActivation == activation ) return;
                                                   >> 130   
                                                   >> 131   // Change activation and account it in fNofActiveObjects
                                                   >> 132   info->fActivation = activation;
                                                   >> 133   if ( activation ) 
                                                   >> 134     fNofActiveObjects++;
                                                   >> 135   else
                                                   >> 136     fNofActiveObjects--;   
                                                   >> 137 }    
255                                                   138 
256 //____________________________________________    139 //_____________________________________________________________________________
257 void  G4HnManager::SetActivation(G4bool activa    140 void  G4HnManager::SetActivation(G4bool activation)
258 {                                                 141 {
259 // Set activation to all objects of the given     142 // Set activation to all objects of the given type
260                                                   143 
261   //std::vector<G4HnInformation*>::iterator it << 144   std::vector<G4HnInformation*>::iterator it;
262   //for ( it = fHnVector.begin(); it != fHnVec << 145   for ( it = fHnVector.begin(); it != fHnVector.end(); it++ ) {
263   //   G4HnInformation* info = *it;            << 146     G4HnInformation* info = *it;
264                                                << 147 
265   for ( auto info : fHnVector )  {             << 148     // Do nothing if activation does not change
266     SetActivation(info, activation);           << 149     if ( info->fActivation == activation ) continue;
267   }                                            << 150   
268 }                                              << 151     // Change activation and account it in fNofActiveObjects
                                                   >> 152     info->fActivation = activation;
                                                   >> 153     if ( activation ) 
                                                   >> 154       fNofActiveObjects++;
                                                   >> 155     else
                                                   >> 156       fNofActiveObjects--; 
                                                   >> 157   }     
                                                   >> 158 }    
269                                                   159 
270 //____________________________________________    160 //_____________________________________________________________________________
271 void  G4HnManager::SetAscii(G4int id, G4bool a    161 void  G4HnManager::SetAscii(G4int id, G4bool ascii)
272 {                                                 162 {
273   auto info = GetHnInformation(id, "SetAscii") << 163   G4HnInformation* info = GetHnInformation(id, "SetAscii");
274                                                   164 
275   if (info == nullptr) return;                 << 165   if ( ! info ) return;
276                                                   166 
277   // Do nothing if ascii does not change          167   // Do nothing if ascii does not change
278   if ( info->GetAscii() == ascii ) return;     << 168   if ( info->fAscii == ascii ) return;
279                                                << 169   
280   // Change ascii and account it in fNofAsciiO    170   // Change ascii and account it in fNofAsciiObjects
281   info->SetAscii(ascii);                       << 171   info->fAscii = ascii;
282   if (ascii) {                                 << 172   if ( ascii ) 
283     fNofAsciiObjects++;                           173     fNofAsciiObjects++;
284   }                                            << 174   else
285   else {                                       << 175     fNofAsciiObjects--;   
286     fNofAsciiObjects--;                        << 176 }    
287   }                                            << 
288 }                                              << 
289                                                << 
290 //____________________________________________ << 
291 void  G4HnManager::SetPlotting(G4int id, G4boo << 
292 {                                              << 
293   auto info = GetHnInformation(id, "SetPlottin << 
294                                                << 
295   if (info == nullptr) return;                 << 
296                                                << 
297   SetPlotting(info, plotting);                 << 
298 }                                              << 
299                                                << 
300 //____________________________________________ << 
301 void  G4HnManager::SetPlotting(G4bool plotting << 
302 {                                              << 
303 // Set plotting to all objects of the given ty << 
304                                                << 
305   for ( auto info : fHnVector )  {             << 
306     SetPlotting(info, plotting);               << 
307   }                                            << 
308 }                                              << 
309                                                << 
310 //____________________________________________ << 
311 void  G4HnManager::SetFileName(G4int id, const << 
312 {                                              << 
313   auto info = GetHnInformation(id, "SetFileNam << 
314                                                << 
315   if (info == nullptr) return;                 << 
316                                                << 
317   SetFileName(info, fileName);                 << 
318 }                                              << 
319                                                << 
320 //____________________________________________ << 
321 void  G4HnManager::SetFileName(const G4String& << 
322 {                                              << 
323 // Set plotting to all objects of the given ty << 
324                                                << 
325   for ( auto info : fHnVector )  {             << 
326     SetFileName(info, fileName);               << 
327   }                                            << 
328 }                                              << 
329                                                << 
330 //____________________________________________ << 
331 G4bool G4HnManager::SetAxisIsLog(unsigned int  << 
332 {                                              << 
333   auto info = GetHnInformation(id, "SetAxisIsL << 
334                                                << 
335   if (info == nullptr) return false;           << 
336                                                << 
337   info->SetIsLogAxis(idim, isLog);             << 
338   return true;                                 << 
339 }                                              << 
340                                                   177 
341 //____________________________________________    178 //_____________________________________________________________________________
342 G4String G4HnManager::GetName(G4int id) const     179 G4String G4HnManager::GetName(G4int id) const
343 {                                                 180 {
344   auto info = GetHnInformation(id, "GetName"); << 181   G4HnInformation* info = GetHnInformation(id, "GetName");
345                                                   182 
346   if (info == nullptr) return "";              << 183   if ( ! info ) return "";
347                                                << 184     
348   return info->GetName();                      << 185   return info->fName;
349 }                                              << 186 }    
350                                                   187 
351 //____________________________________________    188 //_____________________________________________________________________________
352 G4double G4HnManager::GetUnit(unsigned int idi << 189 G4double G4HnManager::GetXUnit(G4int id) const
353 {                                                 190 {
354   auto info = GetHnDimensionInformation(id, id << 191   G4HnInformation* info = GetHnInformation(id, "GetXUnit");
355                                                << 
356   if (info == nullptr) return 1.0;             << 
357                                                   192 
358   return info->fUnit;                          << 193   if ( ! info ) return 1.0;
359 }                                              << 194   
                                                   >> 195   return info->fXUnit;
                                                   >> 196 }    
360                                                   197 
361 //____________________________________________    198 //_____________________________________________________________________________
362 G4bool G4HnManager::GetAxisIsLog(unsigned int  << 199 G4double G4HnManager::GetYUnit(G4int id) const
363 {                                                 200 {
364   auto info = GetHnInformation(id, "GetXAxisIs << 201   G4HnInformation* info = GetHnInformation(id, "GetYUnit");
365                                                   202 
366   if (info == nullptr) return false;           << 203   if ( ! info ) return 1.0;
367                                                << 204   
368   return info->GetIsLogAxis(idim);             << 205   return info->fYUnit;
369 }                                              << 206 }    
370                                                   207 
371 //____________________________________________    208 //_____________________________________________________________________________
372 G4bool G4HnManager::GetActivation(G4int id) co    209 G4bool G4HnManager::GetActivation(G4int id) const
373 {                                                 210 {
374   auto info = GetHnInformation(id, "GetActivat << 211   G4HnInformation* info = GetHnInformation(id, "GetActivation");
375                                                << 
376   if (info == nullptr) return true;            << 
377                                                   212 
378   return info->GetActivation();                << 213   if ( ! info ) return true;
379 }                                              << 214   
                                                   >> 215   return info->fActivation;
                                                   >> 216 }    
380                                                   217 
381 //____________________________________________    218 //_____________________________________________________________________________
382 G4bool G4HnManager::GetAscii(G4int id) const      219 G4bool G4HnManager::GetAscii(G4int id) const
383 {                                                 220 {
384   auto info = GetHnInformation(id, "GetAscii") << 221   G4HnInformation* info = GetHnInformation(id, "GetAscii");
385                                                << 
386   if (info == nullptr) return false;           << 
387                                                << 
388   return info->GetAscii();                     << 
389 }                                              << 
390                                                << 
391 //____________________________________________ << 
392 G4bool G4HnManager::GetPlotting(G4int id) cons << 
393 {                                              << 
394   auto info = GetHnInformation(id, "GetPlottin << 
395                                                   222 
396   if (info == nullptr) return false;           << 223   if ( ! info ) return false;
397                                                << 224   
398   return info->GetPlotting();                  << 225   return info->fAscii;
399 }                                              << 226 }    
400                                                << 
401 //____________________________________________ << 
402 G4String G4HnManager::GetFileName(G4int id) co << 
403 {                                              << 
404   auto info = GetHnInformation(id, "GetFileNam << 
405                                                << 
406   if (info == nullptr) return "";              << 
407                                                << 
408   return info->GetFileName();                  << 
409 }                                              << 
410                                                   227