G4UnitDefinition Class Reference

#include <G4UnitsTable.hh>

Public Member Functions
	G4UnitDefinition (const G4String &name, const G4String &symbol, const G4String &category, G4double value)
const G4String &	GetName () const
const G4String &	GetSymbol () const
G4double	GetValue () const
G4bool	operator!= (const G4UnitDefinition &) const
G4bool	operator== (const G4UnitDefinition &) const
void	PrintDefinition ()
	~G4UnitDefinition ()

Static Public Member Functions
static void	BuildUnitsTable ()
static void	ClearUnitsTable ()
static G4String	GetCategory (const G4String &)
static G4UnitsTable &	GetUnitsTable ()
static G4double	GetValueOf (const G4String &)
static G4bool	IsUnitDefined (const G4String &)
static void	PrintUnitsTable ()

Private Member Functions
	G4UnitDefinition (const G4UnitDefinition &)
G4UnitDefinition &	operator= (const G4UnitDefinition &)

Private Attributes
std::size_t	CategoryIndex = 0
G4String	Name
G4String	SymbolName
G4double	Value = 0.0

Static Private Attributes
static G4ThreadLocal G4UnitsTable *	pUnitsTable = nullptr
static G4ThreadLocal G4bool	unitsTableDestroyed = false

Detailed Description

Definition at line 74 of file G4UnitsTable.hh.

Constructor & Destructor Documentation

G4UnitDefinition() [1/2]

G4UnitDefinition::G4UnitDefinition	(	const G4String &	name,
		const G4String &	symbol,
		const G4String &	category,
		G4double	value
	)

Definition at line 64 of file G4UnitsTable.cc.

  : Name(name)
  , SymbolName(symbol)
  , Value(value)
{
  if(pUnitsTable == nullptr)
  {
    if(unitsTableDestroyed)
    {
      G4Exception("G4UnitDefinition::G4UnitDefinition", "UnitsTable0000",
                  FatalException, "G4UnitsTable had already deleted.");
    }
    pUnitsTable = new G4UnitsTable;
#ifdef G4MULTITHREADED
    if(G4Threading::IsMasterThread())
    {
      pUnitsTableShadow = pUnitsTable;
    }
#endif
  }
 
  // Does the Category objet already exist ?
  //
  std::size_t nbCat = pUnitsTable->size();
  std::size_t i     = 0;
  while((i < nbCat) && ((*pUnitsTable)[i]->GetName() != category))
  {
    ++i;
  }
  if(i == nbCat)
  {
    pUnitsTable->push_back(new G4UnitsCategory(category));
  }
  CategoryIndex = i;
 
  // Insert this Unit in the Units table
  //
  ((*pUnitsTable)[CategoryIndex]->GetUnitsList()).push_back(this);
 
  // Update string max length for name and symbol
  //
  (*pUnitsTable)[i]->UpdateNameMxLen((G4int) name.length());
  (*pUnitsTable)[i]->UpdateSymbMxLen((G4int) symbol.length());
}

References CategoryIndex, FatalException, G4Exception(), GetName(), G4Threading::IsMasterThread(), G4InuclParticleNames::name(), pUnitsTable, and unitsTableDestroyed.

Referenced by BuildUnitsTable().

~G4UnitDefinition()

G4UnitDefinition::~G4UnitDefinition

(

)

Definition at line 112 of file G4UnitsTable.cc.

{}

G4UnitDefinition() [2/2]

G4UnitDefinition::G4UnitDefinition ( const G4UnitDefinition &  right )

private

Definition at line 116 of file G4UnitsTable.cc.

{
  *this = right;
}

Member Function Documentation

BuildUnitsTable()

void G4UnitDefinition::BuildUnitsTable ( )

static

Definition at line 254 of file G4UnitsTable.cc.

{
  // Length
  new G4UnitDefinition("parsec", "pc", "Length", parsec);
  new G4UnitDefinition("kilometer", "km", "Length", kilometer);
  new G4UnitDefinition("meter", "m", "Length", meter);
  new G4UnitDefinition("centimeter", "cm", "Length", centimeter);
  new G4UnitDefinition("millimeter", "mm", "Length", millimeter);
  new G4UnitDefinition("micrometer", "um", "Length", micrometer);
  new G4UnitDefinition("nanometer", "nm", "Length", nanometer);
  new G4UnitDefinition("angstrom", "Ang", "Length", angstrom);
  new G4UnitDefinition("fermi", "fm", "Length", fermi);
 
  // Surface
  new G4UnitDefinition("kilometer2", "km2", "Surface", kilometer2);
  new G4UnitDefinition("meter2", "m2", "Surface", meter2);
  new G4UnitDefinition("centimeter2", "cm2", "Surface", centimeter2);
  new G4UnitDefinition("millimeter2", "mm2", "Surface", millimeter2);
  new G4UnitDefinition("barn", "barn", "Surface", barn);
  new G4UnitDefinition("millibarn", "mbarn", "Surface", millibarn);
  new G4UnitDefinition("microbarn", "mubarn", "Surface", microbarn);
  new G4UnitDefinition("nanobarn", "nbarn", "Surface", nanobarn);
  new G4UnitDefinition("picobarn", "pbarn", "Surface", picobarn);
 
  // Volume
  new G4UnitDefinition("kilometer3", "km3", "Volume", kilometer3);
  new G4UnitDefinition("meter3", "m3", "Volume", meter3);
  new G4UnitDefinition("centimeter3", "cm3", "Volume", centimeter3);
  new G4UnitDefinition("millimeter3", "mm3", "Volume", millimeter3);
 
  new G4UnitDefinition("liter", "L", "Volume", liter);
  new G4UnitDefinition("dL", "dL", "Volume", dL);
  new G4UnitDefinition("cL", "cL", "Volume", cL);
  new G4UnitDefinition("mL", "mL", "Volume", mL);
 
  // Angle
  new G4UnitDefinition("radian", "rad", "Angle", radian);
  new G4UnitDefinition("milliradian", "mrad", "Angle", milliradian);
  new G4UnitDefinition("degree", "deg", "Angle", degree);
 
  // Solid angle
  new G4UnitDefinition("steradian", "sr", "Solid angle", steradian);
  new G4UnitDefinition("millisteradian", "msr", "Solid angle",
                       steradian * 0.001);
 
  // Time
  new G4UnitDefinition("second", "s", "Time", second);
  new G4UnitDefinition("millisecond", "ms", "Time", millisecond);
  new G4UnitDefinition("microsecond", "us", "Time", microsecond);
  new G4UnitDefinition("nanosecond", "ns", "Time", nanosecond);
  new G4UnitDefinition("picosecond", "ps", "Time", picosecond);
  new G4UnitDefinition("minute", "min", "Time", minute);
  new G4UnitDefinition("hour",   "h",   "Time", hour);
  new G4UnitDefinition("day",    "d",   "Time", day);
  new G4UnitDefinition("year",   "y",   "Time", year);
 
  // Frequency
  new G4UnitDefinition("hertz", "Hz", "Frequency", hertz);
  new G4UnitDefinition("kilohertz", "kHz", "Frequency", kilohertz);
  new G4UnitDefinition("megahertz", "MHz", "Frequency", megahertz);
  
  // Velocity
  new G4UnitDefinition("cm/ns", "cm/ns", "Velocity", cm/ns);
  new G4UnitDefinition("mm/ns", "mm/ns", "Velocity", mm/ns);
  new G4UnitDefinition("cm/us", "cm/us", "Velocity", cm/us);
  new G4UnitDefinition("km/s" , "km/s" , "Velocity", km/s);
  new G4UnitDefinition("cm/ms", "cm/ms", "Velocity", cm/ms);
  new G4UnitDefinition( "m/s" ,  "m/s" , "Velocity",  m/s);
  new G4UnitDefinition("cm/s" , "cm/s" , "Velocity", cm/s);
  new G4UnitDefinition("mm/s" , "mm/s" , "Velocity", mm/s);      
 
  // Electric charge
  new G4UnitDefinition("eplus", "e+", "Electric charge", eplus);
  new G4UnitDefinition("coulomb", "C", "Electric charge", coulomb);
 
  // Energy
  new G4UnitDefinition("electronvolt", "eV", "Energy", electronvolt);
  new G4UnitDefinition("kiloelectronvolt", "keV", "Energy", kiloelectronvolt);
  new G4UnitDefinition("megaelectronvolt", "MeV", "Energy", megaelectronvolt);
  new G4UnitDefinition("gigaelectronvolt", "GeV", "Energy", gigaelectronvolt);
  new G4UnitDefinition("teraelectronvolt", "TeV", "Energy", teraelectronvolt);
  new G4UnitDefinition("petaelectronvolt", "PeV", "Energy", petaelectronvolt);
  new G4UnitDefinition("millielectronVolt", "meV", "Energy", millielectronvolt);
  new G4UnitDefinition("joule", "J", "Energy", joule);
  
  //Momentum
  new G4UnitDefinition( "eV/c",  "eV/c", "Momentum", eV);
  new G4UnitDefinition("keV/c", "keV/c", "Momentum", keV);
  new G4UnitDefinition("MeV/c", "MeV/c", "Momentum", MeV);
  new G4UnitDefinition("GeV/c", "GeV/c", "Momentum", GeV);
  new G4UnitDefinition("TeV/c", "TeV/c", "Momentum", TeV);
  
  // Energy/Length
  new G4UnitDefinition("GeV/cm", "GeV/cm", "Energy/Length", GeV / cm);
  new G4UnitDefinition("MeV/cm", "MeV/cm", "Energy/Length", MeV / cm);
  new G4UnitDefinition("keV/cm", "keV/cm", "Energy/Length", keV / cm);
  new G4UnitDefinition("eV/cm", "eV/cm", "Energy/Length", eV / cm);
 
  // Mass
  new G4UnitDefinition("milligram", "mg", "Mass", milligram);
  new G4UnitDefinition("gram", "g", "Mass", gram);
  new G4UnitDefinition("kilogram", "kg", "Mass", kilogram);
 
  // Volumic Mass
  new G4UnitDefinition("g/cm3", "g/cm3", "Volumic Mass", g / cm3);
  new G4UnitDefinition("mg/cm3", "mg/cm3", "Volumic Mass", mg / cm3);
  new G4UnitDefinition("kg/m3", "kg/m3", "Volumic Mass", kg / m3);
 
  // Mass/Surface
  new G4UnitDefinition("g/cm2", "g/cm2", "Mass/Surface", g / cm2);
  new G4UnitDefinition("mg/cm2", "mg/cm2", "Mass/Surface", mg / cm2);
  new G4UnitDefinition("kg/cm2", "kg/cm2", "Mass/Surface", kg / cm2);
 
  // Surface/Mass
  new G4UnitDefinition("cm2/g", "cm2/g", "Surface/Mass", cm2 / g);
 
  // Energy.Surface/Mass
  new G4UnitDefinition("eV*cm2/g", " eV*cm2/g", "Energy*Surface/Mass",
                       eV * cm2 / g);
  new G4UnitDefinition("keV*cm2/g", "keV*cm2/g", "Energy*Surface/Mass",
                       keV * cm2 / g);
  new G4UnitDefinition("MeV*cm2/g", "MeV*cm2/g", "Energy*Surface/Mass",
                       MeV * cm2 / g);
  new G4UnitDefinition("GeV*cm2/g", "GeV*cm2/g", "Energy*Surface/Mass",
                       GeV * cm2 / g);
 
  // Power
  new G4UnitDefinition("watt", "W", "Power", watt);
 
  // Force
  new G4UnitDefinition("newton", "N", "Force", newton);
 
  // Pressure
  new G4UnitDefinition("pascal", "Pa", "Pressure", hep_pascal);
  new G4UnitDefinition("bar", "bar", "Pressure", bar);
  new G4UnitDefinition("atmosphere", "atm", "Pressure", atmosphere);
 
  // Electric current
  new G4UnitDefinition("ampere", "A", "Electric current", ampere);
  new G4UnitDefinition("milliampere", "mA", "Electric current", milliampere);
  new G4UnitDefinition("microampere", "muA", "Electric current", microampere);
  new G4UnitDefinition("nanoampere", "nA", "Electric current", nanoampere);
 
  // Electric potential
  new G4UnitDefinition("volt", "V", "Electric potential", volt);
  new G4UnitDefinition("kilovolt", "kV", "Electric potential", kilovolt);
  new G4UnitDefinition("megavolt", "MV", "Electric potential", megavolt);
 
  // Electric field
  new G4UnitDefinition("volt/m", "V/m", "Electric field", volt / m);
  new G4UnitDefinition("kilovolt/m", "kV/m", "Electric field", kilovolt / m);
  new G4UnitDefinition("megavolt/m", "MV/m", "Electric field", megavolt / m);
 
  // Magnetic flux
  new G4UnitDefinition("weber", "Wb", "Magnetic flux", weber);
 
  // Magnetic flux density
  new G4UnitDefinition("tesla", "T", "Magnetic flux density", tesla);
  new G4UnitDefinition("kilogauss", "kG", "Magnetic flux density", kilogauss);
  new G4UnitDefinition("gauss", "G", "Magnetic flux density", gauss);
 
  // Temperature
  new G4UnitDefinition("kelvin", "K", "Temperature", kelvin);
 
  // Amount of substance
  new G4UnitDefinition("mole", "mol", "Amount of substance", mole);
  new G4UnitDefinition("g/mole", "g/mol", "Molar mass", g / mole);
 
  // Activity
  new G4UnitDefinition("becquerel", "Bq", "Activity", becquerel);
  new G4UnitDefinition("curie", "Ci", "Activity", curie);
 
  // Dose
  new G4UnitDefinition("gray", "Gy", "Dose", gray);
}

References ampere, angstrom, atmosphere, bar, barn, becquerel, centimeter, centimeter2, centimeter3, cL, cm, cm2, cm3, coulomb, curie, day, degree, dL, electronvolt, eplus, eV, fermi, g, G4UnitDefinition(), gauss, GeV, gigaelectronvolt, gram, gray, hep_pascal, hertz, hour, joule, kelvin, keV, kg, kiloelectronvolt, kilogauss, kilogram, kilohertz, kilometer, kilometer2, kilometer3, kilovolt, km, liter, m, m3, megaelectronvolt, megahertz, megavolt, meter, meter2, meter3, MeV, mg, microampere, microbarn, micrometer, microsecond, milliampere, millibarn, millielectronvolt, milligram, millimeter, millimeter2, millimeter3, milliradian, millisecond, minute, mL, mm, mole, ms, nanoampere, nanobarn, nanometer, nanosecond, newton, ns, parsec, petaelectronvolt, picobarn, picosecond, radian, s, second, steradian, teraelectronvolt, tesla, TeV, us, volt, watt, weber, and year.

Referenced by export_G4UnitsTable(), GetUnitsTable(), and G4DimensionedTypeUtils::GetUnitValue().

ClearUnitsTable()

void G4UnitDefinition::ClearUnitsTable ( )

static

Definition at line 447 of file G4UnitsTable.cc.

{
#ifdef G4MULTITHREADED
  delete pUnitsTable;
  pUnitsTable = nullptr;
  if(G4Threading::IsMasterThread())
  {
    pUnitsTableShadow = nullptr;
  }
#else
  for(std::size_t i = 0; i < pUnitsTable->size(); ++i)
  {
    delete(*pUnitsTable)[i];
  }
  pUnitsTable->clear();
#endif
  unitsTableDestroyed = true;
}

References G4Threading::IsMasterThread(), pUnitsTable, and unitsTableDestroyed.

Referenced by G4RunManagerKernel::~G4RunManagerKernel().

GetCategory()

G4String G4UnitDefinition::GetCategory ( const G4String &  str )

static

Definition at line 218 of file G4UnitsTable.cc.

{
  G4String name, symbol;
  for(std::size_t i = 0; i < (GetUnitsTable()).size(); ++i)
  {
    G4UnitsContainer& units = (*pUnitsTable)[i]->GetUnitsList();
    for(std::size_t j = 0; j < units.size(); ++j)
    {
      name   = units[j]->GetName();
      symbol = units[j]->GetSymbol();
      if(str == name || str == symbol)
      {
        return (*pUnitsTable)[i]->GetName();
      }
    }
  }
  std::ostringstream message;
  message << "The unit '" << str << "' does not exist in the Units Table!";
  G4Exception("G4UnitDefinition::GetCategory()", "InvalidUnit", FatalException,
              message);
  name = "None";
  return name;
}

References FatalException, G4Exception(), GetUnitsTable(), G4InuclParticleNames::name(), and pUnitsTable.

Referenced by G4GDMLReadMaterials::AtomRead(), G4GDMLReadParamvol::Box_dimensionsRead(), G4GDMLReadSolids::BoxRead(), G4UIcommand::CategoryOf(), G4VPrimitiveScorer::CheckAndSetUnit(), G4GDMLReadParamvol::Cone_dimensionsRead(), G4GDMLReadSolids::ConeRead(), G4GDMLReadSolids::CutTubeRead(), G4GDMLReadStructure::DivisionvolRead(), G4GDMLReadMaterials::DRead(), G4GDMLReadSolids::ElconeRead(), G4GDMLReadParamvol::Ellipsoid_dimensionsRead(), G4GDMLReadSolids::EllipsoidRead(), G4GDMLReadSolids::EltubeRead(), export_G4UnitsTable(), G4GDMLReadSolids::GenericPolyconeRead(), G4GDMLReadSolids::GenericPolyhedraRead(), G4GDMLReadSolids::GenTrapRead(), G4GDMLReadParamvol::Hype_dimensionsRead(), G4GDMLReadSolids::HypeRead(), G4GDMLParser::ImportRegions(), G4GDMLReadMaterials::MEERead(), G4GDMLReadParamvol::Orb_dimensionsRead(), G4GDMLReadSolids::OrbRead(), G4GDMLReadParamvol::Para_dimensionsRead(), G4GDMLReadSolids::ParaboloidRead(), G4GDMLReadSolids::ParaRead(), G4GDMLReadParamvol::Polycone_dimensionsRead(), G4GDMLReadSolids::PolyconeRead(), G4GDMLReadParamvol::Polyhedra_dimensionsRead(), G4GDMLReadSolids::PolyhedraRead(), G4GDMLReadDefine::PositionRead(), G4GDMLReadMaterials::PRead(), G4VVisCommand::ProvideValueOfUnit(), G4GDMLReadSolids::QuadrangularRead(), G4GDMLReadStructure::QuantityRead(), G4GDMLReadSolids::ReflectedSolidRead(), G4GDMLReadDefine::RotationRead(), G4GDMLReadParamvol::Sphere_dimensionsRead(), G4GDMLReadSolids::SphereRead(), G4AttCheck::Standard(), G4GDMLReadSolids::TetRead(), G4GDMLReadParamvol::Torus_dimensionsRead(), G4GDMLReadSolids::TorusRead(), G4GDMLReadParamvol::Trap_dimensionsRead(), G4GDMLReadSolids::TrapRead(), G4GDMLReadParamvol::Trd_dimensionsRead(), G4GDMLReadSolids::TrdRead(), G4GDMLReadMaterials::TRead(), G4GDMLReadSolids::TriangularRead(), G4GDMLReadParamvol::Tube_dimensionsRead(), G4GDMLReadSolids::TubeRead(), G4GDMLReadSolids::TwistedboxRead(), G4GDMLReadSolids::TwistedtrapRead(), G4GDMLReadSolids::TwistedtrdRead(), G4GDMLReadSolids::TwistedtubsRead(), and G4GDMLReadSolids::XtruRead().

GetName()

const G4String & G4UnitDefinition::GetName ( ) const

inline

Referenced by export_G4UnitsTable(), G4UnitDefinition(), and G4DimensionedTypeUtils::HasName::operator()().

GetSymbol()

const G4String & G4UnitDefinition::GetSymbol ( ) const

inline

Referenced by export_G4UnitsTable(), and G4DimensionedTypeUtils::HasName::operator()().

GetUnitsTable()

G4UnitsTable & G4UnitDefinition::GetUnitsTable ( )

static

Definition at line 151 of file G4UnitsTable.cc.

{
  if(pUnitsTable == nullptr)
  {
    pUnitsTable = new G4UnitsTable;
  }
  if(pUnitsTable->size() == 0)
  {
    BuildUnitsTable();
  }
#ifdef G4MULTITHREADED
  if(G4Threading::IsMasterThread() && pUnitsTableShadow == nullptr)
  {
    pUnitsTableShadow = pUnitsTable;
  }
#endif
  return *pUnitsTable;
}

References BuildUnitsTable(), G4Threading::IsMasterThread(), and pUnitsTable.

Referenced by export_G4UnitsTable(), G4AttCheck::G4AttCheck(), G4BestUnit::G4BestUnit(), G4GDMLRead::G4GDMLRead(), G4RunManagerKernel::G4RunManagerKernel(), GetCategory(), G4DimensionedTypeUtils::GetUnitValue(), GetValueOf(), G4RunManagerKernel::InitializePhysics(), IsUnitDefined(), G4RunManagerKernel::RunInitialization(), G4RunManagerKernel::SetupPhysics(), and G4UIcommand::UnitsList().

GetValue()

G4double G4UnitDefinition::GetValue ( ) const

inline

Referenced by export_G4UnitsTable().

GetValueOf()

G4double G4UnitDefinition::GetValueOf ( const G4String &  str )

static

Definition at line 193 of file G4UnitsTable.cc.

{
  G4String name, symbol;
  for(std::size_t i = 0; i < (GetUnitsTable()).size(); ++i)
  {
    G4UnitsContainer& units = (*pUnitsTable)[i]->GetUnitsList();
    for(std::size_t j = 0; j < units.size(); ++j)
    {
      name   = units[j]->GetName();
      symbol = units[j]->GetSymbol();
      if(str == name || str == symbol)
      {
        return units[j]->GetValue();
      }
    }
  }
  std::ostringstream message;
  message << "The unit '" << str << "' does not exist in the Units Table!";
  G4Exception("G4UnitDefinition::GetValueOf()", "InvalidUnit", FatalException,
              message);
  return 0.;
}

References FatalException, G4Exception(), GetUnitsTable(), and G4InuclParticleNames::name().

Referenced by G4GDMLReadMaterials::AtomRead(), G4GDMLReadParamvol::Box_dimensionsRead(), G4GDMLReadSolids::BoxRead(), G4VPrimitiveScorer::CheckAndSetUnit(), G4GDMLReadParamvol::Cone_dimensionsRead(), G4GDMLReadSolids::ConeRead(), G4GDMLReadSolids::CutTubeRead(), G4GDMLReadStructure::DivisionvolRead(), G4GDMLReadMaterials::DRead(), G4GDMLReadSolids::ElconeRead(), G4GDMLReadParamvol::Ellipsoid_dimensionsRead(), G4GDMLReadSolids::EllipsoidRead(), G4GDMLReadSolids::EltubeRead(), export_G4UnitsTable(), G4ScoreQuantityMessenger::FParticleWithEnergyCommand(), G4GDMLReadSolids::GenericPolyconeRead(), G4GDMLReadSolids::GenericPolyhedraRead(), G4GDMLReadSolids::GenTrapRead(), G4tgrUtils::GetDouble(), G4Analysis::GetUnitValue(), G4GDMLReadParamvol::Hype_dimensionsRead(), G4GDMLReadSolids::HypeRead(), G4GDMLParser::ImportRegions(), G4GDMLReadMaterials::MEERead(), G4GDMLReadParamvol::Orb_dimensionsRead(), G4GDMLReadSolids::OrbRead(), G4GDMLReadParamvol::Para_dimensionsRead(), G4GDMLReadSolids::ParaboloidRead(), G4GDMLReadSolids::ParaRead(), G4GDMLReadParamvol::Polycone_dimensionsRead(), G4GDMLReadSolids::PolyconeRead(), G4GDMLReadParamvol::Polyhedra_dimensionsRead(), G4GDMLReadSolids::PolyhedraRead(), G4GDMLReadDefine::PositionRead(), G4GDMLReadMaterials::PRead(), G4VVisCommand::ProvideValueOfUnit(), G4GDMLReadSolids::QuadrangularRead(), G4GDMLReadStructure::QuantityRead(), G4GDMLReadDefine::QuantityRead(), G4GDMLReadSolids::ReflectedSolidRead(), G4GDMLReadDefine::RotationRead(), G4AdjointSimMessenger::SetNewValue(), G4ScoreQuantityMessenger::SetNewValue(), G4GDMLReadParamvol::Sphere_dimensionsRead(), G4GDMLReadSolids::SphereRead(), G4AttCheck::Standard(), G4GDMLReadSolids::TetRead(), G4GDMLReadParamvol::Torus_dimensionsRead(), G4GDMLReadSolids::TorusRead(), G4GDMLReadParamvol::Trap_dimensionsRead(), G4GDMLReadSolids::TrapRead(), G4GDMLReadParamvol::Trd_dimensionsRead(), G4GDMLReadSolids::TrdRead(), G4GDMLReadMaterials::TRead(), G4GDMLReadSolids::TriangularRead(), G4GDMLReadParamvol::Tube_dimensionsRead(), G4GDMLReadSolids::TubeRead(), G4GDMLReadSolids::TwistedboxRead(), G4GDMLReadSolids::TwistedtrapRead(), G4GDMLReadSolids::TwistedtrdRead(), G4GDMLReadSolids::TwistedtubsRead(), G4UIcommand::ValueOf(), G4GDMLReadDefine::VectorRead(), and G4GDMLReadSolids::XtruRead().

IsUnitDefined()

G4bool G4UnitDefinition::IsUnitDefined ( const G4String &  str )

static

Definition at line 172 of file G4UnitsTable.cc.

{
  G4String name, symbol;
  for(std::size_t i = 0; i < (GetUnitsTable()).size(); ++i)
  {
    G4UnitsContainer& units = (*pUnitsTable)[i]->GetUnitsList();
    for(std::size_t j = 0; j < units.size(); ++j)
    {
      name   = units[j]->GetName();
      symbol = units[j]->GetSymbol();
      if(str == name || str == symbol)
      {
        return true;
      }
    }
  }
  return false;
}

References GetUnitsTable(), and G4InuclParticleNames::name().

Referenced by G4VVisCommand::ConvertToDoublePair(), and G4VVisCommand::ProvideValueOfUnit().

operator!=()

G4bool G4UnitDefinition::operator!=

(

const G4UnitDefinition &

right

)

const

Definition at line 144 of file G4UnitsTable.cc.

{
  return (this != (G4UnitDefinition*) &right);
}

operator=()

G4UnitDefinition & G4UnitDefinition::operator= ( const G4UnitDefinition &  right )

private

Definition at line 123 of file G4UnitsTable.cc.

{
  if(this != &right)
  {
    Name          = right.Name;
    SymbolName    = right.SymbolName;
    Value         = right.Value;
    CategoryIndex = right.CategoryIndex;
  }
  return *this;
}

References CategoryIndex, Name, SymbolName, and Value.

operator==()

G4bool G4UnitDefinition::operator==

(

const G4UnitDefinition &

right

)

const

Definition at line 137 of file G4UnitsTable.cc.

{
  return (this == (G4UnitDefinition*) &right);
}

PrintDefinition()

void G4UnitDefinition::PrintDefinition

(

)

Definition at line 244 of file G4UnitsTable.cc.

{
  G4int nameL = (*pUnitsTable)[CategoryIndex]->GetNameMxLen();
  G4int symbL = (*pUnitsTable)[CategoryIndex]->GetSymbMxLen();
  G4cout << std::setw(nameL) << Name << " (" << std::setw(symbL) << SymbolName
         << ") = " << Value << G4endl;
}

References CategoryIndex, G4cout, G4endl, Name, SymbolName, and Value.

Referenced by export_G4UnitsTable().

PrintUnitsTable()

void G4UnitDefinition::PrintUnitsTable ( )

static

Definition at line 432 of file G4UnitsTable.cc.

{
  G4cout << "\n          ----- The Table of Units ----- \n";
  if(pUnitsTable == nullptr)
  {
    pUnitsTable = new G4UnitsTable;
  }
  for(std::size_t i = 0; i < pUnitsTable->size(); ++i)
  {
    (*pUnitsTable)[i]->PrintCategory();
  }
}

References G4cout, and pUnitsTable.

Referenced by export_G4UnitsTable(), and G4UnitsMessenger::SetNewValue().

Field Documentation

CategoryIndex

std::size_t G4UnitDefinition::CategoryIndex = 0

private

Definition at line 112 of file G4UnitsTable.hh.

Referenced by G4UnitDefinition(), operator=(), and PrintDefinition().

Name

G4String G4UnitDefinition::Name

private

Definition at line 105 of file G4UnitsTable.hh.

Referenced by operator=(), and PrintDefinition().

pUnitsTable

G4ThreadLocal G4UnitsTable * G4UnitDefinition::pUnitsTable = nullptr

staticprivate

Definition at line 109 of file G4UnitsTable.hh.

Referenced by ClearUnitsTable(), G4UnitDefinition(), GetCategory(), GetUnitsTable(), and PrintUnitsTable().

SymbolName

G4String G4UnitDefinition::SymbolName

private

Definition at line 106 of file G4UnitsTable.hh.

Referenced by operator=(), and PrintDefinition().

unitsTableDestroyed

G4ThreadLocal G4bool G4UnitDefinition::unitsTableDestroyed = false

staticprivate

Definition at line 110 of file G4UnitsTable.hh.

Referenced by ClearUnitsTable(), and G4UnitDefinition().

Value

G4double G4UnitDefinition::Value = 0.0

private

Definition at line 107 of file G4UnitsTable.hh.

Referenced by operator=(), and PrintDefinition().

---

The documentation for this class was generated from the following files:

• source/global/management/include/G4UnitsTable.hh
• source/global/management/src/G4UnitsTable.cc