G4UnitDefinition Class Reference

#include <G4UnitsTable.hh>

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

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

Detailed Description

Definition at line 74 of file G4UnitsTable.hh.

Constructor & Destructor Documentation

G4UnitDefinition()

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

Definition at line 60 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());
}

Referenced by BuildUnitsTable().

~G4UnitDefinition()

G4UnitDefinition::~G4UnitDefinition ( )

default

Member Function Documentation

BuildUnitsTable()

void G4UnitDefinition::BuildUnitsTable ( )

static

Definition at line 246 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);
}

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

ClearUnitsTable()

void G4UnitDefinition::ClearUnitsTable ( )

static

Definition at line 439 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;
}

Referenced by G4RunManagerKernel::~G4RunManagerKernel().

GetCategory()

G4String G4UnitDefinition::GetCategory ( const G4String & str )

static

Definition at line 210 of file G4UnitsTable.cc.

{
  G4String name, symbol;
  for(std::size_t i = 0; i < (GetUnitsTable()).size(); ++i)
  {
    G4UnitsContainer& units = (*pUnitsTable)[i]->GetUnitsList();
    for(auto& unit : units)
    {
      name   = unit->GetName();
      symbol = unit->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;
}

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(), G4GDMLReadSolids::GenericPolyconeRead(), G4GDMLReadSolids::GenericPolyhedraRead(), G4GDMLReadSolids::GenTrapRead(), G4GDMLReadParamvol::Hype_dimensionsRead(), G4GDMLReadSolids::HypeRead(), 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 G4UnitDefinition(), and G4DimensionedTypeUtils::HasName::operator()().

GetSymbol()

const G4String & G4UnitDefinition::GetSymbol ( ) const

inline

Referenced by G4DimensionedTypeUtils::HasName::operator()().

GetUnitsTable()

G4UnitsTable & G4UnitDefinition::GetUnitsTable ( )

static

Definition at line 143 of file G4UnitsTable.cc.

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

Referenced by G4AttCheck::G4AttCheck(), G4BestUnit::G4BestUnit(), 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

GetValueOf()

G4double G4UnitDefinition::GetValueOf ( const G4String & str )

static

Definition at line 185 of file G4UnitsTable.cc.

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

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(), G4ScoreQuantityMessenger::FParticleWithEnergyCommand(), G4GDMLReadSolids::GenericPolyconeRead(), G4GDMLReadSolids::GenericPolyhedraRead(), G4GDMLReadSolids::GenTrapRead(), G4tgrUtils::GetDouble(), G4Analysis::GetUnitValue(), G4GDMLReadParamvol::Hype_dimensionsRead(), G4GDMLReadSolids::HypeRead(), 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(), G4GDMLReadDefine::QuantityRead(), G4GDMLReadStructure::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 164 of file G4UnitsTable.cc.

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

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

operator!=()

G4bool G4UnitDefinition::operator!=

(

const G4UnitDefinition &

right

)

const

Definition at line 136 of file G4UnitsTable.cc.

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

operator==()

G4bool G4UnitDefinition::operator==

(

const G4UnitDefinition &

right

)

const

Definition at line 129 of file G4UnitsTable.cc.

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

PrintDefinition()

void G4UnitDefinition::PrintDefinition

(

)

Definition at line 236 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;
}

PrintUnitsTable()

void G4UnitDefinition::PrintUnitsTable ( )

static

Definition at line 424 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();
  }
}

Referenced by G4UnitsMessenger::SetNewValue().

---

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

• G4UnitsTable.hh
• G4UnitsTable.cc