---

PedeSteerer Class Reference

provides steering for pede according to configuration More...

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

List of all members.

Public Member Functions
std::string	buildMasterSteer (const std::vector< std::string > &binaryFiles)
	construct (and return name of) master steering file from config, binaryFiles etc.
void	buildSubSteer (AlignableTracker *aliTracker, AlignableMuon *aliMuon)
	construct steering files about hierarchy, fixing etc. an keep track of their names
double	cmsToPedeFactor (unsigned int parNum) const
void	correctToReferenceSystem ()
	If reference alignables have been configured, shift everything such that mean position and orientation of dets in these alignables are zero.
const std::string &	directory () const
	directory from constructor input, '/' is attached if needed
bool	isNoHiera (const Alignable *ali) const
	True if 'ali' was deselected from hierarchy and any ancestor (e.g. mother) has parameters.
int	parameterSign () const
	results from pede (and start values for pede) might need a sign flip
	PedeSteerer (AlignableTracker *aliTracker, AlignableMuon *aliMuon, AlignmentParameterStore *store, const PedeLabeler *labels, const edm::ParameterSet &config, const std::string &defaultDir, bool noSteerFiles)
	constructor from AlignableTracker/AlignableMuon, their AlignmentParameterStore and the labeler (NOTE: The latter two must live longer than the constructed PedeSteerer!)
bool	runPede (const std::string &masterSteer) const
	run pede, masterSteer should be as returned from buildMasterSteer(...)
	~PedeSteerer ()
	non-virtual destructor: do not inherit from this class
Private Types
typedef std::map< const Alignable *, std::vector < float > >	AlignablePresigmasMap
Private Member Functions
unsigned int	buildNoHierarchyCollection (const std::vector< Alignable * > &alis)
	Store Alignables that have SelectionUserVariables attached to their AlignmentParameters (these must exist) that indicate removal from hierarchy, i.e.
bool	checkParameterChoices (const std::vector< Alignable * > &alis) const
	Checks whether SelectionUserVariables that might be attached to alis' AlignmentParameters (these must exist) are all known.
std::ofstream *	createSteerFile (const std::string &name, bool addToList)
	create and open file with name, if (addToList) append to mySteeringFiles
void	defineCoordinates (const std::vector< Alignable * > &alis, Alignable *aliMaster, const std::string &fileName)
	Create steering file with constraints defining coordinate system via hierarchy constraints between 'aliMaster' and 'alis'; 'aliMaster' must not have parameters: would not make sense!
std::string	fileName (const std::string &addendum) const
	full name with directory and 'idenitfier'
int	fixParameter (Alignable *ali, unsigned int iParam, char selector, std::ofstream *&filePtr, const std::string &fileName)
	If 'selector' means fixing, create corresponding steering file line in file pointed to by 'filePtr'.
std::pair< unsigned int, unsigned int >	fixParameters (const std::vector< Alignable * > &alignables, const std::string &file)
	Checks whether 'alignables' have SelectionUserVariables attached to their AlignmentParameters (these must exist) that indicate fixation of a parameter, a steering 'file' is created accordingly.
void	hierarchyConstraint (const Alignable *ali, const std::vector< Alignable * > &components, std::ofstream &file) const
unsigned int	hierarchyConstraints (const std::vector< Alignable * > &alis, const std::string &file)
unsigned int	presigmas (const std::vector< edm::ParameterSet > &cffPresi, const std::string &fileName, const std::vector< Alignable * > &alis, AlignableTracker *aliTracker, AlignableMuon *aliMuon)
	interprete content of presigma VPSet 'cffPresi' and call presigmasFile
unsigned int	presigmasFile (const std::string &fileName, const std::vector< Alignable * > &alis, const AlignablePresigmasMap &aliPresisMap)
	look for active 'alis' in map of presigma values and create steering file
std::vector< Alignable * >	selectCoordinateAlis (const std::vector< Alignable * > &alignables) const
	Return 'alignables' that have SelectionUserVariables attached to their AlignmentParameters (these must exist) that indicate a definition of a coordinate system.
Private Attributes
edm::ParameterSet	myConfig
	pointer to labeler (not the owner)
std::string	myDirectory
const PedeLabeler *	myLabels
	not the owner!
std::set< const Alignable * >	myNoHieraCollection
	keeps track of created 'secondary' steering files
bool	myNoSteerFiles
	directory of all files
int	myParameterSign
	flag to write steering files to /dev/null
const AlignmentParameterStore *	myParameterStore
std::vector< std::string >	mySteeringFiles
	old pede versions (before May '07) need a sign flip...
std::vector< Alignable * >	theCoordDefiners
	master coordinates, must (?) be global frame
Alignable *	theCoordMaster
	Alignables deselected for hierarchy constr.

---

Detailed Description

provides steering for pede according to configuration

Author:

: Gero Flucke date : October 2006

Date

2008/02/15 14:42:27

Revision

1.15

(last update by

Author

flucke

)

Definition at line 33 of file PedeSteerer.h.

---

Member Typedef Documentation

typedef std::map<const Alignable*,std::vector<float> > PedeSteerer::AlignablePresigmasMap [private]

Definition at line 64 of file PedeSteerer.h.

---

Constructor & Destructor Documentation

PedeSteerer::PedeSteerer	(	AlignableTracker *	aliTracker,
		AlignableMuon *	aliMuon,
		AlignmentParameterStore *	store,
		const PedeLabeler *	labels,
		const edm::ParameterSet &	config,
		const std::string &	defaultDir,
		bool	noSteerFiles
	)

constructor from AlignableTracker/AlignableMuon, their AlignmentParameterStore and the labeler (NOTE: The latter two must live longer than the constructed PedeSteerer!)

Definition at line 47 of file PedeSteerer.cc.

References AlignmentParameterStore::alignables(), correctToReferenceSystem(), Exception, myDirectory, myParameterSign, myParameterStore, selectCoordinateAlis(), theCoordDefiners, and theCoordMaster.

                                            :
  myParameterStore(store), myLabels(labels), myConfig(config),
  myDirectory(myConfig.getUntrackedParameter<std::string>("fileDir")),
  myNoSteerFiles(noSteerFiles),
  myParameterSign(myConfig.getUntrackedParameter<int>("parameterSign")),
  theCoordMaster(0)
{
  if (myParameterSign != 1 && myParameterSign != -1) {
    cms::Exception("BadConfig") << "Expect PedeSteerer.parameterSign = +/-1, "
                                << "found " << myParameterSign << ".";
  }

  // Correct directory, needed before asking for fileName(..):
  if (myDirectory.empty()) myDirectory = defaultDir;
  if (!myDirectory.empty() && myDirectory.find_last_of('/') != myDirectory.size() - 1) {
    myDirectory += '/'; // directory may need '/'
  }

  const std::vector<Alignable*> &alis = myParameterStore->alignables();
  if (!this->checkParameterChoices(alis)) {} // anyway thrown exception

  // Coordinate system selection and correction before everything
  theCoordDefiners = this->selectCoordinateAlis(alis);
  if (!theCoordDefiners.empty()) { // Create steering with constraints to define coordinate system:
    theCoordMaster = aliTracker; // Both tracker and muon have global coordinates, though...
    if (!theCoordMaster) theCoordMaster = aliMuon; // ...which coordinates should not really matter anyway.
    // FIXME: With both tracker and muon, only tracker will be shifted in correctToReferenceSystem!
    // Could be fixed by introducing AlignableComposite with both, but must prevent double deletion.
    // If this has 'global frame', correctToReferenceSystem can use globalParameters (as it does)
    this->correctToReferenceSystem(); // really before 'defineCoordinates'?
  } 

}

PedeSteerer::~PedeSteerer

(

)

non-virtual destructor: do not inherit from this class

Definition at line 85 of file PedeSteerer.cc.

{
}

---

Member Function Documentation

std::string PedeSteerer::buildMasterSteer

(

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

binaryFiles

)

construct (and return name of) master steering file from config, binaryFiles etc.

Definition at line 632 of file PedeSteerer.cc.

References createSteerFile(), edm::ParameterSet::getParameter(), i, myConfig, and mySteeringFiles.

Referenced by MillePedeAlignmentAlgorithm::terminate().

{
  const std::string nameMasterSteer(this->fileName("Master"));
  std::ofstream *mainSteerPtr = this->createSteerFile(nameMasterSteer, false);
  if (!mainSteerPtr) return "";

  // add steering files to master steering file
  std::ofstream &mainSteerRef = *mainSteerPtr;
  for (unsigned int iFile = 0; iFile < mySteeringFiles.size(); ++iFile) {
    mainSteerRef << mySteeringFiles[iFile] << "\n";
  }

  // add binary files to master steering file
  mainSteerRef << "\nCfiles\n";
  for (unsigned int iFile = 0; iFile < binaryFiles.size(); ++iFile) {
    mainSteerRef << binaryFiles[iFile] << "\n";
  }

  // add method
  mainSteerRef << "\nmethod  " << myConfig.getParameter<std::string>("method") << "\n";

  // add further options
  const std::vector<std::string> opt(myConfig.getParameter<std::vector<std::string> >("options"));
  mainSteerRef << "\n* Outlier treatment and other options \n";
  for (unsigned int i = 0; i < opt.size(); ++i) {
    mainSteerRef << opt[i] << "\n";
  }

  delete mainSteerPtr;  // close (and flush) again

  return nameMasterSteer;
}

unsigned int PedeSteerer::buildNoHierarchyCollection

(

const std::vector< Alignable * > &

alis

)

[private]

Store Alignables that have SelectionUserVariables attached to their AlignmentParameters (these must exist) that indicate removal from hierarchy, i.e.

make it 'top level'.

Definition at line 117 of file PedeSteerer.cc.

References Alignable::alignmentParameters(), Exception, SelectionUserVariables::fullSelection(), Alignable::mother(), myNoHieraCollection, params, AlignmentParameters::size(), and AlignmentParameters::userVariables().

{
  myNoHieraCollection.clear();  // just in case of re-use...

  for (std::vector<Alignable*>::const_iterator iAli = alis.begin() ; iAli != alis.end(); ++iAli) {
    AlignmentParameters *params = (*iAli)->alignmentParameters();
    SelectionUserVariables *selVar = dynamic_cast<SelectionUserVariables*>(params->userVariables());
    if (!selVar) continue;
    // Now check whether taking out of hierarchy is selected - must be consistent!
    unsigned int numNoHieraPar = 0;
    unsigned int numHieraPar = 0;
    for (unsigned int iParam = 0; static_cast<int>(iParam) < params->size(); ++iParam) {
      const char selector = selVar->fullSelection()[iParam];
      if (selector == 'C' || selector == 'F' || selector == 'H') {
        ++numNoHieraPar;
      } else if (selector == 'c' || selector == 'f' || selector == '1' || selector == 'r') {
        ++numHieraPar;
      } // else ... accept '0' as undetermined
    }
    if (numNoHieraPar) { // Selected to be taken out.
      if (numHieraPar) { // Inconsistent: Some parameters still in hierarchy ==> exception!
        throw cms::Exception("BadConfig") 
          << "[PedeSteerer::buildNoHierarchyCollection] All active parameters of alignables to be "
          << " taken out of the hierarchy must be marked with capital letters 'C', 'F' or 'H'!";
      }
      bool isInHiera = false; // Check whether Alignable is really part of hierarchy:
      Alignable *mother = *iAli;
      while ((mother = mother->mother())) {
        if (mother->alignmentParameters()) isInHiera = true; // could 'break;', but loop is short
      }
      // Complain, but keep collection short if not in hierarchy:
      if (isInHiera) myNoHieraCollection.insert(*iAli);
      else edm::LogWarning("Alignment") << "@SUB=PedeSteerer::buildNoHierarchyCollection"
                                        << "Alignable not in hierarchy, no need to remove it!";
    }
  } // end loop on alignables

  return myNoHieraCollection.size();
}

void PedeSteerer::buildSubSteer	(	AlignableTracker *	aliTracker,
		AlignableMuon *	aliMuon
	)

construct steering files about hierarchy, fixing etc. an keep track of their names

Definition at line 584 of file PedeSteerer.cc.

References AlignmentParameterStore::alignables(), defineCoordinates(), edm::ParameterSet::getParameter(), hierarchyConstraints(), myConfig, myNoHieraCollection, myParameterStore, presigmas(), theCoordDefiners, and theCoordMaster.

Referenced by MillePedeAlignmentAlgorithm::initialize().

{
  const std::vector<Alignable*> &alis = myParameterStore->alignables();

  if (theCoordMaster && !theCoordDefiners.empty()) {
    const std::string nameCoordFile(this->fileName("Coord"));
    this->defineCoordinates(theCoordDefiners, theCoordMaster, nameCoordFile);
    edm::LogInfo("Alignment") << "@SUB=PedeSteerer::buildSubSteer" 
                              << theCoordDefiners.size() << " highest level objects define the "
                              << "coordinate system, steering file " << nameCoordFile << ".";
  }

  const std::string nameFixFile(this->fileName("FixPara"));
  const std::pair<unsigned int, unsigned int> nFixFixCor(this->fixParameters(alis, nameFixFile));
  if (nFixFixCor.first != 0 || nFixFixCor.second != 0) {
    edm::LogInfo("Alignment") << "@SUB=PedeSteerer::buildSubSteer" 
                              << nFixFixCor.first << " parameters fixed at 0. and "
                              << nFixFixCor.second << " at 'original' position, "
                              << "steering file " << nameFixFile << ".";
  } 

  if (this->buildNoHierarchyCollection(alis)) { // before hierarchyConstraints(..)
    edm::LogInfo("Alignment") << "@SUB=PedeSteerer::buildSubSteer"
                              << myNoHieraCollection.size()<<" alignables taken out of hierarchy.";
  }

  const std::string nameHierarchyFile(this->fileName("Hierarchy"));
  unsigned int nConstraint = this->hierarchyConstraints(alis, nameHierarchyFile);
  if (nConstraint) {
    edm::LogInfo("Alignment") << "@SUB=PedeSteerer::buildSubSteer" 
                              << "Hierarchy constraints for " << nConstraint << " alignables, "
                              << "steering file " << nameHierarchyFile << ".";
  }

  const std::string namePresigmaFile(this->fileName("Presigma"));
  unsigned int nPresigma = 
    this->presigmas(myConfig.getParameter<std::vector<edm::ParameterSet> >("Presigmas"),
                    namePresigmaFile, alis, aliTracker, aliMuon);
  if (nPresigma) {
    edm::LogInfo("Alignment") << "@SUB=PedeSteerer::buildSubSteer" 
                              << "Presigma values set for " << nPresigma << " parameters, "
                              << "steering file " << namePresigmaFile << ".";
  }

  // Delete all SelectionUserVariables now? They will anyway be overwritten by MillePedeVariables...
}

bool PedeSteerer::checkParameterChoices

(

const std::vector< Alignable * > &

alis

)

const [private]

Checks whether SelectionUserVariables that might be attached to alis' AlignmentParameters (these must exist) are all known.

Definition at line 158 of file PedeSteerer.cc.

References Exception, SelectionUserVariables::fullSelection(), EgammaValidation_Zee_cff::sel, AlignmentParameters::size(), and AlignmentParameters::userVariables().

{
  for (std::vector<Alignable*>::const_iterator iAli = alis.begin() ; iAli != alis.end(); ++iAli) {
    AlignmentParameters *paras = (*iAli)->alignmentParameters();
    SelectionUserVariables *selVar = dynamic_cast<SelectionUserVariables*>(paras->userVariables());
    if (!selVar) continue;
    for (unsigned int iParam = 0; static_cast<int>(iParam) < paras->size(); ++iParam) {
      const char sel = selVar->fullSelection()[iParam];
      if (sel != 'f' && sel != 'F' && sel != 'c' && sel != 'C' &&
          sel != '0' && sel != '1' && sel != 'H' && sel != 'r') {
        throw cms::Exception("BadConfig")
          << "[PedeSteerer::unknownParameterChoices] " 
          << "Unexpected parameter selector '" << sel
          << "', use \n'f/F' (fix),\n'c/C' (fix at correct pos.),\n'1/H' (free),\n"
          << "'r' (free, but defining reference system) or \n'0' (ignore).\n"
          << "Capital letters mean that the Alignable is taken out of a possible hierarchy,\n"
          << "but must be used consistently for all its parameters.";
        return false; // unreached
      }
    }
  }

  return true;
}

double PedeSteerer::cmsToPedeFactor

(

unsigned int

parNum

)

const

Definition at line 96 of file PedeSteerer.cc.

References RigidBodyAlignmentParameters::dalpha, RigidBodyAlignmentParameters::dbeta, RigidBodyAlignmentParameters::dgamma, RigidBodyAlignmentParameters::dx, RigidBodyAlignmentParameters::dy, and RigidBodyAlignmentParameters::dz.

Referenced by fixParameter(), MillePedeAlignmentAlgorithm::globalDerivativesHierarchy(), and PedeReader::setParameter().

{
  return 1.; // mmh, otherwise would need to FIXME hierarchyConstraint...

  switch (parNum) {
  case RigidBodyAlignmentParameters::dx:
  case RigidBodyAlignmentParameters::dy:
    return 1000.; // cm to mum *1/10 to get smaller values
  case RigidBodyAlignmentParameters::dz:
    return 2500.;   // cm to mum *1/4 
  case RigidBodyAlignmentParameters::dalpha:
  case RigidBodyAlignmentParameters::dbeta:
    return 1000.; // rad to mrad (no first guess for sensitivity yet)
  case RigidBodyAlignmentParameters::dgamma:
    return 10000.; // rad to mrad *10 to get larger values
  default:
    return 1.;
  }
}

void PedeSteerer::correctToReferenceSystem

(

)

If reference alignables have been configured, shift everything such that mean position and orientation of dets in these alignables are zero.

Definition at line 309 of file PedeSteerer.cc.

References e, it, Alignable::move(), Alignable::rotateInGlobalFrame(), theCoordDefiners, theCoordMaster, and align::toMatrix().

Referenced by PedeSteerer().

{
  typedef RigidBodyAlignmentParameters RbPars;
  if (!theCoordMaster || theCoordDefiners.empty()) return; // nothing was defined

  std::vector<Alignable*> definerDets; // or ...DetUnits
  for (std::vector<Alignable*>::iterator it = theCoordDefiners.begin(), iE = theCoordDefiners.end();
       it != iE; ++it) {// find lowest level objects of alignables that define the coordinate system
    const std::vector<Alignable*> &comp = (*it)->deepComponents();
    definerDets.insert(definerDets.end(), comp.begin(), comp.end());
  }

  for (unsigned int iLoop = 0; ; ++iLoop) { // iterate: shifts and rotations are not independent
    AlgebraicVector meanPars(RbPars::N_PARAM);
    for (std::vector<Alignable*>::iterator it = definerDets.begin(), iE = definerDets.end();
         it != iE; ++it) { // sum up mean displacements/misrotations:
      meanPars += RbPars(*it, true).globalParameters();// requires theCoordMaster has global frame
    }
    meanPars /= definerDets.size();
    const align::Scalar squareSum = meanPars.normsq();

    if (squareSum < 1.e-20) break; // sqrt(1.e-20)=1.e-10: close enough to stop iterating
    if (iLoop == 0) {
      edm::LogInfo("Alignment") << "@SUB=PedeSteerer::correctToReferenceSystem"
                                << "Loop " << iLoop << " "
                                << "Mean misalignment of dets of defined coordinate system"
                                << (squareSum < 1.e-20 ? ":" :
                                    " (will be iteratively corrected to < 1.e-10):") << meanPars;
    }
    if (iLoop >=5) { // 3 iterations should be safe, use 5 for 'more' safety...
        edm::LogError("Alignment") << "@SUB=PedeSteerer::correctToReferenceSystem"
                                   << "No convergence in " << iLoop << " iterations, " 
                                   << "remaining misalignment: " << meanPars;
      break;
    }

    const GlobalVector globalShift(meanPars[RbPars::dx],meanPars[RbPars::dy],meanPars[RbPars::dz]);
    align::EulerAngles globalAngles(3);
    globalAngles[0] = meanPars[RbPars::dalpha];
    globalAngles[1] = meanPars[RbPars::dbeta];
    globalAngles[2] = meanPars[RbPars::dgamma];
    theCoordMaster->move(-globalShift); // sign to revert
    theCoordMaster->rotateInGlobalFrame(align::toMatrix(-globalAngles)); // sign to revert
  }
  
}

std::ofstream * PedeSteerer::createSteerFile	(	const std::string &	name,
		bool	addToList
	)			[private]

create and open file with name, if (addToList) append to mySteeringFiles

Definition at line 553 of file PedeSteerer.cc.

References Exception, myNoSteerFiles, mySteeringFiles, out, and HLT_VtxMuL3::result.

Referenced by buildMasterSteer(), defineCoordinates(), fixParameter(), hierarchyConstraints(), and presigmasFile().

{
  const std::string realName(myNoSteerFiles ? "/dev/null" : name.c_str());

  std::ofstream *result = new std::ofstream(realName.c_str(), std::ios::out);
  if (!result || !result->is_open()) {
    delete result; // needed before exception in case just open failed
    throw cms::Exception("FileOpenProblem") << "[PedeSteerer::createSteerFile]" 
                                            << "Could not open " << realName 
                                            << " as output file.";
  } else if (addToList) {
    mySteeringFiles.push_back(realName); // keep track
  }

  return result;
}

void PedeSteerer::defineCoordinates	(	const std::vector< Alignable * > &	alis,
		Alignable *	aliMaster,
		const std::string &	fileName
	)			[private]

Create steering file with constraints defining coordinate system via hierarchy constraints between 'aliMaster' and 'alis'; 'aliMaster' must not have parameters: would not make sense!

Definition at line 291 of file PedeSteerer.cc.

References Alignable::alignmentParameters(), createSteerFile(), Exception, hierarchyConstraint(), and Alignable::setAlignmentParameters().

Referenced by buildSubSteer().

{
  std::ofstream *filePtr = this->createSteerFile(fileName, true);
  (*filePtr) << "* Constraints to define coordinate system:\n";
  if (!aliMaster || aliMaster->alignmentParameters()) {
    throw cms::Exception("BadConfig")
      << "[PedeSteerer::defineCoordinates] " << "No master alignable or it has parameters!";
  }
  AlignmentParameters *par = new RigidBodyAlignmentParameters(aliMaster, false);
  aliMaster->setAlignmentParameters(par); // hierarchyConstraint needs parameters
  this->hierarchyConstraint(aliMaster, alis, *filePtr);
  aliMaster->setAlignmentParameters(0); // erase dummy parameters

  delete filePtr; // automatically flushes, no problem if NULL ptr.   
}

const std::string& PedeSteerer::directory

(

)

const [inline]

directory from constructor input, '/' is attached if needed

Definition at line 61 of file PedeSteerer.h.

References myDirectory.

Referenced by PedeReader::PedeReader().

{ return myDirectory;}

std::string PedeSteerer::fileName

(

const std::string &

addendum

)

const [private]

full name with directory and 'idenitfier'

Definition at line 572 of file PedeSteerer.cc.

References edm::ParameterSet::getParameter(), myConfig, myDirectory, and name.

{

  std::string name(myDirectory);
  name += myConfig.getParameter<std::string>("steerFile");
  name += addendum;
  name += ".txt";

  return name;
}

int PedeSteerer::fixParameter	(	Alignable *	ali,
		unsigned int	iParam,
		char	selector,
		std::ofstream *&	filePtr,
		const std::string &	fileName
	)			[private]

If 'selector' means fixing, create corresponding steering file line in file pointed to by 'filePtr'.

If 'filePtr == 0' create file with name 'fileName' (and return pointer via reference).

Definition at line 214 of file PedeSteerer.cc.

References PedeLabeler::alignableLabel(), cmsToPedeFactor(), createSteerFile(), file, Alignable::globalPosition(), myLabels, PedeLabeler::parameterLabel(), parameterSign(), and HLT_VtxMuL3::result.

Referenced by fixParameters().

{
  int result = 0;
  float fixAt = 0.;
  if (selector == 'c' || selector == 'C') {
    fixAt = -this->parameterSign() * RigidBodyAlignmentParameters(ali, true).parameters()[iParam];
    result = -1;
  } else if (selector == 'f' || selector == 'F') {
    result = 1;
  }

  if (result) {
    if (!filePtr) {
      filePtr = this->createSteerFile(fileName, true);
      (*filePtr) << "Parameter\n";
    }
    std::ofstream &file = *filePtr;

    const unsigned int aliLabel = myLabels->alignableLabel(ali);
    file << myLabels->parameterLabel(aliLabel, iParam) << "  " 
         << fixAt * this->cmsToPedeFactor(iParam) << " -1.0";
    if (0) { // debug
      const GlobalPoint position(ali->globalPosition());
      file << "* eta " << position.eta() << ", z " << position.z()
           << ", r " << position.perp() << ", phi " << position.phi();
    }
    file << "\n";
  }

  return result;
}

std::pair< unsigned int, unsigned int > PedeSteerer::fixParameters	(	const std::vector< Alignable * > &	alignables,
		const std::string &	file
	)			[private]

Checks whether 'alignables' have SelectionUserVariables attached to their AlignmentParameters (these must exist) that indicate fixation of a parameter, a steering 'file' is created accordingly.

Returns number of parameters fixed at 0 and at 'nominal truth'.

Definition at line 185 of file PedeSteerer.cc.

References fixParameter(), SelectionUserVariables::fullSelection(), params, AlignmentParameters::size(), and AlignmentParameters::userVariables().

{
  // return number of parameters fixed at 0. and fixed at original position 
  std::pair<unsigned int, unsigned int> numFixNumFixCor(0, 0);

  std::ofstream *filePtr = 0;

  for (std::vector<Alignable*>::const_iterator iAli = alis.begin() ; iAli != alis.end(); ++iAli) {
    AlignmentParameters *params = (*iAli)->alignmentParameters();
    SelectionUserVariables *selVar = dynamic_cast<SelectionUserVariables*>(params->userVariables());
    if (!selVar) continue;

    for (unsigned int iParam = 0; static_cast<int>(iParam) < params->size(); ++iParam) {
      int whichFix = this->fixParameter(*iAli, iParam, selVar->fullSelection()[iParam], filePtr,
                                        fileName);
      if (whichFix == 1) {
        ++(numFixNumFixCor.first);
      } else if (whichFix == -1) {
        ++(numFixNumFixCor.second);
      }
    }
  }

  delete filePtr; // automatically flushes, no problem if NULL ptr.   

  return numFixNumFixCor;
}

void PedeSteerer::hierarchyConstraint	(	const Alignable *	ali,
		const std::vector< Alignable * > &	components,
		std::ofstream &	file
	)			const [private]

Definition at line 395 of file PedeSteerer.cc.

References PedeLabeler::alignableLabel(), Alignable::alignableObjectId(), first, Alignable::globalPosition(), AlignmentParameterStore::hierarchyConstraints(), Alignable::id(), myLabels, myParameterStore, PedeLabeler::parameterLabel(), edm::second(), TrackerAlignableId::typeAndLayerFromDetId(), and AlignableObjectId::typeToName().

Referenced by defineCoordinates(), and hierarchyConstraints().

{
  static AlignableObjectId objId; // static since costly constructor FIXME?

  typedef AlignmentParameterStore::ParameterId ParameterId;
  typedef std::vector<Alignable*>::size_type IndexType;

  std::vector<std::vector<ParameterId> > paramIdsVec;
  std::vector<std::vector<float> > factorsVec;
  const bool allConstr = false; // true; // make configurable?
  static bool first = true;
  if (allConstr && first) {
    edm::LogWarning("Alignment") << "@SUB=PedeSteerer::hierarchyConstraint"
                                 << "changed to use all 6 constraints";
    first = false;
  }
  if (!myParameterStore->hierarchyConstraints(ali, components, paramIdsVec, factorsVec, allConstr)){
    edm::LogWarning("Alignment") << "@SUB=PedeSteerer::hierarchyConstraint"
                                 << "Problems from store.";
  }

  for (unsigned int iConstr = 0; iConstr < paramIdsVec.size(); ++iConstr) {
    std::ostringstream aConstr;

    const std::vector<ParameterId> &parIds = paramIdsVec[iConstr];
    const std::vector<float> &factors = factorsVec[iConstr];
    // parIds.size() == factors.size() granted by myParameterStore->hierarchyConstraints
    for (unsigned int iParam = 0; iParam < parIds.size(); ++iParam) {
      Alignable *aliSubComp = parIds[iParam].first;
      const unsigned int compParNum = parIds[iParam].second;
      if (this->isNoHiera(aliSubComp)) {
        if (0) aConstr << "* Taken out of hierarchy: "; // conflict with !aConstr.str().empty()
        else continue;
      }
      const unsigned int aliLabel = myLabels->alignableLabel(aliSubComp);
      const unsigned int paramLabel = myLabels->parameterLabel(aliLabel, compParNum);
      // FIXME: multiply by cmsToPedeFactor(subcomponent)/cmsToPedeFactor(mother) (or vice a versa?)
      aConstr << paramLabel << "    " << factors[iParam];
      if (true) { // debug
        const TrackerAlignableId aliId;

        aConstr << "   ! for param " << compParNum << " of a " 
//              << aliId.alignableTypeName(aliSubComp) 
                << objId.typeToName(aliSubComp->alignableObjectId())
                << " (label " << aliLabel << ")";
      }
      aConstr << "\n";
    } // end loop on params

    if (!aConstr.str().empty()) {
      if (true) { //debug
        const TrackerAlignableId aliId;
        file << "\n* Nr. " << iConstr << " of a '"
             << objId.typeToName(ali->alignableObjectId()) << "' (label "
             << myLabels->alignableLabel(const_cast<Alignable*>(ali)) // ugly cast: FIXME!
             << "), layer " << aliId.typeAndLayerFromDetId(ali->id()).second
             << ", position " << ali->globalPosition()
             << ", r = " << ali->globalPosition().perp();
      }
      file << "\nConstraint   0.\n" << aConstr.str(); // in future 'Wconstraint'?
    }
  } // end loop on constraints
}

unsigned int PedeSteerer::hierarchyConstraints	(	const std::vector< Alignable * > &	alis,
		const std::string &	file
	)			[private]

Definition at line 357 of file PedeSteerer.cc.

References createSteerFile(), and hierarchyConstraint().

Referenced by buildSubSteer().

{
  std::ofstream *filePtr = 0;

  unsigned int nConstraints = 0;
  std::vector<Alignable*> aliDaughts;
  for (std::vector<Alignable*>::const_iterator iA = alis.begin(), iEnd = alis.end();
       iA != iEnd; ++iA) {
    aliDaughts.clear();
    if (!(*iA)->firstCompsWithParams(aliDaughts)) {
      static AlignableObjectId objId; // static since costly constructor FIXME?
      edm::LogWarning("Alignment") << "@SUB=PedeSteerer::hierarchyConstraints"
                                   << "Some but not all daughters of "
                                   << objId. typeToName((*iA)->alignableObjectId())
                                   << " with params!";
    }
//     edm::LogInfo("Alignment") << "@SUB=PedeSteerer::hierarchyConstraints"
//                            << aliDaughts.size() << " ali param components";
    if (aliDaughts.empty()) continue;
//     edm::LogInfo("Alignment") << "@SUB=PedeSteerer::hierarchyConstraints"
//                            << aliDaughts.size() << " alignable components ("
//                            << (*iA)->size() << " in total) for " 
//                            << aliId.alignableTypeName(*iA) 
//                            << ", layer " << aliId.typeAndLayerFromAlignable(*iA).second
//                            << ", position " << (*iA)->globalPosition()
//                            << ", r = " << (*iA)->globalPosition().perp();
    if (!filePtr) filePtr = this->createSteerFile(fileName, true);
    ++nConstraints;
    this->hierarchyConstraint(*iA, aliDaughts, *filePtr);
  }

  delete filePtr; // automatically flushes, no problem if NULL ptr.   

  return nConstraints;
}

bool PedeSteerer::isNoHiera

(

const Alignable *

ali

)

const

True if 'ali' was deselected from hierarchy and any ancestor (e.g. mother) has parameters.

Definition at line 90 of file PedeSteerer.cc.

References myNoHieraCollection.

Referenced by MillePedeAlignmentAlgorithm::globalDerivativesHierarchy().

{
  return (myNoHieraCollection.find(ali) != myNoHieraCollection.end());
}

int PedeSteerer::parameterSign

(

)

const [inline]

results from pede (and start values for pede) might need a sign flip

Definition at line 59 of file PedeSteerer.h.

References myParameterSign.

Referenced by fixParameter(), and PedeReader::setParameter().

{ return myParameterSign; }

unsigned int PedeSteerer::presigmas	(	const std::vector< edm::ParameterSet > &	cffPresi,
		const std::string &	fileName,
		const std::vector< Alignable * > &	alis,
		AlignableTracker *	aliTracker,
		AlignableMuon *	aliMuon
	)			[private]

interprete content of presigma VPSet 'cffPresi' and call presigmasFile

Definition at line 462 of file PedeSteerer.cc.

References AlignmentParameterSelector::addSelections(), AlignmentParameterSelector::clear(), Exception, presigmasFile(), AlignmentParameterSelector::selectedAlignables(), and AlignmentParameterSelector::selectedParameters().

Referenced by buildSubSteer(), and presigmasFile().

{
  // We loop on given PSet's, each containing a parameter selection and the presigma value
  // The resulting presigmas are stored in a map with Alignable* as key.
  // This map, 'fileName' and 'alis' are passed further to create the steering file.

  AlignmentParameterSelector selector(aliTracker, aliMuon);  
  AlignablePresigmasMap aliPresiMap; // map to store alis with presigmas of their parameters 
  for (std::vector<edm::ParameterSet>::const_iterator iSet = cffPresi.begin(), iE = cffPresi.end();
       iSet != iE; ++iSet) { // loop on individual PSets defining ali-params with their presigma
    selector.clear();
    selector.addSelections((*iSet).getParameter<edm::ParameterSet>("Selector"));
    const std::vector<Alignable*> &alis = selector.selectedAlignables();
    const std::vector<std::vector<char> > &sels =  selector.selectedParameters();
    const float presigma = (*iSet).getParameter<double>("presigma");
    if (presigma <= 0.) { // given presigma > 0., 0. later used if not (yet) chosen for parameter
      throw cms::Exception("BadConfig")
        << "[PedeSteerer::presigmas]: Pre-sigma must be > 0., but is " << presigma << ".";
    }
    // now loop on alis of present selection
    for (unsigned int iAli = 0; iAli < alis.size(); ++iAli) {
      std::vector<float> &presigmas = aliPresiMap[alis[iAli]]; // existing or empty, so ensure length:
      if (presigmas.size() < sels[iAli].size()) presigmas.resize(sels[iAli].size(), 0.);
      for (unsigned int iParam = 0; iParam < sels[iAli].size(); ++iParam) { // loop on parameters
        if (sels[iAli][iParam] != '0') { // all but '0' means to apply the chosen presigma
          if (presigmas[iParam] != 0.) { // reset forbidden (would make it order dependent!)
            throw cms::Exception("BadConfig")
              << "[PedeSteerer::presigmas]: Try to set pre-sigma " << presigma << ", but already "
              << "set " << presigmas[iParam] << " (for a " 
              << AlignableObjectId().typeToName(alis[iAli]->alignableObjectId()) << ").";
          }
          presigmas[iParam] = presigma;
        } // end if selected for presigma
      } // end loop on params
    } // end loop on alignables for given selection and presigma
  } // end loop on PSets 

  if (aliPresiMap.empty()) return 0;
  else return this->presigmasFile(fileName, alis, aliPresiMap);
}

unsigned int PedeSteerer::presigmasFile	(	const std::string &	fileName,
		const std::vector< Alignable * > &	alis,
		const AlignablePresigmasMap &	aliPresisMap
	)			[private]

look for active 'alis' in map of presigma values and create steering file

Definition at line 507 of file PedeSteerer.cc.

References PedeLabeler::alignableLabel(), createSteerFile(), SelectionUserVariables::fullSelection(), myLabels, PedeLabeler::parameterLabel(), presigmas(), and AlignableObjectId::typeToName().

Referenced by presigmas().

{
  // Check if 'alis' are in aliPresiMap, 
  // if yes apply presigma - but NOT if parameter is fixed!
  std::ofstream *filePtr = 0;
  const AlignableObjectId aliObjId;

  unsigned int nPresiParam = 0;
  for (std::vector<Alignable*>::const_iterator iAli = alis.begin(), iAliE = alis.end();
       iAli != iAliE; ++iAli) {
    // Any presigma chosen for alignable?
    AlignablePresigmasMap::const_iterator presigmasIt = aliPresiMap.find(*iAli);
    if (presigmasIt == aliPresiMap.end()) continue; // no presigma chosen for alignable

    // Why does the following not work? It does with CMSSW_1_3_X on SLC3...
    // const AlignablePresigmasMap::data_type &presigmas = presigmasIt->second;
    const std::vector<float> &presigmas = presigmasIt->second; // I want to hide float or double...
    for (unsigned int iParam = 0; iParam < presigmas.size(); ++iParam) {
      // Now check whether a presigma value > 0. chosen: 
      if (presigmas[iParam] <= 0.) continue; // must be positive, '<' checked above
      // Do not apply presigma to inactive or fixed values.
      if (!(*iAli)->alignmentParameters()->selector()[iParam]) continue;
      SelectionUserVariables *selVar 
        = dynamic_cast<SelectionUserVariables*>((*iAli)->alignmentParameters()->userVariables());
      const char selChar = (selVar ? selVar->fullSelection()[iParam] : '1');
      if (selChar == 'f' || selChar == 'F' || selChar == 'c' || selChar == 'C') continue;
      // Finally create and write steering file:
      if (!filePtr) {
        filePtr = this->createSteerFile(fileName, true);
        (*filePtr) << "* Presigma values for active parameters: \nParameter\n";
      }
      const unsigned int aliLabel = myLabels->alignableLabel(*iAli);
      (*filePtr) << myLabels->parameterLabel(aliLabel, iParam) << "   0.   " 
                 << presigmas[iParam] * fabs(this->cmsToPedeFactor(iParam)) 
                 << "  ! for a " << aliObjId.typeToName((*iAli)->alignableObjectId()) << '\n';
      ++nPresiParam;
    } // end loop on parameters for alignables with chosen presigmas
  } // end loop on alignables

  delete filePtr; // close properly file
  return nPresiParam;
}

bool PedeSteerer::runPede

(

const std::string &

masterSteer

)

const

run pede, masterSteer should be as returned from buildMasterSteer(...)

Definition at line 666 of file PedeSteerer.cc.

References dbtoconf::command, dump(), edm::ParameterSet::getUntrackedParameter(), myConfig, and myDirectory.

Referenced by MillePedeAlignmentAlgorithm::terminate().

{
  if (masterSteer.empty()) {
    edm::LogError("Alignment") << "@SUB=PedeSteerer::runPede" << "Empty master steer file, stop";
    return false;
  }

  std::string command(myConfig.getUntrackedParameter<std::string>("pedeCommand"));
  (command += " ") += masterSteer;
  const std::string dump(myConfig.getUntrackedParameter<std::string>("pedeDump"));
  if (!dump.empty()) {
    command += " > ";
    (command += myDirectory) += dump;
  }

  edm::LogInfo("Alignment") << "@SUB=PedeSteerer::runPede" << "Start running " << command;
  // FIXME: Recommended interface to system commands?
  int shellReturn = gSystem->Exec(command.c_str());
  if (shellReturn) {
    edm::LogError("Alignment") << "@SUB=PedeSteerer::runPede" << "Command returns " << shellReturn;
  } else {
    edm::LogInfo("Alignment") << "@SUB=PedeSteerer::runPede" << "Command returns " << shellReturn;
  }

  return !shellReturn;
}

std::vector< Alignable * > PedeSteerer::selectCoordinateAlis

(

const std::vector< Alignable * > &

alignables

)

const [private]

Return 'alignables' that have SelectionUserVariables attached to their AlignmentParameters (these must exist) that indicate a definition of a coordinate system.

Throws if ill defined reference objects.

Definition at line 248 of file PedeSteerer.cc.

References Alignable::alignmentParameters(), Exception, SelectionUserVariables::fullSelection(), Alignable::mother(), params, AlignmentParameters::size(), and AlignmentParameters::userVariables().

Referenced by PedeSteerer().

{
  std::vector<Alignable*> coordAlis;

  for (std::vector<Alignable*>::const_iterator iAli = alis.begin() ; iAli != alis.end(); ++iAli) {
    AlignmentParameters *params = (*iAli)->alignmentParameters();
    SelectionUserVariables *selVar = dynamic_cast<SelectionUserVariables*>(params->userVariables());
    if (!selVar) continue;
    unsigned int refParam = 0;
    unsigned int nonRefParam = 0;
    for (unsigned int iParam = 0; static_cast<int>(iParam) < params->size(); ++iParam) {
      const char selector = selVar->fullSelection()[iParam];
      if (selector == 'r') {
        ++refParam;
      } else if (selector != '0' && selector != 'f') { // allow also 'c'?
        ++nonRefParam;
      }
    }
    // Check whether some 'r' selection string. If yes and selection makes sense, add to result:
    if (refParam) {
      if (nonRefParam) {
        throw cms::Exception("BadConfig") 
          << "[PedeSteerer::selectCoordinateAlis] All active parameters of alignables defining "
          << "the coordinate system must be marked with 'r' (or fixed, 'f')!";
      } else {
        Alignable *mother = *iAli;
        while ((mother = mother->mother())) {
          if (mother->alignmentParameters()) {
            throw cms::Exception("BadConfig") << "[PedeSteerer::selectCoordinateAlis] "
                                              << "Alignables defining the coordinate system must "
                                              << "be highest level!";
          }
        }
        coordAlis.push_back(*iAli);
      }
    }
  } // end loop on alignables

  return coordAlis;
}

---

Member Data Documentation

edm::ParameterSet PedeSteerer::myConfig [private]

pointer to labeler (not the owner)

Definition at line 112 of file PedeSteerer.h.

Referenced by buildMasterSteer(), buildSubSteer(), fileName(), and runPede().

std::string PedeSteerer::myDirectory [private]

Definition at line 113 of file PedeSteerer.h.

Referenced by directory(), fileName(), PedeSteerer(), and runPede().

const PedeLabeler* PedeSteerer::myLabels [private]

not the owner!

Definition at line 110 of file PedeSteerer.h.

Referenced by fixParameter(), hierarchyConstraint(), and presigmasFile().

std::set<const Alignable*> PedeSteerer::myNoHieraCollection [private]

keeps track of created 'secondary' steering files

Definition at line 119 of file PedeSteerer.h.

Referenced by buildNoHierarchyCollection(), buildSubSteer(), and isNoHiera().

bool PedeSteerer::myNoSteerFiles [private]

directory of all files

Definition at line 114 of file PedeSteerer.h.

Referenced by createSteerFile().

int PedeSteerer::myParameterSign [private]

flag to write steering files to /dev/null

Definition at line 115 of file PedeSteerer.h.

Referenced by parameterSign(), and PedeSteerer().

const AlignmentParameterStore* PedeSteerer::myParameterStore [private]

Definition at line 109 of file PedeSteerer.h.

Referenced by buildSubSteer(), hierarchyConstraint(), and PedeSteerer().

std::vector<std::string> PedeSteerer::mySteeringFiles [private]

old pede versions (before May '07) need a sign flip...

Definition at line 117 of file PedeSteerer.h.

Referenced by buildMasterSteer(), and createSteerFile().

std::vector<Alignable*> PedeSteerer::theCoordDefiners [private]

master coordinates, must (?) be global frame

Definition at line 121 of file PedeSteerer.h.

Referenced by buildSubSteer(), correctToReferenceSystem(), and PedeSteerer().

Alignable* PedeSteerer::theCoordMaster [private]

Alignables deselected for hierarchy constr.

Definition at line 120 of file PedeSteerer.h.

Referenced by buildSubSteer(), correctToReferenceSystem(), and PedeSteerer().

---

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

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

---