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: Mathieu Karamitros (kara@cenbg.in2p 27 // Author: Mathieu Karamitros (kara@cenbg.in2p3.fr) 28 // 28 // 29 // WARNING : This class is released as a proto 29 // WARNING : This class is released as a prototype. 30 // It might strongly evolve or even disappear 30 // It might strongly evolve or even disappear in the next releases. 31 // 31 // 32 // History: 32 // History: 33 // ----------- 33 // ----------- 34 // 10 Oct 2011 M.Karamitros created 34 // 10 Oct 2011 M.Karamitros created 35 // 35 // 36 // ------------------------------------------- 36 // ------------------------------------------------------------------- 37 37 38 #include "G4DNAChemistryManager.hh" 38 #include "G4DNAChemistryManager.hh" 39 39 40 #include "G4AutoLock.hh" << 40 #include "G4Scheduler.hh" >> 41 #include "G4SystemOfUnits.hh" >> 42 #include "G4Molecule.hh" >> 43 #include "G4VITTrackHolder.hh" >> 44 #include "G4H2O.hh" 41 #include "G4DNAMolecularReactionTable.hh" 45 #include "G4DNAMolecularReactionTable.hh" 42 #include "G4DNAWaterExcitationStructure.hh" 46 #include "G4DNAWaterExcitationStructure.hh" 43 #include "G4DNAWaterIonisationStructure.hh" 47 #include "G4DNAWaterIonisationStructure.hh" 44 #include "G4Electron_aq.hh" 48 #include "G4Electron_aq.hh" 45 #include "G4GeometryManager.hh" << 46 #include "G4H2O.hh" << 47 #include "G4MolecularConfiguration.hh" 49 #include "G4MolecularConfiguration.hh" 48 #include "G4Molecule.hh" << 50 #include "G4VMoleculeCounter.hh" 49 #include "G4MoleculeFinder.hh" << 51 #include "G4VUserChemistryList.hh" 50 #include "G4MoleculeTable.hh" << 52 #include "G4AutoLock.hh" 51 #include "G4PhysChemIO.hh" << 52 #include "G4Scheduler.hh" << 53 #include "G4StateManager.hh" << 54 #include "G4SystemOfUnits.hh" << 55 #include "G4UIcmdWithABool.hh" 53 #include "G4UIcmdWithABool.hh" 56 #include "G4UIcmdWithADoubleAndUnit.hh" 54 #include "G4UIcmdWithADoubleAndUnit.hh" 57 #include "G4UIcmdWithAnInteger.hh" << 58 #include "G4UIcmdWithoutParameter.hh" 55 #include "G4UIcmdWithoutParameter.hh" 59 #include "G4VITTrackHolder.hh" << 56 #include "G4UIcmdWithAnInteger.hh" 60 #include "G4VMoleculeCounter.hh" << 57 #include "G4GeometryManager.hh" 61 #include "G4VUserChemistryList.hh" << 58 #include "G4StateManager.hh" 62 #include "G4VUserPulseInfo.hh" << 59 #include "G4MoleculeFinder.hh" >> 60 #include "G4MoleculeTable.hh" >> 61 #include "G4PhysChemIO.hh" 63 62 64 #include <memory> << 65 63 66 G4DNAChemistryManager* G4DNAChemistryManager:: 64 G4DNAChemistryManager* G4DNAChemistryManager::fgInstance = nullptr; 67 65 68 G4ThreadLocal G4DNAChemistryManager::ThreadLoc 66 G4ThreadLocal G4DNAChemistryManager::ThreadLocalData* 69 G4DNAChemistryManager::fpThreadData = null 67 G4DNAChemistryManager::fpThreadData = nullptr; 70 68 71 G4Mutex chemManExistence; 69 G4Mutex chemManExistence; 72 70 73 //-------------------------------------------- 71 //------------------------------------------------------------------------------ 74 72 75 G4DNAChemistryManager::ThreadLocalData::Thread 73 G4DNAChemistryManager::ThreadLocalData::ThreadLocalData() 76 { 74 { 77 fpPhysChemIO = nullptr; 75 fpPhysChemIO = nullptr; 78 fThreadInitialized = false; 76 fThreadInitialized = false; 79 } 77 } 80 78 81 //-------------------------------------------- 79 //------------------------------------------------------------------------------ 82 80 83 G4DNAChemistryManager::ThreadLocalData::~Threa 81 G4DNAChemistryManager::ThreadLocalData::~ThreadLocalData() 84 { 82 { 85 fpThreadData = nullptr; 83 fpThreadData = nullptr; 86 } 84 } 87 85 88 //-------------------------------------------- 86 //------------------------------------------------------------------------------ 89 87 90 void G4DNAChemistryManager::SetPhysChemIO(std: 88 void G4DNAChemistryManager::SetPhysChemIO(std::unique_ptr<G4VPhysChemIO> pPhysChemIO) 91 { 89 { 92 fpThreadData->fpPhysChemIO = std::move(pPh 90 fpThreadData->fpPhysChemIO = std::move(pPhysChemIO); 93 } 91 } 94 92 95 //-------------------------------------------- 93 //------------------------------------------------------------------------------ 96 94 97 //-------------------------------------------- 95 //------------------------------------------------------------------------------ 98 /* 96 /* 99 * The chemistry manager is shared between thr 97 * The chemistry manager is shared between threads 100 * It is initialized both on the master thread 98 * It is initialized both on the master thread and on the worker threads 101 */ 99 */ 102 //-------------------------------------------- 100 //------------------------------------------------------------------------------ 103 G4DNAChemistryManager::G4DNAChemistryManager() 101 G4DNAChemistryManager::G4DNAChemistryManager() 104 : << 102 : G4UImessenger() 105 fpChemDNADirectory(new G4UIdirectory( << 103 , G4VStateDependent() >> 104 , fpChemDNADirectory(new G4UIdirectory("/chem/")) 106 , fpActivateChem(new G4UIcmdWithABool( 105 , fpActivateChem(new G4UIcmdWithABool("/chem/activate", this)) 107 , fpRunChem(new G4UIcmdWithAnInteger(" 106 , fpRunChem(new G4UIcmdWithAnInteger("/chem/run", this)) 108 , fpSkipReactionsFromChemList(new G4UI 107 , fpSkipReactionsFromChemList(new G4UIcmdWithoutParameter("/chem/skipReactionsFromChemList", this)) 109 , fpScaleForNewTemperature(new G4UIcmd 108 , fpScaleForNewTemperature(new G4UIcmdWithADoubleAndUnit("/chem/temperature", this)) 110 , fpInitChem(new G4UIcmdWithoutParamet 109 , fpInitChem(new G4UIcmdWithoutParameter("/chem/init", this)) 111 , << 110 , fActiveChemistry(false) 112 fpExcitationLevel(nullptr) << 111 , fMasterInitialized(false) >> 112 , fForceThreadReinitialization(false) >> 113 , fpExcitationLevel(nullptr) 113 , fpIonisationLevel(nullptr) 114 , fpIonisationLevel(nullptr) 114 , fpUserChemistryList(nullptr) 115 , fpUserChemistryList(nullptr) >> 116 , fOwnChemistryList(false) >> 117 , fUseInStandalone(false) >> 118 , fPhysicsTableBuilt(false) >> 119 , fSkipReactions(false) >> 120 , fGeometryClosed(false) >> 121 , fVerbose(0) >> 122 , fResetCounterWhenRunEnds(true) 115 { 123 { 116 fpRunChem->SetParameterName("Number of run 124 fpRunChem->SetParameterName("Number of runs to execute for the chemistry module" 117 "(this works w 125 "(this works when used in standalone", true, true); 118 fpRunChem->SetDefaultValue(1); 126 fpRunChem->SetDefaultValue(1); 119 fpScaleForNewTemperature->SetUnitCategory( 127 fpScaleForNewTemperature->SetUnitCategory("Temperature"); 120 } 128 } 121 129 122 //-------------------------------------------- 130 //------------------------------------------------------------------------------ 123 131 124 G4DNAChemistryManager* G4DNAChemistryManager:: 132 G4DNAChemistryManager* G4DNAChemistryManager::Instance() 125 { 133 { 126 if (fgInstance == nullptr) 134 if (fgInstance == nullptr) 127 { 135 { 128 G4AutoLock lock(&chemManExistence); 136 G4AutoLock lock(&chemManExistence); 129 if (fgInstance == nullptr) // MT : dou 137 if (fgInstance == nullptr) // MT : double check at initialisation 130 { 138 { 131 fgInstance = new G4DNAChemistryMan 139 fgInstance = new G4DNAChemistryManager(); 132 } 140 } 133 lock.unlock(); 141 lock.unlock(); 134 } 142 } 135 143 136 // make sure thread local data is initiali 144 // make sure thread local data is initialized for all threads 137 if (fpThreadData == nullptr) 145 if (fpThreadData == nullptr) 138 { 146 { 139 fpThreadData = new ThreadLocalData(); 147 fpThreadData = new ThreadLocalData(); 140 } 148 } 141 149 142 assert(fpThreadData != nullptr); 150 assert(fpThreadData != nullptr); 143 151 144 return fgInstance; 152 return fgInstance; 145 } 153 } 146 154 147 //-------------------------------------------- 155 //------------------------------------------------------------------------------ 148 156 149 G4DNAChemistryManager* G4DNAChemistryManager:: 157 G4DNAChemistryManager* G4DNAChemistryManager::GetInstanceIfExists() 150 { 158 { 151 return fgInstance; 159 return fgInstance; 152 } 160 } 153 161 154 //-------------------------------------------- 162 //------------------------------------------------------------------------------ 155 163 156 G4DNAChemistryManager::~G4DNAChemistryManager( 164 G4DNAChemistryManager::~G4DNAChemistryManager() 157 { 165 { 158 Clear(); 166 Clear(); 159 fgInstance = nullptr; 167 fgInstance = nullptr; 160 } 168 } 161 169 162 //-------------------------------------------- 170 //------------------------------------------------------------------------------ 163 171 164 void G4DNAChemistryManager::Clear() 172 void G4DNAChemistryManager::Clear() 165 { 173 { 166 fpIonisationLevel.reset(); 174 fpIonisationLevel.reset(); 167 fpExcitationLevel.reset(); 175 fpExcitationLevel.reset(); 168 176 169 if (fpUserChemistryList) 177 if (fpUserChemistryList) 170 { 178 { 171 Deregister(*fpUserChemistryList); 179 Deregister(*fpUserChemistryList); 172 } 180 } 173 181 174 fpChemDNADirectory.reset(); 182 fpChemDNADirectory.reset(); 175 fpActivateChem.reset(); 183 fpActivateChem.reset(); 176 fpRunChem.reset(); 184 fpRunChem.reset(); 177 185 178 fpSkipReactionsFromChemList.reset(); 186 fpSkipReactionsFromChemList.reset(); 179 fpInitChem.reset(); 187 fpInitChem.reset(); 180 188 181 if (fpThreadData != nullptr) 189 if (fpThreadData != nullptr) 182 { 190 { 183 delete fpThreadData; 191 delete fpThreadData; 184 fpThreadData = nullptr; 192 fpThreadData = nullptr; 185 } 193 } 186 194 187 G4DNAMolecularReactionTable::DeleteInstanc 195 G4DNAMolecularReactionTable::DeleteInstance(); 188 G4MolecularConfiguration::DeleteManager(); 196 G4MolecularConfiguration::DeleteManager(); 189 G4VMoleculeCounter::DeleteInstance(); 197 G4VMoleculeCounter::DeleteInstance(); 190 } 198 } 191 199 192 //-------------------------------------------- 200 //------------------------------------------------------------------------------ 193 201 194 void G4DNAChemistryManager::DeleteInstance() 202 void G4DNAChemistryManager::DeleteInstance() 195 { 203 { 196 G4AutoLock lock(&chemManExistence); 204 G4AutoLock lock(&chemManExistence); 197 205 198 if (fgInstance != nullptr) 206 if (fgInstance != nullptr) 199 { 207 { 200 G4DNAChemistryManager* pDeleteMe = fgI 208 G4DNAChemistryManager* pDeleteMe = fgInstance; 201 fgInstance = nullptr; 209 fgInstance = nullptr; 202 lock.unlock(); 210 lock.unlock(); 203 delete pDeleteMe; 211 delete pDeleteMe; 204 } 212 } 205 else 213 else 206 { 214 { 207 G4cerr << "G4DNAChemistryManager alrea 215 G4cerr << "G4DNAChemistryManager already deleted" << G4endl; 208 } 216 } 209 lock.unlock(); 217 lock.unlock(); 210 } 218 } 211 219 212 //-------------------------------------------- 220 //------------------------------------------------------------------------------ 213 221 214 G4bool G4DNAChemistryManager::Notify(G4Applica 222 G4bool G4DNAChemistryManager::Notify(G4ApplicationState requestedState) 215 { 223 { 216 if (requestedState == G4State_Quit) 224 if (requestedState == G4State_Quit) 217 { 225 { 218 if (fVerbose != 0) << 226 if (fVerbose) 219 { 227 { 220 G4cout << "G4DNAChemistryManager:: 228 G4cout << "G4DNAChemistryManager::Notify ---> received G4State_Quit" 221 << G4endl; 229 << G4endl; 222 } 230 } 223 Clear(); 231 Clear(); 224 } 232 } 225 else if (requestedState == G4State_GeomClo 233 else if (requestedState == G4State_GeomClosed) 226 { 234 { 227 fGeometryClosed = true; 235 fGeometryClosed = true; 228 } 236 } 229 else if (requestedState == G4State_Idle) 237 else if (requestedState == G4State_Idle) 230 { 238 { 231 InitializeThreadSharedData(); 239 InitializeThreadSharedData(); 232 } 240 } 233 241 234 return true; 242 return true; 235 } 243 } 236 244 237 //-------------------------------------------- 245 //------------------------------------------------------------------------------ 238 246 239 void G4DNAChemistryManager::SetNewValue(G4UIco 247 void G4DNAChemistryManager::SetNewValue(G4UIcommand* pCommand, G4String value) 240 { 248 { 241 if (pCommand == fpActivateChem.get()) 249 if (pCommand == fpActivateChem.get()) 242 { 250 { 243 SetChemistryActivation(G4UIcmdWithABoo 251 SetChemistryActivation(G4UIcmdWithABool::GetNewBoolValue(value)); 244 } 252 } 245 else if (pCommand == fpRunChem.get()) 253 else if (pCommand == fpRunChem.get()) 246 { 254 { 247 int nbExec = value.empty() ? 1 : G4UIc 255 int nbExec = value.empty() ? 1 : G4UIcommand::ConvertToInt(value); 248 for (int i = 0 ; i < nbExec ; ++i) 256 for (int i = 0 ; i < nbExec ; ++i) 249 { 257 { 250 Run(); 258 Run(); 251 } 259 } 252 } 260 } 253 else if (pCommand == fpSkipReactionsFromCh 261 else if (pCommand == fpSkipReactionsFromChemList.get()) 254 { 262 { 255 fSkipReactions = true; 263 fSkipReactions = true; 256 } 264 } 257 else if (pCommand == fpScaleForNewTemperat 265 else if (pCommand == fpScaleForNewTemperature.get()) 258 { 266 { 259 SetGlobalTemperature(fpScaleForNewTemp 267 SetGlobalTemperature(fpScaleForNewTemperature->ConvertToDimensionedDouble(value)); 260 } 268 } 261 else if (pCommand == fpInitChem.get()) 269 else if (pCommand == fpInitChem.get()) 262 { 270 { 263 Initialize(); 271 Initialize(); 264 InitializeThread(); 272 InitializeThread(); 265 } 273 } 266 } 274 } 267 275 268 //-------------------------------------------- 276 //------------------------------------------------------------------------------ 269 277 270 G4String G4DNAChemistryManager::GetCurrentValu 278 G4String G4DNAChemistryManager::GetCurrentValue(G4UIcommand* pCommand) 271 { 279 { 272 if (pCommand == fpActivateChem.get()) 280 if (pCommand == fpActivateChem.get()) 273 { 281 { 274 return G4UIcmdWithABool::ConvertToStri 282 return G4UIcmdWithABool::ConvertToString(fActiveChemistry); 275 } 283 } 276 if (pCommand == fpScaleForNewTemperature.g << 284 else if (pCommand == fpScaleForNewTemperature.get()) 277 { 285 { 278 return fpScaleForNewTemperature->Conve 286 return fpScaleForNewTemperature->ConvertToStringWithBestUnit(G4MolecularConfiguration::GetGlobalTemperature()); 279 } 287 } 280 if (pCommand == fpSkipReactionsFromChemLis << 288 else if (pCommand == fpSkipReactionsFromChemList.get()) 281 { 289 { 282 return G4UIcmdWithABool::ConvertToStri 290 return G4UIcmdWithABool::ConvertToString(fSkipReactions); 283 } 291 } 284 292 285 return ""; 293 return ""; 286 } 294 } 287 295 288 //-------------------------------------------- 296 //------------------------------------------------------------------------------ 289 297 290 void G4DNAChemistryManager::InitializeThreadSh 298 void G4DNAChemistryManager::InitializeThreadSharedData() 291 { 299 { 292 if (!G4Threading::IsMasterThread()) 300 if (!G4Threading::IsMasterThread()) 293 { 301 { 294 return; 302 return; 295 } 303 } 296 304 297 G4MoleculeTable::Instance()->PrepareMolecu 305 G4MoleculeTable::Instance()->PrepareMolecularConfiguration(); 298 G4MoleculeTable::Instance()->Finalize(); 306 G4MoleculeTable::Instance()->Finalize(); 299 } 307 } 300 308 301 //-------------------------------------------- 309 //------------------------------------------------------------------------------ 302 void G4DNAChemistryManager::Run() 310 void G4DNAChemistryManager::Run() 303 { 311 { 304 if (!fActiveChemistry) 312 if (!fActiveChemistry) 305 { 313 { 306 return; 314 return; 307 } 315 } 308 316 309 InitializeThread(); 317 InitializeThread(); 310 318 311 if (!fMasterInitialized) 319 if (!fMasterInitialized) 312 { 320 { 313 G4ExceptionDescription description; 321 G4ExceptionDescription description; 314 description << "Global components were 322 description << "Global components were not initialized."; 315 G4Exception("G4DNAChemistryManager::Ru 323 G4Exception("G4DNAChemistryManager::Run", "MASTER_INIT", FatalException, 316 description); 324 description); 317 } 325 } 318 326 319 if (!fpThreadData->fThreadInitialized) 327 if (!fpThreadData->fThreadInitialized) 320 { 328 { 321 G4ExceptionDescription description; 329 G4ExceptionDescription description; 322 description << "Thread local component 330 description << "Thread local components were not initialized."; 323 G4Exception("G4DNAChemistryManager::Ru 331 G4Exception("G4DNAChemistryManager::Run", "THREAD_INIT", FatalException, 324 description); 332 description); 325 } 333 } 326 334 327 G4MoleculeTable::Instance()->Finalize(); 335 G4MoleculeTable::Instance()->Finalize(); 328 G4Scheduler::Instance()->Process(); 336 G4Scheduler::Instance()->Process(); 329 if (fResetCounterWhenRunEnds) 337 if (fResetCounterWhenRunEnds) 330 { 338 { 331 G4VMoleculeCounter::Instance()->ResetC 339 G4VMoleculeCounter::Instance()->ResetCounter(); 332 } 340 } 333 CloseFile(); 341 CloseFile(); 334 } 342 } 335 343 336 //-------------------------------------------- 344 //------------------------------------------------------------------------------ 337 345 338 void G4DNAChemistryManager::UseAsStandalone(G4 346 void G4DNAChemistryManager::UseAsStandalone(G4bool flag) 339 { 347 { 340 fUseInStandalone = flag; 348 fUseInStandalone = flag; 341 } 349 } 342 350 343 //-------------------------------------------- 351 //------------------------------------------------------------------------------ 344 352 345 void G4DNAChemistryManager::SetGun(G4ITGun* pC 353 void G4DNAChemistryManager::SetGun(G4ITGun* pChemGun) 346 { 354 { 347 G4Scheduler::Instance()->SetGun(pChemGun); 355 G4Scheduler::Instance()->SetGun(pChemGun); 348 } 356 } 349 357 350 //-------------------------------------------- 358 //------------------------------------------------------------------------------ 351 359 352 void G4DNAChemistryManager::Initialize() 360 void G4DNAChemistryManager::Initialize() 353 { 361 { 354 //======================================== 362 //=========================================================================== 355 // MT MODE 363 // MT MODE 356 //======================================== 364 //=========================================================================== 357 if (G4Threading::IsMultithreadedApplicatio 365 if (G4Threading::IsMultithreadedApplication()) 358 { 366 { 359 //==================================== 367 //========================================================================== 360 // ON WORKER THREAD 368 // ON WORKER THREAD 361 //==================================== 369 //========================================================================== 362 if (G4Threading::IsWorkerThread()) 370 if (G4Threading::IsWorkerThread()) 363 { 371 { 364 InitializeThread(); // Will create 372 InitializeThread(); // Will create and initialize G4Scheduler 365 return; 373 return; 366 } 374 } 367 //==================================== 375 //========================================================================== 368 // ON MASTER THREAD 376 // ON MASTER THREAD 369 //==================================== 377 //========================================================================== 370 << 378 else 371 InitializeMaster(); << 379 { 372 InitializeThreadSharedData(); << 380 InitializeMaster(); 373 return; << 381 InitializeThreadSharedData(); >> 382 return; >> 383 } 374 } 384 } 375 //======================================== 385 //=========================================================================== 376 // IS NOT IN MT MODE 386 // IS NOT IN MT MODE 377 //======================================== 387 //=========================================================================== 378 << 388 else 379 InitializeMaster(); << 389 { 380 InitializeThreadSharedData(); << 390 InitializeMaster(); 381 // In this case: InitializeThread is calle << 391 InitializeThreadSharedData(); 382 return; << 392 // In this case: InitializeThread is called when Run() is called >> 393 return; >> 394 } 383 } 395 } 384 396 385 //-------------------------------------------- 397 //------------------------------------------------------------------------------ 386 398 387 void G4DNAChemistryManager::InitializeMaster() 399 void G4DNAChemistryManager::InitializeMaster() 388 { 400 { 389 if (fMasterInitialized) 401 if (fMasterInitialized) 390 { 402 { 391 return; 403 return; 392 } 404 } 393 405 394 if (fVerbose != 0) << 406 if (fVerbose) 395 { 407 { 396 G4cout << "G4DNAChemistryManager::Init 408 G4cout << "G4DNAChemistryManager::InitializeMaster() is called" << G4endl; 397 } 409 } 398 410 399 411 400 if (fpUserChemistryList == nullptr) 412 if (fpUserChemistryList == nullptr) 401 { 413 { 402 G4ExceptionDescription description; 414 G4ExceptionDescription description; 403 description << "No user chemistry list 415 description << "No user chemistry list has been provided."; 404 G4Exception("G4DNAChemistryManager::In 416 G4Exception("G4DNAChemistryManager::InitializeMaster", "NO_CHEM_LIST", 405 FatalException, descriptio 417 FatalException, description); 406 }else << 407 { << 408 fpUserChemistryList->ConstructDissociati << 409 if (!fSkipReactions) << 410 { << 411 fpUserChemistryList->ConstructReacti << 412 } << 413 else << 414 { << 415 G4DNAMolecularReactionTable::GetReac << 416 } << 417 } 418 } 418 419 419 G4Scheduler::Instance(); 420 G4Scheduler::Instance(); 420 // creates a concrete object of the schedu 421 // creates a concrete object of the scheduler >> 422 >> 423 >> 424 fpUserChemistryList->ConstructDissociationChannels(); >> 425 if (!fSkipReactions) >> 426 { >> 427 fpUserChemistryList->ConstructReactionTable(G4DNAMolecularReactionTable::GetReactionTable()); >> 428 } >> 429 else >> 430 { >> 431 G4DNAMolecularReactionTable::GetReactionTable(); // init pointer >> 432 } 421 fMasterInitialized = true; 433 fMasterInitialized = true; 422 } 434 } 423 435 424 //-------------------------------------------- 436 //------------------------------------------------------------------------------ 425 437 426 void G4DNAChemistryManager::HandleStandaloneIn 438 void G4DNAChemistryManager::HandleStandaloneInitialization() 427 { 439 { 428 if (!fUseInStandalone || fPhysicsTableBuil 440 if (!fUseInStandalone || fPhysicsTableBuilt) 429 { 441 { 430 return; 442 return; 431 } 443 } 432 444 433 if (fVerbose != 0) << 445 if (fVerbose) 434 { 446 { 435 G4cout << "G4DNAChemistryManager: Buil 447 G4cout << "G4DNAChemistryManager: Build the physics tables for " 436 "molecule definition only." 448 "molecule definition only." 437 << G4endl; 449 << G4endl; 438 } 450 } 439 451 440 fpUserChemistryList->BuildPhysicsTable(); 452 fpUserChemistryList->BuildPhysicsTable(); 441 453 442 if (!fGeometryClosed) 454 if (!fGeometryClosed) 443 { 455 { 444 if (fVerbose != 0) << 456 if (fVerbose) 445 { 457 { 446 G4cout << "G4DNAChemistryManager: 458 G4cout << "G4DNAChemistryManager: Close geometry" << G4endl; 447 } 459 } 448 460 449 G4GeometryManager* pGeomManager = G4Ge 461 G4GeometryManager* pGeomManager = G4GeometryManager::GetInstance(); 450 pGeomManager->OpenGeometry(); 462 pGeomManager->OpenGeometry(); 451 pGeomManager->CloseGeometry(true, true 463 pGeomManager->CloseGeometry(true, true); 452 fGeometryClosed = true; 464 fGeometryClosed = true; 453 } 465 } 454 466 455 fPhysicsTableBuilt = true; 467 fPhysicsTableBuilt = true; 456 } 468 } 457 469 458 //-------------------------------------------- 470 //------------------------------------------------------------------------------ 459 471 460 void G4DNAChemistryManager::InitializeThread() 472 void G4DNAChemistryManager::InitializeThread() 461 { 473 { 462 if (fpThreadData->fThreadInitialized && !f 474 if (fpThreadData->fThreadInitialized && !fForceThreadReinitialization) 463 { 475 { 464 return; 476 return; 465 } 477 } 466 478 467 if (fpUserChemistryList == nullptr) 479 if (fpUserChemistryList == nullptr) 468 { 480 { 469 G4ExceptionDescription description; 481 G4ExceptionDescription description; 470 description << "No user chemistry list 482 description << "No user chemistry list has been provided."; 471 G4Exception("G4DNAChemistryManager::In 483 G4Exception("G4DNAChemistryManager::InitializeThread", "NO_CHEM_LIST", 472 FatalException, descriptio 484 FatalException, description); 473 }else << 474 { << 475 HandleStandaloneInitialization();// To << 476 fpUserChemistryList->ConstructTimeStep << 477 } 485 } 478 486 479 if (fVerbose != 0) << 487 if (fVerbose) 480 { 488 { 481 G4cout << "G4DNAChemistryManager::Init 489 G4cout << "G4DNAChemistryManager::InitializeThread() is called" 482 << G4endl; 490 << G4endl; 483 } 491 } 484 492 >> 493 HandleStandaloneInitialization(); >> 494 >> 495 fpUserChemistryList->ConstructTimeStepModel(G4DNAMolecularReactionTable::GetReactionTable()); 485 G4Scheduler::Instance()->Initialize(); 496 G4Scheduler::Instance()->Initialize(); 486 497 487 fpThreadData->fThreadInitialized = true; 498 fpThreadData->fThreadInitialized = true; 488 499 489 G4VMoleculeCounter::InitializeInstance(); 500 G4VMoleculeCounter::InitializeInstance(); 490 501 491 InitializeFile(); 502 InitializeFile(); 492 } 503 } 493 504 494 //-------------------------------------------- 505 //------------------------------------------------------------------------------ 495 506 496 void G4DNAChemistryManager::InitializeFile() 507 void G4DNAChemistryManager::InitializeFile() 497 { 508 { 498 if (fVerbose != 0) << 509 if (fVerbose) 499 { 510 { 500 G4cout << "G4DNAChemistryManager::Init 511 G4cout << "G4DNAChemistryManager::InitializeFile() is called" 501 << G4endl; 512 << G4endl; 502 } 513 } 503 514 504 if (fpThreadData->fpPhysChemIO) 515 if (fpThreadData->fpPhysChemIO) 505 { 516 { 506 fpThreadData->fpPhysChemIO->Initialize 517 fpThreadData->fpPhysChemIO->InitializeFile(); 507 } 518 } 508 } 519 } 509 520 510 //-------------------------------------------- 521 //------------------------------------------------------------------------------ 511 522 512 G4bool G4DNAChemistryManager::IsActivated() 523 G4bool G4DNAChemistryManager::IsActivated() 513 { 524 { 514 return fgInstance != nullptr ? fgInstance- << 525 return fgInstance ? fgInstance->IsChemistryActivated() : false; 515 } 526 } 516 527 517 //-------------------------------------------- 528 //------------------------------------------------------------------------------ 518 529 519 G4bool G4DNAChemistryManager::IsChemistryActiv 530 G4bool G4DNAChemistryManager::IsChemistryActivated() 520 { 531 { 521 return fActiveChemistry; 532 return fActiveChemistry; 522 } 533 } 523 534 524 //-------------------------------------------- 535 //------------------------------------------------------------------------------ 525 536 526 void G4DNAChemistryManager::SetChemistryActiva 537 void G4DNAChemistryManager::SetChemistryActivation(G4bool flag) 527 { 538 { 528 fActiveChemistry = flag; 539 fActiveChemistry = flag; 529 } 540 } 530 541 531 //-------------------------------------------- 542 //------------------------------------------------------------------------------ 532 543 533 void G4DNAChemistryManager::WriteInto(const G4 544 void G4DNAChemistryManager::WriteInto(const G4String& output, 534 std::ios 545 std::ios_base::openmode mode) 535 { 546 { 536 if (fVerbose != 0) << 547 if (fVerbose) 537 { 548 { 538 G4cout << "G4DNAChemistryManager: Writ 549 G4cout << "G4DNAChemistryManager: Write chemical stage into " 539 << output.data() << G4endl; 550 << output.data() << G4endl; 540 } 551 } 541 552 542 if (!fpThreadData->fpPhysChemIO) 553 if (!fpThreadData->fpPhysChemIO) 543 { 554 { 544 fpThreadData->fpPhysChemIO = std::make << 555 fpThreadData->fpPhysChemIO.reset(new G4PhysChemIO::FormattedText()); 545 } 556 } 546 557 547 fpThreadData->fpPhysChemIO->WriteInto(outp 558 fpThreadData->fpPhysChemIO->WriteInto(output, mode); 548 559 549 } 560 } 550 561 551 //-------------------------------------------- 562 //------------------------------------------------------------------------------ 552 563 553 void G4DNAChemistryManager::AddEmptyLineInOutp 564 void G4DNAChemistryManager::AddEmptyLineInOutputFile() 554 { 565 { 555 if (fpThreadData->fpPhysChemIO) 566 if (fpThreadData->fpPhysChemIO) 556 { 567 { 557 fpThreadData->fpPhysChemIO->AddEmptyLi 568 fpThreadData->fpPhysChemIO->AddEmptyLineInOutputFile(); 558 } 569 } 559 } 570 } 560 571 561 //-------------------------------------------- 572 //------------------------------------------------------------------------------ 562 573 563 void G4DNAChemistryManager::CloseFile() 574 void G4DNAChemistryManager::CloseFile() 564 { 575 { 565 if (fpThreadData->fpPhysChemIO) 576 if (fpThreadData->fpPhysChemIO) 566 { 577 { 567 fpThreadData->fpPhysChemIO->CloseFile( 578 fpThreadData->fpPhysChemIO->CloseFile(); 568 } 579 } 569 } 580 } 570 581 571 //-------------------------------------------- 582 //------------------------------------------------------------------------------ 572 583 573 G4DNAWaterExcitationStructure* G4DNAChemistryM 584 G4DNAWaterExcitationStructure* G4DNAChemistryManager::GetExcitationLevel() 574 { 585 { 575 if (!fpExcitationLevel) 586 if (!fpExcitationLevel) 576 { 587 { 577 fpExcitationLevel = std::make_unique<G << 588 fpExcitationLevel.reset(new G4DNAWaterExcitationStructure); 578 } 589 } 579 return fpExcitationLevel.get(); 590 return fpExcitationLevel.get(); 580 } 591 } 581 592 582 //-------------------------------------------- 593 //------------------------------------------------------------------------------ 583 594 584 G4DNAWaterIonisationStructure* G4DNAChemistryM 595 G4DNAWaterIonisationStructure* G4DNAChemistryManager::GetIonisationLevel() 585 { 596 { 586 if (!fpIonisationLevel) 597 if (!fpIonisationLevel) 587 { 598 { 588 fpIonisationLevel = std::make_unique<G << 599 fpIonisationLevel.reset(new G4DNAWaterIonisationStructure); 589 } 600 } 590 return fpIonisationLevel.get(); 601 return fpIonisationLevel.get(); 591 } 602 } 592 603 593 //-------------------------------------------- 604 //------------------------------------------------------------------------------ 594 605 595 void G4DNAChemistryManager::CreateWaterMolecul 606 void G4DNAChemistryManager::CreateWaterMolecule(ElectronicModification modification, 596 607 G4int electronicLevel, 597 608 const G4Track* pIncomingTrack) 598 { 609 { 599 if (fpThreadData->fpPhysChemIO) 610 if (fpThreadData->fpPhysChemIO) 600 { 611 { 601 G4double energy = -1.; 612 G4double energy = -1.; 602 613 603 switch (modification) 614 switch (modification) 604 { 615 { 605 case eDissociativeAttachment: 616 case eDissociativeAttachment: 606 energy = 0.; 617 energy = 0.; 607 break; 618 break; 608 case eExcitedMolecule: 619 case eExcitedMolecule: 609 energy = GetExcitationLevel()->Exc 620 energy = GetExcitationLevel()->ExcitationEnergy(electronicLevel); 610 break; 621 break; 611 case eIonizedMolecule: 622 case eIonizedMolecule: 612 energy = GetIonisationLevel()->Ion 623 energy = GetIonisationLevel()->IonisationEnergy(electronicLevel); 613 break; 624 break; 614 } 625 } 615 626 616 fpThreadData->fpPhysChemIO->CreateWate 627 fpThreadData->fpPhysChemIO->CreateWaterMolecule(modification, 617 628 4 - electronicLevel, 618 629 energy, 619 630 pIncomingTrack); 620 } 631 } 621 632 622 if (fActiveChemistry) 633 if (fActiveChemistry) 623 { 634 { 624 auto pH2OMolecule = new G4Molecule(G4 << 635 G4Molecule* pH2OMolecule = new G4Molecule(G4H2O::Definition()); 625 636 626 switch (modification) 637 switch (modification) 627 { 638 { 628 case eDissociativeAttachment: 639 case eDissociativeAttachment: 629 pH2OMolecule->AddElectron(5, 1); 640 pH2OMolecule->AddElectron(5, 1); 630 break; 641 break; 631 case eExcitedMolecule: 642 case eExcitedMolecule: 632 pH2OMolecule->ExciteMolecule(4 - e 643 pH2OMolecule->ExciteMolecule(4 - electronicLevel); 633 break; 644 break; 634 case eIonizedMolecule: 645 case eIonizedMolecule: 635 pH2OMolecule->IonizeMolecule(4 - e 646 pH2OMolecule->IonizeMolecule(4 - electronicLevel); 636 break; 647 break; 637 } 648 } 638 649 639 G4double delayedTime = 0.; << 650 G4Track* pH2OTrack = pH2OMolecule->BuildTrack(picosecond, 640 if(pIncomingTrack->GetUserInformation( << 641 { << 642 auto pPulseInfo = dynamic_cast<G4V << 643 (pIncomingTrack->GetUserInformat << 644 if(pPulseInfo != nullptr) << 645 { << 646 delayedTime = pPulseInfo->GetD << 647 } << 648 } << 649 << 650 G4Track* pH2OTrack = pH2OMolecule->Bui << 651 651 pIncomingTrack->GetPosition()); 652 652 653 pH2OTrack->SetParentID(pIncomingTrack- 653 pH2OTrack->SetParentID(pIncomingTrack->GetTrackID()); 654 pH2OTrack->SetTrackStatus(fStopButAliv 654 pH2OTrack->SetTrackStatus(fStopButAlive); 655 pH2OTrack->SetKineticEnergy(0.); 655 pH2OTrack->SetKineticEnergy(0.); 656 PushTrack(pH2OTrack); 656 PushTrack(pH2OTrack); 657 } 657 } 658 } 658 } 659 659 660 //-------------------------------------------- 660 //------------------------------------------------------------------------------ 661 // pFinalPosition is optional 661 // pFinalPosition is optional 662 void G4DNAChemistryManager::CreateSolvatedElec 662 void G4DNAChemistryManager::CreateSolvatedElectron(const G4Track* pIncomingTrack, 663 663 G4ThreeVector* pFinalPosition) 664 { 664 { 665 if (fpThreadData->fpPhysChemIO) 665 if (fpThreadData->fpPhysChemIO) 666 { 666 { 667 fpThreadData->fpPhysChemIO->CreateSolv 667 fpThreadData->fpPhysChemIO->CreateSolvatedElectron(pIncomingTrack, 668 668 pFinalPosition); 669 } 669 } 670 670 671 if (fActiveChemistry) 671 if (fActiveChemistry) 672 { 672 { 673 G4double delayedTime = 0.; << 673 PushMolecule(std::unique_ptr<G4Molecule>(new G4Molecule(G4Electron_aq::Definition())), 674 if(pIncomingTrack->GetUserInformation( << 674 picosecond, 675 { << 675 pFinalPosition ? *pFinalPosition : pIncomingTrack->GetPosition(), 676 auto pPulseInfo = dynamic_cast<G4V << 677 (pIncomingTrack->GetUserInformat << 678 if(pPulseInfo != nullptr) << 679 { << 680 delayedTime = pPulseInfo->GetD << 681 } << 682 } << 683 << 684 PushMolecule(std::make_unique<G4Molecu << 685 picosecond + delayedTime, << 686 pFinalPosition != nullptr << 687 pIncomingTrack->GetTrackI 676 pIncomingTrack->GetTrackID()); 688 } 677 } 689 } 678 } 690 679 691 //-------------------------------------------- 680 //------------------------------------------------------------------------------ 692 681 693 void G4DNAChemistryManager::PushMolecule(std:: 682 void G4DNAChemistryManager::PushMolecule(std::unique_ptr<G4Molecule> pMolecule, 694 doubl 683 double time, 695 const 684 const G4ThreeVector& position, 696 int p 685 int parentID) 697 { 686 { 698 assert(fActiveChemistry 687 assert(fActiveChemistry 699 && "To inject chemical species, the 688 && "To inject chemical species, the chemistry must be activated. " 700 "Check chemistry activation befo 689 "Check chemistry activation before injecting species."); 701 G4Track* pTrack = pMolecule->BuildTrack(ti 690 G4Track* pTrack = pMolecule->BuildTrack(time, position); 702 pTrack->SetTrackStatus(fAlive); 691 pTrack->SetTrackStatus(fAlive); 703 pTrack->SetParentID(parentID); 692 pTrack->SetParentID(parentID); 704 pMolecule.release(); 693 pMolecule.release(); 705 PushTrack(pTrack); 694 PushTrack(pTrack); 706 } 695 } 707 696 708 //-------------------------------------------- 697 //------------------------------------------------------------------------------ 709 698 710 void G4DNAChemistryManager::SetGlobalTemperatu 699 void G4DNAChemistryManager::SetGlobalTemperature(G4double temp_K) 711 { 700 { 712 G4MolecularConfiguration::SetGlobalTempera 701 G4MolecularConfiguration::SetGlobalTemperature(temp_K); 713 G4DNAMolecularReactionTable::Instance()->S 702 G4DNAMolecularReactionTable::Instance()->ScaleReactionRateForNewTemperature(temp_K); 714 } 703 } 715 704 716 //-------------------------------------------- 705 //------------------------------------------------------------------------------ 717 // [[deprecated]] : chemistry list should neve 706 // [[deprecated]] : chemistry list should never be nullptr 718 void G4DNAChemistryManager::SetChemistryList(G 707 void G4DNAChemistryManager::SetChemistryList(G4VUserChemistryList* pChemistryList) 719 { 708 { 720 fpUserChemistryList.reset(pChemistryList); 709 fpUserChemistryList.reset(pChemistryList); 721 fOwnChemistryList = false; 710 fOwnChemistryList = false; 722 SetChemistryActivation(true); 711 SetChemistryActivation(true); 723 } 712 } 724 713 725 void G4DNAChemistryManager::SetChemistryList(G 714 void G4DNAChemistryManager::SetChemistryList(G4VUserChemistryList& chemistryList) 726 { 715 { 727 fpUserChemistryList.reset(&chemistryList); 716 fpUserChemistryList.reset(&chemistryList); 728 fOwnChemistryList = false; 717 fOwnChemistryList = false; 729 SetChemistryActivation(true); 718 SetChemistryActivation(true); 730 } 719 } 731 720 732 void G4DNAChemistryManager::SetChemistryList(s 721 void G4DNAChemistryManager::SetChemistryList(std::unique_ptr<G4VUserChemistryList> pChemistryList) 733 { 722 { 734 fpUserChemistryList = std::move(pChemistry 723 fpUserChemistryList = std::move(pChemistryList); 735 fOwnChemistryList = true; 724 fOwnChemistryList = true; 736 SetChemistryActivation(true); 725 SetChemistryActivation(true); 737 } 726 } 738 727 739 //-------------------------------------------- 728 //------------------------------------------------------------------------------ 740 729 741 void G4DNAChemistryManager::Deregister(G4VUser 730 void G4DNAChemistryManager::Deregister(G4VUserChemistryList& chemistryList) 742 { 731 { 743 if (fpUserChemistryList.get() == &chemistr 732 if (fpUserChemistryList.get() == &chemistryList) 744 { 733 { 745 if (!fpUserChemistryList->IsPhysicsCon 734 if (!fpUserChemistryList->IsPhysicsConstructor() || fOwnChemistryList) 746 { 735 { 747 fpUserChemistryList.reset(); 736 fpUserChemistryList.reset(); 748 } 737 } 749 738 750 fpUserChemistryList.release(); 739 fpUserChemistryList.release(); 751 } 740 } 752 } 741 } 753 742 754 //-------------------------------------------- 743 //------------------------------------------------------------------------------ 755 744 756 void G4DNAChemistryManager::PushTrack(G4Track* 745 void G4DNAChemistryManager::PushTrack(G4Track* pTrack) 757 { 746 { 758 G4ITTrackHolder::Instance()->Push(pTrack); 747 G4ITTrackHolder::Instance()->Push(pTrack); 759 } 748 } 760 749 761 //-------------------------------------------- 750 //------------------------------------------------------------------------------ 762 751 763 void G4DNAChemistryManager::SetVerbose(G4int v 752 void G4DNAChemistryManager::SetVerbose(G4int verbose) 764 { 753 { 765 fVerbose = verbose; 754 fVerbose = verbose; 766 } 755 } 767 756 768 //-------------------------------------------- 757 //------------------------------------------------------------------------------ 769 758 770 G4bool G4DNAChemistryManager::IsCounterResetWh 759 G4bool G4DNAChemistryManager::IsCounterResetWhenRunEnds() const 771 { 760 { 772 return fResetCounterWhenRunEnds; 761 return fResetCounterWhenRunEnds; 773 } 762 } 774 763 775 //-------------------------------------------- 764 //------------------------------------------------------------------------------ 776 765 777 void G4DNAChemistryManager::ResetCounterWhenRu 766 void G4DNAChemistryManager::ResetCounterWhenRunEnds(G4bool resetCounterWhenRunEnds) 778 { 767 { 779 fResetCounterWhenRunEnds = resetCounterWhe 768 fResetCounterWhenRunEnds = resetCounterWhenRunEnds; 780 } 769 } 781 770 782 //-------------------------------------------- 771 //------------------------------------------------------------------------------ 783 772 784 void G4DNAChemistryManager::ForceRebuildingPhy 773 void G4DNAChemistryManager::ForceRebuildingPhysicsTable() 785 { 774 { 786 fPhysicsTableBuilt = false; 775 fPhysicsTableBuilt = false; 787 } 776 } 788 777 789 //-------------------------------------------- 778 //------------------------------------------------------------------------------ 790 779 791 void G4DNAChemistryManager::ForceMasterReiniti 780 void G4DNAChemistryManager::ForceMasterReinitialization() 792 { 781 { 793 fMasterInitialized = false; 782 fMasterInitialized = false; 794 InitializeMaster(); 783 InitializeMaster(); 795 } 784 } 796 785 797 //-------------------------------------------- 786 //------------------------------------------------------------------------------ 798 787 799 void G4DNAChemistryManager::ForceThreadReiniti 788 void G4DNAChemistryManager::ForceThreadReinitialization() 800 { 789 { 801 fForceThreadReinitialization = true; 790 fForceThreadReinitialization = true; 802 } 791 } 803 792 804 //-------------------------------------------- 793 //------------------------------------------------------------------------------ 805 794 806 void G4DNAChemistryManager::TagThreadForReinit 795 void G4DNAChemistryManager::TagThreadForReinitialization() 807 { 796 { 808 fpThreadData->fThreadInitialized = false; 797 fpThreadData->fThreadInitialized = false; 809 } 798 } 810 799