Geant4 Cross Reference |
1 // 1 // 2 // ******************************************* 2 // ******************************************************************** 3 // * License and Disclaimer << 3 // * DISCLAIMER * 4 // * 4 // * * 5 // * The Geant4 software is copyright of th << 5 // * The following disclaimer summarizes all the specific disclaimers * 6 // * the Geant4 Collaboration. It is provided << 6 // * of contributors to this software. The specific disclaimers,which * 7 // * conditions of the Geant4 Software License << 7 // * govern, are listed with their locations in: * 8 // * LICENSE and available at http://cern.ch/ << 8 // * http://cern.ch/geant4/license * 9 // * include a list of copyright holders. << 10 // * 9 // * * 11 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing * 12 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this * 13 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, * 14 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its * 15 // * use. Please see the license in the file << 14 // * use. * 16 // * for the full disclaimer and the limitatio << 17 // * 15 // * * 18 // * This code implementation is the result << 16 // * This code implementation is the intellectual property of the * 19 // * technical work of the GEANT4 collaboratio << 17 // * GEANT4 collaboration. * 20 // * By using, copying, modifying or distri << 18 // * By copying, distributing or modifying the Program (or any work * 21 // * any work based on the software) you ag << 19 // * based on the Program) you indicate your acceptance of this * 22 // * use in resulting scientific publicati << 20 // * statement, and all its terms. * 23 // * acceptance of all terms of the Geant4 Sof << 24 // ******************************************* 21 // ******************************************************************** 25 // 22 // 26 // G4PhysicsTable class implementation << 27 // 23 // 28 // Author: G.Cosmo, 2 December 1995 << 24 // $Id: G4PhysicsTable.cc,v 1.5.2.1 2001/06/28 19:10:05 gunter Exp $ 29 // First implementation based on objec << 25 // GEANT4 tag $Name: $ 30 // Revisions: << 26 // 31 // - 1st March 1996, K.Amako: modified << 27 // 32 // - 24th February 2001, H.Kurashige: migratio << 28 // ------------------------------------------------------------ 33 // ------------------------------------------- << 29 // GEANT 4 class implementation 34 << 30 // 35 #include <fstream> << 31 // G4PhysicsTable 36 #include <iomanip> << 32 // 37 #include <iostream> << 33 // ------------------------------------------------------------ 38 34 39 #include "G4PhysicsFreeVector.hh" << 40 #include "G4PhysicsLinearVector.hh" << 41 #include "G4PhysicsLogVector.hh" << 42 #include "G4PhysicsTable.hh" << 43 #include "G4PhysicsVector.hh" 35 #include "G4PhysicsVector.hh" 44 #include "G4PhysicsVectorType.hh" << 36 #include "G4PhysicsTable.hh" >> 37 #include "g4std/iostream" >> 38 #include "g4std/fstream" >> 39 #include "g4std/iomanip" 45 40 46 // ------------------------------------------- << 41 G4PhysicsTable::G4PhysicsTable() 47 G4PhysicsTable::G4PhysicsTable(std::size_t cap << 42 : G4PhysCollection() 48 { 43 { 49 reserve(cap); << 50 vecFlag.reserve(cap); << 51 } 44 } 52 45 53 // ------------------------------------------- << 46 G4PhysicsTable::G4PhysicsTable(size_t capacity) 54 G4PhysicsTable::~G4PhysicsTable() << 47 : G4PhysCollection() 55 { 48 { 56 G4PhysCollection::clear(); << 49 reserve(capacity); 57 vecFlag.clear(); << 58 } 50 } 59 51 60 // ------------------------------------------- << 52 G4PhysicsTable::G4PhysicsTable(const G4PhysicsTable& right) 61 void G4PhysicsTable::resize(std::size_t siz, G << 62 { 53 { 63 G4PhysCollection::resize(siz, vec); << 54 *this = right; 64 vecFlag.resize(siz, true); << 65 } 55 } 66 56 67 // ------------------------------------------- << 57 G4PhysicsTable& G4PhysicsTable::operator=(const G4PhysicsTable& right) 68 G4bool G4PhysicsTable::StorePhysicsTable(const << 69 { 58 { 70 std::ofstream fOut; << 59 if (this != &right) 71 << 72 // open output file << 73 if(!ascii) << 74 { 60 { 75 fOut.open(fileName, std::ios::out | std::i << 61 G4PhysCollection::const_iterator itr; >> 62 for (itr=right.begin(); itr!=right.end(); ++itr) >> 63 { >> 64 G4PhysCollection::push_back(*itr); >> 65 } 76 } 66 } >> 67 return *this; >> 68 } >> 69 >> 70 G4PhysicsTable::~G4PhysicsTable() >> 71 { >> 72 clear(); >> 73 } >> 74 >> 75 >> 76 G4bool G4PhysicsTable::StorePhysicsTable(const G4String& fileName, >> 77 G4bool ascii) >> 78 { >> 79 G4std::ofstream fOut; >> 80 >> 81 // open output file // >> 82 #ifdef G4USE_STD_NAMESPACE >> 83 if (!ascii) >> 84 fOut.open(fileName, G4std::ios::out|G4std::ios::binary); 77 else 85 else 78 { << 86 #endif 79 fOut.open(fileName, std::ios::out); << 87 fOut.open(fileName, G4std::ios::out); 80 } << 81 88 82 // check if the file has been opened success << 89 // check if the file has been opened successfully 83 if(!fOut.is_open()) << 90 if (!fOut) { 84 { << 91 #ifdef G4VERBOSE 85 #ifdef G4VERBOSE << 92 G4cerr << "G4PhysicsTable::::StorePhysicsTable "; 86 G4cerr << "G4PhysicsTable::StorePhysicsTab << 93 G4cerr << " Can not open file " << fileName << G4endl; 87 G4cerr << " Cannot open file: " << fileNam << 88 #endif 94 #endif 89 fOut.close(); 95 fOut.close(); 90 return false; 96 return false; 91 } 97 } 92 98 93 // Number of elements 99 // Number of elements 94 std::size_t tableSize = size(); << 100 size_t tableSize = size(); 95 if(!ascii) << 101 if (!ascii){ 96 { << 102 fOut.write( (char*)(&tableSize), sizeof tableSize); 97 fOut.write((char*) (&tableSize), sizeof ta << 103 } else { 98 } << 99 else << 100 { << 101 fOut << tableSize << G4endl; 104 fOut << tableSize << G4endl; 102 } 105 } 103 106 104 // Physics Vector 107 // Physics Vector 105 for(const auto itr : *this) << 108 G4PhysicsTableIterator itr; 106 { << 109 for (itr=begin(); itr!=end(); ++itr) { 107 G4int vType = itr->GetType(); << 110 G4int vType = (*itr)->GetType(); 108 if(!ascii) << 111 if (!ascii){ 109 { << 112 fOut.write( (char*)(&vType), sizeof vType); 110 fOut.write((char*) (&vType), sizeof vTyp << 113 } else { 111 } << 112 else << 113 { << 114 fOut << vType << G4endl; 114 fOut << vType << G4endl; 115 } 115 } 116 itr->Store(fOut, ascii); << 116 (*itr)->Store(fOut,ascii); 117 } 117 } 118 fOut.close(); 118 fOut.close(); 119 return true; 119 return true; 120 } 120 } 121 121 122 // ------------------------------------------- << 123 G4bool G4PhysicsTable::ExistPhysicsTable(const << 124 { << 125 std::ifstream fIn; << 126 G4bool value = true; << 127 // open input file << 128 fIn.open(fileName, std::ios::in); << 129 122 130 // check if the file has been opened success << 131 if(!fIn) << 132 { << 133 value = false; << 134 } << 135 fIn.close(); << 136 return value; << 137 } << 138 123 139 // ------------------------------------------- << 140 G4bool G4PhysicsTable::RetrievePhysicsTable(co 124 G4bool G4PhysicsTable::RetrievePhysicsTable(const G4String& fileName, 141 G4 << 125 G4bool ascii) 142 { 126 { 143 std::ifstream fIn; << 127 G4std::ifstream fIn; 144 // open input file << 128 // open input file // 145 if(ascii) << 129 #ifdef G4USE_STD_NAMESPACE 146 { << 130 if (ascii) 147 fIn.open(fileName, std::ios::in | std::ios << 131 fIn.open(fileName,G4std::ios::in|G4std::ios::binary); 148 } << 149 else 132 else 150 { << 133 #endif 151 fIn.open(fileName, std::ios::in); << 134 fIn.open(fileName,G4std::ios::in); 152 } << 153 135 154 // check if the file has been opened success << 136 // check if the file has been opened successfully 155 if(!fIn.is_open()) << 137 if (!fIn) { 156 { << 138 #ifdef G4VERBOSE 157 #ifdef G4VERBOSE << 139 G4cerr << "G4PhysicsTable::RetrievePhysicsTable "; 158 G4cerr << "G4PhysicsTable::RetrievePhysics << 140 G4cerr << " Can not open file " << fileName << G4endl; 159 G4cerr << " Cannot open file: " << fileNam << 160 #endif 141 #endif 161 fIn.close(); 142 fIn.close(); 162 return false; 143 return false; 163 } 144 } 164 145 165 // clear << 146 // clear 166 clearAndDestroy(); 147 clearAndDestroy(); 167 << 148 168 // Number of elements 149 // Number of elements 169 std::size_t tableSize = 0; << 150 size_t tableSize; 170 if(!ascii) << 151 if (!ascii){ 171 { << 152 fIn.read((char*)(&tableSize), sizeof tableSize); 172 fIn.read((char*) (&tableSize), sizeof tabl << 153 } else { 173 } << 174 else << 175 { << 176 fIn >> tableSize; 154 fIn >> tableSize; 177 } 155 } 178 reserve(tableSize); << 156 reserve(tableSize); 179 vecFlag.clear(); << 180 157 181 // Physics Vector 158 // Physics Vector 182 for(std::size_t idx = 0; idx < tableSize; ++ << 159 for (size_t idx=0; idx<tableSize; ++idx) { 183 { << 160 G4int vType; 184 G4int vType = 0; << 161 if (!ascii){ 185 if(!ascii) << 162 fIn.read( (char*)(&vType), sizeof vType); 186 { << 163 } else { 187 fIn.read((char*) (&vType), sizeof vType) << 164 fIn >> vType; 188 } << 165 } 189 else << 166 G4PhysicsVector* pVec = CreatePhysicsVector(vType); 190 { << 167 if (pVec==0) { 191 fIn >> vType; << 168 #ifdef G4VERBOSE 192 } << 169 G4cerr << "G4PhysicsTable::RetrievePhysicsTable "; 193 G4PhysicsVector* pVec = CreatePhysicsVecto << 170 G4cerr << " illegal Physics Vector type " << vType << " in "; 194 if(pVec == nullptr) << 195 { << 196 #ifdef G4VERBOSE << 197 G4cerr << "G4PhysicsTable::RetrievePhysi << 198 G4cerr << " Illegal Physics Vector type: << 199 G4cerr << fileName << G4endl; 171 G4cerr << fileName << G4endl; 200 #endif << 172 #endif 201 fIn.close(); 173 fIn.close(); 202 return false; 174 return false; 203 } 175 } 204 176 205 if(!(pVec->Retrieve(fIn, ascii))) << 177 if (! (pVec->Retrieve(fIn,ascii)) ){ 206 { << 178 #ifdef G4VERBOSE 207 #ifdef G4VERBOSE << 179 G4cerr << "G4PhysicsTable::RetrievePhysicsTable "; 208 G4cerr << "G4PhysicsTable::RetrievePhysi << 180 G4cerr << " error in retreiving " << idx << "-th Physics Vector from file "; 209 G4cerr << " Rrror in retreiving " << idx << 210 << "-th Physics Vector from file: << 211 G4cerr << fileName << G4endl; 181 G4cerr << fileName << G4endl; 212 #endif << 182 #endif 213 fIn.close(); 183 fIn.close(); 214 return false; 184 return false; 215 } 185 } 216 186 217 // add a PhysicsVector to this PhysicsTabl 187 // add a PhysicsVector to this PhysicsTable 218 G4PhysCollection::push_back(pVec); << 188 push_back(pVec); 219 vecFlag.push_back(true); << 189 } 220 } << 221 fIn.close(); 190 fIn.close(); 222 return true; 191 return true; 223 } 192 } 224 193 225 // ------------------------------------------- << 194 G4std::ostream& operator<<(G4std::ostream& out, 226 std::ostream& operator<<(std::ostream& out, G4 << 195 G4PhysicsTable& right) 227 { 196 { 228 // Printout Physics Vector 197 // Printout Physics Vector 229 std::size_t i = 0; << 198 G4PhysicsTableIterator itr; 230 for(auto itr = right.cbegin(); itr != right. << 199 size_t i=0; 231 { << 200 for (itr=right.begin(); itr!=right.end(); ++itr) { 232 out << std::setw(8) << i << "-th Vector << 201 out << G4std::setw(8) << i << "-th Vector "; 233 if (nullptr == (*itr)) { << 202 out << ": Type " << G4int((*itr)->GetType()) << G4endl; 234 out << "empty" << G4endl; << 235 ++i; << 236 continue; << 237 } << 238 out << ": Type " << G4int((*itr)->GetTy << 239 out << ": Flag "; << 240 if(right.GetFlag(i)) << 241 { << 242 out << " T"; << 243 } << 244 else << 245 { << 246 out << " F"; << 247 } << 248 out << G4endl; << 249 out << *(*itr); 203 out << *(*itr); 250 ++i; << 204 i +=1; 251 } 205 } 252 out << G4endl; 206 out << G4endl; 253 return out; << 207 return out; 254 } << 255 << 256 // ------------------------------------------- << 257 void G4PhysicsTable::ResetFlagArray() << 258 { << 259 size_t tableSize = G4PhysCollection::size(); << 260 vecFlag.clear(); << 261 for(std::size_t idx = 0; idx < tableSize; ++ << 262 { << 263 vecFlag.push_back(true); << 264 } << 265 } 208 } 266 209 267 // ------------------------------------------- << 210 #include "G4PhysicsVectorType.hh" 268 G4PhysicsVector* G4PhysicsTable::CreatePhysics << 211 #include "G4LPhysicsFreeVector.hh" 269 { << 212 #include "G4PhysicsLogVector.hh" 270 G4PhysicsVector* pVector = nullptr; << 213 #include "G4PhysicsFreeVector.hh" 271 switch(type) << 214 #include "G4PhysicsOrderedFreeVector.hh" 272 { << 215 #include "G4PhysicsLinearVector.hh" 273 case T_G4PhysicsLinearVector: << 216 #include "G4PhysicsLnVector.hh" 274 pVector = new G4PhysicsLinearVector(spli << 217 275 break; << 218 G4PhysicsVector* G4PhysicsTable::CreatePhysicsVector(G4int type) 276 << 219 { 277 case T_G4PhysicsLogVector: << 220 G4PhysicsVector* pVector=0; 278 pVector = new G4PhysicsLogVector(spline) << 221 switch (type) { 279 break; << 222 280 << 223 case T_G4PhysicsLinearVector: 281 default: << 224 pVector = new G4PhysicsLinearVector(); 282 pVector = new G4PhysicsVector(spline); << 225 break; 283 break; << 226 >> 227 case T_G4PhysicsLogVector: >> 228 pVector = new G4PhysicsLogVector(); >> 229 break; >> 230 >> 231 case T_G4PhysicsLnVector: >> 232 pVector = new G4PhysicsLnVector(); >> 233 break; >> 234 >> 235 case T_G4PhysicsFreeVector: >> 236 pVector = new G4PhysicsFreeVector(); >> 237 break; >> 238 >> 239 case T_G4PhysicsOrderedFreeVector: >> 240 pVector = new G4PhysicsOrderedFreeVector(); >> 241 break; >> 242 >> 243 case T_G4LPhysicsFreeVector: >> 244 pVector = new G4LPhysicsFreeVector(); >> 245 break; >> 246 >> 247 default: >> 248 break; >> 249 284 } 250 } 285 return pVector; 251 return pVector; 286 } 252 } >> 253 287 254