---

PedeReader Class Reference

read in result from pede text file More...

#include <Alignment/MillePedeAlignmentAlgorithm/src/PedeReader.h>

List of all members.

Public Member Functions
AlignmentParameters *	checkAliParams (Alignable *alignable, bool createUserVars) const
	returns parameters of alignable (creates if not yet existing, but MillePedeVariables are only created if createUserVars == true)
	PedeReader (const edm::ParameterSet &config, const PedeSteerer &steerer, const PedeLabeler &labels)
bool	read (std::vector< Alignable * > &alignables, bool setUserVars)
	Read pede output into AlignmentParameters attached to 'alignables', if (setUserVars == true) also care about MillePedeVariables.
template<class T>
bool	readIfSameLine (std::ifstream &aStream, T &outValue) const
	true if 'outValue' could be read via operator >> from the current line (!) of aStream, false otherwise
Alignable *	setParameter (unsigned int paramLabel, unsigned int bufLength, float *buf, bool setUserVars) const
	Set pede results stored in 'buf' to AlignmentParameters and (if setUserVars == true) to MillePedeVariables, return corresponding Alignable.
	~PedeReader ()
	non virtual destructor: do not inherit from this class
Private Attributes
const PedeLabeler &	myLabels
std::ifstream	myPedeResult
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.3

Date

2007/12/17 18:59:52

(last update by

Author

flucke

)

Definition at line 30 of file PedeReader.h.

---

Constructor & Destructor Documentation

PedeReader::PedeReader	(	const edm::ParameterSet &	config,
		const PedeSteerer &	steerer,
		const PedeLabeler &	labels
	)

Definition at line 32 of file PedeReader.cc.

References PedeSteerer::directory(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), in, and myPedeResult.

  : mySteerer(steerer), myLabels(labels)
{
  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;
  }
}

PedeReader::~PedeReader

(

)

[inline]

non virtual destructor: do not inherit from this class

Definition at line 36 of file PedeReader.h.

{}

---

Member Function Documentation

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 185 of file PedeReader.cc.

References PedeLabeler::alignableLabel(), Alignable::alignmentParameters(), myLabels, params, Alignable::setAlignmentParameters(), AlignmentParameters::setUserVariables(), AlignmentParameters::size(), and AlignmentParameters::userVariables().

Referenced by setParameter().

{
  // first check that we have parameters
  AlignmentParameters *params = alignable->alignmentParameters();
  if (!params) {
    // How to check in future what kind of parameters are needed?
    params = new RigidBodyAlignmentParameters(alignable, false);

    edm::LogInfo("Alignment") << "@SUB=PedeReader::checkAliParams"
                              << "Build RigidBodyAlignmentParameters for alignable with label "
                              << myLabels.alignableLabel(alignable);
    alignable->setAlignmentParameters(params); // transferred memory responsibility
  }
  
  // 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()));
  }
  
  return params;
}

bool PedeReader::read	(	std::vector< Alignable * > &	alignables,
		bool	setUserVars
	)

Read pede output into AlignmentParameters attached to 'alignables', if (setUserVars == true) also care about MillePedeVariables.

Definition at line 51 of file PedeReader.cc.

References myMaxNumValPerParam, myPedeResult, setParameter(), and Alignable::size().

Referenced by MillePedeAlignmentAlgorithm::readFromPede().

{
  alignables.clear();
  myPedeResult.seekg(0, std::ios::beg); // back to start
  bool isAllOk = true;

  std::map<Alignable*,Alignable*> uniqueList; // Probably should use a std::set here...
  
  // loop on lines of text file
  unsigned int nParam = 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;
    }

    Alignable *alignable = this->setParameter(paramLabel, bufferPos, buffer, setUserVars);
    if (!alignable) {
      isAllOk = false;  // or error?
      continue;
    }
    uniqueList[alignable] = alignable;
    ++nParam;
  }

  // add Alignables to output
  for ( std::map<Alignable*,Alignable*>::const_iterator iAli = uniqueList.begin();
        iAli != uniqueList.end(); ++iAli) {
    alignables.push_back((*iAli).first);
  }

  edm::LogInfo("Alignment") << "@SUB=PedeReader::read" << nParam << " parameters for "
                            << alignables.size() << " alignables";

  return isAllOk && nParam; // nParam == 0: empty or bad file
}

template<class T>

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

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

Definition at line 97 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;
}

Alignable * PedeReader::setParameter	(	unsigned int	paramLabel,
		unsigned int	bufLength,
		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 128 of file PedeReader.cc.

References PedeLabeler::alignableFromLabel(), PedeLabeler::alignableLabelFromLabel(), checkAliParams(), AlignmentParameters::clone(), PedeSteerer::cmsToPedeFactor(), AlignmentParameters::covariance(), MillePedeVariables::diffBefore(), MillePedeVariables::globalCor(), MillePedeVariables::isFixed(), MillePedeVariables::isValid(), myLabels, mySteerer, MillePedeVariables::parameter(), AlignmentParameters::parameters(), PedeSteerer::parameterSign(), PedeLabeler::paramNumFromLabel(), params, MillePedeVariables::preSigma(), Alignable::setAlignmentParameters(), MillePedeVariables::setAllDefault(), MillePedeVariables::setLabel(), MillePedeVariables::sigma(), and AlignmentParameters::userVariables().

Referenced by read().

{
  Alignable *alignable = myLabels.alignableFromLabel(paramLabel);
  if (alignable) {
    AlignmentParameters *params = this->checkAliParams(alignable, setUserVars);
    MillePedeVariables *userParams = // static cast ensured by previous checkAliParams
      (setUserVars ? static_cast<MillePedeVariables*>(params->userVariables()) : 0);
    if (userParams) userParams->setLabel(myLabels.alignableLabelFromLabel(paramLabel));

    AlgebraicVector parVec(params->parameters());
    AlgebraicSymMatrix covMat(params->covariance());
    const unsigned int paramNum = myLabels.paramNumFromLabel(paramLabel);

    if (userParams) userParams->setAllDefault(paramNum);
    const double cmsToPede = mySteerer.cmsToPedeFactor(paramNum);

    switch (bufLength) {
    case 5: // global correlation
      if (userParams) userParams->globalCor()[paramNum] = buf[4]; // no break
    case 4: // uncertainty
      if (userParams) userParams->sigma()[paramNum] = buf[3] / cmsToPede;
      covMat[paramNum][paramNum] = buf[3]*buf[3] / (cmsToPede*cmsToPede);
      // no break;
    case 3: // difference to start value
      if (userParams) userParams->diffBefore()[paramNum] = buf[2] / cmsToPede;
      // no break
    case 2: 
      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::LogError("Alignment") << "@SUB=PedeReader::setParameter"
                                       << "Param " << paramLabel << " (from "
                                       << typeid(*alignable).name() << ") without result!";
            userParams->isValid()[paramNum] = 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.
  }
  return alignable;
}

---

Member Data Documentation

const PedeLabeler& PedeReader::myLabels [private]

Definition at line 56 of file PedeReader.h.

Referenced by checkAliParams(), and setParameter().

const unsigned int PedeReader::myMaxNumValPerParam = 5 [static, private]

Definition at line 58 of file PedeReader.h.

Referenced by read().

std::ifstream PedeReader::myPedeResult [private]

Definition at line 54 of file PedeReader.h.

Referenced by PedeReader(), and read().

const PedeSteerer& PedeReader::mySteerer [private]

Definition at line 55 of file PedeReader.h.

Referenced by setParameter().

---

The documentation for this class was generated from the following files:

• Alignment/MillePedeAlignmentAlgorithm/src/PedeReader.h
• Alignment/MillePedeAlignmentAlgorithm/src/PedeReader.cc

---