PedeReader Class Reference

#include <PedeReader.h>

Public Types
typedef PedeLabelerBase::RunNumber	RunNumber
typedef PedeLabelerBase::RunRange	RunRange

Public Member Functions
AlignmentParameters *	checkAliParams (Alignable *alignable, bool createUserVars) const
	PedeReader (const edm::ParameterSet &config, const PedeSteerer &steerer, const PedeLabelerBase &labels, const RunRange &runrange)
bool	read (align::Alignables &alignables, bool setUserVars)
template<class T >
bool	readIfSameLine (std::ifstream &aStream, T &outValue) const
bool	setCalibrationParameter (IntegratedCalibrationBase *calib, unsigned int paramNum, unsigned int bufLength, const float *buf) const
	Set pede results stored in 'buf' to parameter 'paramNum' of IntegratedCalibrationBase. More...
Alignable *	setParameter (unsigned int paramLabel, unsigned int bufLength, const float *buf, bool setUserVars) const
	~PedeReader ()
	non virtual destructor: do not inherit from this class More...

Private Attributes
const PedeLabelerBase &	myLabels
std::ifstream	myPedeResult
const RunRange	myRunRange
const PedeSteerer &	mySteerer

Static Private Attributes
static const unsigned int	myMaxNumValPerParam = 5

Detailed Description

read in result from pede text file

Author

: Gero Flucke date : November 2006

Revision

1.4

Date

2011/02/16 13:11:57

(last update by

Author

mussgill

)

Definition at line 33 of file PedeReader.h.

Member Typedef Documentation

RunNumber

typedef PedeLabelerBase::RunNumber PedeReader::RunNumber

Definition at line 35 of file PedeReader.h.

RunRange

typedef PedeLabelerBase::RunRange PedeReader::RunRange

Definition at line 36 of file PedeReader.h.

Constructor & Destructor Documentation

PedeReader()

PedeReader::PedeReader	(	const edm::ParameterSet &	config,
		const PedeSteerer &	steerer,
		const PedeLabelerBase &	labels,
		const RunRange &	runrange
	)

Definition at line 35 of file PedeReader.cc.

    : mySteerer(steerer), myLabels(labels), myRunRange(runrange) {
  std::string pedeResultFile(config.getUntrackedParameter<std::string>("fileDir"));
  if (pedeResultFile.empty())
    pedeResultFile = steerer.directory();  // includes final '/'
  else if (pedeResultFile.find_last_of('/') != pedeResultFile.size() - 1) {
    pedeResultFile += '/';  // directory may need '/'
  }
 
  pedeResultFile += config.getParameter<std::string>("readFile");
  myPedeResult.open(pedeResultFile.c_str(), std::ios::in);
  if (!myPedeResult.is_open()) {
    edm::LogError("Alignment") << "@SUB=PedeReader"
                               << "Problem opening pede output file " << pedeResultFile;
  }
}

References PedeSteerer::directory(), recoMuon::in, myPedeResult, and AlCaHLTBitMon_QueryRunRegistry::string.

~PedeReader()

PedeReader::~PedeReader ( )

inline

non virtual destructor: do not inherit from this class

Definition at line 43 of file PedeReader.h.

{}

Member Function Documentation

checkAliParams()

AlignmentParameters * PedeReader::checkAliParams	(	Alignable *	alignable,
		bool	createUserVars
	)		const

returns parameters of alignable (creates if not yet existing, but MillePedeVariables are only created if createUserVars == true)

Definition at line 271 of file PedeReader.cc.

                                                                                               {
  // first check that we have parameters
  AlignmentParameters *params = alignable->alignmentParameters();
  if (!params) {
    throw cms::Exception("BadConfig") << "PedeReader::checkAliParams: "
                                      << "Alignable without parameters.";
  }
 
  // now check that we have user parameters of correct type if requested:
  if (createUserVars && !dynamic_cast<MillePedeVariables *>(params->userVariables())) {
    edm::LogInfo("Alignment") << "@SUB=PedeReader::checkAliParams"
                              << "Add user variables for alignable with label " << myLabels.alignableLabel(alignable);
    params->setUserVariables(new MillePedeVariables(
        params->size(),
        myLabels.alignableLabel(alignable),
        myLabels.alignableTracker()->objectIdProvider().typeToName(alignable->alignableObjectId())));
  }
 
  return params;
}

References PedeLabelerBase::alignableLabel(), Alignable::alignableObjectId(), PedeLabelerBase::alignableTracker(), Alignable::alignmentParameters(), Exception, myLabels, AlignableTracker::objectIdProvider(), CalibrationSummaryClient_cfi::params, and AlignableObjectId::typeToName().

Referenced by setParameter().

read()

bool PedeReader::read	(	align::Alignables &	alignables,
		bool	setUserVars
	)

Read pede output into AlignmentParameters attached to 'alignables' (if they fit to the run range). If (setUserVars == true) also care about MillePedeVariables. Also treats parameters belonging to a IntegratedCalibrationBase.

Definition at line 56 of file PedeReader.cc.

                                                                   {
  alignables.clear();
  myPedeResult.seekg(0, std::ios::beg);  // back to start
  bool isAllOk = true;
 
  std::set<Alignable *> uniqueList;
 
  edm::LogInfo("Alignment") << "@SUB=PedeReader::read"
                            << "will read parameters for run range " << myRunRange.first << " - " << myRunRange.second;
 
  // loop on lines of text file
  unsigned int nParam = 0, nParamCalib = 0, nParamUnknown = 0;
  while (myPedeResult.good() && !myPedeResult.eof()) {
    // read label
    unsigned int paramLabel = 0;
    if (!this->readIfSameLine<unsigned int>(myPedeResult, paramLabel))
      continue;  // empty line?
 
    // read up to maximal number of pede result per parameter
    float buffer[myMaxNumValPerParam] = {0.};
    unsigned int bufferPos = 0;
    for (; bufferPos < myMaxNumValPerParam; ++bufferPos) {
      if (!this->readIfSameLine<float>(myPedeResult, buffer[bufferPos]))
        break;
    }
 
    // First check whether parameter is from any calibration (to be done before RunRange check:
    // run dependence for them is not handled here, but probably inside the calibration).
    // Double setting by calling read(..) twice for different RunRanges shouldn't harm.
    std::pair<IntegratedCalibrationBase *, unsigned int> calibParam = myLabels.calibrationParamFromLabel(paramLabel);
    if (calibParam.first) {  // label belongs to a calibration
      if (this->setCalibrationParameter(calibParam.first, calibParam.second, bufferPos, buffer)) {
        ++nParamCalib;
      } else {
        edm::LogError("Alignment") << "@SUB=PedeReader::read"
                                   << "Problems setting results of "
                                   << "parameter " << calibParam.second << " to calibration '"
                                   << calibParam.first->name() << "' (" << calibParam.first << ").";
        isAllOk = false;
      }
      continue;  // does not belong to any Alignable, so go to next line of file
    }
    // Now treat Alignables if paramLabel fits to run range, otherwise skip line:
    const RunRange &runRange = myLabels.runRangeFromLabel(paramLabel);
    if (!(runRange.first <= myRunRange.first && myRunRange.second <= runRange.second))
      continue;
 
    Alignable *alignable = this->setParameter(paramLabel, bufferPos, buffer, setUserVars);
    if (!alignable) {
      // OK, e.g. for PedeReaderInputs: calibration parameters, but not yet known to labeler
      ++nParamUnknown;
      continue;
    }
    uniqueList.insert(alignable);
    ++nParam;
  }
 
  // add Alignables to output
  alignables.insert(alignables.end(), uniqueList.begin(), uniqueList.end());
 
  std::stringstream out;  // "@SUB=PedeReader::read" cannot yet go to 'out' for proper format
  out << nParam << " parameters for " << alignables.size() << " alignables and " << nParamCalib << " for calibrations, "
      << nParamUnknown << " parameters are unknown.\n";
  if (nParamUnknown) {
    edm::LogWarning("Alignment") << "@SUB=PedeReader::read" << out.str();
  } else {
    edm::LogInfo("Alignment") << "@SUB=PedeReader::read" << out.str();
  }
 
  return isAllOk && (nParam + nParamCalib);  // nParam+nParamCalib == 0: empty or bad file
}

References edmScanValgrind::buffer, PedeLabelerBase::calibrationParamFromLabel(), myLabels, myMaxNumValPerParam, myPedeResult, myRunRange, pfTracksFromL1Tracks_cfi::nParam, MillePedeFileConverter_cfg::out, volumeBasedMagneticField_160812_cfi::paramLabel, PedeLabelerBase::runRangeFromLabel(), setCalibrationParameter(), and setParameter().

Referenced by edmIntegrityCheck.PublishToFileSystem::get().

readIfSameLine()

template<class T >

bool PedeReader::readIfSameLine	(	std::ifstream &	aStream,
		T &	outValue
	)		const

true if 'outValue' could be read via operator >> from the current line (!) of aStream, false otherwise

Definition at line 130 of file PedeReader.cc.

                                                                       {
  while (true) {
    const int aChar = aStream.get();
    if (!aStream.good())
      return false;
 
    switch (aChar) {
      case ' ':
      case '\t':
        continue;  // to next character
      case '\n':
        return false;  // end of line
      default:
        aStream.unget();
        aStream >> outValue;
        if (aStream.fail()) {  // not correct type 'T' (!aStream.good() is true also in case of EOF)
          aStream.clear();
          while (aStream.good() && aStream.get() != '\n')
            ;  // forward to end of line
          return false;
        } else {
          return true;
        }
    }  // switch
  }    // while
 
  edm::LogError("Alignment") << "@SUB=PedeReader::readIfSameLine"
                             << "Should never come here!";
  return false;
}

setCalibrationParameter()

bool PedeReader::setCalibrationParameter	(	IntegratedCalibrationBase *	calib,
		unsigned int	paramNum,
		unsigned int	bufLength,
		const float *	buf
	)		const

Set pede results stored in 'buf' to parameter 'paramNum' of IntegratedCalibrationBase.

Definition at line 239 of file PedeReader.cc.

                                                                 {
  if (!calib || !buf)
    return false;
 
  // FIXME: Should we attach MillePedeVariables to IntegratedCalibrationBase to store
  //        'other' results beyond value and error?
  switch (bufLength) {
    case 5:  // buf[4]: global correlation - not treated yet FIXME // no break;
    case 4:  // uncertainty
      calib->setParameterError(paramNum, buf[3]);
      [[fallthrough]];
    case 3:  // buf[2]: difference to start value - not treated yet
    case 2:
      if (bufLength == 2 && buf[1] >= 0.) {  // buf[1]: pre-sigma, < 0 means fixed
        edm::LogWarning("Alignment") << "@SUB=PedeReader::setCalibrationParameter"
                                     << "Param " << paramNum << " of calibration '" << calib->name()
                                     << "' without result!";
      }
      return calib->setParameter(paramNum, buf[0] * mySteerer.parameterSign());
    case 0:
    case 1:
    default:
      edm::LogError("Alignment") << "@SUB=PedeReader::setCalibrationParameter"
                                 << "Expect 2 to 5 values, got " << bufLength << ".";
      return false;
  }
}

References visDQMUpload::buf, mySteerer, and PedeSteerer::parameterSign().

Referenced by read().

setParameter()

Alignable * PedeReader::setParameter	(	unsigned int	paramLabel,
		unsigned int	bufLength,
		const float *	buf,
		bool	setUserVars
	)		const

Set pede results stored in 'buf' to AlignmentParameters and (if setUserVars == true) to MillePedeVariables, return corresponding Alignable.

Definition at line 162 of file PedeReader.cc.

                                                            {
  Alignable *alignable = myLabels.alignableFromLabel(paramLabel);
  const unsigned int paramNum = myLabels.paramNumFromLabel(paramLabel);
  const double cmsToPede = mySteerer.cmsToPedeFactor(paramNum);
  if (alignable) {
    AlignmentParameters *params = this->checkAliParams(alignable, setUserVars);
    MillePedeVariables *userParams =  // static cast ensured by previous checkAliParams
        (setUserVars ? static_cast<MillePedeVariables *>(params->userVariables()) : nullptr);
    // if (userParams && userParams->label() != myLabels.alignableLabelFromLabel(paramLabel)) {
    if (userParams && userParams->label() != myLabels.alignableLabel(alignable)) {
      edm::LogError("Alignment") << "@SUB=PedeReader::setParameter"
                                 << "Label mismatch: paramLabel " << paramLabel << " for alignableLabel "
                                 << userParams->label();
    }
 
    AlgebraicVector parVec(params->parameters());
    AlgebraicSymMatrix covMat(params->covariance());
 
    if (userParams)
      userParams->setAllDefault(paramNum);
 
    switch (bufLength) {
      case 5:  // global correlation
        if (userParams)
          userParams->globalCor()[paramNum] = buf[4];
        [[fallthrough]];
      case 4:  // uncertainty
        if (userParams)
          userParams->sigma()[paramNum] = buf[3] / cmsToPede;
        covMat[paramNum][paramNum] = buf[3] * buf[3] / (cmsToPede * cmsToPede);
        [[fallthrough]];
      case 3:  // difference to start value
        if (userParams)
          userParams->diffBefore()[paramNum] = buf[2] / cmsToPede;
        [[fallthrough]];
      case 2:
        params->setValid(true);
        parVec[paramNum] = buf[0] / cmsToPede * mySteerer.parameterSign();  // parameter
        if (userParams) {
          userParams->parameter()[paramNum] = parVec[paramNum];  // duplicate in millepede parameters
          userParams->preSigma()[paramNum] = buf[1];             // presigma given, probably means fixed
          if (!userParams->isFixed(paramNum)) {
            userParams->preSigma()[paramNum] /= cmsToPede;
            if (bufLength == 2) {
              edm::LogWarning("Alignment")
                  << "@SUB=PedeReader::setParameter"
                  << "Param " << paramLabel << " (from " << typeid(*alignable).name() << ") without result!";
              userParams->isValid()[paramNum] = false;
              params->setValid(false);
            }
          }
        }
        break;
      case 0:
      case 1:
      default:
        edm::LogError("Alignment") << "@SUB=PedeReader::setParameter"
                                   << "Expect 2 to 5 values, got " << bufLength << " for label " << paramLabel;
        break;
    }
    alignable->setAlignmentParameters(params->clone(parVec, covMat));  //transferred mem. responsib.
  } else {
    unsigned int lasBeamId = myLabels.lasBeamIdFromLabel(paramLabel);
    edm::LogError("Alignment") << "@SUB=PedeReader::setParameter"
                               << "No alignable for paramLabel " << paramLabel << ", probably LasBeam with Id "
                               << lasBeamId << ",\nparam " << paramNum << ": "
                               << buf[0] / cmsToPede * mySteerer.parameterSign()
                               << " += " << (bufLength >= 4 ? buf[3] / cmsToPede : -99.);
  }
 
  return alignable;
}

References PedeLabelerBase::alignableFromLabel(), PedeLabelerBase::alignableLabel(), visDQMUpload::buf, checkAliParams(), PedeSteerer::cmsToPedeFactor(), MillePedeVariables::diffBefore(), MillePedeVariables::globalCor(), MillePedeVariables::isFixed(), MillePedeVariables::isValid(), MillePedeVariables::label(), PedeLabelerBase::lasBeamIdFromLabel(), myLabels, mySteerer, MillePedeVariables::parameter(), PedeSteerer::parameterSign(), volumeBasedMagneticField_160812_cfi::paramLabel, PedeLabelerBase::paramNumFromLabel(), CalibrationSummaryClient_cfi::params, MillePedeVariables::preSigma(), Alignable::setAlignmentParameters(), MillePedeVariables::setAllDefault(), and MillePedeVariables::sigma().

Referenced by coreTools.RunOnData::__call__(), trackTools.MakeAODTrackCandidates::__call__(), runJetUncertainties.RunJetUncertainties::__call__(), metTools.AddMETCollection::__call__(), cmsswVersionTools.PickRelValInputFiles::__call__(), coreTools.RemoveMCMatching::__call__(), trackTools.MakePATTrackCandidates::__call__(), trigTools.SwitchOnTrigger::__call__(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties::__call__(), trigTools.SwitchOnTriggerStandAlone::__call__(), tauTools.AddTauCollection::__call__(), trackTools.MakeTrackCandidates::__call__(), trigTools.SwitchOnTriggerMatching::__call__(), trigTools.SwitchOnTriggerMatchingStandAlone::__call__(), trigTools.SwitchOnTriggerMatchEmbedding::__call__(), jetTools.AddJetCollection::__call__(), jetTools.SwitchJetCollection::__call__(), jetTools.UpdateJetCollection::__call__(), jetTools.AddJetID::__call__(), jetTools.SetTagInfos::__call__(), runMETCorrectionsAndUncertainties.RunMETCorrectionsAndUncertainties::jetConfiguration(), and read().

Member Data Documentation

myLabels

const PedeLabelerBase& PedeReader::myLabels

private

Definition at line 71 of file PedeReader.h.

Referenced by checkAliParams(), read(), and setParameter().

myMaxNumValPerParam

const unsigned int PedeReader::myMaxNumValPerParam = 5

staticprivate

Definition at line 74 of file PedeReader.h.

Referenced by read().

myPedeResult

std::ifstream PedeReader::myPedeResult

private

Definition at line 69 of file PedeReader.h.

Referenced by PedeReader(), and read().

myRunRange

const RunRange PedeReader::myRunRange

private

Definition at line 72 of file PedeReader.h.

Referenced by read().

mySteerer

const PedeSteerer& PedeReader::mySteerer

private

Definition at line 70 of file PedeReader.h.

Referenced by setCalibrationParameter(), and setParameter().