HcalCommon/interface/ElectronicsQuantity.h

0001 #ifndef ElectronicsQuantity_h
0002 #define ElectronicsQuantity_h
0003
0004 /**
0005  *  file:       ElectronicsQuantity.h
0006  *  Author:     Viktor Khristenko
0007  */
0008
0009 #include "DQM/HcalCommon/interface/Quantity.h"
0010 #include <unordered_map>
0011
0012 namespace hcaldqm {
0013   namespace quantity {
0014     enum ElectronicsQuantityType {
0015       fFED = 0,
0016       fFEDuTCA = 1,
0017       fFEDVME = 2,
0018       fCrate = 3,
0019       fCrateuTCA = 4,
0020       fCrateVME = 5,
0021       fSlotuTCA = 6,
0022       fSlotVME = 7,
0023       fSpigot = 8,
0024       fFiberuTCA = 9,
0025       fFiberVME = 10,
0026       fFiberCh = 11,
0027
0028       //    Complex Quantities
0029       fFEDuTCASlot = 12,
0030       fFEDVMESpigot = 13,
0031       fFiberuTCAFiberCh = 14,
0032       fFiberVMEFiberCh = 15,
0033
0034       //    Adding Trigger Quantities for VME
0035       fSLB = 16,
0036       fSLBCh = 17,
0037       fSLBSLBCh = 18,
0038
0039       //    Adding Trigger Quantities for uTCA
0040       fFiberuTCATP = 19,
0041       fFiberChuTCATP = 20,
0042       fFiberuTCATPFiberChuTCATP = 21,
0043
0044       nElectronicsQuantityType = 22
0045     };
0046
0047     int getValue_FED(HcalElectronicsId const &);
0048     int getValue_FEDuTCA(HcalElectronicsId const &);
0049     int getValue_FEDVME(HcalElectronicsId const &);
0050     int getValue_Crate(HcalElectronicsId const &);
0051     int getValue_CrateuTCA(HcalElectronicsId const &);
0052     int getValue_CrateVME(HcalElectronicsId const &);
0053     int getValue_SlotuTCA(HcalElectronicsId const &);
0054     int getValue_SlotVME(HcalElectronicsId const &);
0055     int getValue_Spigot(HcalElectronicsId const &);
0056     int getValue_FiberuTCA(HcalElectronicsId const &);
0057     int getValue_FiberVME(HcalElectronicsId const &);
0058     int getValue_FiberCh(HcalElectronicsId const &);
0059     int getValue_FEDuTCASlot(HcalElectronicsId const &);
0060     int getValue_FEDVMESpigot(HcalElectronicsId const &);
0061     int getValue_FiberuTCAFiberCh(HcalElectronicsId const &);
0062     int getValue_FiberVMEFiberCh(HcalElectronicsId const &);
0063     int getValue_SLB(HcalElectronicsId const &);
0064     int getValue_SLBCh(HcalElectronicsId const &);
0065     int getValue_SLBSLBCh(HcalElectronicsId const &);
0066     int getValue_FiberuTCATP(HcalElectronicsId const &);
0067     int getValue_FiberChuTCATP(HcalElectronicsId const &);
0068     int getValue_FiberuTCATPFiberChuTCATP(HcalElectronicsId const &);
0069     uint32_t getBin_FED(HcalElectronicsId const &);
0070     uint32_t getBin_FEDuTCA(HcalElectronicsId const &);
0071     uint32_t getBin_FEDVME(HcalElectronicsId const &);
0072     uint32_t getBin_Crate(HcalElectronicsId const &);
0073     uint32_t getBin_CrateuTCA(HcalElectronicsId const &);
0074     uint32_t getBin_CrateVME(HcalElectronicsId const &);
0075     uint32_t getBin_SlotuTCA(HcalElectronicsId const &);
0076     uint32_t getBin_SlotVME(HcalElectronicsId const &);
0077     uint32_t getBin_Spigot(HcalElectronicsId const &);
0078     uint32_t getBin_FiberuTCA(HcalElectronicsId const &);
0079     uint32_t getBin_FiberVME(HcalElectronicsId const &);
0080     uint32_t getBin_FiberCh(HcalElectronicsId const &);
0081     uint32_t getBin_FEDuTCASlot(HcalElectronicsId const &);
0082     uint32_t getBin_FEDVMESpigot(HcalElectronicsId const &);
0083     uint32_t getBin_FiberuTCAFiberCh(HcalElectronicsId const &);
0084     uint32_t getBin_FiberVMEFiberCh(HcalElectronicsId const &);
0085     uint32_t getBin_SLB(HcalElectronicsId const &);
0086     uint32_t getBin_SLBCh(HcalElectronicsId const &);
0087     uint32_t getBin_SLBSLBCh(HcalElectronicsId const &);
0088     uint32_t getBin_FiberuTCATP(HcalElectronicsId const &);
0089     uint32_t getBin_FiberChuTCATP(HcalElectronicsId const &);
0090     uint32_t getBin_FiberuTCATPFiberChuTCATP(HcalElectronicsId const &);
0091     HcalElectronicsId getEid_FED(int);
0092     HcalElectronicsId getEid_FEDuTCA(int);
0093     HcalElectronicsId getEid_FEDVME(int);
0094     HcalElectronicsId getEid_Crate(int);
0095     HcalElectronicsId getEid_CrateuTCA(int);
0096     HcalElectronicsId getEid_CrateVME(int);
0097     HcalElectronicsId getEid_SlotuTCA(int);
0098     HcalElectronicsId getEid_SlotVME(int);
0099     HcalElectronicsId getEid_Spigot(int);
0100     HcalElectronicsId getEid_FiberuTCA(int);
0101     HcalElectronicsId getEid_FiberVME(int);
0102     HcalElectronicsId getEid_FiberCh(int);
0103     HcalElectronicsId getEid_FEDuTCASlot(int);
0104     HcalElectronicsId getEid_FEDVMESpigot(int);
0105     HcalElectronicsId getEid_FiberuTCAFiberCh(int);
0106     HcalElectronicsId getEid_FiberVMEFiberCh(int);
0107     HcalElectronicsId getEid_SLB(int);
0108     HcalElectronicsId getEid_SLBCh(int);
0109     HcalElectronicsId getEid_SLBSLBCh(int);
0110     HcalElectronicsId getEid_FiberuTCATP(int);
0111     HcalElectronicsId getEid_FiberChuTCATP(int);
0112     HcalElectronicsId getEid_FiberuTCATPFiberChuTCATP(int);
0113     std::vector<std::string> getLabels_FED();
0114     std::vector<std::string> getLabels_FEDuTCA();
0115     std::vector<std::string> getLabels_FEDVME();
0116     std::vector<std::string> getLabels_Crate();
0117     std::vector<std::string> getLabels_CrateuTCA();
0118     std::vector<std::string> getLabels_CrateVME();
0119     std::vector<std::string> getLabels_SlotuTCA();
0120     std::vector<std::string> getLabels_SlotVME();
0121     std::vector<std::string> getLabels_Spigot();
0122     std::vector<std::string> getLabels_FiberuTCA();
0123     std::vector<std::string> getLabels_FiberVME();
0124     std::vector<std::string> getLabels_FiberCh();
0125     std::vector<std::string> getLabels_FEDuTCASlot();
0126     std::vector<std::string> getLabels_FEDVMESpigot();
0127     std::vector<std::string> getLabels_FiberuTCAFiberCh();
0128     std::vector<std::string> getLabels_FiberVMEFiberCh();
0129     std::vector<std::string> getLabels_SLB();
0130     std::vector<std::string> getLabels_SLBCh();
0131     std::vector<std::string> getLabels_SLBSLBCh();
0132     std::vector<std::string> getLabels_FiberuTCATP();
0133     std::vector<std::string> getLabels_FiberChuTCATP();
0134     std::vector<std::string> getLabels_FiberuTCATPFiberChuTCATP();
0135
0136     typedef int (*getValueType_eid)(HcalElectronicsId const &);
0137     typedef uint32_t (*getBinType_eid)(HcalElectronicsId const &);
0138     typedef HcalElectronicsId (*getEid_eid)(int);
0139     typedef std::vector<std::string> (*getLabels_eid)();
0140     const std::map<ElectronicsQuantityType, getValueType_eid> getValue_functions_eid = {
0141         {fFED, getValue_FED},
0142         {fFEDuTCA, getValue_FEDuTCA},
0143         {fFEDVME, getValue_FEDVME},
0144         {fCrate, getValue_Crate},
0145         {fCrateuTCA, getValue_CrateuTCA},
0146         {fCrateVME, getValue_CrateVME},
0147         {fSlotuTCA, getValue_SlotuTCA},
0148         {fSlotVME, getValue_SlotVME},
0149         {fSpigot, getValue_Spigot},
0150         {fFiberuTCA, getValue_FiberuTCA},
0151         {fFiberVME, getValue_FiberVME},
0152         {fFiberCh, getValue_FiberCh},
0153         {fFEDuTCASlot, getValue_FEDuTCASlot},
0154         {fFEDVMESpigot, getValue_FEDVMESpigot},
0155         {fFiberuTCAFiberCh, getValue_FiberuTCAFiberCh},
0156         {fFiberVMEFiberCh, getValue_FiberVMEFiberCh},
0157         {fSLB, getValue_SLB},
0158         {fSLBCh, getValue_SLBCh},
0159         {fSLBSLBCh, getValue_SLBSLBCh},
0160         {fFiberuTCATP, getValue_FiberuTCATP},
0161         {fFiberChuTCATP, getValue_FiberChuTCATP},
0162         {fFiberuTCATPFiberChuTCATP, getValue_FiberuTCATPFiberChuTCATP},
0163     };
0164     const std::map<ElectronicsQuantityType, getBinType_eid> getBin_functions_eid = {
0165         {fFED, getBin_FED},
0166         {fFEDuTCA, getBin_FEDuTCA},
0167         {fFEDVME, getBin_FEDVME},
0168         {fCrate, getBin_Crate},
0169         {fCrateuTCA, getBin_CrateuTCA},
0170         {fCrateVME, getBin_CrateVME},
0171         {fSlotuTCA, getBin_SlotuTCA},
0172         {fSlotVME, getBin_SlotVME},
0173         {fSpigot, getBin_Spigot},
0174         {fFiberuTCA, getBin_FiberuTCA},
0175         {fFiberVME, getBin_FiberVME},
0176         {fFiberCh, getBin_FiberCh},
0177         {fFEDuTCASlot, getBin_FEDuTCASlot},
0178         {fFEDVMESpigot, getBin_FEDVMESpigot},
0179         {fFiberuTCAFiberCh, getBin_FiberuTCAFiberCh},
0180         {fFiberVMEFiberCh, getBin_FiberVMEFiberCh},
0181         {fSLB, getBin_SLB},
0182         {fSLBCh, getBin_SLBCh},
0183         {fSLBSLBCh, getBin_SLBSLBCh},
0184         {fFiberuTCATP, getBin_FiberuTCATP},
0185         {fFiberChuTCATP, getBin_FiberChuTCATP},
0186         {fFiberuTCATPFiberChuTCATP, getBin_FiberuTCATPFiberChuTCATP},
0187     };
0188     const std::map<ElectronicsQuantityType, getEid_eid> getEid_functions_eid = {
0189         {fFED, getEid_FED},
0190         {fFEDuTCA, getEid_FEDuTCA},
0191         {fFEDVME, getEid_FEDVME},
0192         {fCrate, getEid_Crate},
0193         {fCrateuTCA, getEid_CrateuTCA},
0194         {fCrateVME, getEid_CrateVME},
0195         {fSlotuTCA, getEid_SlotuTCA},
0196         {fSlotVME, getEid_SlotVME},
0197         {fSpigot, getEid_Spigot},
0198         {fFiberuTCA, getEid_FiberuTCA},
0199         {fFiberVME, getEid_FiberVME},
0200         {fFiberCh, getEid_FiberCh},
0201         {fFEDuTCASlot, getEid_FEDuTCASlot},
0202         {fFEDVMESpigot, getEid_FEDVMESpigot},
0203         {fFiberuTCAFiberCh, getEid_FiberuTCAFiberCh},
0204         {fFiberVMEFiberCh, getEid_FiberVMEFiberCh},
0205         {fSLB, getEid_SLB},
0206         {fSLBCh, getEid_SLBCh},
0207         {fSLBSLBCh, getEid_SLBSLBCh},
0208         {fFiberuTCATP, getEid_FiberuTCATP},
0209         {fFiberChuTCATP, getEid_FiberChuTCATP},
0210         {fFiberuTCATPFiberChuTCATP, getEid_FiberuTCATPFiberChuTCATP},
0211     };
0212     const std::map<ElectronicsQuantityType, getLabels_eid> getLabels_functions_eid = {
0213         {fFED, getLabels_FED},
0214         {fFEDuTCA, getLabels_FEDuTCA},
0215         {fFEDVME, getLabels_FEDVME},
0216         {fCrate, getLabels_Crate},
0217         {fCrateuTCA, getLabels_CrateuTCA},
0218         {fCrateVME, getLabels_CrateVME},
0219         {fSlotuTCA, getLabels_SlotuTCA},
0220         {fSlotVME, getLabels_SlotVME},
0221         {fSpigot, getLabels_Spigot},
0222         {fFiberuTCA, getLabels_FiberuTCA},
0223         {fFiberVME, getLabels_FiberVME},
0224         {fFiberCh, getLabels_FiberCh},
0225         {fFEDuTCASlot, getLabels_FEDuTCASlot},
0226         {fFEDVMESpigot, getLabels_FEDVMESpigot},
0227         {fFiberuTCAFiberCh, getLabels_FiberuTCAFiberCh},
0228         {fFiberVMEFiberCh, getLabels_FiberVMEFiberCh},
0229         {fSLB, getLabels_SLB},
0230         {fSLBCh, getLabels_SLBCh},
0231         {fSLBSLBCh, getLabels_SLBSLBCh},
0232         {fFiberuTCATP, getLabels_FiberuTCATP},
0233         {fFiberChuTCATP, getLabels_FiberChuTCATP},
0234         {fFiberuTCATPFiberChuTCATP, getLabels_FiberuTCATPFiberChuTCATP},
0235     };
0236     const std::map<ElectronicsQuantityType, std::string> name_eid = {
0237         {fFED, "FED"},
0238         {fFEDuTCA, "FEDuTCA"},
0239         {fFEDVME, "FEDVME"},
0240         {fCrate, "Crate"},
0241         {fCrateuTCA, "CrateuTCA"},
0242         {fCrateVME, "CrateVME"},
0243         {fSlotuTCA, "SlotuTCA"},
0244         {fSlotVME, "SlotVME"},
0245         {fSpigot, "Spigot"},
0246         {fFiberuTCA, "FiberuTCA"},
0247         {fFiberVME, "FiberVME"},
0248         {fFiberCh, "FiberCh"},
0249         {fFEDuTCASlot, "FEDuTCASlot"},
0250         {fFEDVMESpigot, "FEDVMESpigot"},
0251         {fFiberuTCAFiberCh, "FiberuTCAFiberCh"},
0252         {fFiberVMEFiberCh, "FiberVMEFiberCh"},
0253         {fSLB, "SLB"},
0254         {fSLBCh, "SLBCh"},
0255         {fSLBSLBCh, "SLB-SLBCh"},
0256         {fFiberuTCATP, "TPFiber"},
0257         {fFiberChuTCATP, "TPFiberCh"},
0258         {fFiberuTCATPFiberChuTCATP, "TPF-TPFCh"},
0259     };
0260     const std::map<ElectronicsQuantityType, double> min_eid = {
0261         {fFED, -0.5},
0262         {fFEDuTCA, -0.5},
0263         {fFEDVME, -0.5},
0264         {fCrate, -0.5},
0265         {fCrateuTCA, -0.5},
0266         {fCrateVME, -0.5},
0267         {fSlotuTCA, 0.},
0268         {fSlotVME, 0.},
0269         {fSpigot, 0.},
0270         {fFiberuTCA, 0.},
0271         {fFiberVME, 0.},
0272         {fFiberCh, 0.},
0273         {fFEDuTCASlot, 0.},
0274         {fFEDVMESpigot, 0.},
0275         {fFiberuTCAFiberCh, 0.},
0276         {fFiberVMEFiberCh, 0.},
0277         {fSLB, 0.},
0278         {fSLBCh, 0.},
0279         {fSLBSLBCh, 0.},
0280         {fFiberuTCATP, 0.},
0281         {fFiberChuTCATP, 0.},
0282         {fFiberuTCATPFiberChuTCATP, 0.},
0283     };
0284     const std::map<ElectronicsQuantityType, double> max_eid = {
0285         {fFED, constants::fedList.size() - 0.5},
0286         {fFEDuTCA, constants::fedListuTCA.size() - 0.5},
0287         {fFEDVME, constants::fedListVME.size() - 0.5},
0288         {fCrate, constants::crateList.size() - 0.5},
0289         {fCrateuTCA, constants::crateListuTCA.size() - 0.5},
0290         {fCrateVME, constants::crateListVME.size() - 0.5},
0291         {fSlotuTCA, constants::SLOT_uTCA_NUM},
0292         {fSlotVME, constants::SLOT_VME_NUM},
0293         {fSpigot, constants::SPIGOT_NUM},
0294         {fFiberuTCA, constants::FIBER_uTCA_NUM},
0295         {fFiberVME, constants::FIBER_VME_NUM},
0296         {fFiberCh, constants::FIBERCH_NUM},
0297         {fFEDuTCASlot, constants::FED_uTCA_NUM *constants::SLOT_uTCA_NUM},
0298         {fFEDVMESpigot, constants::FED_VME_NUM *constants::SPIGOT_NUM},
0299         {fFiberuTCAFiberCh, constants::FIBER_uTCA_NUM *constants::FIBERCH_NUM},
0300         {fFiberVMEFiberCh, constants::FIBER_VME_NUM *constants::FIBERCH_NUM},
0301         {fSLB, constants::SLB_NUM},
0302         {fSLBCh, constants::SLBCH_NUM},
0303         {fSLBSLBCh, constants::SLB_NUM *constants::SLBCH_NUM},
0304         {fFiberuTCATP, constants::TPFIBER_NUM},
0305         {fFiberChuTCATP, constants::TPFIBERCH_NUM},
0306         {fFiberuTCATPFiberChuTCATP, constants::TPFIBER_NUM *constants::TPFIBERCH_NUM},
0307     };
0308     const std::map<ElectronicsQuantityType, double> nbins_eid = {
0309         {fFED, constants::fedList.size()},
0310         {fFEDuTCA, constants::fedListuTCA.size()},
0311         {fFEDVME, constants::fedListVME.size()},
0312         {fCrate, constants::crateList.size()},
0313         {fCrateuTCA, constants::crateListuTCA.size()},
0314         {fCrateVME, constants::crateListVME.size()},
0315         {fSlotuTCA, constants::SLOT_uTCA_NUM},
0316         {fSlotVME, constants::SLOT_VME_NUM},
0317         {fSpigot, constants::SPIGOT_NUM},
0318         {fFiberuTCA, constants::FIBER_uTCA_NUM},
0319         {fFiberVME, constants::FIBER_VME_NUM},
0320         {fFiberCh, constants::FIBERCH_NUM},
0321         {fFEDuTCASlot, constants::FED_uTCA_NUM *constants::SLOT_uTCA_NUM},
0322         {fFEDVMESpigot, constants::FED_VME_NUM *constants::SPIGOT_NUM},
0323         {fFiberuTCAFiberCh, constants::FIBER_uTCA_NUM *constants::FIBERCH_NUM},
0324         {fFiberVMEFiberCh, constants::FIBER_VME_NUM *constants::FIBERCH_NUM},
0325         {fSLB, constants::SLB_NUM},
0326         {fSLBCh, constants::SLBCH_NUM},
0327         {fSLBSLBCh, constants::SLB_NUM *constants::SLBCH_NUM},
0328         {fFiberuTCATP, constants::TPFIBER_NUM},
0329         {fFiberChuTCATP, constants::TPFIBERCH_NUM},
0330         {fFiberuTCATPFiberChuTCATP, constants::TPFIBER_NUM *constants::TPFIBERCH_NUM},
0331     };
0332
0333     class ElectronicsQuantity : public Quantity {
0334     public:
0335       ElectronicsQuantity() {}
0336       ElectronicsQuantity(ElectronicsQuantityType type, bool isLog = false)
0337           : Quantity(name_eid.at(type), isLog), _type(type) {}
0338       ~ElectronicsQuantity() override {}
0339       ElectronicsQuantity *makeCopy() override { return new ElectronicsQuantity(_type, _isLog); }
0340
0341       int getValue(HcalElectronicsId const &eid) override { return getValue_functions_eid.at(_type)(eid); }
0342       uint32_t getBin(HcalElectronicsId const &eid) override { return getBin_functions_eid.at(_type)(eid); }
0343
0344       QuantityType type() override { return fElectronicsQuantity; }
0345       int nbins() override { return nbins_eid.at(_type); }
0346       double min() override { return min_eid.at(_type); }
0347       double max() override { return max_eid.at(_type); }
0348       bool isCoordinate() override { return true; }
0349       std::vector<std::string> getLabels() override { return getLabels_functions_eid.at(_type)(); }
0350
0351     protected:
0352       ElectronicsQuantityType _type;
0353     };
0354
0355     //  sorted list of FEDs you want to have on the axis
0356     class FEDQuantity : public ElectronicsQuantity {
0357     public:
0358       FEDQuantity() {}
0359       FEDQuantity(std::vector<int> const &vFEDs) : ElectronicsQuantity(fFED, false) { this->setup(vFEDs); }
0360       ~FEDQuantity() override {}
0361
0362       virtual void setup(std::vector<int> const &vFEDs);
0363       int getValue(HcalElectronicsId const &) override;
0364       uint32_t getBin(HcalElectronicsId const &) override;
0365
0366       int nbins() override { return _feds.size(); }
0367       double min() override { return 0; }
0368       double max() override { return _feds.size(); }
0369       std::vector<std::string> getLabels() override;
0370
0371     protected:
0372       typedef std::unordered_map<int, uint32_t> FEDMap;
0373       FEDMap _feds;
0374
0375     public:
0376       FEDQuantity *makeCopy() override {
0377         std::vector<int> vfeds;
0378         for (auto const &p : _feds) {
0379           vfeds.push_back(p.first);
0380         }
0381
0382         //  MUST SORT BEFORE EXITING!
0383         std::sort(vfeds.begin(), vfeds.end());
0384         return new FEDQuantity(vfeds);
0385       }
0386     };
0387
0388     // Crate quantity, initialized from emap (because it is not easy to turn a VME
0389     // crate in an EID)
0390     class CrateQuantity : public ElectronicsQuantity {
0391       typedef std::map<int, uint32_t> CrateHashMap;
0392
0393     public:
0394       CrateQuantity() {}
0395       CrateQuantity(HcalElectronicsMap const *emap) : ElectronicsQuantity(fCrate, false) { this->setup(emap); }
0396       CrateQuantity(std::vector<int> crates, CrateHashMap crateHashes) : ElectronicsQuantity(fCrate, false) {
0397         this->setup(crates, crateHashes);
0398       }
0399       ~CrateQuantity() override {}
0400
0401       virtual void setup(HcalElectronicsMap const *emap);
0402       virtual void setup(std::vector<int> crates, CrateHashMap crateHashes);
0403       int getValue(HcalElectronicsId const &) override;
0404       uint32_t getBin(HcalElectronicsId const &) override;
0405
0406       int nbins() override { return _crates.size(); }
0407       double min() override { return 0; }
0408       double max() override { return _crates.size(); }
0409       std::vector<std::string> getLabels() override;
0410
0411     protected:
0412       std::vector<int> _crates;
0413       CrateHashMap _crateHashes;
0414
0415     public:
0416       CrateQuantity *makeCopy() override {
0417         // Make copies of the crate info
0418         std::vector<int> tmpCrates;
0419         std::map<int, uint32_t> tmpCrateHashes;
0420         for (auto &it_crate : _crates) {
0421           tmpCrates.push_back(it_crate);
0422           tmpCrateHashes[it_crate] = _crateHashes[it_crate];
0423         }
0424         return new CrateQuantity(tmpCrates, tmpCrateHashes);
0425       }
0426     };
0427   }  // namespace quantity
0428 }  // namespace hcaldqm
0429
0430 #endif