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