pos::PixelCalibConfiguration Class Reference

This class implements the steps that are used in a scan over Threshold and CalDelay. More...

#include "interface/PixelCalibConfiguration.h"

Inheritance diagram for pos::PixelCalibConfiguration:

Public Member Functions
void	buildROCAndModuleLists (const PixelNameTranslation *translation, const PixelDetectorConfig *detconfig)
const std::set< PixelChannel > &	channelList () const
const std::vector< std::vector< unsigned int > > &	columnList () const
bool	containsScan (std::string name) const
std::vector< std::pair< unsigned int, std::vector< unsigned int > > > &	fedCardsAndChannels (unsigned int crate, PixelNameTranslation *translation, PixelFEDConfig *fedconfig, PixelDetectorConfig *detconfig) const
std::set< unsigned int >	getFECCrates (const PixelNameTranslation *translation, const PixelFECConfig *fecconfig) const
std::set< unsigned int >	getFEDCrates (const PixelNameTranslation *translation, const PixelFEDConfig *fedconfig) const
std::map< unsigned int, std::set< unsigned int > >	getFEDsAndChannels (PixelNameTranslation *translation)
std::string	getStreamedContent (void) const
std::set< unsigned int >	getTKFECCrates (const PixelPortcardMap *portcardmap, const std::map< std::string, PixelPortCardConfig *> &mapNamePortCard, const PixelTKFECConfig *tkfecconfig) const
unsigned int	iScan (std::string dac) const
unsigned int	maxNumHitsPerROC () const
std::string	mode () const override
const std::set< PixelModuleName > &	moduleList () const
unsigned int	nConfigurations () const
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
bool	noHits () const
unsigned int	nParameters () const
unsigned int	nPixelPatterns () const
unsigned int	nROC () const
unsigned int	nScanPoints (std::string dac) const
unsigned int	nScanPoints () const
unsigned int	nTriggersPerPattern () const
unsigned int	nTriggersTotal () const
unsigned int	numberOfScanVariables () const
std::map< std::string, std::string >	parametersList () const
std::string	parameterValue (std::string parameterName) const
	PixelCalibConfiguration (std::string filename="")
	PixelCalibConfiguration (std::vector< std::vector< std::string > > &)
std::set< std::pair< unsigned int, unsigned int > >	pixelsWithHits (unsigned int state) const
const std::vector< PixelROCName > &	rocList () const
const std::vector< std::vector< unsigned int > > &	rowList () const
unsigned int	scanCounter (std::string dac, unsigned int state) const
std::string	scanName (unsigned int iscan) const
bool	scanningROCForState (PixelROCName roc, unsigned int state) const
unsigned int	scanValue (std::string dac, unsigned int state, PixelROCName roc) const
unsigned int	scanValue (std::string dac, unsigned int state) const
double	scanValueMax (std::string dac) const
double	scanValueMin (std::string dac) const
std::vector< unsigned int >	scanValues (std::string dac) const
bool	scanValuesMixedAcrossROCs (std::string dac) const
double	scanValueStep (std::string dac) const
bool	singleROC () const
void	writeASCII (std::string dir="") const override
void	writeXML (pos::PixelConfigKey key, int version, std::string path) const override
void	writeXML (std::ofstream *out, std::ofstream *out1=nullptr, std::ofstream *out2=nullptr) 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	writeXMLTrailer (std::ofstream *out, std::ofstream *out1=nullptr, std::ofstream *out2=nullptr) const override
	~PixelCalibConfiguration () override
Public Member Functions inherited from pos::PixelCalibBase
	PixelCalibBase ()
virtual	~PixelCalibBase ()
Public Member Functions inherited from pos::PixelConfigBase
std::string	creator ()
std::string	date ()
std::string	description ()
std::string	getAuthor () const
std::string	getComment () const
	PixelConfigBase (std::string description, std::string creator, std::string date)
void	setAuthor (std::string author)
void	setComment (std::string comment)
virtual void	writeXML (std::ofstream *out) const
virtual void	writeXMLHeader (pos::PixelConfigKey key, int version, std::string path, std::ofstream *out) const
virtual void	writeXMLTrailer (std::ofstream *out) const
virtual	~PixelConfigBase ()

Private Member Functions
void	buildObjectsDependingOnTheNameTranslation (const PixelNameTranslation *aNameTranslation)
void	buildROCAndModuleListsFromROCSet (const std::set< PixelROCName > &rocSet)
unsigned int	colCounter (unsigned int state) 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
void	enablePixels (PixelFECConfigInterface *pixelFEC, unsigned int irows, unsigned int icols, pos::PixelROCMaskBits *masks, pos::PixelROCTrimBits *trims, const PixelHdwAddress &theROC) const
unsigned int	nScanPoints (unsigned int iscan) const
unsigned int	numROCsCalibratedOnChannel (PixelROCName roc) const
unsigned int	ROCNumberOnChannelAmongThoseCalibrated (PixelROCName roc) const
unsigned int	rowCounter (unsigned int state) const
unsigned int	scanCounter (unsigned int iscan, unsigned int state) const
unsigned int	scanROC (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
double	scanValueMax (unsigned int iscan) const
double	scanValueMin (unsigned int iscan) const
std::vector< unsigned int >	scanValues (unsigned int iscan) const
bool	scanValuesMixedAcrossROCs (unsigned int iscan) const
double	scanValueStep (unsigned int iscan) const

Private Attributes
bool	_bufferData
std::string	calibFileContent_
std::set< PixelChannel >	channels_
std::vector< std::vector< unsigned int > >	cols_
std::vector< PixelDACScanRange >	dacs_
std::vector< std::pair< unsigned int, std::vector< unsigned int > > >	fedCardsAndChannels_
bool	highVCalRange_
std::set< PixelModuleName >	modules_
unsigned int	nROC_
unsigned int	ntrigger_
std::map< PixelROCName, unsigned int >	numROCsCalibratedOnChannel_
bool	objectsDependingOnTheNameTranslationBuilt_
std::vector< int >	old_icols
std::vector< int >	old_irows
std::map< std::string, std::string >	parameters_
bool	rocAndModuleListsBuilt_
std::vector< PixelROCInfo >	rocInfo_
std::vector< std::string >	rocListInstructions_
std::map< PixelROCName, unsigned int >	ROCNumberOnChannelAmongThoseCalibrated_
std::vector< PixelROCName >	rocs_
std::vector< std::vector< unsigned int > >	rows_
bool	singleROC_
bool	usesROCList_

Friends
std::ostream &	pos::operator<< (std::ostream &s, const PixelCalibConfiguration &calib)

Additional Inherited Members
Protected Attributes inherited from pos::PixelCalibBase
std::string	mode_

Detailed Description

This class implements the steps that are used in a scan over Threshold and CalDelay.

" " " " It features a double inheritance, both from ConfigurationObjects and CalibrationObjects

A longer explanation will be placed here later

Definition at line 65 of file PixelCalibConfiguration.h.

Constructor & Destructor Documentation

PixelCalibConfiguration() [1/2]

PixelCalibConfiguration::PixelCalibConfiguration

(

std::string

filename = ""

)

Definition at line 285 of file PixelCalibConfiguration.cc.

References _bufferData, funct::abs(), cms::cuda::assert(), buildROCAndModuleListsFromROCSet(), calibFileContent_, cols_, gather_cfg::cout, dacs_, corrVsCorr::filename, dqmdumpme::first, highVCalRange_, recoMuon::in, pos::k_DACName_Vcal, dqmdumpme::last, reco_application_tbsim_DetSim-Digi_cfg::mix, pos::PixelCalibBase::mode_, mergeVDriftHistosByStation::name, ntrigger_, objectsDependingOnTheNameTranslationBuilt_, parameters_, rocAndModuleListsBuilt_, rocListInstructions_, mysort::rows, rows_, pos::PixelDACScanRange::setNegative(), pos::PixelDACScanRange::setRelative(), singleROC_, AlCaHLTBitMon_QueryRunRegistry::string, createJobs::tmp, usesROCList_, heppy_batch::val, and contentValuesCheck::values.

                                                                   : PixelCalibBase(), PixelConfigBase("", "", "") {
  std::string mthn = "[PixelCalibConfiguration::PixelCalibConfiguration()]\t    ";

  _bufferData = true;

  std::ifstream in(filename.c_str());

  if (!in.good()) {
    std::cout << __LINE__ << "]\t" << mthn << "Could not open:" << filename << std::endl;
    assert(0);
  } else {
    std::cout << __LINE__ << "]\t" << mthn << "Opened:" << filename << std::endl;
  }

  std::string tmp;

  in >> tmp;

  if (tmp == "Mode:") {
    in >> mode_;
    std::cout << __LINE__ << "]\t" << mthn << "PixelCalibConfiguration mode=" << mode_ << std::endl;
    in >> tmp;
  } else {
    mode_ = "FEDChannelOffsetPixel";
    std::cout << __LINE__ << "]\t" << mthn << "PixelCalibConfiguration mode not set, is this an old file? " << __LINE__
              << "]\t" << std::endl;
    assert(0);
  }

  singleROC_ = false;

  if (tmp == "SingleROC") {
    singleROC_ = true;
    in >> tmp;
  }

  // Read in parameters, if any.
  if (tmp == "Parameters:") {
    in >> tmp;
    while (tmp != "Rows:") {
      assert(!in.eof());
      std::string paramName = tmp;
      in >> tmp;  // tmp contains the parameter value
      parameters_[paramName] = tmp;
      in >> tmp;  // tmp contains the next parameter's name, or "Rows:"
    }
  }

  assert(tmp == "Rows:");

  in >> tmp;

  std::vector<unsigned int> rows;
  while (tmp != "Cols:") {
    if (tmp == "|") {
      rows_.push_back(rows);
      rows.clear();
    } else {
      if (tmp != "*") {
        rows.push_back(atoi(tmp.c_str()));
      }
    }
    in >> tmp;
  }
  rows_.push_back(rows);
  rows.clear();

  in >> tmp;

  std::vector<unsigned int> cols;
  while ((tmp != "VcalLow:") && (tmp != "VcalHigh:") && (tmp != "Vcal:") && (tmp != "VcalHigh") && (tmp != "VcalLow")) {
    if (tmp == "|") {
      cols_.push_back(cols);
      cols.clear();
    } else {
      if (tmp != "*") {
        cols.push_back(atoi(tmp.c_str()));
      }
    }
    in >> tmp;
  }
  cols_.push_back(cols);
  cols.clear();

  highVCalRange_ = true;

  if (tmp == "VcalLow") {
    highVCalRange_ = false;
    in >> tmp;
  }

  if (tmp == "VcalHigh") {
    highVCalRange_ = true;
    in >> tmp;
  }

  if (tmp == "VcalLow:") {
    highVCalRange_ = false;
  }

  if ((tmp == "VcalLow:") || (tmp == "VcalHigh:") || (tmp == "Vcal:")) {
    unsigned int first, last, step;
    in >> first >> last >> step;
    unsigned int index = 1;
    if (!dacs_.empty()) {
      index = dacs_.back().index() * dacs_.back().getNPoints();
    }
    in >> tmp;
    bool mix = false;
    if (tmp == "mix") {
      mix = true;
      in >> tmp;
    }
    PixelDACScanRange dacrange(pos::k_DACName_Vcal, first, last, step, index, mix);
    dacs_.push_back(dacrange);
  } else {
    //in >> tmp;
    while (tmp == "Scan:" || tmp == "ScanValues:") {
      if (tmp == "ScanValues:") {
        std::string dacname;
        in >> dacname;
        vector<unsigned int> values;
        int val;
        in >> val;
        while (val != -1) {
          values.push_back(val);
          in >> val;
        }
        unsigned int index = 1;
        if (!dacs_.empty()) {
          index = dacs_.back().index() * dacs_.back().getNPoints();
        }
        PixelDACScanRange dacrange(dacname, values, index, false);
        dacs_.push_back(dacrange);
        in >> tmp;
      } else {
        std::string dacname;
        in >> dacname;
        unsigned int first, last, step;
        in >> first >> last >> step;
        unsigned int index = 1;
        if (!dacs_.empty()) {
          index = dacs_.back().index() * dacs_.back().getNPoints();
        }
        in >> tmp;
        bool mix = false;
        if (tmp == "mix") {
          mix = true;
          in >> tmp;
        }
        PixelDACScanRange dacrange(dacname, first, last, step, index, mix);
        dacs_.push_back(dacrange);
      }
    }

    while ((tmp == "Set:") || (tmp == "SetRelative:")) {
      string name;
      in >> name;
      int val;
      in >> val;
      unsigned int absval = std::abs(val);
      unsigned int index = 1;
      if (!dacs_.empty())
        index = dacs_.back().index() * dacs_.back().getNPoints();
      PixelDACScanRange dacrange(name, absval, absval, 1, index, false);
      if (tmp == "SetRelative:") {
        dacrange.setRelative();
        if (val < 0) {
          dacrange.setNegative();
        }
      }
      dacs_.push_back(dacrange);
      in >> tmp;
    }
  }

  assert(tmp == "Repeat:");

  in >> ntrigger_;

  in >> tmp;

  usesROCList_ = false;
  bool buildROCListNow = false;
  if (tmp == "Rocs:") {
    buildROCListNow = true;
    usesROCList_ = true;
  } else {
    assert(tmp == "ToCalibrate:");
    buildROCListNow = false;
  }

  while (!in.eof()) {
    tmp = "";
    in >> tmp;

    // added by F.Blekman to be able to deal with POS245 style calib.dat files in CMSSW
    // these files use the syntax:
    // Rocs:
    // all

    if (tmp == "all" || tmp == "+" || tmp == "-") {
      buildROCListNow = false;
    }
    // end of addition by F.B.

    if (tmp.empty())
      continue;
    rocListInstructions_.push_back(tmp);
  }

  in.close();

  rocAndModuleListsBuilt_ = false;
  if (buildROCListNow) {
    std::set<PixelROCName> rocSet;
    for (std::vector<std::string>::iterator rocListInstructions_itr = rocListInstructions_.begin();
         rocListInstructions_itr != rocListInstructions_.end();
         ++rocListInstructions_itr) {
      PixelROCName rocname(*rocListInstructions_itr);
      rocSet.insert(rocname);
    }
    buildROCAndModuleListsFromROCSet(rocSet);
  }

  objectsDependingOnTheNameTranslationBuilt_ = false;

  // Added by Dario as a temporary patch for Debbie (this will disappear in the future)
  std::ifstream inTmp(filename.c_str());
  calibFileContent_ = "";
  while (!inTmp.eof()) {
    std::string tmpString;
    getline(inTmp, tmpString);
    calibFileContent_ += tmpString + "\n";
    //cout << __LINE__ << "]\t" << "[PixelCalibConfiguration::~PixelCalibConfiguration()]\t\t" << calibFileContent_ << endl ;
  }
  inTmp.close();
  // End of temporary patch

  return;
}

PixelCalibConfiguration() [2/2]

PixelCalibConfiguration::PixelCalibConfiguration

(

std::vector< std::vector< std::string > > &

tableMat

)

EXTENSION_TABLE_NAME: PIXEL_CALIB_CLOB (VIEW: CONF_KEY_PIXEL_CALIB_V)

CONFIG_KEY NOT NULL VARCHAR2(80) KEY_TYPE NOT NULL VARCHAR2(80) KEY_ALIAS NOT NULL VARCHAR2(80) VERSION VARCHAR2(40) KIND_OF_COND NOT NULL VARCHAR2(40) CALIB_TYPE VARCHAR2(200) CALIB_OBJ_DATA_FILE NOT NULL VARCHAR2(200) CALIB_OBJ_DATA_CLOB NOT NULL CLOB

Definition at line 24 of file PixelCalibConfiguration.cc.

References _bufferData, cms::cuda::assert(), buildROCAndModuleListsFromROCSet(), DummyCfis::c, calibFileContent_, DMR_cfg::cerr, cols_, gather_cfg::cout, dacs_, dqmdumpme::first, highVCalRange_, recoMuon::in, pos::k_DACName_Vcal, dqmdumpme::last, reco_application_tbsim_DetSim-Digi_cfg::mix, pos::PixelCalibBase::mode_, create_idmaps::n, mergeVDriftHistosByStation::name, ntrigger_, objectsDependingOnTheNameTranslationBuilt_, parameters_, rocAndModuleListsBuilt_, rocListInstructions_, mysort::rows, rows_, pos::PixelDACScanRange::setRelative(), singleROC_, AlCaHLTBitMon_QueryRunRegistry::string, createJobs::tmp, usesROCList_, heppy_batch::val, and contentValuesCheck::values.

    : PixelCalibBase(), PixelConfigBase("", "", "") {
  std::string mthn = "[PixelCalibConfiguration::PixelCalibConfiguration()]\t    ";
  std::map<std::string, int> colM;
  std::vector<std::string> colNames;
  colNames.push_back("CONFIG_KEY");
  colNames.push_back("KEY_TYPE");
  colNames.push_back("KEY_ALIAS");
  colNames.push_back("VERSION");
  colNames.push_back("KIND_OF_COND");
  colNames.push_back("CALIB_TYPE");
  colNames.push_back("CALIB_OBJ_DATA_FILE");
  colNames.push_back("CALIB_OBJ_DATA_CLOB");

  for (unsigned int c = 0; c < tableMat[0].size(); c++) {
    for (unsigned int n = 0; n < colNames.size(); n++) {
      if (tableMat[0][c] == colNames[n]) {
        colM[colNames[n]] = c;
        break;
      }
    }
  }  //end for
  for (unsigned int n = 0; n < colNames.size(); n++) {
    if (colM.find(colNames[n]) == colM.end()) {
      std::cerr << mthn << "Couldn't find in the database the column with name " << colNames[n] << std::endl;
      assert(0);
    }
  }

  _bufferData = true;

  std::istringstream in;
  in.str(tableMat[1][colM["CALIB_OBJ_DATA_CLOB"]]);

  std::string tmp;

  in >> tmp;

  if (tmp == "Mode:") {
    in >> mode_;
    //    std::cout << __LINE__ << "]\t" << mthn << "mode=" << mode_ << std::endl;
    in >> tmp;
  } else {
    mode_ = "FEDChannelOffsetPixel";
    std::cout << __LINE__ << "]\t" << mthn << "mode not set, is this an old file? " << std::endl;
    assert(0);
  }

  singleROC_ = false;

  if (tmp == "SingleROC") {
    singleROC_ = true;
    in >> tmp;
  }

  // Read in parameters, if any.
  if (tmp == "Parameters:") {
    in >> tmp;
    while (tmp != "Rows:") {
      assert(!in.eof());
      std::string paramName = tmp;
      in >> tmp;  // tmp contains the parameter value
      parameters_[paramName] = tmp;
      in >> tmp;  // tmp contains the next parameter's name, or "Rows:"
    }
  }

  assert(tmp == "Rows:");

  in >> tmp;

  std::vector<unsigned int> rows;
  while (tmp != "Cols:") {
    if (tmp == "|") {
      rows_.push_back(rows);
      rows.clear();
    } else {
      if (tmp != "*") {
        rows.push_back(atoi(tmp.c_str()));
      }
    }
    in >> tmp;
  }
  rows_.push_back(rows);
  rows.clear();

  in >> tmp;

  std::vector<unsigned int> cols;
  while ((tmp != "VcalLow:") && (tmp != "VcalHigh:") && (tmp != "Vcal:") && (tmp != "VcalHigh") && (tmp != "VcalLow")) {
    if (tmp == "|") {
      cols_.push_back(cols);
      cols.clear();
    } else {
      if (tmp != "*") {
        cols.push_back(atoi(tmp.c_str()));
      }
    }
    in >> tmp;
  }
  cols_.push_back(cols);
  cols.clear();

  highVCalRange_ = true;

  if (tmp == "VcalLow") {
    highVCalRange_ = false;
    in >> tmp;
  }

  if (tmp == "VcalHigh") {
    highVCalRange_ = true;
    in >> tmp;
  }

  if (tmp == "VcalLow:") {
    highVCalRange_ = false;
  }

  if ((tmp == "VcalLow:") || (tmp == "VcalHigh:") || (tmp == "Vcal:")) {
    unsigned int first, last, step;
    in >> first >> last >> step;
    unsigned int index = 1;
    if (!dacs_.empty()) {
      index = dacs_.back().index() * dacs_.back().getNPoints();
    }
    in >> tmp;
    bool mix = false;
    if (tmp == "mix") {
      mix = true;
      in >> tmp;
    }
    PixelDACScanRange dacrange(pos::k_DACName_Vcal, first, last, step, index, mix);
    dacs_.push_back(dacrange);
  } else {
    //in >> tmp;
    while (tmp == "Scan:" || tmp == "ScanValues:") {
      if (tmp == "ScanValues:") {
        std::string dacname;
        in >> dacname;
        vector<unsigned int> values;
        int val;
        in >> val;
        while (val != -1) {
          values.push_back(val);
          in >> val;
        }
        unsigned int index = 1;
        if (!dacs_.empty()) {
          index = dacs_.back().index() * dacs_.back().getNPoints();
        }
        PixelDACScanRange dacrange(dacname, values, index, false);
        dacs_.push_back(dacrange);
        in >> tmp;
      } else {
        std::string dacname;
        in >> dacname;
        unsigned int first, last, step;
        in >> first >> last >> step;
        unsigned int index = 1;
        if (!dacs_.empty()) {
          index = dacs_.back().index() * dacs_.back().getNPoints();
        }
        in >> tmp;
        bool mix = false;
        if (tmp == "mix") {
          mix = true;
          in >> tmp;
        }
        PixelDACScanRange dacrange(dacname, first, last, step, index, mix);
        dacs_.push_back(dacrange);
      }
    }

    while ((tmp == "Set:") || (tmp == "SetRelative:")) {
      string name;
      in >> name;
      int val;
      in >> val;
      unsigned int index = 1;
      if (!dacs_.empty())
        index = dacs_.back().index() * dacs_.back().getNPoints();
      PixelDACScanRange dacrange(name, val, val, 1, index, false);
      if (tmp == "SetRelative:") {
        dacrange.setRelative();
      }
      dacs_.push_back(dacrange);
      in >> tmp;
    }
  }

  assert(tmp == "Repeat:");

  in >> ntrigger_;

  in >> tmp;

  usesROCList_ = false;
  bool buildROCListNow = false;
  if (tmp == "Rocs:") {
    buildROCListNow = true;
    usesROCList_ = true;
  } else {
    assert(tmp == "ToCalibrate:");
    buildROCListNow = false;
  }

  while (!in.eof()) {
    tmp = "";
    in >> tmp;

    // added by F.Blekman to be able to deal with POS245 style calib.dat files in CMSSW
    // these files use the syntax:
    // Rocs:
    // all

    if (tmp == "all" || tmp == "+" || tmp == "-") {
      buildROCListNow = false;
    }
    // end of addition by F.B.

    if (tmp.empty())
      continue;
    rocListInstructions_.push_back(tmp);
  }

  rocAndModuleListsBuilt_ = false;
  if (buildROCListNow) {
    std::set<PixelROCName> rocSet;
    for (std::vector<std::string>::iterator rocListInstructions_itr = rocListInstructions_.begin();
         rocListInstructions_itr != rocListInstructions_.end();
         ++rocListInstructions_itr) {
      PixelROCName rocname(*rocListInstructions_itr);
      rocSet.insert(rocname);
    }
    buildROCAndModuleListsFromROCSet(rocSet);
  }

  objectsDependingOnTheNameTranslationBuilt_ = false;

  // Added by Dario as a temporary patch for Debbie (this will disappear in the future)
  calibFileContent_ = in.str();
  // End of temporary patch

  return;
}

~PixelCalibConfiguration()

PixelCalibConfiguration::~PixelCalibConfiguration ( )

override

Definition at line 527 of file PixelCalibConfiguration.cc.

{}

Member Function Documentation

buildObjectsDependingOnTheNameTranslation()

void PixelCalibConfiguration::buildObjectsDependingOnTheNameTranslation ( const PixelNameTranslation *  aNameTranslation )

private

Definition at line 713 of file PixelCalibConfiguration.cc.

References cms::cuda::assert(), channels_, pos::PixelNameTranslation::getChannelForROC(), pos::PixelNameTranslation::getROCsFromChannel(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, numROCsCalibratedOnChannel_, objectsDependingOnTheNameTranslationBuilt_, rocAndModuleListsBuilt_, ROCNumberOnChannelAmongThoseCalibrated_, and rocs_.

Referenced by buildROCAndModuleLists().

                                                                                                                    {
  assert(!objectsDependingOnTheNameTranslationBuilt_);
  assert(rocAndModuleListsBuilt_);
  assert(aNameTranslation != nullptr);

  // Build the channel list.
  assert(channels_.empty());
  for (std::vector<PixelROCName>::const_iterator rocs_itr = rocs_.begin(); rocs_itr != rocs_.end(); ++rocs_itr) {
    channels_.insert(aNameTranslation->getChannelForROC(*rocs_itr));
  }

  // Build the maps from ROC to ROC number.

  assert(ROCNumberOnChannelAmongThoseCalibrated_.empty() && numROCsCalibratedOnChannel_.empty());

  std::set<PixelROCName> tempROCs;

  for (std::vector<PixelROCName>::const_iterator it = rocs_.begin(); it != rocs_.end(); ++it) {
    tempROCs.insert(*it);
  }

  for (std::set<PixelChannel>::const_iterator channels_itr = channels_.begin(); channels_itr != channels_.end();
       ++channels_itr) {
    std::vector<PixelROCName> rocsOnChannel = aNameTranslation->getROCsFromChannel(*channels_itr);

    std::set<PixelROCName> foundROCs;

    for (std::vector<PixelROCName>::const_iterator rocsOnChannel_itr = rocsOnChannel.begin();
         rocsOnChannel_itr != rocsOnChannel.end();
         ++rocsOnChannel_itr) {
      if (tempROCs.find(*rocsOnChannel_itr) != tempROCs.end()) {
        ROCNumberOnChannelAmongThoseCalibrated_[*rocsOnChannel_itr] = foundROCs.size();
        foundROCs.insert(*rocsOnChannel_itr);
      }
    }

    for (std::set<PixelROCName>::const_iterator foundROCs_itr = foundROCs.begin(); foundROCs_itr != foundROCs.end();
         ++foundROCs_itr) {
      numROCsCalibratedOnChannel_[*foundROCs_itr] = foundROCs.size();
    }
  }

  objectsDependingOnTheNameTranslationBuilt_ = true;
}

buildROCAndModuleLists()

void PixelCalibConfiguration::buildROCAndModuleLists	(	const PixelNameTranslation *	translation,
		const PixelDetectorConfig *	detconfig
	)

Definition at line 529 of file PixelCalibConfiguration.cc.

References cms::cuda::assert(), buildObjectsDependingOnTheNameTranslation(), buildROCAndModuleListsFromROCSet(), pos::PixelDetectorConfig::containsModule(), pos::PixelDetectorConfig::getModuleList(), pos::PixelNameTranslation::getROCs(), pos::PixelNameTranslation::getROCsFromModule(), pos::PixelDetectorConfig::getROCsList(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, moduleList(), pos::PixelModuleName::modulename(), pos::PixelROCStatus::noAnalogSignal, rocAndModuleListsBuilt_, rocListInstructions_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                           {
  assert(translation != nullptr);
  assert(detconfig != nullptr);

  if (rocAndModuleListsBuilt_) {
    buildObjectsDependingOnTheNameTranslation(translation);
    return;
  }

  // Build the ROC set from the instructions.
  std::set<PixelROCName> rocSet;
  bool addNext = true;
  const map<PixelROCName, PixelROCStatus>& iroclist = detconfig->getROCsList();
  for (std::vector<std::string>::iterator rocListInstructions_itr = rocListInstructions_.begin();
       rocListInstructions_itr != rocListInstructions_.end();
       ++rocListInstructions_itr) {
    std::string instruction = *rocListInstructions_itr;

    if (instruction == "+") {
      addNext = true;
      continue;
    }
    if (instruction == "-") {
      addNext = false;
      continue;
    }

    if (instruction == "all") {
      if (addNext)  // add all ROCs in the configuration
      {
        const std::vector<PixelModuleName>& moduleList = detconfig->getModuleList();
        for (std::vector<PixelModuleName>::const_iterator moduleList_itr = moduleList.begin();
             moduleList_itr != moduleList.end();
             ++moduleList_itr) {
          std::vector<PixelROCName> ROCsOnThisModule = translation->getROCsFromModule(*moduleList_itr);
          for (std::vector<PixelROCName>::const_iterator ROCsOnThisModule_itr = ROCsOnThisModule.begin();
               ROCsOnThisModule_itr != ROCsOnThisModule.end();
               ++ROCsOnThisModule_itr) {
            map<PixelROCName, PixelROCStatus>::const_iterator it = iroclist.find(*ROCsOnThisModule_itr);
            assert(it != iroclist.end());
            PixelROCStatus istatus = it->second;
            if (!istatus.get(PixelROCStatus::noAnalogSignal))
              rocSet.insert(*ROCsOnThisModule_itr);
          }
        }
      } else  // remove all ROCs
      {
        rocSet.clear();
      }
      addNext = true;
      continue;
    }

    // Assume it's a ROC or module name.
    PixelModuleName modulename(instruction);

    // Skip if this module (or the module this ROC is on) isn't in the detector config.
    if (!(detconfig->containsModule(modulename))) {
      addNext = true;
      continue;
    }

    if (modulename.modulename() == instruction)  // it's a module
    {
      std::vector<PixelROCName> ROCsOnThisModule = translation->getROCsFromModule(modulename);
      for (std::vector<PixelROCName>::iterator ROCsOnThisModule_itr = ROCsOnThisModule.begin();
           ROCsOnThisModule_itr != ROCsOnThisModule.end();
           ++ROCsOnThisModule_itr) {
        if (addNext) {
          map<PixelROCName, PixelROCStatus>::const_iterator it = iroclist.find(*ROCsOnThisModule_itr);
          assert(it != iroclist.end());
          PixelROCStatus istatus = it->second;
          if (!istatus.get(PixelROCStatus::noAnalogSignal))
            rocSet.insert(*ROCsOnThisModule_itr);
        } else
          rocSet.erase(*ROCsOnThisModule_itr);
      }
      addNext = true;
      continue;
    } else  // it's a ROC
    {
      PixelROCName rocname(instruction);
      if (addNext) {
        // Only add this ROC if it's in the configuration.
        bool foundIt = false;
        std::list<const PixelROCName*> allROCs = translation->getROCs();
        for (std::list<const PixelROCName*>::iterator allROCs_itr = allROCs.begin(); allROCs_itr != allROCs.end();
             ++allROCs_itr) {
          if ((*(*allROCs_itr)) == rocname) {
            foundIt = true;
            break;
          }
        }
        if (foundIt) {
          map<PixelROCName, PixelROCStatus>::const_iterator it = iroclist.find(rocname);
          assert(it != iroclist.end());
          PixelROCStatus istatus = it->second;
          if (!istatus.get(PixelROCStatus::noAnalogSignal))
            rocSet.insert(rocname);
        }
      } else {
        rocSet.erase(rocname);
      }
      addNext = true;
      continue;
    }

    // should never get here
    assert(0);
  }
  // done building ROC set

  buildROCAndModuleListsFromROCSet(rocSet);

  buildObjectsDependingOnTheNameTranslation(translation);
}

buildROCAndModuleListsFromROCSet()

void PixelCalibConfiguration::buildROCAndModuleListsFromROCSet ( const std::set< PixelROCName > &  rocSet )

private

Definition at line 647 of file PixelCalibConfiguration.cc.

References cms::cuda::assert(), gather_cfg::cout, modules_, nROC_, old_icols, old_irows, rocAndModuleListsBuilt_, rocs_, singleROC_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by buildROCAndModuleLists(), and PixelCalibConfiguration().

                                                                                                 {
  assert(!rocAndModuleListsBuilt_);

  std::string mthn = "[PixelCalibConfiguration::buildROCAndModuleListsFromROCSet()]    ";
  // Build the ROC list from the ROC set.
  for (std::set<PixelROCName>::iterator rocSet_itr = rocSet.begin(); rocSet_itr != rocSet.end(); ++rocSet_itr) {
    rocs_.push_back(*rocSet_itr);
  }

  //t.stop();
  //cout << "buildROCAndModuleListsFromROCSet 1 time="<<t.tottime()<<endl;
  //t.start();

  // Build the module set from the ROC set.
  std::map<PixelModuleName, unsigned int> countROC;
  for (std::set<PixelROCName>::iterator rocSet_itr = rocSet.begin(); rocSet_itr != rocSet.end(); ++rocSet_itr) {
    //t1.start();
    PixelModuleName modulename(*rocSet_itr);
    //t1.stop();
    //t2.start();
    modules_.insert(modulename);
    countROC[modulename]++;
    //t2.stop();
  }

  //t.stop();
  //cout << "buildROCAndModuleListsFromROCSet 2 time="<<t.tottime()<<endl;
  //cout << "buildROCAndModuleListsFromROCSet t1="<<t1.tottime()<<endl;
  //cout << "buildROCAndModuleListsFromROCSet t2="<<t2.tottime()<<endl;
  //t.start();

  // Test printout.
  /*cout << "\nROC list:\n";
    for ( std::vector<PixelROCName>::iterator rocs_itr = rocs_.begin(); 
    rocs_itr != rocs_.end(); 
    rocs_itr++ ){
    cout << rocs_itr->rocname() << "\n";
    }    cout << "\nModule list:\n";
    for ( std::set<PixelModuleName>::iterator modules_itr = modules_.begin(); modules_itr != modules_.end(); modules_itr++ )
    {
    cout << modules_itr->modulename() << "\n";
    }
    cout << "\n";*/

  // Determine max ROCs on a module for singleROC mode.
  nROC_ = 1;
  if (singleROC_) {
    unsigned maxROCs = 0;
    for (std::map<PixelModuleName, unsigned int>::iterator imodule = countROC.begin(); imodule != countROC.end();
         ++imodule) {
      if (imodule->second > maxROCs)
        maxROCs = imodule->second;
    }
    nROC_ = maxROCs;

    std::cout << __LINE__ << "]\t" << mthn << "Max ROCs on a module=" << nROC_ << std::endl;
  }

  for (unsigned int irocs = 0; irocs < rocs_.size(); irocs++) {
    old_irows.push_back(-1);
    old_icols.push_back(-1);
  }

  rocAndModuleListsBuilt_ = true;
}

channelList()

const std::set<PixelChannel>& pos::PixelCalibConfiguration::channelList ( ) const

inline

Definition at line 168 of file PixelCalibConfiguration.h.

References cms::cuda::assert(), channels_, and objectsDependingOnTheNameTranslationBuilt_.

                                                    {
      assert(objectsDependingOnTheNameTranslationBuilt_);
      return channels_;
    }

colCounter()

unsigned int PixelCalibConfiguration::colCounter ( unsigned int  state ) const

private

Definition at line 844 of file PixelCalibConfiguration.cc.

References cms::cuda::assert(), cols_, nScanPoints(), rowCounter(), rows_, and scanROC().

Referenced by nextFECState(), and pixelsWithHits().

                                                                         {
  unsigned int i_col = (state - scanROC(state) * cols_.size() * rows_.size() * nScanPoints() -
                        rowCounter(state) * cols_.size() * nScanPoints()) /
                       (nScanPoints());
  assert(i_col < cols_.size());
  return i_col;
}

columnList()

const std::vector<std::vector<unsigned int> >& pos::PixelCalibConfiguration::columnList ( ) const

inline

Definition at line 158 of file PixelCalibConfiguration.h.

References cols_.

Referenced by SiPixelCalibConfiguration::SiPixelCalibConfiguration().

{ return cols_; }

containsScan()

bool PixelCalibConfiguration::containsScan

(

std::string

name

)

const

Definition at line 1570 of file PixelCalibConfiguration.cc.

References mps_fire::i, mergeVDriftHistosByStation::name, numberOfScanVariables(), and scanName().

                                                               {
  for (unsigned int i = 0; i < numberOfScanVariables(); i++) {
    if (scanName(i) == name) {
      return true;
    }
  }
  return false;
}

disablePixels() [1/2]

void PixelCalibConfiguration::disablePixels ( PixelFECConfigInterface *  pixelFEC, unsigned int  irows, unsigned int  icols, pos::PixelROCTrimBits *  trims, const PixelHdwAddress &  theROC  ) const

private

Definition at line 1401 of file PixelCalibConfiguration.cc.

References _bufferData, ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::bits, cols_, pos::PixelHdwAddress::hubaddress(), pos::PixelHdwAddress::mfec(), pos::PixelHdwAddress::mfecchannel(), pos::PixelHdwAddress::portaddress(), pos::PixelFECConfigInterface::progpix(), pos::PixelHdwAddress::rocid(), rows_, and pos::PixelROCTrimBits::trim().

Referenced by nextFECState().

                                                                                 {
  for (unsigned int irow = 0; irow < rows_[irows].size(); irow++) {
    for (unsigned int icol = 0; icol < cols_[icols].size(); icol++) {
      /*        std::cout << "Will turn off pixel col="
              <<cols_[old_icols][icol]
              <<" row="<<rows_[old_irows][irow]<<std::endl;
          */
      unsigned int bits = trims->trim(cols_[icols][icol], rows_[irows][irow]);
      pixelFEC->progpix(theROC.mfec(),
                        theROC.mfecchannel(),
                        theROC.hubaddress(),
                        theROC.portaddress(),
                        theROC.rocid(),
                        cols_[icols][icol],
                        rows_[irows][irow],
                        bits,
                        _bufferData);
    }
  }
}

disablePixels() [2/2]

void PixelCalibConfiguration::disablePixels ( PixelFECConfigInterface *  pixelFEC, pos::PixelROCTrimBits *  trims, const PixelHdwAddress &  theROC  ) const

private

Definition at line 1426 of file PixelCalibConfiguration.cc.

References _bufferData, ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::bits, cuy::col, pos::PixelHdwAddress::hubaddress(), pos::PixelHdwAddress::mfec(), pos::PixelHdwAddress::mfecchannel(), pos::PixelHdwAddress::portaddress(), pos::PixelFECConfigInterface::progpix(), pos::PixelHdwAddress::rocid(), and pos::PixelROCTrimBits::trim().

                                                                                 {
  //cout<<" disable ROC "<<theROC.hubaddress()<<" "<<theROC.rocid()<<endl;
  //FIXME This should be done with more efficient commands!
  for (unsigned int row = 0; row < 80; row++) {
    for (unsigned int col = 0; col < 52; col++) {
      unsigned int bits = trims->trim(col, row);
      pixelFEC->progpix(theROC.mfec(),
                        theROC.mfecchannel(),
                        theROC.hubaddress(),
                        theROC.portaddress(),
                        theROC.rocid(),
                        col,
                        row,
                        bits,
                        _bufferData);
    }
  }
}

enablePixels()

void PixelCalibConfiguration::enablePixels ( PixelFECConfigInterface *  pixelFEC, unsigned int  irows, unsigned int  icols, pos::PixelROCMaskBits *  masks, pos::PixelROCTrimBits *  trims, const PixelHdwAddress &  theROC  ) const

private

Definition at line 1370 of file PixelCalibConfiguration.cc.

References _bufferData, ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::bits, cols_, pos::PixelHdwAddress::hubaddress(), pos::PixelROCMaskBits::mask(), pos::PixelHdwAddress::mfec(), pos::PixelHdwAddress::mfecchannel(), pos::PixelHdwAddress::portaddress(), pos::PixelFECConfigInterface::progpix(), pos::PixelHdwAddress::rocid(), rows_, and pos::PixelROCTrimBits::trim().

Referenced by nextFECState().

                                                                                {
  for (unsigned int irow = 0; irow < rows_[irows].size(); irow++) {
    for (unsigned int icol = 0; icol < cols_[icols].size(); icol++) {
      /*        std::cout << "Will turn on pixel col="
            <<cols_[icols][icol]
            <<" row="<<rows_[irows][irow]<<std::endl;
      */
      unsigned int bits = trims->trim(cols_[icols][icol], rows_[irows][irow]);

      //if masks==0 always enable pixel
      if (masks == nullptr || masks->mask(cols_[icols][icol], rows_[irows][irow]))
        bits |= 0x80;

      pixelFEC->progpix(theROC.mfec(),
                        theROC.mfecchannel(),
                        theROC.hubaddress(),
                        theROC.portaddress(),
                        theROC.rocid(),
                        cols_[icols][icol],
                        rows_[irows][irow],
                        bits,
                        _bufferData);
    }
  }
}

fedCardsAndChannels()

std::vector< std::pair< unsigned int, std::vector< unsigned int > > > & PixelCalibConfiguration::fedCardsAndChannels	(	unsigned int	crate,
		PixelNameTranslation *	translation,
		PixelFEDConfig *	fedconfig,
		PixelDetectorConfig *	detconfig
	)		const

Definition at line 1182 of file PixelCalibConfiguration.cc.

References cms::cuda::assert(), ewkTauDQM_cfi::channels, pos::PixelDetectorConfig::containsModule(), FCDTask_cfi::crate, pos::PixelFEDConfig::crateFromFEDNumber(), fedCardsAndChannels_, pos::PixelHdwAddress::fedchannel(), pos::PixelHdwAddress::fednumber(), dqmdumpme::first, newFWLiteAna::found, pos::PixelNameTranslation::getHdwAddress(), mps_fire::i, dqmiolumiharvest::j, isotrackApplyRegressor::k, callgraph::module, rocAndModuleListsBuilt_, rocs_, and createJobs::tmp.

                                          {
  assert(rocAndModuleListsBuilt_);

  assert(!rocs_.empty());

  for (unsigned int i = 0; i < rocs_.size(); i++) {
    PixelModuleName module(rocs_[i].rocname());
    if (!detconfig->containsModule(module))
      continue;
    const PixelHdwAddress* hdw = translation->getHdwAddress(rocs_[i]);
    assert(hdw != nullptr);
    //std::cout << "ROC, fednumber:"<<rocs_[i]<<" "<<hdw->fednumber()
    //    << std::endl;
    //first check if fed associated with the roc is in the right crate
    if (fedconfig->crateFromFEDNumber(hdw->fednumber()) != crate)
      continue;
    //next look if we have already found fed number
    unsigned int index = fedCardsAndChannels_.size();
    for (unsigned int j = 0; j < fedCardsAndChannels_.size(); j++) {
      if (fedCardsAndChannels_[j].first == hdw->fednumber()) {
        index = j;
        break;
      }
    }
    //If we didn't find the fedcard we will create it
    if (index == fedCardsAndChannels_.size()) {
      std::vector<unsigned int> tmp;
      tmp.push_back(hdw->fedchannel());
      std::pair<unsigned int, std::vector<unsigned int> > tmp2(hdw->fednumber(), tmp);
      fedCardsAndChannels_.push_back(tmp2);
      continue;
    }
    //Now look and see if the channel has been added
    std::vector<unsigned int>& channels = fedCardsAndChannels_[index].second;
    bool found = false;
    for (unsigned int k = 0; k < channels.size(); k++) {
      if (channels[k] == hdw->fedchannel()) {
        found = true;
        break;
      }
    }
    if (found)
      continue;
    channels.push_back(hdw->fedchannel());
  }

  return fedCardsAndChannels_;
}

getFECCrates()

std::set< unsigned int > PixelCalibConfiguration::getFECCrates	(	const PixelNameTranslation *	translation,
		const PixelFECConfig *	fecconfig
	)		const

Definition at line 1275 of file PixelCalibConfiguration.cc.

References cms::cuda::assert(), pos::PixelFECConfig::crateFromFECNumber(), pos::PixelHdwAddress::fecnumber(), pos::PixelNameTranslation::getChannelsOnModule(), pos::PixelNameTranslation::getHdwAddress(), modules_, and rocAndModuleListsBuilt_.

                                                                                                    {
  assert(rocAndModuleListsBuilt_);

  std::set<unsigned int> feccrates;
  assert(!modules_.empty());
  std::set<PixelModuleName>::iterator imodule = modules_.begin();

  for (; imodule != modules_.end(); ++imodule) {
    std::set<PixelChannel> channelsOnThisModule = translation->getChannelsOnModule(*imodule);
    for (std::set<PixelChannel>::const_iterator channelsOnThisModule_itr = channelsOnThisModule.begin();
         channelsOnThisModule_itr != channelsOnThisModule.end();
         ++channelsOnThisModule_itr) {
      const PixelHdwAddress& channel_hdwaddress = translation->getHdwAddress(*channelsOnThisModule_itr);
      unsigned int fecnumber = channel_hdwaddress.fecnumber();
      feccrates.insert(fecconfig->crateFromFECNumber(fecnumber));
    }
  }

  return feccrates;
}

getFEDCrates()

std::set< unsigned int > PixelCalibConfiguration::getFEDCrates	(	const PixelNameTranslation *	translation,
		const PixelFEDConfig *	fedconfig
	)		const

Definition at line 1253 of file PixelCalibConfiguration.cc.

References cms::cuda::assert(), pos::PixelFEDConfig::crateFromFEDNumber(), pos::PixelHdwAddress::fednumber(), pos::PixelNameTranslation::getChannelsOnModule(), pos::PixelNameTranslation::getHdwAddress(), modules_, and rocAndModuleListsBuilt_.

                                                                                                    {
  assert(rocAndModuleListsBuilt_);

  std::set<unsigned int> fedcrates;
  assert(!modules_.empty());
  std::set<PixelModuleName>::iterator imodule = modules_.begin();

  for (; imodule != modules_.end(); ++imodule) {
    std::set<PixelChannel> channelsOnThisModule = translation->getChannelsOnModule(*imodule);
    for (std::set<PixelChannel>::const_iterator channelsOnThisModule_itr = channelsOnThisModule.begin();
         channelsOnThisModule_itr != channelsOnThisModule.end();
         ++channelsOnThisModule_itr) {
      const PixelHdwAddress& channel_hdwaddress = translation->getHdwAddress(*channelsOnThisModule_itr);
      unsigned int fednumber = channel_hdwaddress.fednumber();
      fedcrates.insert(fedconfig->crateFromFEDNumber(fednumber));
    }
  }

  return fedcrates;
}

getFEDsAndChannels()

std::map< unsigned int, std::set< unsigned int > > PixelCalibConfiguration::getFEDsAndChannels

(

PixelNameTranslation *

translation

)

Definition at line 1235 of file PixelCalibConfiguration.cc.

References cms::cuda::assert(), pos::PixelHdwAddress::fedchannel(), pos::PixelHdwAddress::fednumber(), pos::PixelNameTranslation::getHdwAddress(), rocAndModuleListsBuilt_, and rocs_.

                                       {
  assert(rocAndModuleListsBuilt_);

  std::map<unsigned int, std::set<unsigned int> > fedsChannels;
  assert(!rocs_.empty());
  std::vector<PixelROCName>::iterator iroc = rocs_.begin();

  for (; iroc != rocs_.end(); ++iroc) {
    const PixelHdwAddress* roc_hdwaddress = translation->getHdwAddress(*iroc);
    unsigned int fednumber = roc_hdwaddress->fednumber();
    unsigned int fedchannel = roc_hdwaddress->fedchannel();
    fedsChannels[fednumber].insert(fedchannel);
  }

  return fedsChannels;
}

getStreamedContent()

std::string pos::PixelCalibConfiguration::getStreamedContent ( void  ) const

inline

Definition at line 185 of file PixelCalibConfiguration.h.

References calibFileContent_.

{ return calibFileContent_; };

getTKFECCrates()

std::set< unsigned int > PixelCalibConfiguration::getTKFECCrates	(	const PixelPortcardMap *	portcardmap,
		const std::map< std::string, PixelPortCardConfig *> &	mapNamePortCard,
		const PixelTKFECConfig *	tkfecconfig
	)		const

Definition at line 1297 of file PixelCalibConfiguration.cc.

References cms::cuda::assert(), pos::PixelTKFECConfig::crateFromTKFECID(), modules_, pos::PixelPortcardMap::portcards(), rocAndModuleListsBuilt_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                               {
  assert(rocAndModuleListsBuilt_);

  std::set<unsigned int> tkfeccrates;
  assert(!modules_.empty());
  std::set<PixelModuleName>::iterator imodule = modules_.begin();

  for (; imodule != modules_.end(); ++imodule) {
    // implement this by module --(PixelPortcardMap)-> port card(s) --(PixelPortCardConfig)-> FEC # --(PixelFECConfig theTKFECConfiguration_)-> crate
    const std::set<std::string> portCards = portcardmap->portcards(*imodule);
    for (std::set<std::string>::const_iterator portCards_itr = portCards.begin(); portCards_itr != portCards.end();
         ++portCards_itr) {
      const std::string& portcardname = *portCards_itr;
      std::map<std::string, PixelPortCardConfig*>::const_iterator portcardconfig_itr =
          mapNamePortCard.find(portcardname);
      assert(portcardconfig_itr != mapNamePortCard.end());
      PixelPortCardConfig* portcardconfig = portcardconfig_itr->second;
      std::string TKFECID = portcardconfig->getTKFECID();
      tkfeccrates.insert(tkfecconfig->crateFromTKFECID(TKFECID));
    }
  }

  return tkfeccrates;
}

iScan()

unsigned int PixelCalibConfiguration::iScan

(

std::string

dac

)

const

Definition at line 758 of file PixelCalibConfiguration.cc.

References cms::cuda::assert(), gather_cfg::cout, dacs_, mps_fire::i, and mergeVDriftHistosByStation::name.

Referenced by nScanPoints(), scanCounter(), scanValue(), scanValueMax(), scanValueMin(), scanValues(), scanValuesMixedAcrossROCs(), and scanValueStep().

                                                               {
  for (unsigned int i = 0; i < dacs_.size(); i++) {
    if (dac == dacs_[i].name())
      return i;
  }

  std::cout << __LINE__ << "]\t[PixelCalibConfiguration::iScan()]\t\t    could not find dac=" << dac << std::endl;

  assert(0);

  return 0;
}

maxNumHitsPerROC()

unsigned int PixelCalibConfiguration::maxNumHitsPerROC

(

)

const

Definition at line 1540 of file PixelCalibConfiguration.cc.

References cols_, WZElectronSkims53X_cff::max, rows_, and trackerHitRTTI::vector.

Referenced by noHits().

                                                             {
  unsigned int returnValue = 0;
  for (std::vector<std::vector<unsigned int> >::const_iterator rows_itr = rows_.begin(); rows_itr != rows_.end();
       ++rows_itr) {
    for (std::vector<std::vector<unsigned int> >::const_iterator cols_itr = cols_.begin(); cols_itr != cols_.end();
         ++cols_itr) {
      unsigned int theSize = rows_itr->size() * cols_itr->size();
      returnValue = max(returnValue, theSize);
    }
  }
  return returnValue;
}

mode()

std::string pos::PixelCalibConfiguration::mode ( ) const

inlineoverridevirtual

Reimplemented from pos::PixelCalibBase.

Definition at line 173 of file PixelCalibConfiguration.h.

References pos::PixelCalibBase::mode_.

Referenced by SiPixelCalibConfigurationObjectMaker::analyze(), nextFECState(), and SiPixelCalibConfiguration::SiPixelCalibConfiguration().

{ return mode_; }

moduleList()

const std::set<PixelModuleName>& pos::PixelCalibConfiguration::moduleList ( ) const

inline

Definition at line 164 of file PixelCalibConfiguration.h.

References cms::cuda::assert(), modules_, and rocAndModuleListsBuilt_.

Referenced by buildROCAndModuleLists().

                                                      {
      assert(rocAndModuleListsBuilt_);
      return modules_;
    }

nConfigurations()

unsigned int pos::PixelCalibConfiguration::nConfigurations ( ) const

inline

Definition at line 118 of file PixelCalibConfiguration.h.

References nPixelPatterns(), nROC(), and nScanPoints().

Referenced by nextFECState(), nTriggersTotal(), scanCounter(), and scanROC().

{ return nPixelPatterns() * nScanPoints() * nROC(); }

nextFECState()

void PixelCalibConfiguration::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

Definition at line 852 of file PixelCalibConfiguration.cc.

References _bufferData, cms::cuda::assert(), cuy::col, colCounter(), cols_, gather_cfg::cout, dacs_, pos::PixelROCInfo::defaultDACs_, disablePixels(), enablePixels(), pos::PixelHdwAddress::fecnumber(), dqmdumpme::first, pos::PixelNameTranslation::getChannelForROC(), pos::PixelNameTranslation::getHdwAddress(), pos::PixelROCInfo::hdwadd_, highVCalRange_, pos::PixelHdwAddress::hubaddress(), mps_fire::i, cuy::ii, dqmiolumiharvest::j, pos::k_DACAddress_WBC, pos::PixelROCInfo::masks_, WZElectronSkims53X_cff::max, pos::PixelHdwAddress::mfec(), pos::PixelHdwAddress::mfecchannel(), mode(), callgraph::module, create_idmaps::n, mergeVDriftHistosByStation::name, nConfigurations(), parameterValue(), pos::PixelHdwAddress::portaddress(), relativeConstraints::relative, rocAndModuleListsBuilt_, pos::PixelHdwAddress::rocid(), rocInfo_, rocs_, rowCounter(), rows_, scanCounter(), scanningROCForState(), scanValue(), AlCaHLTBitMon_QueryRunRegistry::string, pos::PixelROCInfo::tbmChannel_, pos::PixelChannel::TBMChannelString(), pos::PixelROCInfo::trims_, and pos::PixelROCInfo::use_.

                                                                     {
  std::string mthn = "[PixelCalibConfiguration::nextFECState()]\t\t    ";
  std::string modeName = parameterValue("ScanMode");

  int mode = -1;

  if (modeName == "maskAllPixel")
    mode = 0;
  if (modeName == "useAllPixel" || modeName.empty())
    mode = 1;
  if (modeName == "default")
    mode = 2;

  static bool first = true;

  if (first) {
    cout << __LINE__ << "]\t" << mthn << "mode=" << mode << endl;
    first = false;
  }

  if (mode == -1) {
    cout << __LINE__ << "]\t" << mthn << "ScanMode=" << modeName << " not understood." << endl;
    ::abort();
  }

  if (rocInfo_.empty()) {
    //here we will do some initialization...
    for (unsigned int i = 0; i < rocs_.size(); i++) {
      const PixelHdwAddress* hdwadd = trans->getHdwAddress(rocs_[i]);
      PixelROCInfo rocInfo;
      rocInfo.use_ = true;
      //FIXME This is very inefficient
      PixelModuleName module(rocs_[i].rocname());

      std::map<pos::PixelModuleName, pos::PixelMaskBase*>::const_iterator foundMask = masks->find(module);
      if (foundMask == masks->end()) {
        rocInfo.use_ = false;
        rocInfo_.push_back(rocInfo);
        continue;
      }

      rocInfo.hdwadd_ = hdwadd;
      rocInfo.trims_ = (*trims)[module]->getTrimBits(rocs_[i]);
      rocInfo.masks_ = (*masks)[module]->getMaskBits(rocs_[i]);

#ifdef BPIX
      const PixelChannel channel = trans->getChannelForROC(rocs_[i]);
      string tbmChannel = channel.TBMChannelString();
      //cout<<" tbm channel "<<tbmChannel<<endl;
      rocInfo.tbmChannel_ = tbmChannel;
#endif

      std::map<std::string, unsigned int> defaultDACValues;
      (*dacs)[PixelModuleName(rocs_[i].rocname())]->getDACSettings(rocs_[i])->getDACs(defaultDACValues);

      for (std::vector<PixelDACScanRange>::const_iterator dacs_itr = dacs_.begin(); dacs_itr != dacs_.end();
           ++dacs_itr) {
        std::map<std::string, unsigned int>::const_iterator foundThisDAC = defaultDACValues.find(dacs_itr->name());
        assert(foundThisDAC != defaultDACValues.end());

        pair<unsigned int, unsigned int> dacchannelAndValue(dacs_itr->dacchannel(), foundThisDAC->second);

        rocInfo.defaultDACs_.push_back(dacchannelAndValue);
      }
      rocInfo_.push_back(rocInfo);
    }
  }

  assert(rocs_.size() == rocInfo_.size());

  bool changedWBC = false;

  //std::map<unsigned int, PixelFECConfigInterface*>::iterator iPixelFEC=pixelFECs.begin();
  //for(;iPixelFEC!=pixelFECs.end();++iPixelFEC){
  //iPixelFEC->second->fecDebug(1);
  //}

  //unsigned long version=0;
  //pixelFEC->getversion(&version);
  //std::cout<<"mfec firmware version:"<<version<<std::endl;

  assert(rocAndModuleListsBuilt_);

  assert(state < nConfigurations());

  // Which set of rows we're on.
  unsigned int i_row = rowCounter(state);

  // Which set of columns we're on.
  unsigned int i_col = colCounter(state);

  // Whether we're beginning a new scan over the DACs after changing which ROC or which pixel pattern.
  unsigned int first_scan = true;
  for (unsigned int i = 0; i < dacs_.size(); i++) {
    if (scanCounter(i, state) != 0)
      first_scan = false;
  }

  // Disable all pixels at the beginning.
  if (state == 0 && (mode == 0 || mode == 1)) {
    for (unsigned int i = 0; i < rocs_.size(); i++) {
      if (!rocInfo_[i].use_)
        continue;

      PixelHdwAddress theROC = *rocInfo_[i].hdwadd_;
      PixelROCTrimBits* rocTrims = rocInfo_[i].trims_;

      //Turn off all pixels
      disablePixels(pixelFECs[theROC.fecnumber()], rocTrims, theROC);
    }

    // reset
    //cout<<"finish init"<<endl;
    //sleep(1);
    //pixelFEC->injectrstroc(7,1);
    // or do    pixelFEC->rocreset(theROC.mfec(),
    //             theROC.mfecchannel(),
    //             14,                    //FIXME hardcode for Channel A
    //             theROC.hubaddress());
  }

  // When a scan is complete for a given ROC or pixel pattern, reset the DACs to default values and disable the previously-enabled pixels.
  if (first_scan && state != 0 && mode != 2) {
    unsigned int previousState = state - 1;

    unsigned int i_row_previous = rowCounter(previousState);

    unsigned int i_col_previous = colCounter(previousState);

    for (unsigned int i = 0; i < rocs_.size(); i++) {
      if (!rocInfo_[i].use_)
        continue;

      PixelHdwAddress theROC = *rocInfo_[i].hdwadd_;

      if (!scanningROCForState(rocs_[i], previousState))
        continue;

      // Set the DACs back to their default values when we're done with a scan.
      for (unsigned int j = 0; j < dacs_.size(); j++) {
        //Try to not reprogram DACs as often..
        if (state != 0) {
          if (scanCounter(dacs_[j].name(), state) == scanCounter(dacs_[j].name(), state - 1)) {
            continue;
          }
        }

        pixelFECs[theROC.fecnumber()]->progdac(theROC.mfec(),
                                               theROC.mfecchannel(),
                                               theROC.hubaddress(),
                                               theROC.portaddress(),
                                               theROC.rocid(),
                                               rocInfo_[i].defaultDACs_[j].first,
                                               rocInfo_[i].defaultDACs_[j].second,
                                               _bufferData);

        if (dacs_[j].dacchannel() == k_DACAddress_WBC) {
          changedWBC = true;
          //cout << "Changed WBC 1"<<endl;
        }
      }

      PixelROCTrimBits* rocTrims = rocInfo_[i].trims_;

      disablePixels(pixelFECs[theROC.fecnumber()], i_row_previous, i_col_previous, rocTrims, theROC);
    }
  }

  // Set each ROC with the new settings for this state.
  for (unsigned int i = 0; i < rocs_.size(); i++) {
    if (!rocInfo_[i].use_)
      continue;

    PixelHdwAddress theROC = *rocInfo_[i].hdwadd_;

    // Skip this ROC if we're in SingleROC mode and we're not on this ROC number.
    if (!scanningROCForState(rocs_[i], state))
      continue;

    //  std::cout << "Will call progdac for vcal:"<< vcal << std::endl;

    // Program all the DAC values.
    for (unsigned int ii = 0; ii < dacs_.size(); ii++) {
      //Try to not reprogram DACs as often..
      if (state != 0) {
        if (scanCounter(dacs_[ii].name(), state) == scanCounter(dacs_[ii].name(), state - 1)) {
          continue;
        }
      }

      int dacvalue = scanValue(ii, state, rocs_[i]);

      //cout << "dacname ii:"<<dacs_[ii].name()<<" "<<ii<<endl;

      if (dacs_[ii].relative()) {
        //We have to find the default DAC setting so that we can
        //add the offset as we are in relative mode.

        if (dacs_[ii].negative())
          dacvalue = -dacvalue;

        dacvalue += rocInfo_[i].defaultDACs_[ii].second;
        //cout << "[PixelCalibConfiguration::nextFECState] ROC="<<rocs_[i]
        //     << " dac="<<dacs_[ii].name()<<" new value="<<dacvalue<<endl;
      }

      pixelFECs[theROC.fecnumber()]->progdac(theROC.mfec(),
                                             theROC.mfecchannel(),
                                             theROC.hubaddress(),
                                             theROC.portaddress(),
                                             theROC.rocid(),
                                             rocInfo_[i].defaultDACs_[ii].first,
                                             dacvalue,
                                             _bufferData);

      if (dacs_[ii].dacchannel() == k_DACAddress_WBC) {
        changedWBC = true;
        //cout << "Changed WBC 2"<<endl;
      }
    }

    // At the beginning of a scan, set the pixel pattern.
    if (first_scan) {
      // Set masks and trims.
      if (mode != 2) {
        PixelROCMaskBits* rocMasks = rocInfo_[i].masks_;
        PixelROCTrimBits* rocTrims = rocInfo_[i].trims_;

        if (mode == 1)
          rocMasks = nullptr;

        //std::cout << "Will enable pixels!" <<std::endl;
        enablePixels(pixelFECs[theROC.fecnumber()], i_row, i_col, rocMasks, rocTrims, theROC);
      }

      // Set high or low Vcal range.

      if (state == 0) {
        PixelModuleName module(rocs_[i].rocname());

        unsigned int roccontrolword = (*dacs)[module]->getDACSettings(rocs_[i])->getControlRegister();

        //range is controlled here by one bit, but rest must match config
        //bit 0 on/off= 20/40 MHz speed; bit 1 on/off=disabled/enable; bit 3=Vcal range

        if (highVCalRange_)
          roccontrolword |= 0x4;  //turn range bit on
        else
          roccontrolword &= 0xfb;  //turn range bit off

        pixelFECs[theROC.fecnumber()]->progdac(theROC.mfec(),
                                               theROC.mfecchannel(),
                                               theROC.hubaddress(),
                                               theROC.portaddress(),
                                               theROC.rocid(),
                                               0xfd,
                                               roccontrolword,
                                               _bufferData);
      }

      // Clear all pixels before setting the pixel pattern.
      pixelFECs[theROC.fecnumber()]->clrcal(
          theROC.mfec(), theROC.mfecchannel(), theROC.hubaddress(), theROC.portaddress(), theROC.rocid(), _bufferData);

      // Program the pixel pattern.
      unsigned int nrow = rows_[i_row].size();
      unsigned int ncol = cols_[i_col].size();
      unsigned int nmax = std::max(nrow, ncol);
      if (nrow == 0 || ncol == 0)
        nmax = 0;
      for (unsigned int n = 0; n < nmax; n++) {
        unsigned int irow = n;
        unsigned int icol = n;
        if (irow >= nrow)
          irow = nrow - 1;
        if (icol >= ncol)
          icol = ncol - 1;
        unsigned int row = rows_[i_row][irow];
        unsigned int col = cols_[i_col][icol];

        pixelFECs[theROC.fecnumber()]->calpix(theROC.mfec(),
                                              theROC.mfecchannel(),
                                              theROC.hubaddress(),
                                              theROC.portaddress(),
                                              theROC.rocid(),
                                              col,
                                              row,
                                              1,
                                              _bufferData);
      }

    }  // end of instructions for the beginning of a scan
  }  // end of loop over ROCs

  if (_bufferData) {
    std::map<unsigned int, PixelFECConfigInterface*>::iterator iPixelFEC = pixelFECs.begin();
    for (; iPixelFEC != pixelFECs.end(); ++iPixelFEC) {
      iPixelFEC->second->qbufsend();
    }
  }

  if (changedWBC) {
    for (unsigned int i = 0; i < rocs_.size(); i++) {
      if (!rocInfo_[i].use_)
        continue;

      PixelHdwAddress theROC = *rocInfo_[i].hdwadd_;

      int tbmRegister = 14;  // define for TBM-A
#ifdef BPIX
      string tbmChannel = rocInfo_[i].tbmChannel_;  // get TBM channel
      if (tbmChannel == "B")
        tbmRegister = 15;  // for TBM=B
#endif

      pixelFECs[theROC.fecnumber()]->rocreset(theROC.mfec(), theROC.mfecchannel(), tbmRegister, theROC.hubaddress());
    }  // for rocs
  }

  return;
}

noHits()

bool pos::PixelCalibConfiguration::noHits ( ) const

inline

Definition at line 121 of file PixelCalibConfiguration.h.

References maxNumHitsPerROC().

{ return (maxNumHitsPerROC() == 0); }  // returns true if no hits will be produced

nParameters()

unsigned int pos::PixelCalibConfiguration::nParameters ( ) const

inline

Definition at line 177 of file PixelCalibConfiguration.h.

References parameters_.

{ return parameters_.size(); }

nPixelPatterns()

unsigned int pos::PixelCalibConfiguration::nPixelPatterns ( ) const

inline

Definition at line 107 of file PixelCalibConfiguration.h.

References cols_, and rows_.

Referenced by nConfigurations().

{ return rows_.size() * cols_.size(); }

nROC()

unsigned int pos::PixelCalibConfiguration::nROC ( ) const

inline

Definition at line 103 of file PixelCalibConfiguration.h.

References cms::cuda::assert(), nROC_, and rocAndModuleListsBuilt_.

Referenced by nConfigurations().

                              {
      assert(rocAndModuleListsBuilt_);
      return nROC_;
    }

nScanPoints() [1/3]

unsigned int pos::PixelCalibConfiguration::nScanPoints ( std::string  dac ) const

inline

Definition at line 109 of file PixelCalibConfiguration.h.

References iScan(), and nScanPoints().

Referenced by nScanPoints().

{ return nScanPoints(iScan(dac)); }

nScanPoints() [2/3]

unsigned int pos::PixelCalibConfiguration::nScanPoints ( ) const

inline

Definition at line 111 of file PixelCalibConfiguration.h.

References dacs_, and mps_fire::i.

Referenced by colCounter(), nConfigurations(), rowCounter(), scanCounter(), scanROC(), scanValue(), and scanValueMax().

                                     {
      unsigned int points = 1;
      for (unsigned int i = 0; i < dacs_.size(); i++) {
        points *= nScanPoints(i);
      }
      return points;
    }

nScanPoints() [3/3]

unsigned int pos::PixelCalibConfiguration::nScanPoints ( unsigned int  iscan ) const

inlineprivate

Definition at line 212 of file PixelCalibConfiguration.h.

References dacs_.

{ return dacs_[iscan].getNPoints(); }

nTriggersPerPattern()

unsigned int pos::PixelCalibConfiguration::nTriggersPerPattern ( ) const

inline

Definition at line 108 of file PixelCalibConfiguration.h.

References ntrigger_.

Referenced by nTriggersTotal(), and SiPixelCalibConfiguration::SiPixelCalibConfiguration().

{ return ntrigger_; }

nTriggersTotal()

unsigned int pos::PixelCalibConfiguration::nTriggersTotal ( ) const

inline

Definition at line 119 of file PixelCalibConfiguration.h.

References nConfigurations(), and nTriggersPerPattern().

{ return nConfigurations() * nTriggersPerPattern(); }

numberOfScanVariables()

unsigned int pos::PixelCalibConfiguration::numberOfScanVariables ( ) const

inline

Definition at line 144 of file PixelCalibConfiguration.h.

References dacs_.

Referenced by containsScan().

{ return dacs_.size(); }

numROCsCalibratedOnChannel()

unsigned int PixelCalibConfiguration::numROCsCalibratedOnChannel ( PixelROCName  roc ) const

private

Definition at line 816 of file PixelCalibConfiguration.cc.

References cms::cuda::assert(), numROCsCalibratedOnChannel_, objectsDependingOnTheNameTranslationBuilt_, and PixelMapPlotter::roc.

Referenced by scanValue().

                                                                                       {
  assert(objectsDependingOnTheNameTranslationBuilt_);
  std::map<PixelROCName, unsigned int>::const_iterator foundROC = numROCsCalibratedOnChannel_.find(roc);
  assert(foundROC != numROCsCalibratedOnChannel_.end());
  return foundROC->second;
}

parametersList()

std::map<std::string, std::string> pos::PixelCalibConfiguration::parametersList ( ) const

inline

Definition at line 180 of file PixelCalibConfiguration.h.

References parameters_.

{ return parameters_; }

parameterValue()

std::string PixelCalibConfiguration::parameterValue

(

std::string

parameterName

)

const

Definition at line 1447 of file PixelCalibConfiguration.cc.

References parameters_.

Referenced by nextFECState().

                                                                               {
  std::map<std::string, std::string>::const_iterator itr = parameters_.find(parameterName);
  if (itr == parameters_.end())  // parameterName is not in the list
  {
    return "";
  } else {
    return itr->second;
  }
}

pixelsWithHits()

std::set< std::pair< unsigned int, unsigned int > > PixelCalibConfiguration::pixelsWithHits

(

unsigned int

state

)

const

Definition at line 1553 of file PixelCalibConfiguration.cc.

References colCounter(), cols_, Hcal_Conditions_forGlobalTag_cff::pixels, rowCounter(), and rows_.

                                                                                                             {
  std::set<std::pair<unsigned int, unsigned int> > pixels;
  //                  column #      row #

  for (std::vector<unsigned int>::const_iterator col_itr = cols_[colCounter(state)].begin();
       col_itr != cols_[colCounter(state)].end();
       ++col_itr) {
    for (std::vector<unsigned int>::const_iterator row_itr = rows_[rowCounter(state)].begin();
         row_itr != rows_[rowCounter(state)].end();
         ++row_itr) {
      pixels.insert(std::pair<unsigned int, unsigned int>(*col_itr, *row_itr));
    }
  }

  return pixels;
}

rocList()

const std::vector<PixelROCName>& pos::PixelCalibConfiguration::rocList ( ) const

inline

Definition at line 160 of file PixelCalibConfiguration.h.

References cms::cuda::assert(), rocAndModuleListsBuilt_, and rocs_.

                                                   {
      assert(rocAndModuleListsBuilt_);
      return rocs_;
    }

ROCNumberOnChannelAmongThoseCalibrated()

unsigned int PixelCalibConfiguration::ROCNumberOnChannelAmongThoseCalibrated ( PixelROCName  roc ) const

private

Definition at line 809 of file PixelCalibConfiguration.cc.

References cms::cuda::assert(), objectsDependingOnTheNameTranslationBuilt_, PixelMapPlotter::roc, and ROCNumberOnChannelAmongThoseCalibrated_.

Referenced by scanningROCForState(), and scanValue().

                                                                                                   {
  assert(objectsDependingOnTheNameTranslationBuilt_);
  std::map<PixelROCName, unsigned int>::const_iterator foundROC = ROCNumberOnChannelAmongThoseCalibrated_.find(roc);
  assert(foundROC != ROCNumberOnChannelAmongThoseCalibrated_.end());
  return foundROC->second;
}

rowCounter()

unsigned int PixelCalibConfiguration::rowCounter ( unsigned int  state ) const

private

Definition at line 837 of file PixelCalibConfiguration.cc.

References cms::cuda::assert(), cols_, nScanPoints(), rows_, and scanROC().

Referenced by colCounter(), nextFECState(), and pixelsWithHits().

                                                                         {
  unsigned int i_row =
      (state - scanROC(state) * cols_.size() * rows_.size() * nScanPoints()) / (cols_.size() * nScanPoints());
  assert(i_row < rows_.size());
  return i_row;
}

rowList()

const std::vector<std::vector<unsigned int> >& pos::PixelCalibConfiguration::rowList ( ) const

inline

Definition at line 159 of file PixelCalibConfiguration.h.

References rows_.

Referenced by SiPixelCalibConfiguration::SiPixelCalibConfiguration().

{ return rows_; }

scanCounter() [1/2]

unsigned int pos::PixelCalibConfiguration::scanCounter ( std::string  dac, unsigned int  state  ) const

inline

Definition at line 132 of file PixelCalibConfiguration.h.

References iScan(), and scanCounter().

Referenced by nextFECState(), scanCounter(), and scanValue().

{ return scanCounter(iScan(dac), state); }

scanCounter() [2/2]

unsigned int PixelCalibConfiguration::scanCounter ( unsigned int  iscan, unsigned int  state  ) const

private

Definition at line 823 of file PixelCalibConfiguration.cc.

References cms::cuda::assert(), mps_fire::i, nConfigurations(), and nScanPoints().

                                                                                              {
  assert(state < nConfigurations());

  unsigned int i_scan = state % nScanPoints();

  for (unsigned int i = 0; i < iscan; i++) {
    i_scan /= nScanPoints(i);
  }

  unsigned int i_threshold = i_scan % nScanPoints(iscan);

  return i_threshold;
}

scanName()

std::string pos::PixelCalibConfiguration::scanName ( unsigned int  iscan ) const

inline

Definition at line 148 of file PixelCalibConfiguration.h.

References dacs_.

Referenced by containsScan(), and SiPixelCalibConfiguration::SiPixelCalibConfiguration().

{ return dacs_[iscan].name(); }

scanningROCForState()

bool PixelCalibConfiguration::scanningROCForState	(	PixelROCName	roc,
		unsigned int	state
	)		const

Definition at line 796 of file PixelCalibConfiguration.cc.

References PixelMapPlotter::roc, ROCNumberOnChannelAmongThoseCalibrated(), scanROC(), and singleROC_.

Referenced by nextFECState().

                                                                                            {
  if (!singleROC_)
    return true;
  return scanROC(state) == ROCNumberOnChannelAmongThoseCalibrated(roc);
}

scanROC()

unsigned int PixelCalibConfiguration::scanROC ( unsigned int  state ) const

private

Definition at line 771 of file PixelCalibConfiguration.cc.

References cms::cuda::assert(), cols_, nConfigurations(), nScanPoints(), and rows_.

Referenced by colCounter(), rowCounter(), and scanningROCForState().

                                                                      {
  assert(state < nConfigurations());

  unsigned int i_ROC = state / (cols_.size() * rows_.size() * nScanPoints());

  return i_ROC;
}

scanValue() [1/4]

unsigned int pos::PixelCalibConfiguration::scanValue ( std::string  dac, unsigned int  state, PixelROCName  roc  ) const

inline

Definition at line 134 of file PixelCalibConfiguration.h.

References iScan(), and PixelMapPlotter::roc.

Referenced by nextFECState(), and scanValue().

                                                                                      {
      return scanValue(iScan(dac), state, roc);
    }

scanValue() [2/4]

unsigned int pos::PixelCalibConfiguration::scanValue ( std::string  dac, unsigned int  state  ) const

inline

Definition at line 139 of file PixelCalibConfiguration.h.

References cms::cuda::assert(), dacs_, iScan(), and scanValue().

                                                                    {
      assert(!(dacs_[iScan(dac)].mixValuesAcrossROCs()));
      return scanValue(iScan(dac), state, 0, 1);
    }

scanValue() [3/4]

unsigned int PixelCalibConfiguration::scanValue ( unsigned int  iscan, unsigned int  state, unsigned int  ROCNumber, unsigned int  ROCsOnChannel  ) const

private

Definition at line 779 of file PixelCalibConfiguration.cc.

References dacs_, nScanPoints(), scanCounter(), and DiMuonV_cfg::threshold.

                                                                                  {
  unsigned int i_threshold = scanCounter(iscan, state);

  // Spread the DAC values on the different ROCs uniformly across the scan range.
  if (dacs_[iscan].mixValuesAcrossROCs())
    i_threshold = (i_threshold + (nScanPoints(iscan) * ROCNumber) / ROCsOnChannel) % nScanPoints(iscan);

  unsigned int threshold = dacs_[iscan].value(i_threshold);

  //assert(threshold==dacs_[iscan].first()+i_threshold*dacs_[iscan].step());

  return threshold;
}

scanValue() [4/4]

unsigned int PixelCalibConfiguration::scanValue ( unsigned int  iscan, unsigned int  state, PixelROCName  roc  ) const

private

Definition at line 802 of file PixelCalibConfiguration.cc.

References numROCsCalibratedOnChannel(), PixelMapPlotter::roc, ROCNumberOnChannelAmongThoseCalibrated(), and scanValue().

                                                                                                              {
  unsigned int ROCNumber = ROCNumberOnChannelAmongThoseCalibrated(roc);
  unsigned int ROCsOnChannel = numROCsCalibratedOnChannel(roc);

  return scanValue(iscan, state, ROCNumber, ROCsOnChannel);
}

scanValueMax() [1/2]

double pos::PixelCalibConfiguration::scanValueMax ( std::string  dac ) const

inline

Definition at line 152 of file PixelCalibConfiguration.h.

References iScan(), and scanValueMax().

Referenced by scanValueMax().

{ return scanValueMax(iScan(dac)); }

scanValueMax() [2/2]

double pos::PixelCalibConfiguration::scanValueMax ( unsigned int  iscan ) const

inlineprivate

Definition at line 225 of file PixelCalibConfiguration.h.

References dacs_, and nScanPoints().

                                                  {
      return dacs_[iscan].first() + dacs_[iscan].step() * (nScanPoints(iscan) - 1);
    }

scanValueMin() [1/2]

double pos::PixelCalibConfiguration::scanValueMin ( std::string  dac ) const

inline

Definition at line 151 of file PixelCalibConfiguration.h.

References iScan(), and scanValueMin().

Referenced by scanValueMin().

{ return scanValueMin(iScan(dac)); }

scanValueMin() [2/2]

double pos::PixelCalibConfiguration::scanValueMin ( unsigned int  iscan ) const

inlineprivate

Definition at line 224 of file PixelCalibConfiguration.h.

References dacs_.

{ return dacs_[iscan].first(); }

scanValues() [1/2]

std::vector<unsigned int> pos::PixelCalibConfiguration::scanValues ( std::string  dac ) const

inline

Definition at line 149 of file PixelCalibConfiguration.h.

References iScan(), and scanValues().

Referenced by scanValues(), and SiPixelCalibConfiguration::SiPixelCalibConfiguration().

{ return scanValues(iScan(dac)); }

scanValues() [2/2]

std::vector<unsigned int> pos::PixelCalibConfiguration::scanValues ( unsigned int  iscan ) const

inlineprivate

Definition at line 222 of file PixelCalibConfiguration.h.

References dacs_.

{ return dacs_[iscan].values(); }

scanValuesMixedAcrossROCs() [1/2]

bool pos::PixelCalibConfiguration::scanValuesMixedAcrossROCs ( std::string  dac ) const

inline

Definition at line 154 of file PixelCalibConfiguration.h.

References iScan(), and scanValuesMixedAcrossROCs().

Referenced by scanValuesMixedAcrossROCs().

{ return scanValuesMixedAcrossROCs(iScan(dac)); }

scanValuesMixedAcrossROCs() [2/2]

bool pos::PixelCalibConfiguration::scanValuesMixedAcrossROCs ( unsigned int  iscan ) const

inlineprivate

Definition at line 229 of file PixelCalibConfiguration.h.

References dacs_.

{ return dacs_[iscan].mixValuesAcrossROCs(); }

scanValueStep() [1/2]

double pos::PixelCalibConfiguration::scanValueStep ( std::string  dac ) const

inline

Definition at line 153 of file PixelCalibConfiguration.h.

References iScan(), and scanValueStep().

Referenced by scanValueStep().

{ return scanValueStep(iScan(dac)); }

scanValueStep() [2/2]

double pos::PixelCalibConfiguration::scanValueStep ( unsigned int  iscan ) const

inlineprivate

Definition at line 228 of file PixelCalibConfiguration.h.

References dacs_.

{ return dacs_[iscan].step(); }

singleROC()

bool pos::PixelCalibConfiguration::singleROC ( ) const

inline

Definition at line 175 of file PixelCalibConfiguration.h.

References singleROC_.

{ return singleROC_; }

writeASCII()

void PixelCalibConfiguration::writeASCII ( std::string  dir = "" ) const

overridevirtual

Implements pos::PixelConfigBase.

Definition at line 1457 of file PixelCalibConfiguration.cc.

References cols_, dacs_, DeadROC_duringRun::dir, corrVsCorr::filename, dqmdumpme::first, highVCalRange_, mps_fire::i, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, dqmiolumiharvest::j, pos::PixelCalibBase::mode_, ntrigger_, MillePedeFileConverter_cfg::out, parameters_, rocListInstructions_, rows_, singleROC_, AlCaHLTBitMon_QueryRunRegistry::string, and usesROCList_.

Referenced by writeXMLHeader().

                                                            {
  //FIXME this is not tested for all the use cases...

  if (!dir.empty())
    dir += "/";
  std::string filename = dir + "calib.dat";
  std::ofstream out(filename.c_str());

  out << "Mode: " << mode_ << endl;
  if (singleROC_)
    out << "SingleROC" << endl;
  if (!parameters_.empty()) {
    out << "Parameters:" << endl;
    std::map<std::string, std::string>::const_iterator it = parameters_.begin();
    for (; it != parameters_.end(); ++it) {
      out << it->first << "        " << it->second << endl;
    }
  }
  out << "Rows:" << endl;
  for (unsigned int i = 0; i < rows_.size(); i++) {
    for (unsigned int j = 0; j < rows_[i].size(); j++) {
      out << rows_[i][j] << " ";
    }
    if (i != rows_.size() - 1)
      out << "|";
    out << endl;
  }
  out << "Cols:" << endl;
  for (unsigned int i = 0; i < cols_.size(); i++) {
    for (unsigned int j = 0; j < cols_[i].size(); j++) {
      out << cols_[i][j] << " ";
    }
    if (i != cols_.size() - 1)
      out << "|";
    out << endl;
  }

  if (highVCalRange_) {
    out << "VcalHigh" << endl;
  } else {
    out << "VcalLow" << endl;
  }

  for (unsigned int i = 0; i < dacs_.size(); i++) {
    if (dacs_[i].uniformSteps()) {
      if (dacs_[i].first() != dacs_[i].last()) {
        out << "Scan: " << dacs_[i].name() << " ";
        out << dacs_[i].first() << " ";
        out << dacs_[i].last() << " ";
        out << dacs_[i].step() << endl;
      } else {
        out << "Set: " << dacs_[i].name() << " ";
        out << dacs_[i].first() << endl;
      }
    } else {
      out << "ScanValues: " << dacs_[i].name() << " ";
      for (unsigned int ival = 0; ival < dacs_[i].getNPoints(); ival++) {
        out << dacs_[i].value(ival) << " ";
      }
      out << " -1" << endl;
    }
  }

  out << "Repeat:" << endl;
  out << ntrigger_ << endl;

  if (usesROCList_) {
    out << "Rocs:" << endl;
  } else {
    out << "ToCalibrate:" << endl;
  }
  for (unsigned int i = 0; i < rocListInstructions_.size(); i++) {
    out << rocListInstructions_[i] << endl;
    if (rocListInstructions_[i] == "+" || rocListInstructions_[i] == "-") {
      out << " ";
    } else {
      out << endl;
    }
  }

  out.close();
}

writeXML() [1/2]

void pos::PixelCalibConfiguration::writeXML ( pos::PixelConfigKey  key, int  version, std::string  path  ) const

inlineoverridevirtual

Reimplemented from pos::PixelConfigBase.

Definition at line 190 of file PixelCalibConfiguration.h.

{ ; }

writeXML() [2/2]

void PixelCalibConfiguration::writeXML ( std::ofstream *  out, std::ofstream *  out1 = nullptr, std::ofstream *  out2 = nullptr  ) const

overridevirtual

Reimplemented from pos::PixelCalibBase.

Definition at line 1627 of file PixelCalibConfiguration.cc.

References AlCaHLTBitMon_QueryRunRegistry::string.

                                                                      {
  std::string mthn = "[PixelCalibConfiguration::writeXML()]\t\t    ";

  *outstream << " " << std::endl;
  *outstream << "  <DATA>" << std::endl;
  *outstream << "   <CALIB_OBJ_DATA_FILE>./calib.dat</CALIB_OBJ_DATA_FILE>" << std::endl;
  *outstream << "   <CALIB_TYPE>calib</CALIB_TYPE>" << std::endl;
  *outstream << "  </DATA>" << std::endl;
  *outstream << " " << std::endl;
}

writeXMLHeader()

void PixelCalibConfiguration::writeXMLHeader ( pos::PixelConfigKey  key, int  version, std::string  path, std::ofstream *  out, std::ofstream *  out1 = nullptr, std::ofstream *  out2 = nullptr  ) const

overridevirtual

Reimplemented from pos::PixelCalibBase.

Definition at line 1580 of file PixelCalibConfiguration.cc.

References gather_cfg::cout, pos::PixelConfigBase::getAuthor(), pos::PixelConfigBase::getComment(), pos::PixelTimeFormatter::getmSecTime(), pos::PixelTimeFormatter::getTime(), EnsembleCalibrationLA_cfg::path, AlCaHLTBitMon_QueryRunRegistry::string, relval_steps::version, and writeASCII().

                                                                            {
  std::string mthn = "[PixelCalibConfiguration::writeXMLHeader()]\t\t    ";
  std::stringstream maskFullPath;

  writeASCII(path);

  maskFullPath << path << "/PixelCalib_Test_" << PixelTimeFormatter::getmSecTime() << ".xml";
  std::cout << __LINE__ << "]\t" << mthn << "Writing to: " << maskFullPath.str() << std::endl;

  outstream->open(maskFullPath.str().c_str());

  *outstream << "<?xml version='1.0' encoding='UTF-8' standalone='yes'?>" << std::endl;
  *outstream << "<ROOT xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>" << std::endl;
  *outstream << "" << std::endl;
  *outstream << " <!-- " << mthn << "-->" << std::endl;
  *outstream << "" << std::endl;
  *outstream << " <HEADER>" << std::endl;
  *outstream << "  <TYPE>" << std::endl;
  *outstream << "   <EXTENSION_TABLE_NAME>PIXEL_CALIB_CLOB</EXTENSION_TABLE_NAME>" << std::endl;
  *outstream << "   <NAME>Calibration Object Clob</NAME>" << std::endl;
  *outstream << "  </TYPE>" << std::endl;
  *outstream << "  <RUN>" << std::endl;
  *outstream << "   <RUN_TYPE>Gain Calibration</RUN_TYPE>" << std::endl;
  *outstream << "   <RUN_NUMBER>1</RUN_NUMBER>" << std::endl;
  *outstream << "   <RUN_BEGIN_TIMESTAMP>" << PixelTimeFormatter::getTime() << "</RUN_BEGIN_TIMESTAMP>" << std::endl;
  *outstream << "   <LOCATION>CERN P5</LOCATION>" << std::endl;
  *outstream << "  </RUN>" << std::endl;
  *outstream << " </HEADER>" << std::endl;
  *outstream << "" << std::endl;
  *outstream << " <DATA_SET>" << std::endl;
  *outstream << "" << std::endl;
  *outstream << "  <VERSION>" << version << "</VERSION>" << std::endl;
  *outstream << "  <COMMENT_DESCRIPTION>" << getComment() << "</COMMENT_DESCRIPTION>" << std::endl;
  *outstream << "  <CREATED_BY_USER>" << getAuthor() << "</CREATED_BY_USER>" << std::endl;
  *outstream << "" << std::endl;
  *outstream << "  <PART>" << std::endl;
  *outstream << "   <NAME_LABEL>CMS-PIXEL-ROOT</NAME_LABEL>" << std::endl;
  *outstream << "   <KIND_OF_PART>Detector ROOT</KIND_OF_PART>" << std::endl;
  *outstream << "  </PART>" << std::endl;
}

writeXMLTrailer()

void PixelCalibConfiguration::writeXMLTrailer ( std::ofstream *  out, std::ofstream *  out1 = nullptr, std::ofstream *  out2 = nullptr  ) const

overridevirtual

Reimplemented from pos::PixelCalibBase.

Definition at line 1641 of file PixelCalibConfiguration.cc.

References gather_cfg::cout, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                             {
  std::string mthn = "[PixelCalibConfiguration::writeXMLTrailer()]\t\t    ";

  *outstream << " </DATA_SET>" << std::endl;
  *outstream << "</ROOT>" << std::endl;

  outstream->close();
  std::cout << __LINE__ << "]\t" << mthn << "Data written " << std::endl;
}

Friends And Related Function Documentation

pos::operator<<

std::ostream& pos::operator<< ( std::ostream &  s, const PixelCalibConfiguration &  calib  )

friend

Member Data Documentation

_bufferData

bool pos::PixelCalibConfiguration::_bufferData

private

Definition at line 296 of file PixelCalibConfiguration.h.

Referenced by disablePixels(), enablePixels(), nextFECState(), and PixelCalibConfiguration().

calibFileContent_

std::string pos::PixelCalibConfiguration::calibFileContent_

private

Definition at line 301 of file PixelCalibConfiguration.h.

Referenced by getStreamedContent(), and PixelCalibConfiguration().

channels_

std::set<PixelChannel> pos::PixelCalibConfiguration::channels_

private

Definition at line 251 of file PixelCalibConfiguration.h.

Referenced by buildObjectsDependingOnTheNameTranslation(), and channelList().

cols_

std::vector<std::vector<unsigned int> > pos::PixelCalibConfiguration::cols_

private

Definition at line 242 of file PixelCalibConfiguration.h.

Referenced by colCounter(), columnList(), disablePixels(), enablePixels(), maxNumHitsPerROC(), nextFECState(), nPixelPatterns(), PixelCalibConfiguration(), pixelsWithHits(), rowCounter(), scanROC(), and writeASCII().

dacs_

std::vector<PixelDACScanRange> pos::PixelCalibConfiguration::dacs_

private

Definition at line 260 of file PixelCalibConfiguration.h.

Referenced by iScan(), nextFECState(), nScanPoints(), numberOfScanVariables(), PixelCalibConfiguration(), scanName(), scanValue(), scanValueMax(), scanValueMin(), scanValues(), scanValuesMixedAcrossROCs(), scanValueStep(), and writeASCII().

fedCardsAndChannels_

std::vector<std::pair<unsigned int, std::vector<unsigned int> > > pos::PixelCalibConfiguration::fedCardsAndChannels_

mutableprivate

Definition at line 256 of file PixelCalibConfiguration.h.

Referenced by fedCardsAndChannels().

highVCalRange_

bool pos::PixelCalibConfiguration::highVCalRange_

private

Definition at line 271 of file PixelCalibConfiguration.h.

Referenced by nextFECState(), PixelCalibConfiguration(), and writeASCII().

modules_

std::set<PixelModuleName> pos::PixelCalibConfiguration::modules_

private

Definition at line 246 of file PixelCalibConfiguration.h.

Referenced by buildROCAndModuleListsFromROCSet(), getFECCrates(), getFEDCrates(), getTKFECCrates(), and moduleList().

nROC_

unsigned int pos::PixelCalibConfiguration::nROC_

private

Definition at line 269 of file PixelCalibConfiguration.h.

Referenced by buildROCAndModuleListsFromROCSet(), and nROC().

ntrigger_

unsigned int pos::PixelCalibConfiguration::ntrigger_

private

Definition at line 268 of file PixelCalibConfiguration.h.

Referenced by nTriggersPerPattern(), PixelCalibConfiguration(), and writeASCII().

numROCsCalibratedOnChannel_

std::map<PixelROCName, unsigned int> pos::PixelCalibConfiguration::numROCsCalibratedOnChannel_

private

Definition at line 253 of file PixelCalibConfiguration.h.

Referenced by buildObjectsDependingOnTheNameTranslation(), and numROCsCalibratedOnChannel().

objectsDependingOnTheNameTranslationBuilt_

bool pos::PixelCalibConfiguration::objectsDependingOnTheNameTranslationBuilt_

private

Definition at line 254 of file PixelCalibConfiguration.h.

Referenced by buildObjectsDependingOnTheNameTranslation(), channelList(), numROCsCalibratedOnChannel(), PixelCalibConfiguration(), and ROCNumberOnChannelAmongThoseCalibrated().

old_icols

std::vector<int> pos::PixelCalibConfiguration::old_icols

mutableprivate

Definition at line 291 of file PixelCalibConfiguration.h.

Referenced by buildROCAndModuleListsFromROCSet().

old_irows

std::vector<int> pos::PixelCalibConfiguration::old_irows

mutableprivate

Definition at line 290 of file PixelCalibConfiguration.h.

Referenced by buildROCAndModuleListsFromROCSet().

parameters_

std::map<std::string, std::string> pos::PixelCalibConfiguration::parameters_

private

Definition at line 293 of file PixelCalibConfiguration.h.

Referenced by Mixins._TypedParameterizable::clone(), Types.PSet::clone(), Types.EDAlias::clone(), Mixins._TypedParameterizable::copy(), nParameters(), parametersList(), parameterValue(), PixelCalibConfiguration(), and writeASCII().

rocAndModuleListsBuilt_

bool pos::PixelCalibConfiguration::rocAndModuleListsBuilt_

private

Definition at line 247 of file PixelCalibConfiguration.h.

Referenced by buildObjectsDependingOnTheNameTranslation(), buildROCAndModuleLists(), buildROCAndModuleListsFromROCSet(), fedCardsAndChannels(), getFECCrates(), getFEDCrates(), getFEDsAndChannels(), getTKFECCrates(), moduleList(), nextFECState(), nROC(), PixelCalibConfiguration(), and rocList().

rocInfo_

std::vector<PixelROCInfo> pos::PixelCalibConfiguration::rocInfo_

mutableprivate

Definition at line 245 of file PixelCalibConfiguration.h.

Referenced by nextFECState().

rocListInstructions_

std::vector<std::string> pos::PixelCalibConfiguration::rocListInstructions_

private

Definition at line 248 of file PixelCalibConfiguration.h.

Referenced by buildROCAndModuleLists(), PixelCalibConfiguration(), and writeASCII().

ROCNumberOnChannelAmongThoseCalibrated_

std::map<PixelROCName, unsigned int> pos::PixelCalibConfiguration::ROCNumberOnChannelAmongThoseCalibrated_

private

Definition at line 252 of file PixelCalibConfiguration.h.

Referenced by buildObjectsDependingOnTheNameTranslation(), and ROCNumberOnChannelAmongThoseCalibrated().

rocs_

std::vector<PixelROCName> pos::PixelCalibConfiguration::rocs_

mutableprivate

Definition at line 244 of file PixelCalibConfiguration.h.

Referenced by buildObjectsDependingOnTheNameTranslation(), buildROCAndModuleListsFromROCSet(), fedCardsAndChannels(), getFEDsAndChannels(), nextFECState(), and rocList().

rows_

std::vector<std::vector<unsigned int> > pos::PixelCalibConfiguration::rows_

private

Definition at line 241 of file PixelCalibConfiguration.h.

Referenced by colCounter(), disablePixels(), enablePixels(), maxNumHitsPerROC(), nextFECState(), nPixelPatterns(), PixelCalibConfiguration(), pixelsWithHits(), rowCounter(), rowList(), scanROC(), and writeASCII().

singleROC_

bool pos::PixelCalibConfiguration::singleROC_

private

Definition at line 239 of file PixelCalibConfiguration.h.

Referenced by buildROCAndModuleListsFromROCSet(), PixelCalibConfiguration(), scanningROCForState(), singleROC(), and writeASCII().

usesROCList_

bool pos::PixelCalibConfiguration::usesROCList_

private

Definition at line 298 of file PixelCalibConfiguration.h.

Referenced by PixelCalibConfiguration(), and writeASCII().