PixelCalibConfiguration.h

Go to the documentation of this file.

#ifndef PixelCalibConfiguration_h
#define PixelCalibConfiguration_h
 
#include <vector>
#include <set>
#include <map>
#include <string>
#include <sstream>
#include <utility>
#include "CalibFormats/SiPixelObjects/interface/PixelCalibBase.h"
#include "CalibFormats/SiPixelObjects/interface/PixelNameTranslation.h"
#include "CalibFormats/SiPixelObjects/interface/PixelDetectorConfig.h"
#include "CalibFormats/SiPixelObjects/interface/PixelFEDConfig.h"
#include "CalibFormats/SiPixelObjects/interface/PixelFECConfig.h"
#include "CalibFormats/SiPixelObjects/interface/PixelTKFECConfig.h"
#include "CalibFormats/SiPixelObjects/interface/PixelFECConfigInterface.h"
#include "CalibFormats/SiPixelObjects/interface/PixelROCName.h"
#include "CalibFormats/SiPixelObjects/interface/PixelModuleName.h"
#include "CalibFormats/SiPixelObjects/interface/PixelModuleName.h"
#include "CalibFormats/SiPixelObjects/interface/PixelMaskBase.h"
#include "CalibFormats/SiPixelObjects/interface/PixelTrimBase.h"
#include "CalibFormats/SiPixelObjects/interface/PixelROCMaskBits.h"
#include "CalibFormats/SiPixelObjects/interface/PixelROCTrimBits.h"
#include "CalibFormats/SiPixelObjects/interface/PixelDACSettings.h"
#include "CalibFormats/SiPixelObjects/interface/PixelConfigBase.h"
#include "CalibFormats/SiPixelObjects/interface/PixelDACScanRange.h"
#include "CalibFormats/SiPixelObjects/interface/PixelPortcardMap.h"
#include "CalibFormats/SiPixelObjects/interface/PixelPortCardConfig.h"
 
namespace pos {
  class PixelHdwAddress;
 
  //This class contains info about a ROC
  class PixelROCInfo {
  public:
    bool use_;
    const PixelHdwAddress* hdwadd_;
    //FIXME these should be const but it has ripple effects...
    PixelROCTrimBits* trims_;
    PixelROCMaskBits* masks_;
    std::vector<std::pair<unsigned int, unsigned int> > defaultDACs_;
    std::string tbmChannel_;
  };
 
  class PixelCalibConfiguration;
  std::ostream& operator<<(std::ostream& s, const PixelCalibConfiguration& calib);
 
  class PixelCalibConfiguration : public PixelCalibBase, public PixelConfigBase {
  public:
    PixelCalibConfiguration(std::string filename = "");
    PixelCalibConfiguration(std::vector<std::vector<std::string> >&);
 
    ~PixelCalibConfiguration() override;
 
    // This must be run before using commands that require the ROC list.
    void buildROCAndModuleLists(const PixelNameTranslation* translation, const PixelDetectorConfig* detconfig);
 
    void nextFECState(std::map<unsigned int, PixelFECConfigInterface*>& pixelFECs,
                      PixelDetectorConfig* detconfig,
                      PixelNameTranslation* trans,
                      std::map<pos::PixelModuleName, pos::PixelMaskBase*>* masks,
                      std::map<pos::PixelModuleName, pos::PixelTrimBase*>* trims,
                      std::map<pos::PixelModuleName, pos::PixelDACSettings*>* dacss,
                      unsigned int state) const;
 
    //return vector of fed# and channels controlled by this fed supervisor
    std::vector<std::pair<unsigned int, std::vector<unsigned int> > >& fedCardsAndChannels(
        unsigned int crate,
        PixelNameTranslation* translation,
        PixelFEDConfig* fedconfig,
        PixelDetectorConfig* detconfig) const;
 
    std::map<unsigned int, std::set<unsigned int> > getFEDsAndChannels(PixelNameTranslation* translation);
 
    // Returns a std::set of FED crates that are used by this Calib object
    std::set<unsigned int> getFEDCrates(const PixelNameTranslation* translation, const PixelFEDConfig* fedconfig) const;
 
    // Returns a std::set of FEC crates that are used by this Calib object
    std::set<unsigned int> getFECCrates(const PixelNameTranslation* translation, const PixelFECConfig* fecconfig) const;
 
    // Returns a std::set of TKFEC crates that are used by this Calib object
    std::set<unsigned int> getTKFECCrates(const PixelPortcardMap* portcardmap,
                                          const std::map<std::string, PixelPortCardConfig*>& mapNamePortCard,
                                          const PixelTKFECConfig* tkfecconfig) const;
 
    unsigned int nROC() const {
      assert(rocAndModuleListsBuilt_);
      return nROC_;
    }
    unsigned int nPixelPatterns() const { return rows_.size() * cols_.size(); }
    unsigned int nTriggersPerPattern() const { return ntrigger_; }
    unsigned int nScanPoints(std::string dac) const { return nScanPoints(iScan(dac)); }
 
    unsigned int nScanPoints() const {
      unsigned int points = 1;
      for (unsigned int i = 0; i < dacs_.size(); i++) {
        points *= nScanPoints(i);
      }
      return points;
    }
    unsigned int nConfigurations() const { return nPixelPatterns() * nScanPoints() * nROC(); }
    unsigned int nTriggersTotal() const { return nConfigurations() * nTriggersPerPattern(); }
 
    bool noHits() const { return (maxNumHitsPerROC() == 0); }  // returns true if no hits will be produced
    unsigned int maxNumHitsPerROC()
        const;  // returns the maximum number of hits that will be produced in any pixel pattern
 
    // Return all the pixels that are enabled for this state.
    std::set<std::pair<unsigned int, unsigned int> > pixelsWithHits(unsigned int state) const;
    //                  column #      row #
 
    // Whether this ROC is currently being scanned.  (Always true when not in SingleROC mode.)
    bool scanningROCForState(PixelROCName roc, unsigned int state) const;
 
    unsigned int scanCounter(std::string dac, unsigned int state) const { return scanCounter(iScan(dac), state); }
 
    unsigned int scanValue(std::string dac, unsigned int state, PixelROCName roc) const {
      return scanValue(iScan(dac), state, roc);
    }
 
    // This function should not be used -- provided for backwards compatibility only.  It asserts if the scan values for this dac are mixed across different ROCs.
    unsigned int scanValue(std::string dac, unsigned int state) const {
      assert(!(dacs_[iScan(dac)].mixValuesAcrossROCs()));
      return scanValue(iScan(dac), state, 0, 1);
    }
 
    unsigned int numberOfScanVariables() const { return dacs_.size(); }
 
    bool containsScan(std::string name) const;
 
    std::string scanName(unsigned int iscan) const { return dacs_[iscan].name(); }
    std::vector<unsigned int> scanValues(std::string dac) const { return scanValues(iScan(dac)); }
 
    double scanValueMin(std::string dac) const { return scanValueMin(iScan(dac)); }
    double scanValueMax(std::string dac) const { return scanValueMax(iScan(dac)); }
    double scanValueStep(std::string dac) const { return scanValueStep(iScan(dac)); }
    bool scanValuesMixedAcrossROCs(std::string dac) const { return scanValuesMixedAcrossROCs(iScan(dac)); }
 
    unsigned int iScan(std::string dac) const;
 
    const std::vector<std::vector<unsigned int> >& columnList() const { return cols_; }
    const std::vector<std::vector<unsigned int> >& rowList() const { return rows_; }
    const std::vector<PixelROCName>& rocList() const {
      assert(rocAndModuleListsBuilt_);
      return rocs_;
    }
    const std::set<PixelModuleName>& moduleList() const {
      assert(rocAndModuleListsBuilt_);
      return modules_;
    }
    const std::set<PixelChannel>& channelList() const {
      assert(objectsDependingOnTheNameTranslationBuilt_);
      return channels_;
    }
 
    std::string mode() const override { return mode_; }
 
    bool singleROC() const { return singleROC_; }
 
    unsigned int nParameters() const { return parameters_.size(); }
 
    // Added by Dario Apr 24th, 2008
    std::map<std::string, std::string> parametersList() const { return parameters_; }
    // get the value of parameter parameterName, or "" if parameterName is not in the list
    std::string parameterValue(std::string parameterName) const;
 
    // Added by Dario May 8th, 2008
    std::string getStreamedContent(void) const { return calibFileContent_; };
 
    friend std::ostream& pos::operator<<(std::ostream& s, const PixelCalibConfiguration& calib);
 
    void writeASCII(std::string dir = "") const override;
    void writeXML(pos::PixelConfigKey key, int version, std::string path) const override { ; }
    void writeXMLHeader(pos::PixelConfigKey key,
                        int version,
                        std::string path,
                        std::ofstream* out,
                        std::ofstream* out1 = nullptr,
                        std::ofstream* out2 = nullptr) const override;
    void writeXML(std::ofstream* out, std::ofstream* out1 = nullptr, std::ofstream* out2 = nullptr) const override;
    void writeXMLTrailer(std::ofstream* out,
                         std::ofstream* out1 = nullptr,
                         std::ofstream* out2 = nullptr) const override;
 
  private:
    // Which set of rows we're on.
    unsigned int rowCounter(unsigned int state) const;
 
    // Which set of columns we're on.
    unsigned int colCounter(unsigned int state) const;
 
    // In SingleROC mode, which ROC we're on.  In normal mode, this equals 1.
    unsigned int scanROC(unsigned int state) const;
 
    unsigned int nScanPoints(unsigned int iscan) const { return dacs_[iscan].getNPoints(); }
 
    unsigned int scanCounter(unsigned int iscan, unsigned int state) const;
 
    unsigned int scanValue(unsigned int iscan,
                           unsigned int state,
                           unsigned int ROCNumber,
                           unsigned int ROCsOnChannel) const;
    unsigned int scanValue(unsigned int iscan, unsigned int state, PixelROCName roc) const;
 
    std::vector<unsigned int> scanValues(unsigned int iscan) const { return dacs_[iscan].values(); }
 
    double scanValueMin(unsigned int iscan) const { return dacs_[iscan].first(); }
    double scanValueMax(unsigned int iscan) const {
      return dacs_[iscan].first() + dacs_[iscan].step() * (nScanPoints(iscan) - 1);
    }
    double scanValueStep(unsigned int iscan) const { return dacs_[iscan].step(); }
    bool scanValuesMixedAcrossROCs(unsigned int iscan) const { return dacs_[iscan].mixValuesAcrossROCs(); }
 
    // Used in constructor or in buildROCAndModuleLists()
    void buildROCAndModuleListsFromROCSet(const std::set<PixelROCName>& rocSet);
 
    void buildObjectsDependingOnTheNameTranslation(const PixelNameTranslation* aNameTranslation);
 
    unsigned int ROCNumberOnChannelAmongThoseCalibrated(PixelROCName roc) const;
    unsigned int numROCsCalibratedOnChannel(PixelROCName roc) const;
 
    bool singleROC_;
 
    std::vector<std::vector<unsigned int> > rows_;
    std::vector<std::vector<unsigned int> > cols_;
 
    mutable std::vector<PixelROCName> rocs_;
    mutable std::vector<PixelROCInfo> rocInfo_;
    std::set<PixelModuleName> modules_;
    bool rocAndModuleListsBuilt_;
    std::vector<std::string> rocListInstructions_;
 
    // Objects built using the name translation.
    std::set<PixelChannel> channels_;
    std::map<PixelROCName, unsigned int> ROCNumberOnChannelAmongThoseCalibrated_;
    std::map<PixelROCName, unsigned int> numROCsCalibratedOnChannel_;
    bool objectsDependingOnTheNameTranslationBuilt_;
 
    mutable std::vector<std::pair<unsigned int, std::vector<unsigned int> > > fedCardsAndChannels_;
 
    //unsigned int vcal_;
 
    std::vector<PixelDACScanRange> dacs_;
 
    //std::vector<std::string> dacname_;
    //std::vector<unsigned int> dacchannel_;
    //std::vector<unsigned int> dac_first_;
    //std::vector<unsigned int> dac_last_;
    //std::vector<unsigned int> dac_step_;
 
    unsigned int ntrigger_;
    unsigned int nROC_;  //This is the maximal #ROCs on a given TBM
 
    bool highVCalRange_;
 
    void enablePixels(PixelFECConfigInterface* pixelFEC,
                      unsigned int irows,
                      unsigned int icols,
                      pos::PixelROCMaskBits* masks,
                      pos::PixelROCTrimBits* trims,
                      const PixelHdwAddress& theROC) const;
 
    void disablePixels(PixelFECConfigInterface* pixelFEC,
                       unsigned int irows,
                       unsigned int icols,
                       pos::PixelROCTrimBits* trims,
                       const PixelHdwAddress& theROC) const;
 
    void disablePixels(PixelFECConfigInterface* pixelFEC,
                       pos::PixelROCTrimBits* trims,
                       const PixelHdwAddress& theROC) const;
 
    mutable std::vector<int> old_irows;
    mutable std::vector<int> old_icols;
 
    std::map<std::string, std::string> parameters_;
    //       name         value
 
    bool _bufferData;
 
    bool usesROCList_;
 
    // Added by Dario May 8th, 2008
    std::string calibFileContent_;
  };
}  // namespace pos
/* @} */
#endif