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