Geant4 Cross Reference |
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 26 27 // Author: Ivana Hrivnacova, 09/07/2013 (ivan 27 // Author: Ivana Hrivnacova, 09/07/2013 (ivana@ipno.in2p3.fr) 28 28 29 #include "G4VAnalysisReader.hh" 29 #include "G4VAnalysisReader.hh" 30 #include "G4AnalysisUtilities.hh" 30 #include "G4AnalysisUtilities.hh" 31 #include "G4HnManager.hh" 31 #include "G4HnManager.hh" 32 #include "G4VRNtupleManager.hh" 32 #include "G4VRNtupleManager.hh" 33 #include "G4VRFileManager.hh" 33 #include "G4VRFileManager.hh" 34 #include "G4Threading.hh" 34 #include "G4Threading.hh" 35 35 36 using namespace G4Analysis; 36 using namespace G4Analysis; 37 37 38 //____________________________________________ 38 //_____________________________________________________________________________ 39 G4VAnalysisReader::G4VAnalysisReader(const G4S 39 G4VAnalysisReader::G4VAnalysisReader(const G4String& type) 40 : fState(type, ! G4Threading::IsWorkerThread( 40 : fState(type, ! G4Threading::IsWorkerThread()) 41 {} 41 {} 42 42 43 //____________________________________________ 43 //_____________________________________________________________________________ 44 G4VAnalysisReader::~G4VAnalysisReader() = defa 44 G4VAnalysisReader::~G4VAnalysisReader() = default; 45 45 46 // 46 // 47 // protected methods 47 // protected methods 48 // 48 // 49 49 50 //____________________________________________ 50 //_____________________________________________________________________________ 51 void G4VAnalysisReader::SetH1Manager(G4VTBaseH << 51 void G4VAnalysisReader::SetH1Manager(G4VTBaseHnManager<1>* h1Manager) 52 { 52 { 53 fVH1Manager.reset(h1Manager); 53 fVH1Manager.reset(h1Manager); 54 } 54 } 55 55 56 //____________________________________________ 56 //_____________________________________________________________________________ 57 void G4VAnalysisReader::SetH2Manager(G4VTBaseH << 57 void G4VAnalysisReader::SetH2Manager(G4VTBaseHnManager<2>* h2Manager) 58 { 58 { 59 fVH2Manager.reset(h2Manager); 59 fVH2Manager.reset(h2Manager); 60 } 60 } 61 61 62 //____________________________________________ 62 //_____________________________________________________________________________ 63 void G4VAnalysisReader::SetH3Manager(G4VTBaseH << 63 void G4VAnalysisReader::SetH3Manager(G4VTBaseHnManager<3>* h3Manager) 64 { 64 { 65 fVH3Manager.reset(h3Manager); 65 fVH3Manager.reset(h3Manager); 66 } 66 } 67 67 68 //____________________________________________ 68 //_____________________________________________________________________________ 69 void G4VAnalysisReader::SetP1Manager(G4VTBaseH << 69 void G4VAnalysisReader::SetP1Manager(G4VTBaseHnManager<2>* p1Manager) 70 { 70 { 71 fVP1Manager.reset(p1Manager); 71 fVP1Manager.reset(p1Manager); 72 } 72 } 73 73 74 //____________________________________________ 74 //_____________________________________________________________________________ 75 void G4VAnalysisReader::SetP2Manager(G4VTBaseH << 75 void G4VAnalysisReader::SetP2Manager(G4VTBaseHnManager<3>* p2Manager) 76 { 76 { 77 fVP2Manager.reset(p2Manager); 77 fVP2Manager.reset(p2Manager); 78 } 78 } 79 79 80 //____________________________________________ 80 //_____________________________________________________________________________ 81 void G4VAnalysisReader::SetNtupleManager(std:: 81 void G4VAnalysisReader::SetNtupleManager(std::shared_ptr<G4VRNtupleManager> ntupleManager) 82 { 82 { 83 fVNtupleManager = std::move(ntupleManager); 83 fVNtupleManager = std::move(ntupleManager); 84 } 84 } 85 85 86 //____________________________________________ 86 //_____________________________________________________________________________ 87 void G4VAnalysisReader::SetFileManager(std::sh 87 void G4VAnalysisReader::SetFileManager(std::shared_ptr<G4VRFileManager> fileManager) 88 { 88 { 89 fVFileManager = std::move(fileManager); 89 fVFileManager = std::move(fileManager); 90 } 90 } 91 91 92 // 92 // 93 // public methods 93 // public methods 94 // 94 // 95 95 96 //____________________________________________ 96 //_____________________________________________________________________________ 97 G4bool G4VAnalysisReader::CloseFiles(G4bool re 97 G4bool G4VAnalysisReader::CloseFiles(G4bool reset) 98 { 98 { 99 return CloseFilesImpl(reset); 99 return CloseFilesImpl(reset); 100 } 100 } 101 101 102 //____________________________________________ 102 //_____________________________________________________________________________ 103 void G4VAnalysisReader::SetFileName(const G4St 103 void G4VAnalysisReader::SetFileName(const G4String& fileName) 104 { 104 { 105 fVFileManager->SetFileName(fileName); 105 fVFileManager->SetFileName(fileName); 106 } 106 } 107 107 108 //____________________________________________ 108 //_____________________________________________________________________________ 109 G4String G4VAnalysisReader::GetFileName() cons 109 G4String G4VAnalysisReader::GetFileName() const 110 { 110 { 111 return fVFileManager->GetFileName(); 111 return fVFileManager->GetFileName(); 112 } 112 } 113 113 114 //____________________________________________ 114 //_____________________________________________________________________________ 115 G4int G4VAnalysisReader::ReadH1(const G4String 115 G4int G4VAnalysisReader::ReadH1(const G4String& h1Name, 116 const G4String 116 const G4String& fileName, 117 const G4String 117 const G4String& dirName) 118 { 118 { 119 if ( fileName != "" ) { 119 if ( fileName != "" ) { 120 return ReadH1Impl(h1Name, fileName, dirNam 120 return ReadH1Impl(h1Name, fileName, dirName, true); 121 } 121 } 122 if (fVFileManager->GetFileName() == "") { 122 if (fVFileManager->GetFileName() == "") { 123 Warn("Cannot get H1 " + h1Name + ". File n 123 Warn("Cannot get H1 " + h1Name + ". File name has to be set first.", fkClass, "ReadH1"); 124 return kInvalidId; 124 return kInvalidId; 125 } 125 } 126 return ReadH1Impl(h1Name, fVFileManager->Get 126 return ReadH1Impl(h1Name, fVFileManager->GetFileName(), dirName, false); 127 } 127 } 128 128 129 //____________________________________________ 129 //_____________________________________________________________________________ 130 G4int G4VAnalysisReader::ReadH2(const G4String 130 G4int G4VAnalysisReader::ReadH2(const G4String& h2Name, 131 const G4String 131 const G4String& fileName, 132 const G4String 132 const G4String& dirName) 133 { 133 { 134 if ( fileName != "" ) { 134 if ( fileName != "" ) { 135 return ReadH2Impl(h2Name, fileName, dirNam 135 return ReadH2Impl(h2Name, fileName, dirName, true); 136 } 136 } 137 if (fVFileManager->GetFileName() == "") { 137 if (fVFileManager->GetFileName() == "") { 138 Warn("Cannot get H2 " + h2Name + ". File n 138 Warn("Cannot get H2 " + h2Name + ". File name has to be set first.", fkClass, "ReadH2"); 139 return kInvalidId; 139 return kInvalidId; 140 } 140 } 141 return ReadH2Impl(h2Name, fVFileManager->Get 141 return ReadH2Impl(h2Name, fVFileManager->GetFileName(), dirName, false); 142 } 142 } 143 143 144 //____________________________________________ 144 //_____________________________________________________________________________ 145 G4int G4VAnalysisReader::ReadH3(const G4String 145 G4int G4VAnalysisReader::ReadH3(const G4String& h3Name, 146 const G4String 146 const G4String& fileName, 147 const G4String 147 const G4String& dirName) 148 { 148 { 149 if ( fileName != "" ) { 149 if ( fileName != "" ) { 150 return ReadH3Impl(h3Name, fileName, dirNam 150 return ReadH3Impl(h3Name, fileName, dirName, true); 151 } 151 } 152 if (fVFileManager->GetFileName() == "") { 152 if (fVFileManager->GetFileName() == "") { 153 Warn("Cannot get H3 " + h3Name + ". File n 153 Warn("Cannot get H3 " + h3Name + ". File name has to be set first.", fkClass, "ReadH3"); 154 return kInvalidId; 154 return kInvalidId; 155 } 155 } 156 return ReadH3Impl(h3Name, fVFileManager->Get 156 return ReadH3Impl(h3Name, fVFileManager->GetFileName(), dirName, false); 157 } 157 } 158 158 159 //____________________________________________ 159 //_____________________________________________________________________________ 160 G4int G4VAnalysisReader::ReadP1(const G4String 160 G4int G4VAnalysisReader::ReadP1(const G4String& p1Name, 161 const G4String 161 const G4String& fileName, 162 const G4String 162 const G4String& dirName) 163 { 163 { 164 if ( fileName != "" ) { 164 if ( fileName != "" ) { 165 return ReadP1Impl(p1Name, fileName, dirNam 165 return ReadP1Impl(p1Name, fileName, dirName, true); 166 } 166 } 167 if (fVFileManager->GetFileName() == "") { 167 if (fVFileManager->GetFileName() == "") { 168 Warn("Cannot get P1 " + p1Name + ". File n 168 Warn("Cannot get P1 " + p1Name + ". File name has to be set first.", fkClass, "ReadP1"); 169 return kInvalidId; 169 return kInvalidId; 170 } 170 } 171 return ReadP1Impl(p1Name, fVFileManager->Get 171 return ReadP1Impl(p1Name, fVFileManager->GetFileName(), dirName, false); 172 } 172 } 173 173 174 //____________________________________________ 174 //_____________________________________________________________________________ 175 G4int G4VAnalysisReader::ReadP2(const G4String 175 G4int G4VAnalysisReader::ReadP2(const G4String& p2Name, 176 const G4String 176 const G4String& fileName, 177 const G4String 177 const G4String& dirName) 178 { 178 { 179 if ( fileName != "" ) { 179 if ( fileName != "" ) { 180 return ReadP2Impl(p2Name, fileName, dirNam 180 return ReadP2Impl(p2Name, fileName, dirName, true); 181 } 181 } 182 if (fVFileManager->GetFileName() == "") { 182 if (fVFileManager->GetFileName() == "") { 183 Warn("Cannot get P2 " + p2Name + ". File n 183 Warn("Cannot get P2 " + p2Name + ". File name has to be set first.", fkClass, "ReadP2"); 184 return kInvalidId; 184 return kInvalidId; 185 } 185 } 186 return ReadP2Impl(p2Name, fVFileManager->Get 186 return ReadP2Impl(p2Name, fVFileManager->GetFileName(), dirName, false); 187 } 187 } 188 188 189 //____________________________________________ 189 //_____________________________________________________________________________ 190 G4bool G4VAnalysisReader::SetFirstHistoId(G4in 190 G4bool G4VAnalysisReader::SetFirstHistoId(G4int firstId) 191 { 191 { 192 auto result = true; 192 auto result = true; 193 193 194 result &= SetFirstH1Id(firstId); 194 result &= SetFirstH1Id(firstId); 195 result &= SetFirstH2Id(firstId); 195 result &= SetFirstH2Id(firstId); 196 result &= SetFirstH3Id(firstId); 196 result &= SetFirstH3Id(firstId); 197 197 198 return result; 198 return result; 199 } 199 } 200 200 201 //____________________________________________ 201 //_____________________________________________________________________________ 202 G4bool G4VAnalysisReader::SetFirstH1Id(G4int f 202 G4bool G4VAnalysisReader::SetFirstH1Id(G4int firstId) 203 { 203 { 204 return fVH1Manager->GetHnManager()->SetFirst 204 return fVH1Manager->GetHnManager()->SetFirstId(firstId); 205 } 205 } 206 206 207 //____________________________________________ 207 //_____________________________________________________________________________ 208 G4bool G4VAnalysisReader::SetFirstH2Id(G4int f 208 G4bool G4VAnalysisReader::SetFirstH2Id(G4int firstId) 209 { 209 { 210 return fVH2Manager->GetHnManager()->SetFirst 210 return fVH2Manager->GetHnManager()->SetFirstId(firstId); 211 } 211 } 212 212 213 //____________________________________________ 213 //_____________________________________________________________________________ 214 G4bool G4VAnalysisReader::SetFirstH3Id(G4int f 214 G4bool G4VAnalysisReader::SetFirstH3Id(G4int firstId) 215 { 215 { 216 return fVH3Manager->GetHnManager()->SetFirst 216 return fVH3Manager->GetHnManager()->SetFirstId(firstId); 217 } 217 } 218 218 219 //____________________________________________ 219 //_____________________________________________________________________________ 220 G4bool G4VAnalysisReader::SetFirstProfileId(G4 220 G4bool G4VAnalysisReader::SetFirstProfileId(G4int firstId) 221 { 221 { 222 auto result = true; 222 auto result = true; 223 223 224 result &= SetFirstP1Id(firstId); 224 result &= SetFirstP1Id(firstId); 225 result &= SetFirstP2Id(firstId); 225 result &= SetFirstP2Id(firstId); 226 226 227 return result; 227 return result; 228 } 228 } 229 229 230 //____________________________________________ 230 //_____________________________________________________________________________ 231 G4bool G4VAnalysisReader::SetFirstP1Id(G4int f 231 G4bool G4VAnalysisReader::SetFirstP1Id(G4int firstId) 232 { 232 { 233 return fVP1Manager->GetHnManager()->SetFirst 233 return fVP1Manager->GetHnManager()->SetFirstId(firstId); 234 } 234 } 235 235 236 //____________________________________________ 236 //_____________________________________________________________________________ 237 G4bool G4VAnalysisReader::SetFirstP2Id(G4int f 237 G4bool G4VAnalysisReader::SetFirstP2Id(G4int firstId) 238 { 238 { 239 return fVP2Manager->GetHnManager()->SetFirst 239 return fVP2Manager->GetHnManager()->SetFirstId(firstId); 240 } 240 } 241 241 242 //____________________________________________ 242 //_____________________________________________________________________________ 243 G4bool G4VAnalysisReader::SetFirstNtupleId(G4i 243 G4bool G4VAnalysisReader::SetFirstNtupleId(G4int firstId) 244 { 244 { 245 return fVNtupleManager->SetFirstId(firstId); 245 return fVNtupleManager->SetFirstId(firstId); 246 } 246 } 247 247 248 //____________________________________________ 248 //_____________________________________________________________________________ 249 G4int G4VAnalysisReader::GetNtuple(const G4Str 249 G4int G4VAnalysisReader::GetNtuple(const G4String& ntupleName, 250 const G4Str 250 const G4String& fileName, 251 const G4Str 251 const G4String& dirName) 252 { 252 { 253 if ( fileName != "" ) { 253 if ( fileName != "" ) { 254 return fVNtupleManager->ReadNtupleImpl(ntu 254 return fVNtupleManager->ReadNtupleImpl(ntupleName, fileName, dirName, true); 255 } 255 } 256 // Check if fileName was set 256 // Check if fileName was set 257 if (fVFileManager->GetFileName() == "") { 257 if (fVFileManager->GetFileName() == "") { 258 Warn("Cannot read Ntuple " + ntupleName += 258 Warn("Cannot read Ntuple " + ntupleName += ". File name has to be set first.", fkClass, 259 "ReadNtuple"); 259 "ReadNtuple"); 260 return kInvalidId; 260 return kInvalidId; 261 } 261 } 262 return fVNtupleManager->ReadNtupleImpl(ntupl 262 return fVNtupleManager->ReadNtupleImpl(ntupleName, fVFileManager->GetFileName(), dirName, false); 263 } 263 } 264 264 265 //____________________________________________ 265 //_____________________________________________________________________________ 266 G4bool G4VAnalysisReader::SetNtupleIColumn(con 266 G4bool G4VAnalysisReader::SetNtupleIColumn(const G4String& columnName, 267 G4 267 G4int& value) 268 { 268 { 269 return fVNtupleManager->SetNtupleIColumn(col 269 return fVNtupleManager->SetNtupleIColumn(columnName, value); 270 } 270 } 271 271 272 //____________________________________________ 272 //_____________________________________________________________________________ 273 G4bool G4VAnalysisReader::SetNtupleFColumn(con 273 G4bool G4VAnalysisReader::SetNtupleFColumn(const G4String& columnName, 274 G4 274 G4float& value) 275 { 275 { 276 return fVNtupleManager->SetNtupleFColumn(col 276 return fVNtupleManager->SetNtupleFColumn(columnName, value); 277 } 277 } 278 278 279 //____________________________________________ 279 //_____________________________________________________________________________ 280 G4bool G4VAnalysisReader::SetNtupleDColumn(con 280 G4bool G4VAnalysisReader::SetNtupleDColumn(const G4String& columnName, 281 G4 281 G4double& value) 282 { 282 { 283 return fVNtupleManager->SetNtupleDColumn(col 283 return fVNtupleManager->SetNtupleDColumn(columnName, value); 284 } 284 } 285 285 286 //____________________________________________ 286 //_____________________________________________________________________________ 287 G4bool G4VAnalysisReader::SetNtupleSColumn(con 287 G4bool G4VAnalysisReader::SetNtupleSColumn(const G4String& columnName, 288 G4 288 G4String& value) 289 { 289 { 290 return fVNtupleManager->SetNtupleSColumn(col 290 return fVNtupleManager->SetNtupleSColumn(columnName, value); 291 } 291 } 292 292 293 //____________________________________________ 293 //_____________________________________________________________________________ 294 G4bool G4VAnalysisReader::SetNtupleIColumn(con 294 G4bool G4VAnalysisReader::SetNtupleIColumn(const G4String& columnName, 295 st 295 std::vector<int>& vector) 296 { 296 { 297 return fVNtupleManager->SetNtupleIColumn(col 297 return fVNtupleManager->SetNtupleIColumn(columnName, vector); 298 } 298 } 299 299 300 //____________________________________________ 300 //_____________________________________________________________________________ 301 G4bool G4VAnalysisReader::SetNtupleFColumn(con 301 G4bool G4VAnalysisReader::SetNtupleFColumn(const G4String& columnName, 302 st 302 std::vector<float>& vector) 303 { 303 { 304 return fVNtupleManager->SetNtupleFColumn(col 304 return fVNtupleManager->SetNtupleFColumn(columnName, vector); 305 } 305 } 306 306 307 //____________________________________________ 307 //_____________________________________________________________________________ 308 G4bool G4VAnalysisReader::SetNtupleDColumn(con 308 G4bool G4VAnalysisReader::SetNtupleDColumn(const G4String& columnName, 309 st 309 std::vector<double>& vector) 310 { 310 { 311 return fVNtupleManager->SetNtupleDColumn(col 311 return fVNtupleManager->SetNtupleDColumn(columnName, vector); 312 } 312 } 313 313 314 //____________________________________________ 314 //_____________________________________________________________________________ 315 G4bool G4VAnalysisReader::SetNtupleSColumn(con 315 G4bool G4VAnalysisReader::SetNtupleSColumn(const G4String& columnName, 316 st 316 std::vector<std::string>& vector) 317 { 317 { 318 return fVNtupleManager->SetNtupleSColumn(col 318 return fVNtupleManager->SetNtupleSColumn(columnName, vector); 319 } 319 } 320 320 321 //____________________________________________ 321 //_____________________________________________________________________________ 322 G4bool G4VAnalysisReader::SetNtupleIColumn(G4i 322 G4bool G4VAnalysisReader::SetNtupleIColumn(G4int ntupleId, 323 co 323 const G4String& columnName, 324 G4 324 G4int& value) 325 { 325 { 326 return fVNtupleManager->SetNtupleIColumn(ntu 326 return fVNtupleManager->SetNtupleIColumn(ntupleId, columnName, value); 327 } 327 } 328 328 329 //____________________________________________ 329 //_____________________________________________________________________________ 330 G4bool G4VAnalysisReader::SetNtupleFColumn(G4i 330 G4bool G4VAnalysisReader::SetNtupleFColumn(G4int ntupleId, 331 co 331 const G4String& columnName, 332 G4 332 G4float& value) 333 { 333 { 334 return fVNtupleManager->SetNtupleFColumn(ntu 334 return fVNtupleManager->SetNtupleFColumn(ntupleId, columnName, value); 335 } 335 } 336 336 337 //____________________________________________ 337 //_____________________________________________________________________________ 338 G4bool G4VAnalysisReader::SetNtupleDColumn(G4i 338 G4bool G4VAnalysisReader::SetNtupleDColumn(G4int ntupleId, 339 co 339 const G4String& columnName, 340 G4 340 G4double& value) 341 { 341 { 342 return fVNtupleManager->SetNtupleDColumn(ntu 342 return fVNtupleManager->SetNtupleDColumn(ntupleId, columnName, value); 343 } 343 } 344 344 345 //____________________________________________ 345 //_____________________________________________________________________________ 346 G4bool G4VAnalysisReader::SetNtupleSColumn(G4i 346 G4bool G4VAnalysisReader::SetNtupleSColumn(G4int ntupleId, 347 co 347 const G4String& columnName, 348 G4 348 G4String& value) 349 { 349 { 350 return fVNtupleManager->SetNtupleSColumn(ntu 350 return fVNtupleManager->SetNtupleSColumn(ntupleId, columnName, value); 351 } 351 } 352 352 353 //____________________________________________ 353 //_____________________________________________________________________________ 354 G4bool G4VAnalysisReader::SetNtupleIColumn(G4i 354 G4bool G4VAnalysisReader::SetNtupleIColumn(G4int ntupleId, 355 co 355 const G4String& columnName, 356 st 356 std::vector<int>& vector) 357 { 357 { 358 return fVNtupleManager->SetNtupleIColumn(ntu 358 return fVNtupleManager->SetNtupleIColumn(ntupleId, columnName, vector); 359 } 359 } 360 360 361 //____________________________________________ 361 //_____________________________________________________________________________ 362 G4bool G4VAnalysisReader::SetNtupleFColumn(G4i 362 G4bool G4VAnalysisReader::SetNtupleFColumn(G4int ntupleId, 363 co 363 const G4String& columnName, 364 st 364 std::vector<float>& vector) 365 { 365 { 366 return fVNtupleManager->SetNtupleFColumn(ntu 366 return fVNtupleManager->SetNtupleFColumn(ntupleId, columnName, vector); 367 } 367 } 368 368 369 //____________________________________________ 369 //_____________________________________________________________________________ 370 G4bool G4VAnalysisReader::SetNtupleDColumn(G4i 370 G4bool G4VAnalysisReader::SetNtupleDColumn(G4int ntupleId, 371 co 371 const G4String& columnName, 372 st 372 std::vector<double>& vector) 373 { 373 { 374 return fVNtupleManager->SetNtupleDColumn(ntu 374 return fVNtupleManager->SetNtupleDColumn(ntupleId, columnName, vector); 375 } 375 } 376 376 377 //____________________________________________ 377 //_____________________________________________________________________________ 378 G4bool G4VAnalysisReader::SetNtupleSColumn(G4i 378 G4bool G4VAnalysisReader::SetNtupleSColumn(G4int ntupleId, 379 co 379 const G4String& columnName, 380 st 380 std::vector<std::string>& vector) 381 { 381 { 382 return fVNtupleManager->SetNtupleSColumn(ntu 382 return fVNtupleManager->SetNtupleSColumn(ntupleId, columnName, vector); 383 } 383 } 384 384 385 //____________________________________________ 385 //_____________________________________________________________________________ 386 G4bool G4VAnalysisReader::GetNtupleRow() 386 G4bool G4VAnalysisReader::GetNtupleRow() 387 { 387 { 388 return fVNtupleManager->GetNtupleRow(); 388 return fVNtupleManager->GetNtupleRow(); 389 } 389 } 390 390 391 391 392 //____________________________________________ 392 //_____________________________________________________________________________ 393 G4bool G4VAnalysisReader::GetNtupleRow(G4int n 393 G4bool G4VAnalysisReader::GetNtupleRow(G4int ntupleId) 394 { 394 { 395 return fVNtupleManager->GetNtupleRow(ntupleI 395 return fVNtupleManager->GetNtupleRow(ntupleId); 396 } 396 } 397 397 398 //____________________________________________ 398 //_____________________________________________________________________________ 399 G4int G4VAnalysisReader::GetNofH1s(G4bool only << 399 G4int G4VAnalysisReader::GetNofH1s() const 400 { 400 { 401 return fVH1Manager->GetNofHns(onlyIfExist); << 401 return fVH1Manager->GetHnManager()->GetNofHns(); 402 } 402 } 403 403 404 //____________________________________________ 404 //_____________________________________________________________________________ 405 G4int G4VAnalysisReader::GetNofH2s(G4bool only << 405 G4int G4VAnalysisReader::GetNofH2s() const 406 { 406 { 407 return fVH2Manager->GetNofHns(onlyIfExist); << 407 return fVH2Manager->GetHnManager()->GetNofHns(); 408 } 408 } 409 409 410 //____________________________________________ 410 //_____________________________________________________________________________ 411 G4int G4VAnalysisReader::GetNofH3s(G4bool only << 411 G4int G4VAnalysisReader::GetNofH3s() const 412 { 412 { 413 return fVH3Manager->GetNofHns(onlyIfExist); << 413 return fVH3Manager->GetHnManager()->GetNofHns(); 414 } 414 } 415 415 416 //____________________________________________ 416 //_____________________________________________________________________________ 417 G4int G4VAnalysisReader::GetNofP1s(G4bool only << 417 G4int G4VAnalysisReader::GetNofP1s() const 418 { 418 { 419 return fVP1Manager->GetNofHns(onlyIfExist); << 419 return fVP1Manager->GetHnManager()->GetNofHns(); 420 } 420 } 421 421 422 //____________________________________________ 422 //_____________________________________________________________________________ 423 G4int G4VAnalysisReader::GetNofP2s(G4bool only << 423 G4int G4VAnalysisReader::GetNofP2s() const 424 { 424 { 425 return fVP2Manager->GetNofHns(onlyIfExist); << 425 return fVP2Manager->GetHnManager()->GetNofHns(); 426 } 426 } 427 427 428 //____________________________________________ 428 //_____________________________________________________________________________ 429 G4int G4VAnalysisReader::GetNofNtuples() const 429 G4int G4VAnalysisReader::GetNofNtuples() const 430 { 430 { 431 return fVNtupleManager->GetNofNtuples(); 431 return fVNtupleManager->GetNofNtuples(); 432 } 432 } 433 433 434 // GetH1Id(), GetH2Id in .icc 434 // GetH1Id(), GetH2Id in .icc 435 435 436 // Access methods in .icc 436 // Access methods in .icc 437 437 438 //____________________________________________ 438 //_____________________________________________________________________________ 439 void G4VAnalysisReader::SetVerboseLevel(G4int 439 void G4VAnalysisReader::SetVerboseLevel(G4int verboseLevel) 440 { 440 { 441 fState.SetVerboseLevel(verboseLevel); 441 fState.SetVerboseLevel(verboseLevel); 442 } 442 } 443 443 444 // GetVerboseLevel() in .icc 444 // GetVerboseLevel() in .icc 445 445