Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/global/management/src/G4UnitsTable.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /global/management/src/G4UnitsTable.cc (Version 11.3.0) and /global/management/src/G4UnitsTable.cc (Version 8.1.p2)


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