ALIUnitDefinition Class Reference

#include <ALIUnitsTable.h>

Inheritance diagram for ALIUnitDefinition:

Public Member Functions
	ALIUnitDefinition (ALIstring name, ALIstring symbol, ALIstring category, ALIdouble value)
ALIstring	GetName () const
ALIstring	GetSymbol () const
ALIdouble	GetValue () const
ALIint	operator!= (const ALIUnitDefinition &) const
ALIint	operator== (const ALIUnitDefinition &) const
void	PrintDefinition ()
	~ALIUnitDefinition ()

Static Public Member Functions
static void	BuildUnitsTable ()
static ALIstring	GetCategory (ALIstring)
static ALIUnitsTable &	GetUnitsTable ()
static ALIdouble	GetValueOf (ALIstring)
static void	PrintUnitsTable ()

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

Private Attributes
size_t	CategoryIndex
ALIstring	Name
ALIstring	SymbolName
ALIdouble	Value

Static Private Attributes
static ALIUnitsTable	theUnitsTable

Detailed Description

Definition at line 52 of file ALIUnitsTable.h.

Constructor & Destructor Documentation

ALIUnitDefinition() [1/2]

ALIUnitDefinition::ALIUnitDefinition	(	ALIstring	name,
		ALIstring	symbol,
		ALIstring	category,
		ALIdouble	value
	)

Definition at line 13 of file ALIUnitsTable.cc.

    : Name(name), SymbolName(symbol), Value(value) {
  //
  //does the Category objet already exist ?
  size_t nbCat = theUnitsTable.size();
  size_t i = 0;
  while ((i < nbCat) && (theUnitsTable[i]->GetName() != category))
    i++;
  if (i == nbCat)
    theUnitsTable.push_back(new ALIUnitsCategory(category));
  CategoryIndex = i;
  //
  //insert this Unit in the Unitstable
  (theUnitsTable[CategoryIndex]->GetUnitsList()).emplace_back(shared_from_this());
 
  //update ALIstring max length for name and symbol
  theUnitsTable[i]->UpdateNameMxLen((ALIint)name.length());
  theUnitsTable[i]->UpdateSymbMxLen((ALIint)symbol.length());
}

References taus_updatedMVAIds_cff::category, CategoryIndex, GetName(), mps_fire::i, Skims_PA_cff::name, and theUnitsTable.

~ALIUnitDefinition()

ALIUnitDefinition::~ALIUnitDefinition

(

)

Definition at line 35 of file ALIUnitsTable.cc.

{}

ALIUnitDefinition() [2/2]

ALIUnitDefinition::ALIUnitDefinition ( ALIUnitDefinition &  right )

private

Definition at line 39 of file ALIUnitsTable.cc.

    : std::enable_shared_from_this<ALIUnitDefinition>(right) {
  *this = right;
}

Member Function Documentation

BuildUnitsTable()

void ALIUnitDefinition::BuildUnitsTable ( )

static

Definition at line 116 of file ALIUnitsTable.cc.

                                        {
  //Length
  std::make_shared<ALIUnitDefinition>("kilometer", "km", "Length", kilometer);
  std::make_shared<ALIUnitDefinition>("meter", "m", "Length", meter);
  std::make_shared<ALIUnitDefinition>("centimeter", "cm", "Length", centimeter);
  std::make_shared<ALIUnitDefinition>("millimeter", "mm", "Length", millimeter);
  std::make_shared<ALIUnitDefinition>("micrometer", "mum", "Length", micrometer);
  std::make_shared<ALIUnitDefinition>("nanometer", "nm", "Length", nanometer);
  std::make_shared<ALIUnitDefinition>("angstrom", "Ang", "Length", angstrom);
  std::make_shared<ALIUnitDefinition>("fermi", "fm", "Length", fermi);
 
  //Surface
  std::make_shared<ALIUnitDefinition>("kilometer2", "km2", "Surface", kilometer2);
  std::make_shared<ALIUnitDefinition>("meter2", "m2", "Surface", meter2);
  std::make_shared<ALIUnitDefinition>("centimeter2", "cm2", "Surface", centimeter2);
  std::make_shared<ALIUnitDefinition>("millimeter2", "mm2", "Surface", millimeter2);
  std::make_shared<ALIUnitDefinition>("barn", "barn", "Surface", barn);
  std::make_shared<ALIUnitDefinition>("millibarn", "mbarn", "Surface", millibarn);
  std::make_shared<ALIUnitDefinition>("microbarn", "mubarn", "Surface", microbarn);
  std::make_shared<ALIUnitDefinition>("nanobarn", "nbarn", "Surface", nanobarn);
  std::make_shared<ALIUnitDefinition>("picobarn", "pbarn", "Surface", picobarn);
 
  //Volume
  std::make_shared<ALIUnitDefinition>("kilometer3", "km3", "Volume", kilometer3);
  std::make_shared<ALIUnitDefinition>("meter3", "m3", "Volume", meter3);
  std::make_shared<ALIUnitDefinition>("centimeter3", "cm3", "Volume", centimeter3);
  std::make_shared<ALIUnitDefinition>("millimeter3", "mm3", "Volume", millimeter3);
 
  //Angle
  std::make_shared<ALIUnitDefinition>("radian", "rad", "Angle", radian);
  std::make_shared<ALIUnitDefinition>("milliradian", "mrad", "Angle", milliradian);
  std::make_shared<ALIUnitDefinition>("milliradian", "murad", "Angle", 0.001 * milliradian);
  std::make_shared<ALIUnitDefinition>("steradian", "sr", "Angle", steradian);
  std::make_shared<ALIUnitDefinition>("degree", "deg", "Angle", degree);
 
  //Time
  std::make_shared<ALIUnitDefinition>("second", "s", "Time", second);
  std::make_shared<ALIUnitDefinition>("millisecond", "ms", "Time", millisecond);
  std::make_shared<ALIUnitDefinition>("microsecond", "mus", "Time", microsecond);
  std::make_shared<ALIUnitDefinition>("nanosecond", "ns", "Time", nanosecond);
  std::make_shared<ALIUnitDefinition>("picosecond", "ps", "Time", picosecond);
 
  //Frequency
  std::make_shared<ALIUnitDefinition>("hertz", "Hz", "Frequency", hertz);
  std::make_shared<ALIUnitDefinition>("kilohertz", "kHz", "Frequency", kilohertz);
  std::make_shared<ALIUnitDefinition>("megahertz", "MHz", "Frequency", megahertz);
 
  //Electric charge
  std::make_shared<ALIUnitDefinition>("eplus", "e+", "Electric charge", eplus);
  std::make_shared<ALIUnitDefinition>("coulomb", "C", "Electric charge", coulomb);
 
  //Energy
  std::make_shared<ALIUnitDefinition>("electronvolt", "eV", "Energy", electronvolt);
  std::make_shared<ALIUnitDefinition>("kiloelectronvolt", "keV", "Energy", kiloelectronvolt);
  std::make_shared<ALIUnitDefinition>("megaelectronvolt", "MeV", "Energy", megaelectronvolt);
  std::make_shared<ALIUnitDefinition>("gigaelectronvolt", "GeV", "Energy", gigaelectronvolt);
  std::make_shared<ALIUnitDefinition>("teraelectronvolt", "TeV", "Energy", teraelectronvolt);
  std::make_shared<ALIUnitDefinition>("petaelectronvolt", "PeV", "Energy", petaelectronvolt);
  std::make_shared<ALIUnitDefinition>("joule", "J", "Energy", joule);
 
  //Mass
  std::make_shared<ALIUnitDefinition>("milligram", "mg", "Mass", milligram);
  std::make_shared<ALIUnitDefinition>("gram", "g", "Mass", gram);
  std::make_shared<ALIUnitDefinition>("kilogram", "kg", "Mass", kilogram);
 
  //Volumic Mass
  std::make_shared<ALIUnitDefinition>("g/cm3", "g/cm3", "Volumic Mass", g / cm3);
  std::make_shared<ALIUnitDefinition>("mg/cm3", "mg/cm3", "Volumic Mass", mg / cm3);
  std::make_shared<ALIUnitDefinition>("kg/m3", "kg/m3", "Volumic Mass", kg / m3);
 
  //Power
  std::make_shared<ALIUnitDefinition>("watt", "W", "Power", watt);
 
  //Force
  std::make_shared<ALIUnitDefinition>("newton", "N", "Force", newton);
 
  //Pressure
  std::make_shared<ALIUnitDefinition>("pascal", "Pa", "Pressure", pascal);
  std::make_shared<ALIUnitDefinition>("bar", "bar", "Pressure", bar);
  std::make_shared<ALIUnitDefinition>("atmosphere", "atm", "Pressure", atmosphere);
 
  //Electric current
  std::make_shared<ALIUnitDefinition>("ampere", "A", "Electric current", ampere);
  std::make_shared<ALIUnitDefinition>("milliampere", "mA", "Electric current", milliampere);
  std::make_shared<ALIUnitDefinition>("microampere", "muA", "Electric current", microampere);
  std::make_shared<ALIUnitDefinition>("nanoampere", "nA", "Electric current", nanoampere);
 
  //Electric potential
  std::make_shared<ALIUnitDefinition>("volt", "V", "Electric potential", volt);
  std::make_shared<ALIUnitDefinition>("kilovolt", "kV", "Electric potential", kilovolt);
  std::make_shared<ALIUnitDefinition>("megavolt", "MV", "Electric potential", megavolt);
 
  //Magnetic flux
  std::make_shared<ALIUnitDefinition>("weber", "Wb", "Magnetic flux", weber);
 
  //Magnetic flux density
  std::make_shared<ALIUnitDefinition>("tesla", "T", "Magnetic flux density", tesla);
  std::make_shared<ALIUnitDefinition>("kilogauss", "kG", "Magnetic flux density", kilogauss);
  std::make_shared<ALIUnitDefinition>("gauss", "G", "Magnetic flux density", gauss);
 
  //Temperature
  std::make_shared<ALIUnitDefinition>("kelvin", "K", "Temperature", kelvin);
 
  //Amount of substance
  std::make_shared<ALIUnitDefinition>("mole", "mol", "Amount of substance", mole);
 
  //Activity
  std::make_shared<ALIUnitDefinition>("becquerel", "Bq", "Activity", becquerel);
  std::make_shared<ALIUnitDefinition>("curie", "Ci", "Activity", curie);
 
  //Dose
  std::make_shared<ALIUnitDefinition>("gray", "Gy", "Dose", gray);
}

References fermi, g, geant_units::joule(), and edm::second().

Referenced by GetCategory(), and GetValueOf().

GetCategory()

ALIstring ALIUnitDefinition::GetCategory ( ALIstring  stri )

static

Definition at line 86 of file ALIUnitsTable.cc.

                                                       {
  if (theUnitsTable.empty())
    BuildUnitsTable();
  ALIstring name, symbol;
  for (size_t i = 0; i < theUnitsTable.size(); i++) {
    ALIUnitsContainer& units = theUnitsTable[i]->GetUnitsList();
    for (size_t j = 0; j < units.size(); j++) {
      name = units[j]->GetName();
      symbol = units[j]->GetSymbol();
      if (stri == name || stri == symbol)
        return theUnitsTable[i]->GetName();
    }
  }
  std::cout << "Warning from ALIUnitDefinition::GetCategory(" << stri << ")."
            << " The unit " << stri << " does not exist in UnitsTable."
            << " Return category = None" << std::endl;
  name = "None";
  return name;
}

References BuildUnitsTable(), gather_cfg::cout, mps_fire::i, dqmiolumiharvest::j, Skims_PA_cff::name, theUnitsTable, and units().

GetName()

ALIstring ALIUnitDefinition::GetName ( ) const

inline

Definition at line 66 of file ALIUnitsTable.h.

{ return Name; }

References Name.

Referenced by ALIUnitDefinition().

GetSymbol()

ALIstring ALIUnitDefinition::GetSymbol ( ) const

inline

Definition at line 67 of file ALIUnitsTable.h.

{ return SymbolName; }

References SymbolName.

GetUnitsTable()

static ALIUnitsTable& ALIUnitDefinition::GetUnitsTable ( )

inlinestatic

Definition at line 75 of file ALIUnitsTable.h.

{ return theUnitsTable; }

References theUnitsTable.

Referenced by ALIBestUnit::ALIBestUnit(), and operator<<().

GetValue()

ALIdouble ALIUnitDefinition::GetValue ( ) const

inline

Definition at line 68 of file ALIUnitsTable.h.

{ return Value; }

References Value.

GetValueOf()

ALIdouble ALIUnitDefinition::GetValueOf ( ALIstring  stri )

static

Definition at line 65 of file ALIUnitsTable.cc.

                                                      {
  if (theUnitsTable.empty())
    BuildUnitsTable();
  ALIstring name, symbol;
  for (size_t i = 0; i < theUnitsTable.size(); i++) {
    ALIUnitsContainer& units = theUnitsTable[i]->GetUnitsList();
    for (size_t j = 0; j < units.size(); j++) {
      name = units[j]->GetName();
      symbol = units[j]->GetSymbol();
      if (stri == name || stri == symbol)
        return units[j]->GetValue();
    }
  }
  std::cout << "Warning from ALIUnitDefinition::GetValueOf(" << stri << ")."
            << " The unit " << stri << " does not exist in UnitsTable."
            << " Return Value = 0." << std::endl;
  return 0.;
}

References BuildUnitsTable(), gather_cfg::cout, mps_fire::i, dqmiolumiharvest::j, Skims_PA_cff::name, theUnitsTable, and units().

Referenced by ParameterMgr::getVal().

operator!=()

ALIint ALIUnitDefinition::operator!=

(

const ALIUnitDefinition &

right

)

const

Definition at line 62 of file ALIUnitsTable.cc.

{ return (this != &right); }

operator=()

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

private

Definition at line 46 of file ALIUnitsTable.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==()

ALIint ALIUnitDefinition::operator==

(

const ALIUnitDefinition &

right

)

const

Definition at line 58 of file ALIUnitsTable.cc.

{ return (this == &right); }

PrintDefinition()

void ALIUnitDefinition::PrintDefinition

(

)

Definition at line 108 of file ALIUnitsTable.cc.

                                        {
  ALIint nameL = theUnitsTable[CategoryIndex]->GetNameMxLen();
  ALIint symbL = theUnitsTable[CategoryIndex]->GetSymbMxLen();
  std::cout << std::setw(nameL) << Name << " (" << std::setw(symbL) << SymbolName << ") = " << Value << std::endl;
}

References CategoryIndex, gather_cfg::cout, Name, SymbolName, theUnitsTable, and Value.

PrintUnitsTable()

void ALIUnitDefinition::PrintUnitsTable ( )

static

Definition at line 232 of file ALIUnitsTable.cc.

                                        {
  std::cout << "\n          ----- The Table of Units ----- \n";
  for (size_t i = 0; i < theUnitsTable.size(); i++)
    theUnitsTable[i]->PrintCategory();
}

References gather_cfg::cout, mps_fire::i, and theUnitsTable.

Member Data Documentation

CategoryIndex

size_t ALIUnitDefinition::CategoryIndex

private

Definition at line 87 of file ALIUnitsTable.h.

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

Name

ALIstring ALIUnitDefinition::Name

private

Definition at line 81 of file ALIUnitsTable.h.

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

SymbolName

ALIstring ALIUnitDefinition::SymbolName

private

Definition at line 82 of file ALIUnitsTable.h.

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

theUnitsTable

ALIUnitsTable ALIUnitDefinition::theUnitsTable

staticprivate

Definition at line 85 of file ALIUnitsTable.h.

Referenced by ALIUnitDefinition(), GetCategory(), GetUnitsTable(), GetValueOf(), PrintDefinition(), and PrintUnitsTable().

Value

ALIdouble ALIUnitDefinition::Value

private

Definition at line 83 of file ALIUnitsTable.h.

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