Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2025-03-13 08:19:42 

0001 //==========================================================================
0002 //  AIDA Detector description implementation 
0003 //--------------------------------------------------------------------------
0004 // Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
0005 // All rights reserved.
0006 //
0007 // For the licensing terms see $DD4hepINSTALL/LICENSE.
0008 // For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
0009 //
0010 //  RootDictionary.h
0011 //
0012 //
0013 //  M.Frank
0014 //
0015 //==========================================================================
0016 #ifndef DDCORE_SRC_ROOTDICTIONARY_H
0017 #define DDCORE_SRC_ROOTDICTIONARY_H
0018 
0019 // Framework include files
0020 #include <Evaluator/Evaluator.h>
0021 #include <DD4hep/DD4hepRootPersistency.h>
0022 #include <DD4hep/Printout.h>
0023 #include <DD4hep/Grammar.h>
0024 #include <DD4hep/detail/ObjectsInterna.h>
0025 #include <DD4hep/detail/DetectorInterna.h>
0026 #include <DD4hep/detail/ConditionsInterna.h>
0027 #include <DD4hep/detail/AlignmentsInterna.h>
0028 #include <DD4hep/detail/VolumeManagerInterna.h>
0029 
0030 #include <DD4hep/World.h>
0031 #include <DD4hep/DD4hepUI.h>
0032 #include <DD4hep/Callback.h>
0033 #include <DD4hep/Conditions.h>
0034 #include <DD4hep/Alignments.h>
0035 #include <DD4hep/FieldTypes.h>
0036 #include <DD4hep/DD4hepUnits.h>
0037 #include <DD4hep/DetectorData.h>
0038 #include <DD4hep/DetectorProcessor.h>
0039 #include <DD4hep/ComponentProperties.h>
0040 #include <DD4hep/DetectorImp.h>
0041 
0042 // C/C++ include files
0043 #include <vector>
0044 #include <map>
0045  #include <string>
0046 
0047 #include <TRint.h>
0048 
0049 namespace dd4hep {
0050   namespace cond {}
0051   namespace align {}
0052   namespace detail {}
0053   void run_interpreter(const std::string& name)  {
0054     std::pair<int, char**> a(0,0);
0055     TRint app(name.c_str(), &a.first, a.second);
0056     app.Run();
0057   }
0058 
0059   tools::Evaluator& evaluator();
0060   tools::Evaluator& g4Evaluator();
0061 
0062   std::size_t always (const std::string& src, const std::string& msg) { return printout(ALWAYS,  src, msg); }
0063   std::size_t verbose(const std::string& src, const std::string& msg) { return printout(VERBOSE, src, msg); }
0064   std::size_t debug  (const std::string& src, const std::string& msg) { return printout(DEBUG,   src, msg); }
0065   std::size_t info   (const std::string& src, const std::string& msg) { return printout(INFO,    src, msg); }
0066   std::size_t warning(const std::string& src, const std::string& msg) { return printout(WARNING, src, msg); }
0067   std::size_t error  (const std::string& src, const std::string& msg) { return printout(ERROR,   src, msg); }
0068   std::size_t fatal  (const std::string& src, const std::string& msg) { return printout(FATAL,   src, msg); }
0069   void        exception(const std::string& src, const std::string& msg) { except(src, "%s", msg.c_str()); }
0070 
0071   namespace detail {
0072     /// Helper to invoke the ROOT interpreter
0073     struct interp  {
0074     public:
0075       interp() = default;
0076       virtual ~interp() = default;
0077       static void run(const std::string& name)  {
0078     std::pair<int, char**> a(0,0);
0079     TRint app(name.c_str(), &a.first, a.second);
0080     app.Run();
0081       }
0082     };
0083     //// Helper to access the evaluator instances
0084     struct eval  {
0085     public:
0086       eval() = default;
0087       virtual ~eval() = default;
0088       static dd4hep::tools::Evaluator& instance()     {
0089     return dd4hep::evaluator();
0090       }
0091       static dd4hep::tools::Evaluator& g4instance()   {
0092     return dd4hep::g4Evaluator();
0093       }
0094     };
0095   }
0096   class dd4hep_units  {
0097   public:
0098     static constexpr double millimeter       = dd4hep::mm;
0099     static constexpr double millimeter2      = dd4hep::mm2;
0100     static constexpr double millimeter3      = dd4hep::mm3;
0101     static constexpr double centimeter       = dd4hep::centimeter;
0102     static constexpr double centimeter2      = dd4hep::centimeter2;
0103     static constexpr double centimeter3      = dd4hep::centimeter3;
0104 
0105     static constexpr double meter            = dd4hep::meter;
0106     static constexpr double meter2           = dd4hep::meter2;
0107     static constexpr double meter3           = dd4hep::meter3;
0108 
0109     static constexpr double kilometer        = dd4hep::kilometer;
0110     static constexpr double kilometer2       = dd4hep::kilometer2;
0111     static constexpr double kilometer3       = dd4hep::kilometer3;
0112 
0113 
0114     static constexpr double parsec           = dd4hep::parsec;
0115 
0116     static constexpr double micrometer       = dd4hep::micrometer;
0117     static constexpr double nanometer        = dd4hep::nanometer;
0118     static constexpr double angstrom         = dd4hep::angstrom;
0119     static constexpr double fermi            = dd4hep::fermi;
0120 
0121     static constexpr double barn             = dd4hep::barn;
0122     static constexpr double millibarn        = dd4hep::millibarn;
0123     static constexpr double microbarn        = dd4hep::microbarn;
0124     static constexpr double nanobarn         = dd4hep::nanobarn;
0125     static constexpr double picobarn         = dd4hep::picobarn;
0126 
0127     // symbols
0128     static constexpr double nm               = dd4hep::nm;
0129     static constexpr double um               = dd4hep::um;
0130 
0131     static constexpr double mm               = dd4hep::mm;
0132     static constexpr double mm2              = dd4hep::mm2;
0133     static constexpr double mm3              = dd4hep::mm3;
0134 
0135     static constexpr double cm               = dd4hep::cm;
0136     static constexpr double cm2              = dd4hep::cm2;
0137     static constexpr double cm3              = dd4hep::cm3;
0138 
0139     static constexpr double m                = dd4hep::m;
0140     static constexpr double m2               = dd4hep::m2;
0141     static constexpr double m3               = dd4hep::m3;
0142 
0143     static constexpr double km               = dd4hep::km;
0144     static constexpr double km2              = dd4hep::km2;
0145     static constexpr double km3              = dd4hep::km3;
0146 
0147     static constexpr double pc               = dd4hep::pc;
0148     //
0149     // Angle
0150     //
0151     static constexpr double radian           = dd4hep::radian;
0152     static constexpr double milliradian      = dd4hep::milliradian;
0153     static constexpr double degree           = dd4hep::degree;
0154     static constexpr double steradian        = dd4hep::degree;
0155 
0156     // symbols
0157     static constexpr double rad              = dd4hep::rad;
0158     static constexpr double mrad             = dd4hep::mrad;
0159     static constexpr double sr               = dd4hep::sr;
0160     static constexpr double deg              = dd4hep::deg;
0161 
0162     //
0163     // Time [T]
0164     //
0165     static constexpr double picosecond       = dd4hep::picosecond;
0166     static constexpr double nanosecond       = dd4hep::nanosecond;
0167     static constexpr double microsecond      = dd4hep::microsecond;
0168     static constexpr double millisecond      = dd4hep::millisecond;
0169     static constexpr double second           = dd4hep::second;
0170 
0171     static constexpr double hertz            = dd4hep::hertz;
0172     static constexpr double kilohertz        = dd4hep::kilohertz;
0173     static constexpr double megahertz        = dd4hep::megahertz;
0174     // symbols
0175     static constexpr double ns               = dd4hep::ns;
0176     static constexpr double s                = dd4hep::s;
0177     static constexpr double ms               = dd4hep::ms;
0178     //
0179     // Electric charge [Q]
0180     //
0181     static constexpr double eplus            = dd4hep::eplus;
0182     static constexpr double e_SI             = dd4hep::e_SI;
0183     static constexpr double coulomb          = dd4hep::coulomb;
0184     //
0185     // Energy [E]
0186     //
0187     static constexpr double electronvolt     = dd4hep::electronvolt;
0188     static constexpr double kiloelectronvolt = dd4hep::kiloelectronvolt;
0189     static constexpr double megaelectronvolt = dd4hep::megaelectronvolt;
0190     static constexpr double gigaelectronvolt = dd4hep::gigaelectronvolt;
0191     static constexpr double teraelectronvolt = dd4hep::teraelectronvolt;
0192     static constexpr double petaelectronvolt = dd4hep::petaelectronvolt;
0193 
0194     static constexpr double joule            = dd4hep::joule;
0195     static constexpr double kilojoule        = dd4hep::kilojoule;
0196 
0197     // symbols
0198     static constexpr double eV               = dd4hep::eV;
0199     static constexpr double keV              = dd4hep::keV;
0200     static constexpr double MeV              = dd4hep::MeV;
0201     static constexpr double GeV              = dd4hep::GeV;
0202     static constexpr double TeV              = dd4hep::TeV;
0203     static constexpr double PeV              = dd4hep::PeV;
0204     //
0205     // Mass [E][T^2][L^-2]
0206     //
0207     static constexpr double kilogram         = dd4hep::kilogram;
0208     static constexpr double gram             = dd4hep::gram;
0209     static constexpr double milligram        = dd4hep::milligram;
0210     // symbols
0211     static constexpr double kg               = dd4hep::kg;
0212     static constexpr double g                = dd4hep::g;
0213     static constexpr double mg               = dd4hep::mg;
0214     //
0215     // Power [E][T^-1]
0216     //
0217     static constexpr double watt             = dd4hep::watt;
0218     static constexpr double kilowatt         = dd4hep::kilowatt;
0219     static constexpr double megawatt         = dd4hep::megawatt;
0220     //
0221     // Force [E][L^-1]
0222     //
0223     static constexpr double newton           = dd4hep::newton;
0224     //
0225     // Pressure [E][L^-3]
0226     //
0227     static constexpr double hep_pascal       = dd4hep::hep_pascal;
0228     static constexpr double bar              = dd4hep::bar;
0229     static constexpr double atmosphere       = dd4hep::atmosphere;
0230     //
0231     // Electric current [Q][T^-1]
0232     //
0233     static constexpr double ampere           = dd4hep::ampere;
0234     static constexpr double milliampere      = dd4hep::milliampere;
0235     static constexpr double microampere      = dd4hep::microampere;
0236     static constexpr double nanoampere       = dd4hep::nanoampere;
0237     //
0238     // Electric potential [E][Q^-1]
0239     //
0240     static constexpr double megavolt         = dd4hep::megavolt;
0241     static constexpr double kilovolt         = dd4hep::kilovolt;
0242     static constexpr double volt             = dd4hep::volt;
0243     //
0244     // Electric resistance [E][T][Q^-2]
0245     //
0246     static constexpr double ohm              = dd4hep::ohm;
0247     //
0248     // Electric capacitance [Q^2][E^-1]
0249     //
0250     static constexpr double farad            = dd4hep::farad;
0251     static constexpr double millifarad       = dd4hep::millifarad;
0252     static constexpr double microfarad       = dd4hep::microfarad;
0253     static constexpr double nanofarad        = dd4hep::nanofarad;
0254     static constexpr double picofarad        = dd4hep::picofarad;
0255     //
0256     // Magnetic Flux [T][E][Q^-1]
0257     //
0258     static constexpr double weber            = dd4hep::weber;
0259     //
0260     // Magnetic Field [T][E][Q^-1][L^-2]
0261     //
0262     static constexpr double tesla            = dd4hep::tesla;
0263 
0264     static constexpr double gauss            = dd4hep::gauss;
0265     static constexpr double kilogauss        = dd4hep::kilogauss;
0266     //
0267     // Inductance [T^2][E][Q^-2]
0268     //
0269     static constexpr double henry            = dd4hep::henry;
0270     //
0271     // Temperature
0272     //
0273     static constexpr double kelvin           = dd4hep::kelvin;
0274     //
0275     // Amount of substance
0276     //
0277     static constexpr double mole             = dd4hep::mole;
0278     //
0279     // Activity [T^-1]
0280     //
0281     static constexpr double becquerel        = dd4hep::becquerel;
0282     static constexpr double curie            = dd4hep::curie;
0283     //
0284     // Absorbed dose [L^2][T^-2]
0285     //
0286     static constexpr double gray             = dd4hep::gray;
0287     static constexpr double kilogray         = dd4hep::kilogray;
0288     static constexpr double milligray        = dd4hep::milligray;
0289     static constexpr double microgray        = dd4hep::microgray;
0290     //
0291     // Luminous intensity [I]
0292     //
0293     static constexpr double candela          = dd4hep::candela;
0294     //
0295     // Luminous flux [I]
0296     //
0297     static constexpr double lumen            = dd4hep::lumen;
0298     //
0299     // Illuminance [I][L^-2]
0300     //
0301     static constexpr double lux              = dd4hep::lux;
0302     //
0303     // Miscellaneous
0304     //
0305     static constexpr double perCent          = dd4hep::perCent;
0306     static constexpr double perThousand      = dd4hep::perThousand;
0307     static constexpr double perMillion       = dd4hep::perMillion;
0308 
0309     static constexpr double pi               = dd4hep::pi;
0310     static constexpr double twopi            = dd4hep::twopi;
0311     static constexpr double halfpi           = dd4hep::halfpi;
0312     static constexpr double pi2              = dd4hep::pi2;
0313     //
0314     //
0315     //
0316     static constexpr double Avogadro         = dd4hep::Avogadro;
0317     //
0318     // c   = 299.792458 mm/ns
0319     // c^2 = 898.7404 (mm/ns)^2
0320     //
0321     static constexpr double c_light          = dd4hep::c_light;
0322       static constexpr double c_squared      = dd4hep::c_squared;
0323     //
0324     // h     = 4.13566e-12 MeV*ns
0325     // hbar  = 6.58212e-13 MeV*ns
0326     // hbarc = 197.32705e-12 MeV*mm
0327     //
0328     static constexpr double h_Planck         = dd4hep::h_Planck;
0329     static constexpr double hbar_Planck      = dd4hep::hbar_Planck;
0330     static constexpr double hbarc            = dd4hep::hbarc;
0331     static constexpr double hbarc_squared    = dd4hep::hbarc_squared;
0332     //
0333     //
0334     //
0335     static constexpr double electron_charge  = dd4hep::electron_charge;
0336     static constexpr double e_squared        = dd4hep::e_squared;
0337     //
0338     // amu_c2 - atomic equivalent mass unit
0339     //        - AKA, unified atomic mass unit (u)
0340     // amu    - atomic mass unit
0341     //
0342     static constexpr double electron_mass_c2 = dd4hep::electron_mass_c2;
0343     static constexpr double proton_mass_c2   = dd4hep::proton_mass_c2;
0344     static constexpr double neutron_mass_c2  = dd4hep::neutron_mass_c2;
0345     static constexpr double amu_c2           = dd4hep::amu_c2;
0346     static constexpr double amu              = dd4hep::amu;
0347     //
0348     // permeability of free space mu0    = 2.01334e-16 Mev*(ns*eplus)^2/mm
0349     // permittivity of free space epsil0 = 5.52636e+10 eplus^2/(MeV*mm)
0350     //
0351     static constexpr double mu0              = dd4hep::mu0;
0352     static constexpr double epsilon0         = dd4hep::epsilon0;
0353     //
0354     // electromagnetic coupling = 1.43996e-12 MeV*mm/(eplus^2)
0355     //
0356     static constexpr double elm_coupling     = dd4hep::elm_coupling;
0357     static constexpr double fine_structure_const = dd4hep::fine_structure_const;
0358     static constexpr double classic_electr_radius = dd4hep::classic_electr_radius;
0359     static constexpr double electron_Compton_length = dd4hep::electron_Compton_length;
0360     static constexpr double Bohr_radius      = dd4hep::Bohr_radius;
0361     static constexpr double alpha_rcl2       = dd4hep::alpha_rcl2;
0362     static constexpr double twopi_mc2_rcl2   = dd4hep::twopi_mc2_rcl2;
0363     //
0364     static constexpr double k_Boltzmann      = dd4hep::k_Boltzmann;
0365     //
0366     // IUPAC standard temperature and pressure (STP)
0367     // STP uses 273.15 K (0 °C, 32 °F) and (since 1982) 1 bar (100 kPa) and not 1 atm!
0368     static constexpr double Temperature_STP  = dd4hep::Temperature_STP;
0369     static constexpr double Pressure_STP     = dd4hep::Pressure_STP;
0370     //
0371     // NTP uses the NIST convention: 20 °C (293.15 K, 68 °F), 1 atm (14.696 psi, 101.325 kPa)
0372     static constexpr double Temperature_NTP  = dd4hep::Temperature_NTP;
0373     static constexpr double Pressure_NTP     = dd4hep::Pressure_NTP;
0374     //
0375     static constexpr double kGasThreshold    = dd4hep::kGasThreshold;
0376     static constexpr double universe_mean_density = dd4hep::universe_mean_density;
0377 
0378     dd4hep_units() = default;
0379     ~dd4hep_units() = default;
0380   };
0381 }
0382 
0383 namespace dd4hep   {   namespace Parsers   {
0384     int parse(dd4hep::AlignmentData&, const std::string&);
0385     int parse(dd4hep::detail::AlignmentObject&, const std::string&);
0386   }}
0387 
0388 // -------------------------------------------------------------------------
0389 // Regular dd4hep dictionaries
0390 // -------------------------------------------------------------------------
0391 #ifdef DD4HEP_DICTIONARY_MODE
0392 #pragma link off all globals;
0393 #pragma link off all classes;
0394 #pragma link off all functions;
0395 
0396 #pragma link C++ namespace dd4hep;
0397 
0398 #pragma link C++ namespace dd4hep::tools;
0399 #pragma link C++ class dd4hep::tools::Evaluator;
0400 #pragma link C++ function dd4hep::evaluator;
0401 #pragma link C++ function dd4hep::g4Evaluator;
0402 
0403 #pragma link C++ namespace dd4hep::detail;
0404 #pragma link C++ namespace dd4hep::cond;
0405 #pragma link C++ namespace dd4hep::align;
0406 #pragma link C++ namespace dd4hep::DDSegmentation;
0407 
0408 #pragma link C++ enum dd4hep::PrintLevel;
0409 #pragma link C++ function dd4hep::always;
0410 #pragma link C++ function dd4hep::verbose;
0411 #pragma link C++ function dd4hep::debug;
0412 #pragma link C++ function dd4hep::info;
0413 #pragma link C++ function dd4hep::warning;
0414 #pragma link C++ function dd4hep::error;
0415 #pragma link C++ function dd4hep::fatal;
0416 #pragma link C++ function dd4hep::except;
0417 #pragma link C++ function dd4hep::printout;
0418 #pragma link C++ function dd4hep::exception;
0419 
0420 // System of units:
0421 // Length [L]
0422 #pragma link C++ global dd4hep::fermi;
0423 #pragma link C++ global dd4hep::angstrom;
0424 #pragma link C++ global dd4hep::nanometer;
0425 #pragma link C++ global dd4hep::micrometer;
0426 #pragma link C++ global dd4hep::millimeter;
0427 #pragma link C++ global dd4hep::millimeter2;
0428 #pragma link C++ global dd4hep::millimeter3;
0429 #pragma link C++ global dd4hep::centimeter;
0430 #pragma link C++ global dd4hep::centimeter2;
0431 #pragma link C++ global dd4hep::centimeter3;
0432 #pragma link C++ global dd4hep::meter;
0433 #pragma link C++ global dd4hep::meter2;
0434 #pragma link C++ global dd4hep::meter3;
0435 #pragma link C++ global dd4hep::kilometer;
0436 #pragma link C++ global dd4hep::kilometer2;
0437 #pragma link C++ global dd4hep::kilometer3;
0438 #pragma link C++ global dd4hep::parsec;
0439 // Area/cross-section
0440 #pragma link C++ global dd4hep::barn;
0441 #pragma link C++ global dd4hep::millibarn;
0442 #pragma link C++ global dd4hep::microbarn;
0443 #pragma link C++ global dd4hep::nanobarn;
0444 #pragma link C++ global dd4hep::picobarn;
0445 #pragma link C++ global dd4hep::radian;
0446 #pragma link C++ global dd4hep::milliradian;
0447 #pragma link C++ global dd4hep::degree;
0448 #pragma link C++ global dd4hep::steradian;
0449 
0450 #pragma link C++ global dd4hep::nm;
0451 #pragma link C++ global dd4hep::um;
0452 #pragma link C++ global dd4hep::mm;
0453 #pragma link C++ global dd4hep::mm2;
0454 #pragma link C++ global dd4hep::mm3;
0455 #pragma link C++ global dd4hep::cm;
0456 #pragma link C++ global dd4hep::cm2;
0457 #pragma link C++ global dd4hep::cm3;
0458 #pragma link C++ global dd4hep::m;
0459 #pragma link C++ global dd4hep::m2;
0460 #pragma link C++ global dd4hep::m3;
0461 #pragma link C++ global dd4hep::km;
0462 #pragma link C++ global dd4hep::km2;
0463 #pragma link C++ global dd4hep::km3;
0464 #pragma link C++ global dd4hep::m;
0465 #pragma link C++ global dd4hep::m2;
0466 #pragma link C++ global dd4hep::pc;
0467 #pragma link C++ global dd4hep::rad;
0468 #pragma link C++ global dd4hep::mrad;
0469 #pragma link C++ global dd4hep::sr;
0470 // Time [T]
0471 #pragma link C++ global dd4hep::nanosecond;
0472 #pragma link C++ global dd4hep::second;
0473 #pragma link C++ global dd4hep::millisecond;
0474 #pragma link C++ global dd4hep::microsecond;
0475 #pragma link C++ global dd4hep::picosecond;
0476 #pragma link C++ global dd4hep::hertz;
0477 #pragma link C++ global dd4hep::kilohertz;
0478 #pragma link C++ global dd4hep::megahertz;
0479 
0480 #pragma link C++ global dd4hep::ns;
0481 #pragma link C++ global dd4hep::s;
0482 #pragma link C++ global dd4hep::ms;
0483 // Electric charge [Q]
0484 #pragma link C++ global dd4hep::eplus;
0485 #pragma link C++ global dd4hep::e_SI;
0486 #pragma link C++ global dd4hep::coulomb;
0487 // Energy [E]
0488 #pragma link C++ global dd4hep::joule;
0489 #pragma link C++ global dd4hep::kilojoule;
0490 #pragma link C++ global dd4hep::electronvolt;
0491 #pragma link C++ global dd4hep::kiloelectronvolt;
0492 #pragma link C++ global dd4hep::megaelectronvolt;
0493 #pragma link C++ global dd4hep::gigaelectronvolt;
0494 #pragma link C++ global dd4hep::teraelectronvolt;
0495 #pragma link C++ global dd4hep::petaelectronvolt;
0496 
0497 #pragma link C++ global dd4hep::eV;
0498 #pragma link C++ global dd4hep::keV;
0499 #pragma link C++ global dd4hep::MeV;
0500 #pragma link C++ global dd4hep::GeV;
0501 #pragma link C++ global dd4hep::TeV;
0502 #pragma link C++ global dd4hep::PeV;
0503 // Mass [E][T^2][L^-2]
0504 #pragma link C++ global dd4hep::milligram;
0505 #pragma link C++ global dd4hep::gram;
0506 #pragma link C++ global dd4hep::kilogram;
0507 #pragma link C++ global dd4hep::mg;
0508 #pragma link C++ global dd4hep::g;
0509 #pragma link C++ global dd4hep::kg;
0510 // Power [E][T^-1]
0511 #pragma link C++ global dd4hep::watt;
0512 #pragma link C++ global dd4hep::kilowatt;
0513 #pragma link C++ global dd4hep::megawatt;
0514 // Force [E][L^-1]
0515 #pragma link C++ global dd4hep::newton;
0516 // Pressure [E][L^-3]
0517 #pragma link C++ global dd4hep::hep_pascal;
0518 #pragma link C++ global dd4hep::bar;
0519 #pragma link C++ global dd4hep::atmosphere;
0520 // Electric current [Q][T^-1]
0521 #pragma link C++ global dd4hep::nanoampere;
0522 #pragma link C++ global dd4hep::microampere;
0523 #pragma link C++ global dd4hep::milliampere;
0524 #pragma link C++ global dd4hep::ampere;
0525 // Electric potential [E][Q^-1]
0526 #pragma link C++ global dd4hep::volt;
0527 #pragma link C++ global dd4hep::kilovolt;
0528 #pragma link C++ global dd4hep::megavolt;
0529 // Electric resistance [E][T][Q^-2]
0530 #pragma link C++ global dd4hep::ohm;
0531 // Electric capacitance [Q^2][E^-1]
0532 #pragma link C++ global dd4hep::picofarad;
0533 #pragma link C++ global dd4hep::nanofarad;
0534 #pragma link C++ global dd4hep::microfarad;
0535 #pragma link C++ global dd4hep::millifarad;
0536 #pragma link C++ global dd4hep::farad;
0537 // Magnetic Flux [T][E][Q^-1]
0538 #pragma link C++ global dd4hep::weber;
0539 // Magnetic Field [T][E][Q^-1][L^-2]
0540 #pragma link C++ global dd4hep::tesla;
0541 #pragma link C++ global dd4hep::gauss;
0542 #pragma link C++ global dd4hep::kilogauss;
0543 // Inductance [T^2][E][Q^-2]
0544 #pragma link C++ global dd4hep::henry;
0545 // Temperature
0546 #pragma link C++ global dd4hep::kelvin;
0547 // Amount of substance
0548 #pragma link C++ global dd4hep::mole;
0549 // Absorbed dose [L^2][T^-2]
0550 #pragma link C++ global dd4hep::microgray;
0551 #pragma link C++ global dd4hep::milligray;
0552 #pragma link C++ global dd4hep::gray;
0553 #pragma link C++ global dd4hep::kilogray;
0554 // Luminous intensity [I]
0555 #pragma link C++ global dd4hep::candela;
0556 // Illuminance [I][L^-2]
0557 #pragma link C++ global dd4hep::lux;
0558 // Miscellaneous
0559 #pragma link C++ global dd4hep::perCent;
0560 #pragma link C++ global dd4hep::perThousand;
0561 #pragma link C++ global dd4hep::perMillion;
0562 // Physical Constants
0563 #pragma link C++ global dd4hep::pi;
0564 #pragma link C++ global dd4hep::twopi;
0565 #pragma link C++ global dd4hep::halfpi;
0566 #pragma link C++ global dd4hep::pi2;
0567 #pragma link C++ global dd4hep::Avogadro;
0568 #pragma link C++ global dd4hep::c_light;
0569 #pragma link C++ global dd4hep::c_squared;
0570 #pragma link C++ global dd4hep::h_Planck;
0571 #pragma link C++ global dd4hep::hbar_Planck;
0572 #pragma link C++ global dd4hep::hbarc;
0573 #pragma link C++ global dd4hep::hbarc_squared;
0574 #pragma link C++ global dd4hep::electron_charge;
0575 #pragma link C++ global dd4hep::e_squared;
0576 #pragma link C++ global dd4hep::electron_mass_c2;
0577 #pragma link C++ global dd4hep::proton_mass_c2;
0578 #pragma link C++ global dd4hep::neutron_mass_c2;
0579 #pragma link C++ global dd4hep::amu_c2;
0580 #pragma link C++ global dd4hep::amu;
0581 #pragma link C++ global dd4hep::mu0;
0582 #pragma link C++ global dd4hep::epsilon0;
0583 #pragma link C++ global dd4hep::elm_coupling;
0584 #pragma link C++ global dd4hep::fine_structure_const;
0585 #pragma link C++ global dd4hep::classic_electr_radius;
0586 #pragma link C++ global dd4hep::electron_Compton_length;
0587 #pragma link C++ global dd4hep::Bohr_radius;
0588 #pragma link C++ global dd4hep::alpha_rcl2;
0589 #pragma link C++ global dd4hep::twopi_mc2_rcl2;
0590 #pragma link C++ global dd4hep::k_Boltzmann;
0591 #pragma link C++ global dd4hep::Temperature_STP;
0592 #pragma link C++ global dd4hep::Pressure_STP;
0593 #pragma link C++ global dd4hep::Temperature_NTP;
0594 #pragma link C++ global dd4hep::Pressure_NTP;
0595 #pragma link C++ global dd4hep::kGasThreshold;
0596 #pragma link C++ global dd4hep::universe_mean_density;
0597 
0598 #ifndef __ROOTCLING__
0599 template std::pair<unsigned int, std::string>;
0600 template class dd4hep::Handle<dd4hep::NamedObject>;
0601 template class std::pair< string, dd4hep::Handle<dd4hep::NamedObject> >;
0602 template class std::map< string, dd4hep::Handle<dd4hep::NamedObject> >;
0603 template class std::pair<dd4hep::Callback,unsigned long>;
0604 #endif
0605 
0606 #pragma link C++ class DD4hepRootPersistency+;
0607 #pragma link C++ class DD4hepRootCheck+;
0608 #pragma link C++ class dd4hep::dd4hep_units;
0609 
0610 #pragma link C++ class std::pair<unsigned int,std::string>+;
0611 //#pragma link C++ class dd4hep::Callback+;
0612 #pragma link C++ class std::pair<dd4hep::Callback,unsigned long>+;
0613 #pragma link C++ class dd4hep::NamedObject+;
0614 #pragma link C++ class dd4hep::Ref_t+;
0615 #pragma link C++ class dd4hep::Handle<dd4hep::NamedObject>+;
0616 #pragma link C++ class std::pair<std::string, dd4hep::Handle<dd4hep::NamedObject> >+;
0617 #pragma link C++ class std::map<std::string, dd4hep::Handle<dd4hep::NamedObject> >+;
0618 #pragma link C++ class std::map<std::string, dd4hep::Handle<dd4hep::NamedObject> >::iterator;
0619 #pragma link C++ class std::map<std::string, dd4hep::Handle<dd4hep::NamedObject> >::const_iterator;
0620 #pragma link C++ class dd4hep::detail::DD4hepUI;
0621 
0622 #ifdef R__MACOSX
0623 // We only need these declarations for the clang compiler
0624 #pragma link C++ function operator==( const std::map<std::string, dd4hep::Handle<dd4hep::NamedObject> >::iterator&,const std::map<std::string, dd4hep::Handle<dd4hep::NamedObject> >::iterator& );
0625 #pragma link C++ function operator!=( const std::map<std::string, dd4hep::Handle<dd4hep::NamedObject> >::iterator&,const std::map<std::string, dd4hep::Handle<dd4hep::NamedObject> >::iterator& );
0626 #endif
0627 
0628 #pragma link C++ class dd4hep::BasicGrammar+;
0629 #pragma link C++ class dd4hep::ObjectExtensions+;
0630 template class dd4hep::Handle<TNamed>;
0631 #pragma link C++ class dd4hep::Handle<TNamed>+;
0632 
0633 #pragma link C++ class dd4hep::IOV+;
0634 #pragma link C++ class dd4hep::IOVType+;
0635 #pragma link C++ class dd4hep::OpaqueData+;
0636 #pragma link C++ class dd4hep::OpaqueDataBlock+;
0637 
0638 #pragma link C++ class dd4hep::Detector+;
0639 #pragma link C++ class dd4hep::DetectorImp+;
0640 #pragma link C++ class dd4hep::DetectorLoad+;
0641 #pragma link C++ class dd4hep::DetectorData+;
0642 #pragma link C++ class dd4hep::DetectorData::ObjectHandleMap+;
0643 #pragma link C++ class dd4hep::Detector::PropertyValues+;
0644 #pragma link C++ class dd4hep::Detector::Properties+;
0645 #pragma link C++ class std::pair<dd4hep::IDDescriptor,dd4hep::DDSegmentation::Segmentation*>+;
0646 #pragma link C++ class std::map<dd4hep::Readout,pair<dd4hep::IDDescriptor,dd4hep::DDSegmentation::Segmentation*> >+;
0647 
0648 // These below are the Namedobject instances to be generated ....
0649 //#pragma link C++ class dd4hep::Detector::HandleMap+;
0650 //#pragma link C++ class dd4hep::Detector::HandleMap::iterator;
0651 //#pragma link C++ class dd4hep::Detector::HandleMap::const_iterator;
0652 //#pragma link C++ class dd4hep::Detector::HandleMap::key_type; // == string
0653 //#pragma link C++ class dd4hep::Detector::HandleMap::value_type+;
0654 
0655 #pragma link C++ class dd4hep::VolumeManager+;
0656 #pragma link C++ class dd4hep::detail::VolumeManagerObject+;
0657 #pragma link C++ class dd4hep::VolumeManagerContext+;
0658 #pragma link C++ class dd4hep::detail::VolumeManagerContextExtension+;
0659 #pragma link C++ class dd4hep::Handle<dd4hep::detail::VolumeManagerObject>+;
0660 #pragma link C++ class std::pair<Long64_t,dd4hep::VolumeManager>+;
0661 #pragma link C++ class std::map<dd4hep::DetElement,dd4hep::VolumeManager>+;
0662 #pragma link C++ class std::map<dd4hep::VolumeID,dd4hep::VolumeManager>+;
0663 #pragma link C++ class std::map<dd4hep::VolumeID,dd4hep::VolumeManagerContext*>+;
0664 
0665 #pragma link C++ class dd4hep::CartesianField+;
0666 #pragma link C++ class dd4hep::CartesianField::TypedObject+;
0667 #pragma link C++ class dd4hep::CartesianField::Object+;
0668 #pragma link C++ class dd4hep::Handle<dd4hep::CartesianField::Object>+;
0669 #pragma link C++ class dd4hep::OverlayedField+;
0670 #pragma link C++ class dd4hep::OverlayedField::Object+;
0671 #pragma link C++ class dd4hep::Handle<dd4hep::OverlayedField::Object>+;
0672 
0673 // FieldTypes.h
0674 #pragma link C++ class dd4hep::ConstantField+;
0675 #pragma link C++ class dd4hep::Handle<dd4hep::ConstantField>+;
0676 #pragma link C++ class dd4hep::SolenoidField+;
0677 #pragma link C++ class dd4hep::Handle<dd4hep::SolenoidField>+;
0678 #pragma link C++ class dd4hep::DipoleField+;
0679 #pragma link C++ class dd4hep::Handle<dd4hep::DipoleField>+;
0680 
0681 #pragma link C++ class dd4hep::IDDescriptor+;
0682 #pragma link C++ class dd4hep::IDDescriptorObject+;
0683 #pragma link C++ class dd4hep::Handle<dd4hep::IDDescriptorObject>+;
0684 
0685 // Objects.h
0686 #pragma link C++ class dd4hep::Author+;
0687 #pragma link C++ class std::vector<dd4hep::Author>+;
0688 
0689 #pragma link C++ class dd4hep::Header+;
0690 #pragma link C++ class dd4hep::HeaderObject+;
0691 #pragma link C++ class dd4hep::Handle<dd4hep::HeaderObject>+;
0692 
0693 #pragma link C++ class dd4hep::Constant+;
0694 #pragma link C++ class dd4hep::ConstantObject+;
0695 #pragma link C++ class dd4hep::Handle<dd4hep::ConstantObject>+;
0696 #pragma link C++ class std::vector<dd4hep::Constant>+;
0697 
0698 #pragma link C++ class dd4hep::Atom+;
0699 #pragma link C++ class std::vector<dd4hep::Atom>+;
0700 #pragma link C++ class dd4hep::Handle<TGeoElement>+;
0701 
0702 #pragma link C++ class dd4hep::Material+;
0703 #pragma link C++ class std::vector<dd4hep::Material>+;
0704 #pragma link C++ class dd4hep::Handle<TGeoMedium>+;
0705 
0706 #pragma link C++ class dd4hep::VisAttr+;
0707 #pragma link C++ class std::vector<dd4hep::VisAttr>+;
0708 #pragma link C++ class dd4hep::VisAttrObject+;
0709 #pragma link C++ class dd4hep::Handle<dd4hep::VisAttrObject>+;
0710 
0711 #pragma link C++ class dd4hep::Limit+;
0712 #pragma link C++ class std::set<dd4hep::Limit>+;
0713 #pragma link C++ class std::vector<dd4hep::Limit>+;
0714 #pragma link C++ class dd4hep::LimitSet+;
0715 #pragma link C++ class std::vector<dd4hep::LimitSet>+;
0716 #pragma link C++ class dd4hep::LimitSetObject+;
0717 #pragma link C++ class dd4hep::Handle<dd4hep::LimitSetObject>+;
0718 #pragma link C++ class dd4hep::Region+;
0719 #pragma link C++ class dd4hep::RegionObject+;
0720 #pragma link C++ class dd4hep::Handle<dd4hep::RegionObject>+;
0721 #pragma link C++ class std::vector<dd4hep::Region>+;
0722 
0723 // Readout.h
0724 #pragma link C++ class std::vector<pair<size_t,string> >+;
0725 #pragma link C++ class dd4hep::Segmentation+;
0726 #pragma link C++ class dd4hep::SegmentationObject+;
0727 #pragma link C++ class dd4hep::Handle<dd4hep::SegmentationObject>+;
0728 #pragma link C++ class dd4hep::HitCollection+;
0729 #pragma link C++ class dd4hep::Readout+;
0730 #pragma link C++ class dd4hep::HitCollection+;
0731 #pragma link C++ class dd4hep::ReadoutObject+;
0732 #pragma link C++ class dd4hep::Handle<dd4hep::ReadoutObject>+;
0733 #pragma link C++ class std::vector<dd4hep::HitCollection>+;
0734 #pragma link C++ class std::vector<dd4hep::Readout>+;
0735 #pragma link C++ class std::vector<dd4hep::HitCollection*>+;
0736 #pragma link C++ class std::vector<const dd4hep::HitCollection*>+;
0737 #pragma link C++ class std::vector<dd4hep::IDDescriptor>+;
0738 
0739 // Alignment stuff
0740 #pragma link C++ class dd4hep::Delta+;
0741 #pragma link C++ class dd4hep::Alignment+;
0742 #pragma link C++ class dd4hep::AlignmentData+;
0743 #pragma link C++ class dd4hep::Handle<dd4hep::AlignmentData>+;
0744 //#pragma link C++ class dd4hep::Grammar<dd4hep::AlignmentData>+;
0745 
0746 #pragma link C++ class dd4hep::AlignmentCondition+;
0747 #pragma link C++ class dd4hep::detail::AlignmentObject+;
0748 #pragma link C++ class dd4hep::Handle<dd4hep::detail::AlignmentObject>+;
0749 #pragma link C++ class std::pair<dd4hep::DetElement,dd4hep::AlignmentCondition>+;
0750 //#pragma link C++ class dd4hep::Grammar<dd4hep::detail::AlignmentObject>+;
0751 
0752 #pragma link C++ class dd4hep::align::GlobalAlignment+;
0753 #pragma link C++ class dd4hep::Handle<TGeoPhysicalNode>+;
0754 
0755 // Conditions stuff
0756 #pragma link C++ class dd4hep::Condition+;
0757 #pragma link C++ class std::vector<dd4hep::Condition>+;
0758 #pragma link C++ class dd4hep::ConditionKey+;
0759 #pragma link C++ class std::vector<dd4hep::ConditionKey>+;
0760 #pragma link C++ class dd4hep::detail::ConditionObject+;
0761 #pragma link C++ class dd4hep::Handle<dd4hep::detail::ConditionObject>+;
0762 #pragma link C++ class dd4hep::OpaqueData+;
0763 #pragma link C++ class dd4hep::OpaqueDataBlock+;
0764 
0765 // DetElement.h
0766 #pragma link C++ class dd4hep::World+;
0767 #pragma link C++ class dd4hep::WorldObject+;
0768 #pragma link C++ class dd4hep::Handle<dd4hep::WorldObject>+;
0769 #pragma link C++ class dd4hep::DetElement+;
0770 #pragma link C++ class dd4hep::DetElement::Processor+;
0771 #pragma link C++ class dd4hep::DetElementObject+;
0772 #pragma link C++ class dd4hep::Handle<dd4hep::DetElementObject>+;
0773 #pragma link C++ class std::vector<dd4hep::DetElement>+;
0774 #pragma link C++ class std::pair<std::string,dd4hep::DetElement>+;
0775 #pragma link C++ class std::map<std::string,dd4hep::DetElement>+;
0776 #pragma link C++ class std::map<std::string,dd4hep::DetElement>::iterator;
0777 #pragma link C++ class std::map<std::string,dd4hep::DetElement>::const_iterator;
0778 
0779 #pragma link C++ class dd4hep::DetectorProcessor+;
0780 #pragma link C++ class dd4hep::DetectorScanner+;
0781 
0782 #pragma link C++ class std::pair<dd4hep::DetElement,dd4hep::VolumeManager>+;
0783 
0784 #ifdef R__MACOSX
0785 // We only need these declarations for the clang compiler
0786 #pragma link C++ function operator==( const std::map<std::string, dd4hep::DetElement >::iterator&,const std::map<std::string, dd4hep::DetElement >::iterator& );
0787 #pragma link C++ function operator!=( const std::map<std::string, dd4hep::DetElement >::iterator&,const std::map<std::string, dd4hep::DetElement >::iterator& );
0788 #endif
0789 
0790 #pragma link C++ class dd4hep::SensitiveDetector+;
0791 #pragma link C++ class dd4hep::SensitiveDetectorObject+;
0792 #pragma link C++ class dd4hep::Handle<dd4hep::SensitiveDetectorObject>+;
0793 #pragma link C++ class vector<dd4hep::SensitiveDetector>+;
0794 
0795 #pragma link C++ class std::pair<std::string, std::string>+;
0796 #pragma link C++ class std::map<std::string, std::string>+;
0797 #pragma link C++ class std::map<std::string, std::string>::iterator;
0798 #pragma link C++ class std::map<std::string, std::string>::const_iterator;
0799 
0800 #ifdef R__MACOSX
0801 // We only need these declarations for the clang compiler
0802 #pragma link C++ function operator==( const std::map<std::string, std::string>::iterator&, const std::map<std::string, std::string>::iterator& );
0803 #pragma link C++ function operator!=( const std::map<std::string, std::string>::iterator&, const std::map<std::string, std::string>::iterator& );
0804 #endif
0805 
0806 #pragma link C++ class std::pair<std::string, std::map<std::string, std::string> >+;
0807 #pragma link C++ class std::map<std::string, std::map<std::string, std::string> >+;
0808 #pragma link C++ class std::map<std::string, std::map<std::string,std::string>>::iterator;
0809 #pragma link C++ class std::map<std::string, std::map<std::string,std::string>>::const_iterator;
0810 
0811 #ifdef R__MACOSX
0812 // We only need these declarations for the clang compiler
0813 #pragma link C++ function operator==( const std::map<std::string, std::map<std::string,std::string>>::iterator&, const std::map<std::string, std::map<std::string,std::string>>::iterator& );
0814 #pragma link C++ function operator!=( const std::map<std::string, std::map<std::string,std::string>>::iterator&, const std::map<std::string, std::map<std::string,std::string>>::iterator& );
0815 #endif
0816 
0817 #pragma link C++ class dd4hep::Detector+;
0818 
0819 #pragma link C++ class dd4hep::detail::interp;
0820 #pragma link C++ class dd4hep::detail::eval;
0821 
0822 #pragma link C++ function dd4hep::run_interpreter(const std::string& name);
0823 #pragma link C++ function dd4hep::_toDictionary(const std::string&, const std::string&);
0824 #pragma link C++ function dd4hep::toStringSolid(const TGeoShape*, int);
0825 #pragma link C++ function dd4hep::toStringMesh(const TGeoShape*, int);
0826 #pragma link C++ function dd4hep::toStringMesh(dd4hep::PlacedVolume, int);
0827 
0828 #include <DD4hep/ConditionsData.h>
0829 #pragma link C++ class dd4hep::cond::ClientData+;
0830 #pragma link C++ class dd4hep::cond::AbstractMap+;
0831 #pragma link C++ class dd4hep::cond::AbstractMap::Params+;
0832 
0833 #endif  // __CINT__
0834 #endif // DDCORE_SRC_ROOTDICTIONARY_H
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!