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 // G4UnitsTable class implementation << 27 // 26 // 28 // Author: M.Maire, 17.05.1998 - First version << 27 // $Id: G4UnitsTable.cc,v 1.37 2008/05/06 17:17:08 maire Exp $ 29 // Revisions: G.Cosmo, 06.03.2001 - Migrated t << 28 // GEANT4 tag $Name: geant4-09-03-patch-01 $ 30 // ------------------------------------------- << 29 // 31 << 30 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 32 #include <iomanip> << 31 // 33 #include <sstream> << 32 // 17-05-98: first version, M.Maire >> 33 // 05-08-98: angstrom,microbarn,picobarn,petaelectronvolt, M.Maire >> 34 // 13-10-98: units and symbols printed in fixed length, M.Maire >> 35 // 01-03-01: parsec, M.Maire >> 36 // 06-03-01: migration to STL vectors, G.Cosmo >> 37 // 06-05-02: BestUnit operator<< flux instead of G4cout (mma) >> 38 // 12-08-05: cm2/g ("Surface/Mass") (mma) >> 39 // 30-06-05: um for micrometer (mma) >> 40 // 07-02-06: GeV/cm MeV/cm keV/cm eV/cm ("Energy/Length") (mma) >> 41 // 15-02-06: g/cm2 ("Mass/Surface") >> 42 // MeV*cm2/g ..etc.. ("Energy*Surface/Mass") >> 43 // 18-08-06: remove symbol mum (mma) >> 44 // 06-05-08: V/m ("Electric field") (mma) >> 45 // >> 46 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... >> 47 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 34 48 35 #include "G4SystemOfUnits.hh" << 49 36 #include "G4Threading.hh" << 37 #include "G4UnitsTable.hh" 50 #include "G4UnitsTable.hh" 38 51 39 G4ThreadLocal G4UnitsTable* G4UnitDefinition:: << 52 #include <iomanip> 40 G4ThreadLocal G4bool G4UnitDefinition::unitsTa << 53 #include <sstream> 41 << 42 #ifdef G4MULTITHREADED << 43 G4UnitsTable* G4UnitDefinition::pUnitsTableSha << 44 << 45 // ------------------------------------------- << 46 << 47 G4UnitsTable::~G4UnitsTable() << 48 { << 49 for(const auto itr : *this) << 50 { << 51 delete itr; << 52 } << 53 clear(); << 54 } << 55 << 56 #endif << 57 54 58 // ------------------------------------------- << 55 G4UnitsTable G4UnitDefinition::theUnitsTable; 59 56 60 G4UnitDefinition::G4UnitDefinition(const G4Str << 57 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... >> 58 >> 59 G4UnitDefinition::G4UnitDefinition(const G4String& name, >> 60 const G4String& symbol, 61 const G4Str 61 const G4String& category, G4double value) 62 : Name(name) << 62 : Name(name),SymbolName(symbol),Value(value) 63 , SymbolName(symbol) << 63 { 64 , Value(value) << 64 // >> 65 //does the Category objet already exist ? >> 66 size_t nbCat = theUnitsTable.size(); >> 67 size_t i = 0; >> 68 while ((i<nbCat)&&(theUnitsTable[i]->GetName()!=category)) { i++; } >> 69 if (i == nbCat) >> 70 { theUnitsTable.push_back( new G4UnitsCategory(category)); } >> 71 CategoryIndex = i; >> 72 // >> 73 //insert this Unit in the Unitstable >> 74 (theUnitsTable[CategoryIndex]->GetUnitsList()).push_back(this); >> 75 >> 76 //update string max length for name and symbol >> 77 theUnitsTable[i]->UpdateNameMxLen((G4int)name.length()); >> 78 theUnitsTable[i]->UpdateSymbMxLen((G4int)symbol.length()); >> 79 } >> 80 >> 81 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... >> 82 >> 83 G4UnitDefinition::~G4UnitDefinition() 65 { 84 { 66 if(pUnitsTable == nullptr) << 67 { << 68 if(unitsTableDestroyed) << 69 { << 70 G4Exception("G4UnitDefinition::G4UnitDef << 71 FatalException, "G4UnitsTabl << 72 } << 73 pUnitsTable = new G4UnitsTable; << 74 #ifdef G4MULTITHREADED << 75 if(G4Threading::IsMasterThread()) << 76 { << 77 pUnitsTableShadow = pUnitsTable; << 78 } << 79 #endif << 80 } << 81 << 82 // Does the Category objet already exist ? << 83 // << 84 std::size_t nbCat = pUnitsTable->size(); << 85 std::size_t i = 0; << 86 while((i < nbCat) && ((*pUnitsTable)[i]->Get << 87 { << 88 ++i; << 89 } << 90 if(i == nbCat) << 91 { << 92 pUnitsTable->push_back(new G4UnitsCategory << 93 } << 94 CategoryIndex = i; << 95 << 96 // Insert this Unit in the Units table << 97 // << 98 ((*pUnitsTable)[CategoryIndex]->GetUnitsList << 99 << 100 // Update string max length for name and sym << 101 // << 102 (*pUnitsTable)[i]->UpdateNameMxLen((G4int) n << 103 (*pUnitsTable)[i]->UpdateSymbMxLen((G4int) s << 104 } 85 } 105 86 106 // ------------------------------------------- << 87 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 107 << 88 108 G4UnitDefinition::G4UnitDefinition(const G4Uni 89 G4UnitDefinition::G4UnitDefinition(const G4UnitDefinition& right) 109 { 90 { 110 *this = right; << 91 *this = right; 111 } 92 } 112 93 113 // ------------------------------------------- << 94 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 114 << 95 115 G4UnitDefinition& G4UnitDefinition::operator=( 96 G4UnitDefinition& G4UnitDefinition::operator=(const G4UnitDefinition& right) 116 { 97 { 117 if(this != &right) << 98 if (this != &right) 118 { << 99 { 119 Name = right.Name; << 100 Name = right.Name; 120 SymbolName = right.SymbolName; << 101 SymbolName = right.SymbolName; 121 Value = right.Value; << 102 Value = right.Value; 122 CategoryIndex = right.CategoryIndex; << 103 CategoryIndex = right.CategoryIndex; 123 } << 104 } 124 return *this; 105 return *this; 125 } 106 } 126 107 127 // ------------------------------------------- << 108 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 128 << 109 129 G4bool G4UnitDefinition::operator==(const G4Un << 110 G4int G4UnitDefinition::operator==(const G4UnitDefinition& right) const 130 { 111 { 131 return (this == (G4UnitDefinition*) &right); << 112 return (this == (G4UnitDefinition *) &right); 132 } 113 } 133 114 134 // ------------------------------------------- << 115 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 135 << 116 136 G4bool G4UnitDefinition::operator!=(const G4Un << 117 G4int G4UnitDefinition::operator!=(const G4UnitDefinition &right) const 137 { 118 { 138 return (this != (G4UnitDefinition*) &right); << 119 return (this != (G4UnitDefinition *) &right); 139 } 120 } 140 121 141 // ------------------------------------------- << 122 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 142 << 123 143 G4UnitsTable& G4UnitDefinition::GetUnitsTable( 124 G4UnitsTable& G4UnitDefinition::GetUnitsTable() 144 { 125 { 145 if(pUnitsTable == nullptr) << 126 return theUnitsTable; 146 { << 147 pUnitsTable = new G4UnitsTable; << 148 } << 149 if(pUnitsTable->empty()) << 150 { << 151 BuildUnitsTable(); << 152 } << 153 #ifdef G4MULTITHREADED << 154 if(G4Threading::IsMasterThread() && pUnitsTa << 155 { << 156 pUnitsTableShadow = pUnitsTable; << 157 } << 158 #endif << 159 return *pUnitsTable; << 160 } << 161 << 162 // ------------------------------------------- << 163 << 164 G4bool G4UnitDefinition::IsUnitDefined(const G << 165 { << 166 G4String name, symbol; << 167 for(std::size_t i = 0; i < (GetUnitsTable()) << 168 { << 169 G4UnitsContainer& units = (*pUnitsTable)[i << 170 for(auto& unit : units) << 171 { << 172 name = unit->GetName(); << 173 symbol = unit->GetSymbol(); << 174 if(str == name || str == symbol) << 175 { << 176 return true; << 177 } << 178 } << 179 } << 180 return false; << 181 } 127 } 182 << 128 183 // ------------------------------------------- << 129 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 184 << 130 185 G4double G4UnitDefinition::GetValueOf(const G4 131 G4double G4UnitDefinition::GetValueOf(const G4String& str) 186 { 132 { 187 G4String name, symbol; << 133 if(theUnitsTable.size()==0) { BuildUnitsTable(); } 188 for(std::size_t i = 0; i < (GetUnitsTable()) << 134 G4String name,symbol; 189 { << 135 for (size_t i=0;i<theUnitsTable.size();i++) 190 G4UnitsContainer& units = (*pUnitsTable)[i << 136 { 191 for(auto& unit : units) << 137 G4UnitsContainer& units = theUnitsTable[i]->GetUnitsList(); 192 { << 138 for (size_t j=0;j<units.size();j++) 193 name = unit->GetName(); << 139 { 194 symbol = unit->GetSymbol(); << 140 name=units[j]->GetName(); symbol=units[j]->GetSymbol(); 195 if(str == name || str == symbol) << 141 if(str==name||str==symbol) 196 { << 142 { return units[j]->GetValue(); } 197 return unit->GetValue(); << 143 } 198 } << 144 } 199 } << 145 G4cout << "Warning from G4UnitDefinition::GetValueOf(" << str << ")." 200 } << 146 << " The unit " << str << " does not exist in UnitsTable." 201 std::ostringstream message; << 147 << " Return Value = 0." << G4endl; 202 message << "The unit '" << str << "' does no << 148 return 0.; 203 G4Exception("G4UnitDefinition::GetValueOf()" << 204 message); << 205 return 0.; << 206 } 149 } 207 150 208 // ------------------------------------------- << 151 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 209 << 152 210 G4String G4UnitDefinition::GetCategory(const G 153 G4String G4UnitDefinition::GetCategory(const G4String& str) 211 { 154 { 212 G4String name, symbol; << 155 if(theUnitsTable.size()==0) { BuildUnitsTable(); } 213 for(std::size_t i = 0; i < (GetUnitsTable()) << 156 G4String name,symbol; 214 { << 157 for (size_t i=0;i<theUnitsTable.size();i++) 215 G4UnitsContainer& units = (*pUnitsTable)[i << 158 { 216 for(auto& unit : units) << 159 G4UnitsContainer& units = theUnitsTable[i]->GetUnitsList(); 217 { << 160 for (size_t j=0;j<units.size();j++) 218 name = unit->GetName(); << 161 { 219 symbol = unit->GetSymbol(); << 162 name=units[j]->GetName(); symbol=units[j]->GetSymbol(); 220 if(str == name || str == symbol) << 163 if(str==name||str==symbol) 221 { << 164 { return theUnitsTable[i]->GetName(); } 222 return (*pUnitsTable)[i]->GetName(); << 165 } 223 } << 166 } 224 } << 167 G4cout << "Warning from G4UnitDefinition::GetCategory(" << str << ")." 225 } << 168 << " The unit " << str << " does not exist in UnitsTable." 226 std::ostringstream message; << 169 << " Return category = None" << G4endl; 227 message << "The unit '" << str << "' does no << 170 name = "None"; 228 G4Exception("G4UnitDefinition::GetCategory() << 171 return name; 229 message); << 230 name = "None"; << 231 return name; << 232 } 172 } 233 173 234 // ------------------------------------------- << 174 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 235 << 175 236 void G4UnitDefinition::PrintDefinition() 176 void G4UnitDefinition::PrintDefinition() 237 { 177 { 238 G4int nameL = (*pUnitsTable)[CategoryIndex]- << 178 G4int nameL = theUnitsTable[CategoryIndex]->GetNameMxLen(); 239 G4int symbL = (*pUnitsTable)[CategoryIndex]- << 179 G4int symbL = theUnitsTable[CategoryIndex]->GetSymbMxLen(); 240 G4cout << std::setw(nameL) << Name << " (" < << 180 G4cout << std::setw(nameL) << Name << " (" 241 << ") = " << Value << G4endl; << 181 << std::setw(symbL) << SymbolName << ") = " << Value << G4endl; 242 } 182 } 243 183 244 // ------------------------------------------- << 184 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 245 << 185 246 void G4UnitDefinition::BuildUnitsTable() 186 void G4UnitDefinition::BuildUnitsTable() 247 { 187 { 248 // Length << 188 //Length 249 new G4UnitDefinition("parsec", "pc", "Length << 189 new G4UnitDefinition( "parsec","pc" ,"Length",parsec); 250 new G4UnitDefinition("kilometer", "km", "Len << 190 new G4UnitDefinition( "kilometer","km" ,"Length",kilometer); 251 new G4UnitDefinition("meter", "m", "Length", << 191 new G4UnitDefinition( "meter","m" ,"Length",meter); 252 new G4UnitDefinition("centimeter", "cm", "Le << 192 new G4UnitDefinition("centimeter","cm" ,"Length",centimeter); 253 new G4UnitDefinition("millimeter", "mm", "Le << 193 new G4UnitDefinition("millimeter","mm" ,"Length",millimeter); 254 new G4UnitDefinition("micrometer", "um", "Le << 194 new G4UnitDefinition("micrometer","um" ,"Length",micrometer); 255 new G4UnitDefinition("nanometer", "nm", "Len << 195 new G4UnitDefinition( "nanometer","nm" ,"Length",nanometer); 256 new G4UnitDefinition("angstrom", "Ang", "Len << 196 new G4UnitDefinition( "angstrom","Ang" ,"Length",angstrom); 257 new G4UnitDefinition("fermi", "fm", "Length" << 197 new G4UnitDefinition( "fermi","fm" ,"Length",fermi); 258 << 198 259 // Surface << 199 //Surface 260 new G4UnitDefinition("kilometer2", "km2", "S << 200 new G4UnitDefinition( "kilometer2","km2" ,"Surface",kilometer2); 261 new G4UnitDefinition("meter2", "m2", "Surfac << 201 new G4UnitDefinition( "meter2","m2" ,"Surface",meter2); 262 new G4UnitDefinition("centimeter2", "cm2", " << 202 new G4UnitDefinition("centimeter2","cm2" ,"Surface",centimeter2); 263 new G4UnitDefinition("millimeter2", "mm2", " << 203 new G4UnitDefinition("millimeter2","mm2" ,"Surface",millimeter2); 264 new G4UnitDefinition("barn", "barn", "Surfac << 204 new G4UnitDefinition( "barn","barn" ,"Surface",barn); 265 new G4UnitDefinition("millibarn", "mbarn", " << 205 new G4UnitDefinition( "millibarn","mbarn" ,"Surface",millibarn); 266 new G4UnitDefinition("microbarn", "mubarn", << 206 new G4UnitDefinition( "microbarn","mubarn" ,"Surface",microbarn); 267 new G4UnitDefinition("nanobarn", "nbarn", "S << 207 new G4UnitDefinition( "nanobarn","nbarn" ,"Surface",nanobarn); 268 new G4UnitDefinition("picobarn", "pbarn", "S << 208 new G4UnitDefinition( "picobarn","pbarn" ,"Surface",picobarn); 269 << 209 270 // Volume << 210 //Volume 271 new G4UnitDefinition("kilometer3", "km3", "V << 211 new G4UnitDefinition( "kilometer3","km3" ,"Volume",kilometer3); 272 new G4UnitDefinition("meter3", "m3", "Volume << 212 new G4UnitDefinition( "meter3","m3" ,"Volume",meter3); 273 new G4UnitDefinition("centimeter3", "cm3", " << 213 new G4UnitDefinition("centimeter3","cm3" ,"Volume",centimeter3); 274 new G4UnitDefinition("millimeter3", "mm3", " << 214 new G4UnitDefinition("millimeter3","mm3" ,"Volume",millimeter3); 275 << 215 276 new G4UnitDefinition("liter", "L", "Volume", << 216 //Angle 277 new G4UnitDefinition("dL", "dL", "Volume", d << 217 new G4UnitDefinition( "radian","rad" ,"Angle",radian); 278 new G4UnitDefinition("cL", "cL", "Volume", c << 218 new G4UnitDefinition("milliradian","mrad" ,"Angle",milliradian); 279 new G4UnitDefinition("mL", "mL", "Volume", m << 219 new G4UnitDefinition( "steradian","sr" ,"Angle",steradian); 280 << 220 new G4UnitDefinition( "degree","deg" ,"Angle",degree); 281 // Angle << 221 282 new G4UnitDefinition("radian", "rad", "Angle << 222 //Time 283 new G4UnitDefinition("milliradian", "mrad", << 223 new G4UnitDefinition( "second","s" ,"Time",second); 284 new G4UnitDefinition("degree", "deg", "Angle << 224 new G4UnitDefinition("millisecond","ms" ,"Time",millisecond); 285 << 225 new G4UnitDefinition("microsecond","mus" ,"Time",microsecond); 286 // Solid angle << 226 new G4UnitDefinition( "nanosecond","ns" ,"Time",nanosecond); 287 new G4UnitDefinition("steradian", "sr", "Sol << 227 new G4UnitDefinition( "picosecond","ps" ,"Time",picosecond); 288 new G4UnitDefinition("millisteradian", "msr" << 228 289 steradian * 0.001); << 229 //Frequency 290 << 230 new G4UnitDefinition( "hertz","Hz" ,"Frequency",hertz); 291 // Time << 231 new G4UnitDefinition("kilohertz","kHz" ,"Frequency",kilohertz); 292 new G4UnitDefinition("second", "s", "Time", << 232 new G4UnitDefinition("megahertz","MHz" ,"Frequency",megahertz); 293 new G4UnitDefinition("millisecond", "ms", "T << 233 294 new G4UnitDefinition("microsecond", "us", "T << 234 //Electric charge 295 new G4UnitDefinition("nanosecond", "ns", "Ti << 235 new G4UnitDefinition( "eplus","e+" ,"Electric charge",eplus); 296 new G4UnitDefinition("picosecond", "ps", "Ti << 236 new G4UnitDefinition("coulomb","C" ,"Electric charge",coulomb); 297 new G4UnitDefinition("minute", "min", "Time" << 237 298 new G4UnitDefinition("hour", "h", "Time" << 238 //Energy 299 new G4UnitDefinition("day", "d", "Time" << 239 new G4UnitDefinition( "electronvolt","eV" ,"Energy",electronvolt); 300 new G4UnitDefinition("year", "y", "Time" << 240 new G4UnitDefinition("kiloelectronvolt","keV","Energy",kiloelectronvolt); 301 << 241 new G4UnitDefinition("megaelectronvolt","MeV","Energy",megaelectronvolt); 302 // Frequency << 242 new G4UnitDefinition("gigaelectronvolt","GeV","Energy",gigaelectronvolt); 303 new G4UnitDefinition("hertz", "Hz", "Frequen << 243 new G4UnitDefinition("teraelectronvolt","TeV","Energy",teraelectronvolt); 304 new G4UnitDefinition("kilohertz", "kHz", "Fr << 244 new G4UnitDefinition("petaelectronvolt","PeV","Energy",petaelectronvolt); 305 new G4UnitDefinition("megahertz", "MHz", "Fr << 245 new G4UnitDefinition( "joule","J" ,"Energy",joule); 306 << 246 307 // Velocity << 247 // Energy/Length 308 new G4UnitDefinition("cm/ns", "cm/ns", "Velo << 248 new G4UnitDefinition( "GeV/cm", "GeV/cm","Energy/Length", GeV/cm); 309 new G4UnitDefinition("mm/ns", "mm/ns", "Velo << 249 new G4UnitDefinition( "MeV/cm", "MeV/cm","Energy/Length", MeV/cm); 310 new G4UnitDefinition("cm/us", "cm/us", "Velo << 250 new G4UnitDefinition( "keV/cm", "keV/cm","Energy/Length", keV/cm); 311 new G4UnitDefinition("km/s" , "km/s" , "Velo << 251 new G4UnitDefinition( "eV/cm", "eV/cm","Energy/Length", eV/cm); 312 new G4UnitDefinition("cm/ms", "cm/ms", "Velo << 313 new G4UnitDefinition( "m/s" , "m/s" , "Velo << 314 new G4UnitDefinition("cm/s" , "cm/s" , "Velo << 315 new G4UnitDefinition("mm/s" , "mm/s" , "Velo << 316 << 317 // Electric charge << 318 new G4UnitDefinition("eplus", "e+", "Electri << 319 new G4UnitDefinition("coulomb", "C", "Electr << 320 << 321 // Energy << 322 new G4UnitDefinition("electronvolt", "eV", " << 323 new G4UnitDefinition("kiloelectronvolt", "ke << 324 new G4UnitDefinition("megaelectronvolt", "Me << 325 new G4UnitDefinition("gigaelectronvolt", "Ge << 326 new G4UnitDefinition("teraelectronvolt", "Te << 327 new G4UnitDefinition("petaelectronvolt", "Pe << 328 new G4UnitDefinition("millielectronVolt", "m << 329 new G4UnitDefinition("joule", "J", "Energy", << 330 << 331 //Momentum << 332 new G4UnitDefinition( "eV/c", "eV/c", "Mome << 333 new G4UnitDefinition("keV/c", "keV/c", "Mome << 334 new G4UnitDefinition("MeV/c", "MeV/c", "Mome << 335 new G4UnitDefinition("GeV/c", "GeV/c", "Mome << 336 new G4UnitDefinition("TeV/c", "TeV/c", "Mome << 337 252 338 // Energy/Length << 253 //Mass 339 new G4UnitDefinition("GeV/cm", "GeV/cm", "En << 254 new G4UnitDefinition("milligram","mg","Mass",milligram); 340 new G4UnitDefinition("MeV/cm", "MeV/cm", "En << 255 new G4UnitDefinition( "gram","g" ,"Mass",gram); 341 new G4UnitDefinition("keV/cm", "keV/cm", "En << 256 new G4UnitDefinition( "kilogram","kg","Mass",kilogram); 342 new G4UnitDefinition("eV/cm", "eV/cm", "Ener << 257 343 << 258 //Volumic Mass 344 // Mass << 259 new G4UnitDefinition( "g/cm3", "g/cm3","Volumic Mass", g/cm3); 345 new G4UnitDefinition("milligram", "mg", "Mas << 260 new G4UnitDefinition("mg/cm3","mg/cm3","Volumic Mass",mg/cm3); 346 new G4UnitDefinition("gram", "g", "Mass", gr << 261 new G4UnitDefinition("kg/m3", "kg/m3", "Volumic Mass",kg/m3); 347 new G4UnitDefinition("kilogram", "kg", "Mass << 262 348 << 263 // Mass/Surface 349 // Volumic Mass << 264 new G4UnitDefinition( "g/cm2", "g/cm2","Mass/Surface", g/cm2); 350 new G4UnitDefinition("g/cm3", "g/cm3", "Volu << 265 new G4UnitDefinition( "mg/cm2", "mg/cm2","Mass/Surface", mg/cm2); 351 new G4UnitDefinition("mg/cm3", "mg/cm3", "Vo << 266 new G4UnitDefinition( "kg/cm2", "kg/cm2","Mass/Surface", kg/cm2); 352 new G4UnitDefinition("kg/m3", "kg/m3", "Volu << 267 353 << 268 // Surface/Mass 354 // Mass/Surface << 269 new G4UnitDefinition( "cm2/g", "cm2/g","Surface/Mass", cm2/g); 355 new G4UnitDefinition("g/cm2", "g/cm2", "Mass << 270 356 new G4UnitDefinition("mg/cm2", "mg/cm2", "Ma << 271 // Energy.Surface/Mass 357 new G4UnitDefinition("kg/cm2", "kg/cm2", "Ma << 272 new G4UnitDefinition( "eV*cm2/g", " eV*cm2/g","Energy*Surface/Mass", eV*cm2/g); 358 << 273 new G4UnitDefinition("keV*cm2/g", "keV*cm2/g","Energy*Surface/Mass",keV*cm2/g); 359 // Surface/Mass << 274 new G4UnitDefinition("MeV*cm2/g", "MeV*cm2/g","Energy*Surface/Mass",MeV*cm2/g); 360 new G4UnitDefinition("cm2/g", "cm2/g", "Surf << 275 new G4UnitDefinition("GeV*cm2/g", "GeV*cm2/g","Energy*Surface/Mass",GeV*cm2/g); 361 << 276 362 // Energy.Surface/Mass << 277 //Power 363 new G4UnitDefinition("eV*cm2/g", " eV*cm2/g" << 278 new G4UnitDefinition("watt","W","Power",watt); 364 eV * cm2 / g); << 279 365 new G4UnitDefinition("keV*cm2/g", "keV*cm2/g << 280 //Force 366 keV * cm2 / g); << 281 new G4UnitDefinition("newton","N","Force",newton); 367 new G4UnitDefinition("MeV*cm2/g", "MeV*cm2/g << 282 368 MeV * cm2 / g); << 283 //Pressure 369 new G4UnitDefinition("GeV*cm2/g", "GeV*cm2/g << 284 new G4UnitDefinition( "pascal","Pa" ,"Pressure",pascal); 370 GeV * cm2 / g); << 285 new G4UnitDefinition( "bar","bar","Pressure",bar); 371 << 286 new G4UnitDefinition("atmosphere","atm","Pressure",atmosphere); 372 // Power << 287 373 new G4UnitDefinition("watt", "W", "Power", w << 288 //Electric current 374 << 289 new G4UnitDefinition( "ampere","A" ,"Electric current",ampere); 375 // Force << 290 new G4UnitDefinition("milliampere","mA" ,"Electric current",milliampere); 376 new G4UnitDefinition("newton", "N", "Force", << 291 new G4UnitDefinition("microampere","muA","Electric current",microampere); 377 << 292 new G4UnitDefinition( "nanoampere","nA" ,"Electric current",nanoampere); 378 // Pressure << 293 379 new G4UnitDefinition("pascal", "Pa", "Pressu << 294 //Electric potential 380 new G4UnitDefinition("bar", "bar", "Pressure << 295 new G4UnitDefinition( "volt","V" ,"Electric potential",volt); 381 new G4UnitDefinition("atmosphere", "atm", "P << 296 new G4UnitDefinition("kilovolt","kV","Electric potential",kilovolt); 382 << 297 new G4UnitDefinition("megavolt","MV","Electric potential",megavolt); 383 // Electric current << 298 384 new G4UnitDefinition("ampere", "A", "Electri << 299 //Electric field 385 new G4UnitDefinition("milliampere", "mA", "E << 300 new G4UnitDefinition( "volt/m","V/m","Electric field",volt/m); 386 new G4UnitDefinition("microampere", "muA", " << 301 387 new G4UnitDefinition("nanoampere", "nA", "El << 302 //Magnetic flux 388 << 303 new G4UnitDefinition("weber","Wb","Magnetic flux",weber); 389 // Electric potential << 304 390 new G4UnitDefinition("volt", "V", "Electric << 305 //Magnetic flux density 391 new G4UnitDefinition("kilovolt", "kV", "Elec << 306 new G4UnitDefinition( "tesla","T" ,"Magnetic flux density",tesla); 392 new G4UnitDefinition("megavolt", "MV", "Elec << 307 new G4UnitDefinition("kilogauss","kG","Magnetic flux density",kilogauss); 393 << 308 new G4UnitDefinition( "gauss","G" ,"Magnetic flux density",gauss); 394 // Electric field << 309 395 new G4UnitDefinition("volt/m", "V/m", "Elect << 310 //Temperature 396 new G4UnitDefinition("kilovolt/m", "kV/m", " << 311 new G4UnitDefinition("kelvin","K","Temperature",kelvin); 397 new G4UnitDefinition("megavolt/m", "MV/m", " << 312 398 << 313 //Amount of substance 399 // Magnetic flux << 314 new G4UnitDefinition("mole","mol","Amount of substance",mole); 400 new G4UnitDefinition("weber", "Wb", "Magneti << 315 401 << 316 //Activity 402 // Magnetic flux density << 317 new G4UnitDefinition("becquerel","Bq","Activity",becquerel); 403 new G4UnitDefinition("tesla", "T", "Magnetic << 318 new G4UnitDefinition( "curie","Ci","Activity",curie); 404 new G4UnitDefinition("kilogauss", "kG", "Mag << 319 405 new G4UnitDefinition("gauss", "G", "Magnetic << 320 //Dose 406 << 321 new G4UnitDefinition("gray","Gy","Dose",gray); 407 // Temperature << 408 new G4UnitDefinition("kelvin", "K", "Tempera << 409 << 410 // Amount of substance << 411 new G4UnitDefinition("mole", "mol", "Amount << 412 new G4UnitDefinition("g/mole", "g/mol", "Mol << 413 << 414 // Activity << 415 new G4UnitDefinition("becquerel", "Bq", "Act << 416 new G4UnitDefinition("curie", "Ci", "Activit << 417 << 418 // Dose << 419 new G4UnitDefinition("gray", "Gy", "Dose", g << 420 } 322 } 421 323 422 // ------------------------------------------- << 324 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 423 << 325 424 void G4UnitDefinition::PrintUnitsTable() 326 void G4UnitDefinition::PrintUnitsTable() 425 { 327 { 426 G4cout << "\n ----- The Table of Un 328 G4cout << "\n ----- The Table of Units ----- \n"; 427 if(pUnitsTable == nullptr) << 329 for(size_t i=0;i<theUnitsTable.size();i++) 428 { 330 { 429 pUnitsTable = new G4UnitsTable; << 331 theUnitsTable[i]->PrintCategory(); 430 } << 431 for(std::size_t i = 0; i < pUnitsTable->size << 432 { << 433 (*pUnitsTable)[i]->PrintCategory(); << 434 } 332 } 435 } 333 } 436 334 437 // ------------------------------------------- << 335 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 438 336 439 void G4UnitDefinition::ClearUnitsTable() 337 void G4UnitDefinition::ClearUnitsTable() 440 { 338 { 441 #ifdef G4MULTITHREADED << 339 for (size_t i=0;i<theUnitsTable.size();i++) 442 delete pUnitsTable; << 443 pUnitsTable = nullptr; << 444 if(G4Threading::IsMasterThread()) << 445 { << 446 pUnitsTableShadow = nullptr; << 447 } << 448 #else << 449 for(std::size_t i = 0; i < pUnitsTable->size << 450 { 340 { 451 delete(*pUnitsTable)[i]; << 341 delete theUnitsTable[i]; 452 } 342 } 453 pUnitsTable->clear(); << 343 theUnitsTable.clear(); 454 #endif << 455 unitsTableDestroyed = true; << 456 } 344 } 457 345 458 // ------------------------------------------- << 346 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 459 << 347 460 G4UnitsCategory::G4UnitsCategory(const G4Strin 348 G4UnitsCategory::G4UnitsCategory(const G4String& name) 461 : Name(name) << 349 : Name(name),UnitsList(),NameMxLen(0),SymbMxLen(0) 462 {} << 350 { 463 << 351 } 464 // ------------------------------------------- << 465 352 >> 353 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... >> 354 466 G4UnitsCategory::~G4UnitsCategory() 355 G4UnitsCategory::~G4UnitsCategory() 467 { 356 { 468 for(auto& i : UnitsList) << 357 for(size_t i=0;i<UnitsList.size();i++) 469 { 358 { 470 delete i; << 359 delete UnitsList[i]; 471 } 360 } 472 UnitsList.clear(); 361 UnitsList.clear(); 473 } 362 } 474 363 475 // ------------------------------------------- << 364 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 476 << 365 477 G4UnitsCategory::G4UnitsCategory(const G4Units 366 G4UnitsCategory::G4UnitsCategory(const G4UnitsCategory& right) 478 { 367 { 479 *this = right; 368 *this = right; 480 } 369 } 481 370 482 // ------------------------------------------- << 371 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 483 << 372 484 G4UnitsCategory& G4UnitsCategory::operator=(co 373 G4UnitsCategory& G4UnitsCategory::operator=(const G4UnitsCategory& right) 485 { 374 { 486 if(this != &right) << 375 if (this != &right) 487 { << 376 { 488 Name = right.Name; << 377 Name = right.Name; 489 UnitsList = right.UnitsList; << 378 UnitsList = right.UnitsList; 490 NameMxLen = right.NameMxLen; << 379 NameMxLen = right.NameMxLen; 491 SymbMxLen = right.SymbMxLen; << 380 SymbMxLen = right.SymbMxLen; 492 } << 381 } 493 return *this; 382 return *this; 494 } 383 } 495 384 496 // ------------------------------------------- << 385 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 497 << 386 498 G4bool G4UnitsCategory::operator==(const G4Uni << 387 G4int G4UnitsCategory::operator==(const G4UnitsCategory& right) const 499 { 388 { 500 return (this == (G4UnitsCategory*) &right); << 389 return (this == (G4UnitsCategory *) &right); 501 } 390 } 502 391 503 // ------------------------------------------- << 392 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 504 << 393 505 G4bool G4UnitsCategory::operator!=(const G4Uni << 394 G4int G4UnitsCategory::operator!=(const G4UnitsCategory &right) const 506 { 395 { 507 return (this != (G4UnitsCategory*) &right); << 396 return (this != (G4UnitsCategory *) &right); 508 } 397 } 509 398 510 // ------------------------------------------- << 399 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 511 << 400 512 void G4UnitsCategory::PrintCategory() 401 void G4UnitsCategory::PrintCategory() 513 { 402 { 514 G4cout << "\n category: " << Name << G4endl 403 G4cout << "\n category: " << Name << G4endl; 515 for(auto& i : UnitsList) << 404 for(size_t i=0;i<UnitsList.size();i++) 516 { << 405 { UnitsList[i]->PrintDefinition(); } 517 i->PrintDefinition(); << 518 } << 519 } 406 } 520 407 521 // ------------------------------------------- << 408 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 522 << 409 523 G4BestUnit::G4BestUnit(G4double value, const G 410 G4BestUnit::G4BestUnit(G4double value, const G4String& category) 524 : nbOfVals(1) 411 : nbOfVals(1) 525 { 412 { 526 // find the category << 413 // find the category 527 G4UnitsTable& theUnitsTable = G4UnitDefiniti << 414 G4UnitsTable& theUnitsTable = G4UnitDefinition::GetUnitsTable(); 528 std::size_t nbCat = theUnitsTable. << 415 size_t nbCat = theUnitsTable.size(); 529 std::size_t i = 0; << 416 size_t i = 0; 530 while((i < nbCat) && (theUnitsTable[i]->GetN << 417 while ((i<nbCat)&&(theUnitsTable[i]->GetName()!=category)) { i++; } 531 { << 418 if (i == nbCat) 532 ++i; << 419 { 533 } << 420 G4cout << " G4BestUnit: the category " << category 534 if(i == nbCat) << 421 << " does not exist !!" << G4endl; 535 { << 422 G4Exception("G4BestUnit::G4BestUnit()", "InvalidCall", 536 G4cout << " G4BestUnit: the category " << << 423 FatalException, "Missing unit category !") ; 537 << G4endl; << 424 } 538 G4Exception("G4BestUnit::G4BestUnit()", "I << 425 // 539 "Missing unit category !"); << 426 Value[0] = value; 540 } << 427 Value[1] = 0.; 541 << 428 Value[2] = 0.; 542 Value[0] = value; << 429 IndexOfCategory = i; 543 Value[1] = 0.; << 544 Value[2] = 0.; << 545 Category = category; << 546 IndexOfCategory = i; << 547 } 430 } 548 431 549 // ------------------------------------------- << 432 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 550 << 433 551 G4BestUnit::G4BestUnit(const G4ThreeVector& va 434 G4BestUnit::G4BestUnit(const G4ThreeVector& value, const G4String& category) 552 : nbOfVals(3) 435 : nbOfVals(3) 553 { 436 { 554 // find the category << 437 // find the category 555 G4UnitsTable& theUnitsTable = G4UnitDefiniti << 438 G4UnitsTable& theUnitsTable = G4UnitDefinition::GetUnitsTable(); 556 std::size_t nbCat = theUnitsTable. << 439 size_t nbCat = theUnitsTable.size(); 557 std::size_t i = 0; << 440 size_t i = 0; 558 while((i < nbCat) && (theUnitsTable[i]->GetN << 441 while ((i<nbCat)&&(theUnitsTable[i]->GetName()!=category)) { i++; } 559 { << 442 if (i == nbCat) 560 ++i; << 443 { 561 } << 444 G4cerr << " G4BestUnit: the category " << category 562 if(i == nbCat) << 445 << " does not exist." << G4endl; 563 { << 446 G4Exception("G4BestUnit::G4BestUnit()", "InvalidCall", 564 G4cerr << " G4BestUnit: the category " << << 447 FatalException, "Missing unit category !") ; 565 << G4endl; << 448 } 566 G4Exception("G4BestUnit::G4BestUnit()", "I << 449 // 567 "Missing unit category !"); << 450 Value[0] = value.x(); 568 } << 451 Value[1] = value.y(); 569 << 452 Value[2] = value.z(); 570 Value[0] = value.x(); << 453 IndexOfCategory = i; 571 Value[1] = value.y(); << 454 } 572 Value[2] = value.z(); << 455 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 573 Category = category; << 456 574 IndexOfCategory = i; << 457 G4BestUnit::~G4BestUnit() 575 } << 458 {} 576 459 577 // ------------------------------------------- << 460 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 578 461 579 G4BestUnit::operator G4String() const << 462 G4BestUnit::operator G4String () const 580 { 463 { 581 std::ostringstream oss; 464 std::ostringstream oss; 582 oss << *this; 465 oss << *this; 583 return oss.str(); 466 return oss.str(); 584 } 467 } 585 468 586 // ------------------------------------------- << 469 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 587 << 470 588 std::ostream& operator<<(std::ostream& flux, c << 471 std::ostream& operator<<(std::ostream& flux, G4BestUnit a) 589 { 472 { 590 G4UnitsTable& theUnitsTable = G4UnitDefiniti 473 G4UnitsTable& theUnitsTable = G4UnitDefinition::GetUnitsTable(); 591 G4UnitsContainer& List = theUnitsTable[a.Ind << 474 G4UnitsContainer& List = theUnitsTable[a.IndexOfCategory] 592 G4int len = theUnitsTable[a.Ind << 475 ->GetUnitsList(); 593 << 476 G4int len = theUnitsTable[a.IndexOfCategory]->GetSymbMxLen(); 594 G4long ksup(-1), kinf(-1); << 477 >> 478 G4int ksup(-1), kinf(-1); 595 G4double umax(0.), umin(DBL_MAX); 479 G4double umax(0.), umin(DBL_MAX); 596 G4double rsup(DBL_MAX), rinf(0.); 480 G4double rsup(DBL_MAX), rinf(0.); 597 481 598 // for a ThreeVector, choose the best unit f << 482 //for a ThreeVector, choose the best unit for the biggest value 599 G4double value = << 483 G4double value = std::max(std::max(std::fabs(a.Value[0]), 600 std::max(std::max(std::fabs(a.Value[0]), s << 484 std::fabs(a.Value[1])), 601 std::fabs(a.Value[2])); << 485 std::fabs(a.Value[2])); 602 << 486 603 //special treatement for Energy. << 487 for (size_t k=0; k<List.size(); k++) 604 if ((a.Category == "Energy") && (value == 0. << 488 { 605 for (G4int j = 0; j < a.nbOfVals; ++j) { << 489 G4double unit = List[k]->GetValue(); 606 flux << a.Value[j] << " "; << 490 if (!(value!=DBL_MAX)) 607 } << 491 {if(unit>umax) {umax=unit; ksup=k;}} 608 std::ios::fmtflags oldform = flux.flags(); << 492 else if (value<=DBL_MIN) 609 flux.setf(std::ios::left, std::ios::adjust << 493 {if(unit<umin) {umin=unit; kinf=k;}} 610 flux << std::setw(len) << "eV"; << 494 else 611 flux.flags(oldform); << 495 { 612 return flux; << 496 G4double ratio = value/unit; 613 } << 497 if ((ratio>=1.)&&(ratio<rsup)) {rsup=ratio; ksup=k;} 614 << 498 if ((ratio< 1.)&&(ratio>rinf)) {rinf=ratio; kinf=k;} 615 //here, value != 0. << 499 } 616 for(std::size_t k = 0; k < List.size(); ++k) << 500 } 617 { << 501 618 G4double unit = List[k]->GetValue(); << 502 G4int index=ksup; 619 if(!(value != DBL_MAX)) << 503 if(index==-1) { index=kinf; } 620 { << 504 if(index==-1) { index=0; } 621 if(unit > umax) << 505 622 { << 506 for (G4int j=0; j<a.nbOfVals; j++) 623 umax = unit; << 507 { flux << a.Value[j]/(List[index]->GetValue()) << " "; } 624 ksup = k; << 625 } << 626 } << 627 else if(value <= DBL_MIN) << 628 { << 629 if(unit < umin) << 630 { << 631 umin = unit; << 632 kinf = k; << 633 } << 634 } << 635 else << 636 { << 637 G4double ratio = value / unit; << 638 if((ratio >= 1.) && (ratio < rsup)) << 639 { << 640 rsup = ratio; << 641 ksup = k; << 642 } << 643 if((ratio < 1.) && (ratio > rinf)) << 644 { << 645 rinf = ratio; << 646 kinf = k; << 647 } << 648 } << 649 } << 650 << 651 G4long index = ksup; << 652 if(index == -1) << 653 { << 654 index = kinf; << 655 } << 656 if(index == -1) << 657 { << 658 index = 0; << 659 } << 660 << 661 for(G4int j = 0; j < a.nbOfVals; ++j) << 662 { << 663 flux << a.Value[j] / (List[index]->GetValu << 664 } << 665 508 666 std::ios::fmtflags oldform = flux.flags(); 509 std::ios::fmtflags oldform = flux.flags(); 667 510 668 flux.setf(std::ios::left, std::ios::adjustfi << 511 flux.setf(std::ios::left,std::ios::adjustfield); 669 flux << std::setw(len) << List[index]->GetSy << 512 flux << std::setw(len) << List[index]->GetSymbol(); 670 flux.flags(oldform); 513 flux.flags(oldform); 671 514 672 return flux; 515 return flux; 673 } << 516 } 674 << 675 // ------------------------------------------- << 676 << 677 #ifdef G4MULTITHREADED << 678 << 679 void G4UnitsTable::Synchronize() << 680 { << 681 G4UnitsTable* orig = &(G4UnitDefinition::Get << 682 if(this == orig) << 683 { << 684 return; << 685 } << 686 << 687 for(const auto category : *orig) << 688 { << 689 G4String catName = category->GetN << 690 G4UnitsContainer* units = &(category->Ge << 691 for(const auto unit : *units) << 692 { << 693 if(!Contains(unit, catName)) << 694 { << 695 new G4UnitDefinition(unit->GetName(), << 696 unit->GetValue()) << 697 } << 698 } << 699 } << 700 } << 701 << 702 // ------------------------------------------- << 703 << 704 G4bool G4UnitsTable::Contains(const G4UnitDefi << 705 const G4String& << 706 { << 707 for(const auto category : *this) << 708 { << 709 G4String catName = category->GetName(); << 710 if(catName != categoryName) << 711 { << 712 continue; << 713 } << 714 G4UnitsContainer* units = &(category->GetU << 715 for(const auto ucItr : *units) << 716 { << 717 if(ucItr->GetName() == unit->GetName() & << 718 ucItr->GetSymbol() == unit->GetSymbol << 719 { << 720 return true; << 721 } << 722 } << 723 } << 724 return false; << 725 } << 726 517 727 #endif << 518 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo...... 728 519