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 * G4PhysChemIO.cc 27 * G4PhysChemIO.cc 28 * 28 * 29 * Created on: 3 févr. 2017 29 * Created on: 3 févr. 2017 30 * Author: matkara 30 * Author: matkara 31 */ 31 */ 32 32 33 #include "G4PhysChemIO.hh" 33 #include "G4PhysChemIO.hh" 34 #include "G4SystemOfUnits.hh" 34 #include "G4SystemOfUnits.hh" 35 #include "G4Track.hh" 35 #include "G4Track.hh" 36 #include "G4VAnalysisManager.hh" 36 #include "G4VAnalysisManager.hh" 37 37 38 using namespace std; 38 using namespace std; 39 39 40 //-------------------------------------------- 40 //------------------------------------------------------------------------------ 41 41 42 namespace G4PhysChemIO{ 42 namespace G4PhysChemIO{ 43 43 44 FormattedText::FormattedText(){ 44 FormattedText::FormattedText(){ 45 fRunID = -1; 45 fRunID = -1; 46 fEventID = -1; 46 fEventID = -1; 47 fFileInitialized = false; 47 fFileInitialized = false; 48 } 48 } 49 49 50 //-------------------------------------------- 50 //------------------------------------------------------------------------------ 51 51 52 FormattedText::~FormattedText(){ 52 FormattedText::~FormattedText(){ 53 CloseFile(); 53 CloseFile(); 54 } 54 } 55 55 56 //-------------------------------------------- 56 //------------------------------------------------------------------------------ 57 57 58 void FormattedText::InitializeFile() 58 void FormattedText::InitializeFile() 59 { 59 { 60 if(fFileInitialized) return; 60 if(fFileInitialized) return; 61 61 62 fOfstream << std::setprecision(6) << std::sc 62 fOfstream << std::setprecision(6) << std::scientific; 63 fOfstream << setw(11) << left << "#Parent ID 63 fOfstream << setw(11) << left << "#Parent ID" << setw(10) << "Molecule" 64 << setw(14) << "Elec Modif" << setw(13) << " 64 << setw(14) << "Elec Modif" << setw(13) << "Energy (eV)" 65 << setw(22) << "X pos of parent [nm]" << set 65 << setw(22) << "X pos of parent [nm]" << setw(22) 66 << "Y pos of parent [nm]" << setw(22) << "Z 66 << "Y pos of parent [nm]" << setw(22) << "Z pos of parent [nm]" 67 << setw(14) << "X pos [nm]" << setw(14) << " 67 << setw(14) << "X pos [nm]" << setw(14) << "Y pos [nm]" 68 << setw(14) << "Z pos [nm]" << G4endl<< setw 68 << setw(14) << "Z pos [nm]" << G4endl<< setw(21) << "#" 69 << setw(13) << "1)io/ex=0/1" 69 << setw(13) << "1)io/ex=0/1" 70 << G4endl 70 << G4endl 71 << setw(21) << "#" 71 << setw(21) << "#" 72 << setw(13) << "2)level=0...5" 72 << setw(13) << "2)level=0...5" 73 << G4endl; 73 << G4endl; 74 74 75 fFileInitialized = true; 75 fFileInitialized = true; 76 } 76 } 77 77 78 //-------------------------------------------- 78 //------------------------------------------------------------------------------ 79 79 80 void FormattedText::WriteInto(const G4String& 80 void FormattedText::WriteInto(const G4String& output, 81 ios_base::openmo 81 ios_base::openmode mode) 82 { 82 { 83 fOfstream.open(output.data(), mode); 83 fOfstream.open(output.data(), mode); 84 fFileInitialized = false; 84 fFileInitialized = false; 85 } 85 } 86 86 87 //-------------------------------------------- 87 //------------------------------------------------------------------------------ 88 88 89 void FormattedText::AddEmptyLineInOutputFile() 89 void FormattedText::AddEmptyLineInOutputFile() 90 { 90 { 91 if(fFileInitialized) fOfstream << G4endl; 91 if(fFileInitialized) fOfstream << G4endl; 92 } 92 } 93 93 94 //-------------------------------------------- 94 //------------------------------------------------------------------------------ 95 95 96 void FormattedText::CloseFile() 96 void FormattedText::CloseFile() 97 { 97 { 98 if (!fFileInitialized) return; 98 if (!fFileInitialized) return; 99 99 100 if (fOfstream.is_open()) 100 if (fOfstream.is_open()) 101 { 101 { 102 fOfstream.close(); 102 fOfstream.close(); 103 } 103 } 104 } 104 } 105 105 106 //-------------------------------------------- 106 //------------------------------------------------------------------------------ 107 107 108 void FormattedText::CreateWaterMolecule(G4int 108 void FormattedText::CreateWaterMolecule(G4int modification, 109 G4int 109 G4int electronicLevel, 110 G4doub 110 G4double energy, 111 const 111 const G4Track* theIncomingTrack) 112 { 112 { 113 if(!fFileInitialized) InitializeFile(); 113 if(!fFileInitialized) InitializeFile(); 114 114 115 fOfstream << setw(11) << left << theIncoming 115 fOfstream << setw(11) << left << theIncomingTrack->GetTrackID() 116 << setw(10) << "H2O" << left << modification 116 << setw(10) << "H2O" << left << modification << internal 117 << ":" << right << electronicLevel << left < 117 << ":" << right << electronicLevel << left << setw(11) << "" 118 << std::setprecision(2) << std::fixed << set 118 << std::setprecision(2) << std::fixed << setw(13) 119 << energy / eV << std::setprecision(6) << st 119 << energy / eV << std::setprecision(6) << std::scientific 120 << setw(22) 120 << setw(22) 121 << (theIncomingTrack->GetPosition().x()) / n 121 << (theIncomingTrack->GetPosition().x()) / nanometer 122 << setw(22) 122 << setw(22) 123 << (theIncomingTrack->GetPosition().y()) / n 123 << (theIncomingTrack->GetPosition().y()) / nanometer 124 << setw(22) 124 << setw(22) 125 << (theIncomingTrack->GetPosition().z()) / n 125 << (theIncomingTrack->GetPosition().z()) / nanometer 126 << G4endl; 126 << G4endl; 127 } 127 } 128 128 129 //-------------------------------------------- 129 //------------------------------------------------------------------------------ 130 130 131 void FormattedText::CreateSolvatedElectron(con 131 void FormattedText::CreateSolvatedElectron(const G4Track* theIncomingTrack, 132 G4T 132 G4ThreeVector* finalPosition) 133 { 133 { 134 if(!fFileInitialized) InitializeFile(); 134 if(!fFileInitialized) InitializeFile(); 135 135 136 fOfstream << setw(11) << theIncomingTrack->G 136 fOfstream << setw(11) << theIncomingTrack->GetTrackID() << setw(10) 137 << "e_aq" << setw(14) << -1 << std::setpreci 137 << "e_aq" << setw(14) << -1 << std::setprecision(2) 138 << std::fixed << setw(13) 138 << std::fixed << setw(13) 139 << theIncomingTrack->GetKineticEnergy() / eV 139 << theIncomingTrack->GetKineticEnergy() / eV 140 << std::setprecision(6) << std::scientific < 140 << std::setprecision(6) << std::scientific << setw(22) 141 << (theIncomingTrack->GetPosition().x()) / n 141 << (theIncomingTrack->GetPosition().x()) / nanometer 142 << setw(22) 142 << setw(22) 143 << (theIncomingTrack->GetPosition().y()) / n 143 << (theIncomingTrack->GetPosition().y()) / nanometer 144 << setw(22) 144 << setw(22) 145 << (theIncomingTrack->GetPosition().z()) / n 145 << (theIncomingTrack->GetPosition().z()) / nanometer; 146 146 147 if (finalPosition != nullptr) 147 if (finalPosition != nullptr) 148 { 148 { 149 fOfstream << setw(14) << (finalPosition->x 149 fOfstream << setw(14) << (finalPosition->x()) / nanometer << setw(14) 150 << (finalPosition->y()) / nanometer << set 150 << (finalPosition->y()) / nanometer << setw(14) 151 << (finalPosition->z()) / nanometer; 151 << (finalPosition->z()) / nanometer; 152 } 152 } 153 153 154 fOfstream << G4endl; 154 fOfstream << G4endl; 155 } 155 } 156 156 157 //-------------------------------------------- 157 //------------------------------------------------------------------------------ 158 // 158 // 159 // Using G4analysis 159 // Using G4analysis 160 // 160 // 161 161 162 G4Analysis::G4Analysis(G4VAnalysisManager* ana 162 G4Analysis::G4Analysis(G4VAnalysisManager* analysisManager): 163 fpAnalysisManager(analysisManager) 163 fpAnalysisManager(analysisManager) 164 { 164 { 165 fFileInitialized = false; 165 fFileInitialized = false; 166 fNtupleID = -1; 166 fNtupleID = -1; 167 } 167 } 168 168 169 //-------------------------------------------- 169 //------------------------------------------------------------------------------ 170 170 171 G4Analysis::~G4Analysis() 171 G4Analysis::~G4Analysis() 172 { 172 { 173 fpAnalysisManager = nullptr; 173 fpAnalysisManager = nullptr; 174 } 174 } 175 175 176 //-------------------------------------------- 176 //------------------------------------------------------------------------------ 177 177 178 void G4Analysis::InitializeFile() 178 void G4Analysis::InitializeFile() 179 { 179 { 180 if (fFileInitialized) return; 180 if (fFileInitialized) return; 181 181 182 fNtupleID = fpAnalysisManager->CreateNtuple( 182 fNtupleID = fpAnalysisManager->CreateNtuple("PhysChem","PhysChem"); 183 fpAnalysisManager->CreateNtupleIColumn(fNtup 183 fpAnalysisManager->CreateNtupleIColumn(fNtupleID, "ParentID"); 184 fpAnalysisManager->CreateNtupleSColumn(fNtup 184 fpAnalysisManager->CreateNtupleSColumn(fNtupleID, "Molecule"); 185 185 186 //------------------------------------------ 186 //---------------------------------------------------------------------------- 187 // valid for H2O only 187 // valid for H2O only 188 fpAnalysisManager->CreateNtupleIColumn(fNtup 188 fpAnalysisManager->CreateNtupleIColumn(fNtupleID, "ElectronicModif"); 189 // ionization = 0 / excitation = 1 / diss at 189 // ionization = 0 / excitation = 1 / diss att = 2 190 fpAnalysisManager->CreateNtupleIColumn(fNtup 190 fpAnalysisManager->CreateNtupleIColumn(fNtupleID, "level"); 191 // valid for ion and exc only 191 // valid for ion and exc only 192 fpAnalysisManager->CreateNtupleDColumn(fNtup 192 fpAnalysisManager->CreateNtupleDColumn(fNtupleID, "Energy_eV"); 193 // valid for ion and exc only 193 // valid for ion and exc only 194 194 195 //------------------------------------------ 195 //---------------------------------------------------------------------------- 196 fpAnalysisManager->CreateNtupleDColumn(fNtup 196 fpAnalysisManager->CreateNtupleDColumn(fNtupleID, "x_parent_nm"); 197 fpAnalysisManager->CreateNtupleDColumn(fNtup 197 fpAnalysisManager->CreateNtupleDColumn(fNtupleID, "y_parent_nm"); 198 fpAnalysisManager->CreateNtupleDColumn(fNtup 198 fpAnalysisManager->CreateNtupleDColumn(fNtupleID, "z_parent_nm"); 199 fpAnalysisManager->CreateNtupleDColumn(fNtup 199 fpAnalysisManager->CreateNtupleDColumn(fNtupleID, "x_nm"); 200 fpAnalysisManager->CreateNtupleDColumn(fNtup 200 fpAnalysisManager->CreateNtupleDColumn(fNtupleID, "y_nm"); 201 fpAnalysisManager->CreateNtupleDColumn(fNtup 201 fpAnalysisManager->CreateNtupleDColumn(fNtupleID, "z_nm"); 202 fpAnalysisManager->FinishNtuple(fNtupleID); 202 fpAnalysisManager->FinishNtuple(fNtupleID); 203 203 204 fFileInitialized = true; 204 fFileInitialized = true; 205 } 205 } 206 206 207 //-------------------------------------------- 207 //------------------------------------------------------------------------------ 208 208 209 void G4Analysis::WriteInto(const G4String& out 209 void G4Analysis::WriteInto(const G4String& output, 210 ios_base::openmode) 210 ios_base::openmode) 211 { 211 { 212 fpAnalysisManager->OpenFile(output); 212 fpAnalysisManager->OpenFile(output); 213 fFileInitialized = false; 213 fFileInitialized = false; 214 } 214 } 215 215 216 //-------------------------------------------- 216 //------------------------------------------------------------------------------ 217 217 218 void G4Analysis::CloseFile() 218 void G4Analysis::CloseFile() 219 { 219 { 220 // fpAnalysisManager->Write(); 220 // fpAnalysisManager->Write(); 221 // fpAnalysisManager->CloseFile(); 221 // fpAnalysisManager->CloseFile(); 222 } 222 } 223 223 224 //-------------------------------------------- 224 //------------------------------------------------------------------------------ 225 225 226 void G4Analysis::CreateWaterMolecule(G4int mod 226 void G4Analysis::CreateWaterMolecule(G4int modification, 227 G4int ele 227 G4int electronicLevel, 228 G4double 228 G4double energy, 229 const G4T 229 const G4Track* theIncomingTrack) 230 { 230 { 231 if(!fFileInitialized) InitializeFile(); 231 if(!fFileInitialized) InitializeFile(); 232 232 233 // parent ID 233 // parent ID 234 fpAnalysisManager->FillNtupleIColumn(fNtuple 234 fpAnalysisManager->FillNtupleIColumn(fNtupleID, 0, 235 theInco 235 theIncomingTrack->GetTrackID()); 236 236 237 // molecule type 237 // molecule type 238 fpAnalysisManager->FillNtupleSColumn(fNtuple 238 fpAnalysisManager->FillNtupleSColumn(fNtupleID, 1, "H2O"); 239 239 240 //------------------------------------------ 240 //---------------------------------------------------------------------------- 241 // valid for H2O only 241 // valid for H2O only 242 242 243 // electronic modif 243 // electronic modif 244 fpAnalysisManager->FillNtupleIColumn(fNtuple 244 fpAnalysisManager->FillNtupleIColumn(fNtupleID, 2, modification); 245 // ionization = 0 / excitation = 1 / diss at 245 // ionization = 0 / excitation = 1 / diss att = 2 246 fpAnalysisManager->FillNtupleIColumn(fNtuple 246 fpAnalysisManager->FillNtupleIColumn(fNtupleID, 3, electronicLevel); 247 fpAnalysisManager->FillNtupleDColumn(fNtuple 247 fpAnalysisManager->FillNtupleDColumn(fNtupleID, 4, energy / eV); 248 248 249 //------------------------------------------ 249 //---------------------------------------------------------------------------- 250 const G4ThreeVector& parentPos = theIncoming 250 const G4ThreeVector& parentPos = theIncomingTrack->GetPosition(); 251 251 252 fpAnalysisManager->FillNtupleDColumn(fNtuple 252 fpAnalysisManager->FillNtupleDColumn(fNtupleID,5,(parentPos.x())/nanometer); 253 fpAnalysisManager->FillNtupleDColumn(fNtuple 253 fpAnalysisManager->FillNtupleDColumn(fNtupleID,6,(parentPos.y())/nanometer); 254 fpAnalysisManager->FillNtupleDColumn(fNtuple 254 fpAnalysisManager->FillNtupleDColumn(fNtupleID,7,(parentPos.z())/nanometer); 255 255 256 fpAnalysisManager->FillNtupleDColumn(fNtuple 256 fpAnalysisManager->FillNtupleDColumn(fNtupleID,8,(parentPos.x())/nanometer); 257 fpAnalysisManager->FillNtupleDColumn(fNtuple 257 fpAnalysisManager->FillNtupleDColumn(fNtupleID,9,(parentPos.y())/nanometer); 258 fpAnalysisManager->FillNtupleDColumn(fNtuple 258 fpAnalysisManager->FillNtupleDColumn(fNtupleID,10,(parentPos.z())/nanometer); 259 fpAnalysisManager->AddNtupleRow(fNtupleID); 259 fpAnalysisManager->AddNtupleRow(fNtupleID); 260 } 260 } 261 261 262 //-------------------------------------------- 262 //------------------------------------------------------------------------------ 263 263 264 void G4Analysis::CreateSolvatedElectron(const 264 void G4Analysis::CreateSolvatedElectron(const G4Track* electronTrack, 265 G4Thre 265 G4ThreeVector* finalPosition) 266 { 266 { 267 if(!fFileInitialized) InitializeFile(); 267 if(!fFileInitialized) InitializeFile(); 268 268 269 // parent ID 269 // parent ID 270 fpAnalysisManager->FillNtupleIColumn(fNtuple 270 fpAnalysisManager->FillNtupleIColumn(fNtupleID, 0, 271 electro 271 electronTrack->GetTrackID()); 272 272 273 // molecule type 273 // molecule type 274 fpAnalysisManager->FillNtupleSColumn(fNtuple 274 fpAnalysisManager->FillNtupleSColumn(fNtupleID, 1, "e_aq"); 275 275 276 //------------------------------------------ 276 //---------------------------------------------------------------------------- 277 // valid for H2O only 277 // valid for H2O only 278 278 279 // electronic modif 279 // electronic modif 280 fpAnalysisManager->FillNtupleIColumn(fNtuple 280 fpAnalysisManager->FillNtupleIColumn(fNtupleID, 2, -1); // electronic modif 281 fpAnalysisManager->FillNtupleIColumn(fNtuple 281 fpAnalysisManager->FillNtupleIColumn(fNtupleID, 3, -1); // electronic level 282 fpAnalysisManager->FillNtupleDColumn(fNtuple 282 fpAnalysisManager->FillNtupleDColumn(fNtupleID, 4, 283 electro 283 electronTrack->GetKineticEnergy() / eV); 284 284 285 //------------------------------------------ 285 //---------------------------------------------------------------------------- 286 const G4ThreeVector& parentPos = electronTra 286 const G4ThreeVector& parentPos = electronTrack->GetPosition(); 287 const double i_nm = 1./nanometer; 287 const double i_nm = 1./nanometer; 288 288 289 fpAnalysisManager->FillNtupleDColumn(fNtuple 289 fpAnalysisManager->FillNtupleDColumn(fNtupleID,5, parentPos.x() *i_nm); 290 fpAnalysisManager->FillNtupleDColumn(fNtuple 290 fpAnalysisManager->FillNtupleDColumn(fNtupleID,6, parentPos.y() *i_nm); 291 fpAnalysisManager->FillNtupleDColumn(fNtuple 291 fpAnalysisManager->FillNtupleDColumn(fNtupleID,7, parentPos.z() *i_nm); 292 292 293 if (finalPosition != nullptr) 293 if (finalPosition != nullptr) 294 { 294 { 295 fpAnalysisManager->FillNtupleDColumn(fNtup 295 fpAnalysisManager->FillNtupleDColumn(fNtupleID,8, finalPosition->x()*i_nm); 296 fpAnalysisManager->FillNtupleDColumn(fNtup 296 fpAnalysisManager->FillNtupleDColumn(fNtupleID,9, finalPosition->y()*i_nm); 297 fpAnalysisManager->FillNtupleDColumn(fNtup 297 fpAnalysisManager->FillNtupleDColumn(fNtupleID,10, finalPosition->z()*i_nm); 298 } 298 } 299 else 299 else 300 { 300 { 301 fpAnalysisManager->FillNtupleDColumn(fNtup 301 fpAnalysisManager->FillNtupleDColumn(fNtupleID,8, parentPos.x() *i_nm); 302 fpAnalysisManager->FillNtupleDColumn(fNtup 302 fpAnalysisManager->FillNtupleDColumn(fNtupleID,9, parentPos.y() *i_nm); 303 fpAnalysisManager->FillNtupleDColumn(fNtup 303 fpAnalysisManager->FillNtupleDColumn(fNtupleID,10, parentPos.z() *i_nm); 304 } 304 } 305 305 306 fpAnalysisManager->AddNtupleRow(fNtupleID); 306 fpAnalysisManager->AddNtupleRow(fNtupleID); 307 } 307 } 308 } 308 } 309 309