File indexing completed on 2023-10-25 09:31:43
0001
0002 #include "Alignment/CocoaModel/interface/ALIUnitsTable.h"
0003 #include "CLHEP/Units/GlobalSystemOfUnits.h"
0004
0005 #include <iomanip>
0006 #include <cstdlib>
0007 #include <cmath> // include floating-point std::abs functions
0008
0009 ALIUnitsTable ALIUnitDefinition::theUnitsTable;
0010
0011
0012
0013 ALIUnitDefinition::ALIUnitDefinition(ALIstring name, ALIstring symbol, ALIstring category, ALIdouble value)
0014 : Name(name), SymbolName(symbol), Value(value) {
0015
0016
0017 size_t nbCat = theUnitsTable.size();
0018 size_t i = 0;
0019 while ((i < nbCat) && (theUnitsTable[i]->GetName() != category))
0020 i++;
0021 if (i == nbCat)
0022 theUnitsTable.push_back(new ALIUnitsCategory(category));
0023 CategoryIndex = i;
0024
0025
0026 (theUnitsTable[CategoryIndex]->GetUnitsList()).emplace_back(shared_from_this());
0027
0028
0029 theUnitsTable[i]->UpdateNameMxLen((ALIint)name.length());
0030 theUnitsTable[i]->UpdateSymbMxLen((ALIint)symbol.length());
0031 }
0032
0033
0034
0035 ALIUnitDefinition::~ALIUnitDefinition() {}
0036
0037
0038
0039 ALIUnitDefinition::ALIUnitDefinition(ALIUnitDefinition& right)
0040 : std::enable_shared_from_this<ALIUnitDefinition>(right) {
0041 *this = right;
0042 }
0043
0044
0045
0046 ALIUnitDefinition& ALIUnitDefinition::operator=(const ALIUnitDefinition& right) {
0047 if (this != &right) {
0048 Name = right.Name;
0049 SymbolName = right.SymbolName;
0050 Value = right.Value;
0051 CategoryIndex = right.CategoryIndex;
0052 }
0053 return *this;
0054 }
0055
0056
0057
0058 ALIint ALIUnitDefinition::operator==(const ALIUnitDefinition& right) const { return (this == &right); }
0059
0060
0061
0062 ALIint ALIUnitDefinition::operator!=(const ALIUnitDefinition& right) const { return (this != &right); }
0063
0064
0065 ALIdouble ALIUnitDefinition::GetValueOf(ALIstring stri) {
0066 if (theUnitsTable.empty())
0067 BuildUnitsTable();
0068 ALIstring name, symbol;
0069 for (size_t i = 0; i < theUnitsTable.size(); i++) {
0070 ALIUnitsContainer& units = theUnitsTable[i]->GetUnitsList();
0071 for (size_t j = 0; j < units.size(); j++) {
0072 name = units[j]->GetName();
0073 symbol = units[j]->GetSymbol();
0074 if (stri == name || stri == symbol)
0075 return units[j]->GetValue();
0076 }
0077 }
0078 std::cout << "Warning from ALIUnitDefinition::GetValueOf(" << stri << ")."
0079 << " The unit " << stri << " does not exist in UnitsTable."
0080 << " Return Value = 0." << std::endl;
0081 return 0.;
0082 }
0083
0084
0085
0086 ALIstring ALIUnitDefinition::GetCategory(ALIstring stri) {
0087 if (theUnitsTable.empty())
0088 BuildUnitsTable();
0089 ALIstring name, symbol;
0090 for (size_t i = 0; i < theUnitsTable.size(); i++) {
0091 ALIUnitsContainer& units = theUnitsTable[i]->GetUnitsList();
0092 for (size_t j = 0; j < units.size(); j++) {
0093 name = units[j]->GetName();
0094 symbol = units[j]->GetSymbol();
0095 if (stri == name || stri == symbol)
0096 return theUnitsTable[i]->GetName();
0097 }
0098 }
0099 std::cout << "Warning from ALIUnitDefinition::GetCategory(" << stri << ")."
0100 << " The unit " << stri << " does not exist in UnitsTable."
0101 << " Return category = None" << std::endl;
0102 name = "None";
0103 return name;
0104 }
0105
0106
0107
0108 void ALIUnitDefinition::PrintDefinition() {
0109 ALIint nameL = theUnitsTable[CategoryIndex]->GetNameMxLen();
0110 ALIint symbL = theUnitsTable[CategoryIndex]->GetSymbMxLen();
0111 std::cout << std::setw(nameL) << Name << " (" << std::setw(symbL) << SymbolName << ") = " << Value << std::endl;
0112 }
0113
0114
0115
0116 void ALIUnitDefinition::BuildUnitsTable() {
0117
0118 std::make_shared<ALIUnitDefinition>("kilometer", "km", "Length", kilometer);
0119 std::make_shared<ALIUnitDefinition>("meter", "m", "Length", meter);
0120 std::make_shared<ALIUnitDefinition>("centimeter", "cm", "Length", centimeter);
0121 std::make_shared<ALIUnitDefinition>("millimeter", "mm", "Length", millimeter);
0122 std::make_shared<ALIUnitDefinition>("micrometer", "mum", "Length", micrometer);
0123 std::make_shared<ALIUnitDefinition>("nanometer", "nm", "Length", nanometer);
0124 std::make_shared<ALIUnitDefinition>("angstrom", "Ang", "Length", angstrom);
0125 std::make_shared<ALIUnitDefinition>("fermi", "fm", "Length", fermi);
0126
0127
0128 std::make_shared<ALIUnitDefinition>("kilometer2", "km2", "Surface", kilometer2);
0129 std::make_shared<ALIUnitDefinition>("meter2", "m2", "Surface", meter2);
0130 std::make_shared<ALIUnitDefinition>("centimeter2", "cm2", "Surface", centimeter2);
0131 std::make_shared<ALIUnitDefinition>("millimeter2", "mm2", "Surface", millimeter2);
0132 std::make_shared<ALIUnitDefinition>("barn", "barn", "Surface", barn);
0133 std::make_shared<ALIUnitDefinition>("millibarn", "mbarn", "Surface", millibarn);
0134 std::make_shared<ALIUnitDefinition>("microbarn", "mubarn", "Surface", microbarn);
0135 std::make_shared<ALIUnitDefinition>("nanobarn", "nbarn", "Surface", nanobarn);
0136 std::make_shared<ALIUnitDefinition>("picobarn", "pbarn", "Surface", picobarn);
0137
0138
0139 std::make_shared<ALIUnitDefinition>("kilometer3", "km3", "Volume", kilometer3);
0140 std::make_shared<ALIUnitDefinition>("meter3", "m3", "Volume", meter3);
0141 std::make_shared<ALIUnitDefinition>("centimeter3", "cm3", "Volume", centimeter3);
0142 std::make_shared<ALIUnitDefinition>("millimeter3", "mm3", "Volume", millimeter3);
0143
0144
0145 std::make_shared<ALIUnitDefinition>("radian", "rad", "Angle", radian);
0146 std::make_shared<ALIUnitDefinition>("milliradian", "mrad", "Angle", milliradian);
0147 std::make_shared<ALIUnitDefinition>("milliradian", "murad", "Angle", 0.001 * milliradian);
0148 std::make_shared<ALIUnitDefinition>("steradian", "sr", "Angle", steradian);
0149 std::make_shared<ALIUnitDefinition>("degree", "deg", "Angle", degree);
0150
0151
0152 std::make_shared<ALIUnitDefinition>("second", "s", "Time", second);
0153 std::make_shared<ALIUnitDefinition>("millisecond", "ms", "Time", millisecond);
0154 std::make_shared<ALIUnitDefinition>("microsecond", "mus", "Time", microsecond);
0155 std::make_shared<ALIUnitDefinition>("nanosecond", "ns", "Time", nanosecond);
0156 std::make_shared<ALIUnitDefinition>("picosecond", "ps", "Time", picosecond);
0157
0158
0159 std::make_shared<ALIUnitDefinition>("hertz", "Hz", "Frequency", hertz);
0160 std::make_shared<ALIUnitDefinition>("kilohertz", "kHz", "Frequency", kilohertz);
0161 std::make_shared<ALIUnitDefinition>("megahertz", "MHz", "Frequency", megahertz);
0162
0163
0164 std::make_shared<ALIUnitDefinition>("eplus", "e+", "Electric charge", eplus);
0165 std::make_shared<ALIUnitDefinition>("coulomb", "C", "Electric charge", coulomb);
0166
0167
0168 std::make_shared<ALIUnitDefinition>("electronvolt", "eV", "Energy", electronvolt);
0169 std::make_shared<ALIUnitDefinition>("kiloelectronvolt", "keV", "Energy", kiloelectronvolt);
0170 std::make_shared<ALIUnitDefinition>("megaelectronvolt", "MeV", "Energy", megaelectronvolt);
0171 std::make_shared<ALIUnitDefinition>("gigaelectronvolt", "GeV", "Energy", gigaelectronvolt);
0172 std::make_shared<ALIUnitDefinition>("teraelectronvolt", "TeV", "Energy", teraelectronvolt);
0173 std::make_shared<ALIUnitDefinition>("petaelectronvolt", "PeV", "Energy", petaelectronvolt);
0174 std::make_shared<ALIUnitDefinition>("joule", "J", "Energy", joule);
0175
0176
0177 std::make_shared<ALIUnitDefinition>("milligram", "mg", "Mass", milligram);
0178 std::make_shared<ALIUnitDefinition>("gram", "g", "Mass", gram);
0179 std::make_shared<ALIUnitDefinition>("kilogram", "kg", "Mass", kilogram);
0180
0181
0182 std::make_shared<ALIUnitDefinition>("g/cm3", "g/cm3", "Volumic Mass", g / cm3);
0183 std::make_shared<ALIUnitDefinition>("mg/cm3", "mg/cm3", "Volumic Mass", mg / cm3);
0184 std::make_shared<ALIUnitDefinition>("kg/m3", "kg/m3", "Volumic Mass", kg / m3);
0185
0186
0187 std::make_shared<ALIUnitDefinition>("watt", "W", "Power", watt);
0188
0189
0190 std::make_shared<ALIUnitDefinition>("newton", "N", "Force", newton);
0191
0192
0193 std::make_shared<ALIUnitDefinition>("pascal", "Pa", "Pressure", pascal);
0194 std::make_shared<ALIUnitDefinition>("bar", "bar", "Pressure", bar);
0195 std::make_shared<ALIUnitDefinition>("atmosphere", "atm", "Pressure", atmosphere);
0196
0197
0198 std::make_shared<ALIUnitDefinition>("ampere", "A", "Electric current", ampere);
0199 std::make_shared<ALIUnitDefinition>("milliampere", "mA", "Electric current", milliampere);
0200 std::make_shared<ALIUnitDefinition>("microampere", "muA", "Electric current", microampere);
0201 std::make_shared<ALIUnitDefinition>("nanoampere", "nA", "Electric current", nanoampere);
0202
0203
0204 std::make_shared<ALIUnitDefinition>("volt", "V", "Electric potential", volt);
0205 std::make_shared<ALIUnitDefinition>("kilovolt", "kV", "Electric potential", kilovolt);
0206 std::make_shared<ALIUnitDefinition>("megavolt", "MV", "Electric potential", megavolt);
0207
0208
0209 std::make_shared<ALIUnitDefinition>("weber", "Wb", "Magnetic flux", weber);
0210
0211
0212 std::make_shared<ALIUnitDefinition>("tesla", "T", "Magnetic flux density", tesla);
0213 std::make_shared<ALIUnitDefinition>("kilogauss", "kG", "Magnetic flux density", kilogauss);
0214 std::make_shared<ALIUnitDefinition>("gauss", "G", "Magnetic flux density", gauss);
0215
0216
0217 std::make_shared<ALIUnitDefinition>("kelvin", "K", "Temperature", kelvin);
0218
0219
0220 std::make_shared<ALIUnitDefinition>("mole", "mol", "Amount of substance", mole);
0221
0222
0223 std::make_shared<ALIUnitDefinition>("becquerel", "Bq", "Activity", becquerel);
0224 std::make_shared<ALIUnitDefinition>("curie", "Ci", "Activity", curie);
0225
0226
0227 std::make_shared<ALIUnitDefinition>("gray", "Gy", "Dose", gray);
0228 }
0229
0230
0231
0232 void ALIUnitDefinition::PrintUnitsTable() {
0233 std::cout << "\n ----- The Table of Units ----- \n";
0234 for (size_t i = 0; i < theUnitsTable.size(); i++)
0235 theUnitsTable[i]->PrintCategory();
0236 }
0237
0238
0239
0240 ALIUnitsCategory::ALIUnitsCategory(ALIstring name) : Name(name), NameMxLen(0), SymbMxLen(0) {
0241 UnitsList = *(new ALIUnitsContainer);
0242 }
0243
0244
0245
0246 ALIUnitsCategory::~ALIUnitsCategory() {}
0247
0248
0249
0250 ALIUnitsCategory::ALIUnitsCategory(ALIUnitsCategory& right) { *this = right; }
0251
0252
0253
0254 ALIUnitsCategory& ALIUnitsCategory::operator=(const ALIUnitsCategory& right) {
0255 if (this != &right) {
0256 Name = right.Name;
0257 UnitsList = right.UnitsList;
0258 NameMxLen = right.NameMxLen;
0259 SymbMxLen = right.SymbMxLen;
0260 }
0261 return *this;
0262 }
0263
0264
0265
0266 ALIint ALIUnitsCategory::operator==(const ALIUnitsCategory& right) const { return (this == &right); }
0267
0268
0269
0270 ALIint ALIUnitsCategory::operator!=(const ALIUnitsCategory& right) const { return (this != &right); }
0271
0272
0273
0274 void ALIUnitsCategory::PrintCategory() {
0275 std::cout << "\n category: " << Name << std::endl;
0276 for (size_t i = 0; i < UnitsList.size(); i++)
0277 UnitsList[i]->PrintDefinition();
0278 }
0279
0280
0281
0282 ALIBestUnit::ALIBestUnit(ALIdouble value, ALIstring category) {
0283
0284 ALIUnitsTable& theUnitsTable = ALIUnitDefinition::GetUnitsTable();
0285 size_t nbCat = theUnitsTable.size();
0286 size_t i = 0;
0287 while ((i < nbCat) && (theUnitsTable[i]->GetName() != category))
0288 i++;
0289 if (i == nbCat) {
0290 std::cout << " ALIBestUnit: the category " << category << " does not exist !!" << std::endl;
0291 std::cerr << "Missing unit category !" << std::endl;
0292 abort();
0293 }
0294
0295 IndexOfCategory = i;
0296 nbOfVals = 1;
0297 Value[0] = value;
0298 Value[1] = 0.;
0299 Value[2] = 0.;
0300 }
0301
0302
0303
0304 ALIBestUnit::ALIBestUnit(const CLHEP::Hep3Vector& value, ALIstring category) {
0305
0306 ALIUnitsTable& theUnitsTable = ALIUnitDefinition::GetUnitsTable();
0307 size_t nbCat = theUnitsTable.size();
0308 size_t i = 0;
0309 while ((i < nbCat) && (theUnitsTable[i]->GetName() != category))
0310 i++;
0311 if (i == nbCat) {
0312 std::cerr << " ALIBestUnit: the category " << category << " does not exist." << std::endl;
0313 std::cerr << "Unit category not existing !" << std::endl;
0314 abort();
0315 }
0316
0317 IndexOfCategory = i;
0318 nbOfVals = 3;
0319 Value[0] = value.x();
0320 Value[1] = value.y();
0321 Value[2] = value.z();
0322 }
0323
0324
0325 ALIBestUnit::~ALIBestUnit() {}
0326
0327
0328
0329 std::ostream& operator<<(std::ostream& flux, ALIBestUnit a) {
0330 ALIUnitsTable& theUnitsTable = ALIUnitDefinition::GetUnitsTable();
0331 ALIUnitsContainer& List = theUnitsTable[a.IndexOfCategory]->GetUnitsList();
0332 ALIint len = theUnitsTable[a.IndexOfCategory]->GetSymbMxLen();
0333
0334 ALIint ksup(-1), kinf(-1);
0335 ALIdouble umax(0.), umin(1.E12);
0336 ALIdouble rsup(1.E12), rinf(0.);
0337
0338
0339 ALIdouble value = std::max(std::max(std::abs(a.Value[0]), std::abs(a.Value[1])), std::abs(a.Value[2]));
0340
0341 for (size_t k = 0; k < List.size(); k++) {
0342 ALIdouble unit = List[k]->GetValue();
0343 if (value == 1.E12) {
0344 if (unit > umax) {
0345 umax = unit;
0346 ksup = k;
0347 }
0348 } else if (value <= -1.E12) {
0349 if (unit < umin) {
0350 umin = unit;
0351 kinf = k;
0352 }
0353 }
0354
0355 else {
0356 ALIdouble ratio = value / unit;
0357 if ((ratio >= 1.) && (ratio < rsup)) {
0358 rsup = ratio;
0359 ksup = k;
0360 }
0361 if ((ratio < 1.) && (ratio > rinf)) {
0362 rinf = ratio;
0363 kinf = k;
0364 }
0365 }
0366 }
0367
0368 ALIint index = ksup;
0369 if (index == -1)
0370 index = kinf;
0371 if (index == -1)
0372 index = 0;
0373
0374 for (ALIint j = 0; j < a.nbOfVals; j++) {
0375 flux << a.Value[j] / (List[index]->GetValue()) << " ";
0376 }
0377
0378 #ifdef ALIUSE_STD_NAMESPACE
0379 std::ios::fmtflags oldform = std::cout.flags();
0380 #else
0381
0382 #endif
0383
0384 flux.setf(std::ios::left, std::ios::adjustfield);
0385 flux << std::setw(len) << List[index]->GetSymbol();
0386
0387
0388 return flux;
0389 }
0390
0391