#include <MillePedeFileReader.h>

Public Types
enum	{ SIZE_LG_STRUCTS = 6, SIZE_HG_STRUCTS = 820 }

Public Member Functions
const int	binariesAmount () const

const mpPCLresults	getResults () const

const std::map< std::string, std::array< bool, 6 > > &	getResultsHG () const

const AlignPCLThresholdsHG::threshold_map	getThresholdMap () const

const std::array< double, SIZE_LG_STRUCTS > &	getTXobs () const

const std::array< double, SIZE_HG_STRUCTS > &	getTXobs_HG () const

const std::array< double, SIZE_LG_STRUCTS > &	getTXobsErr () const

const std::array< double, SIZE_HG_STRUCTS > &	getTXobsErr_HG () const

const std::array< double, SIZE_LG_STRUCTS > &	getTYobs () const

const std::array< double, SIZE_HG_STRUCTS > &	getTYobs_HG () const

const std::array< double, SIZE_LG_STRUCTS > &	getTYobsErr () const

const std::array< double, SIZE_HG_STRUCTS > &	getTYobsErr_HG () const

const std::array< double, SIZE_LG_STRUCTS > &	getTZobs () const

const std::array< double, SIZE_HG_STRUCTS > &	getTZobs_HG () const

const std::array< double, SIZE_LG_STRUCTS > &	getTZobsErr () const

const std::array< double, SIZE_HG_STRUCTS > &	getTZobsErr_HG () const

const std::array< double, SIZE_LG_STRUCTS > &	getXobs () const

const std::array< double, SIZE_HG_STRUCTS > &	getXobs_HG () const

const std::array< double, SIZE_LG_STRUCTS > &	getXobsErr () const

const std::array< double, SIZE_HG_STRUCTS > &	getXobsErr_HG () const

const std::array< double, SIZE_LG_STRUCTS > &	getYobs () const

const std::array< double, SIZE_HG_STRUCTS > &	getYobs_HG () const

const std::array< double, SIZE_LG_STRUCTS > &	getYobsErr () const

const std::array< double, SIZE_HG_STRUCTS > &	getYobsErr_HG () const

const std::array< double, SIZE_LG_STRUCTS > &	getZobs () const

const std::array< double, SIZE_HG_STRUCTS > &	getZobs_HG () const

const std::array< double, SIZE_LG_STRUCTS > &	getZobsErr () const

const std::array< double, SIZE_HG_STRUCTS > &	getZobsErr_HG () const

	MillePedeFileReader (const edm::ParameterSet &, const std::shared_ptr< const PedeLabelerBase > &, const std::shared_ptr< const AlignPCLThresholdsHG > &, const std::shared_ptr< const PixelTopologyMap > &, const std::shared_ptr< const SiPixelQuality > &)

void	read ()

bool	storeAlignments ()

virtual	~MillePedeFileReader ()=default

Static Public Member Functions
static void	fillPSetDescription (edm::ParameterSetDescription &desc)

Private Types
enum	PclHLS : int { PclHLS::NotInPCL = -1, PclHLS::TPEHalfCylinderXplusZminus = 0, PclHLS::TPEHalfCylinderXminusZminus = 1, PclHLS::TPBHalfBarrelXplus = 2, PclHLS::TPBHalfBarrelXminus = 3, PclHLS::TPEHalfCylinderXplusZplus = 4, PclHLS::TPEHalfCylinderXminusZplus = 5, PclHLS::TPBLadderLayer1 = 6, PclHLS::TPBLadderLayer2 = 7, PclHLS::TPBLadderLayer3 = 8, PclHLS::TPBLadderLayer4 = 9, PclHLS::TPEPanelDisk1 = 10, PclHLS::TPEPanelDisk2 = 11, PclHLS::TPEPanelDisk3 = 12, PclHLS::TPEPanelDiskM1 = 13, PclHLS::TPEPanelDiskM2 = 14, PclHLS::TPEPanelDiskM3 = 15 }

Private Member Functions
PclHLS	getHLS (const Alignable *)

int	getIndexForHG (align::ID id, PclHLS HLS)

std::string	getStringFromHLS (PclHLS HLS)

void	initializeIndexHelper ()

bool	isAlignableActive (const Alignable *alignable, const std::shared_ptr< const SiPixelQuality > &pixelQual)

void	readMillePedeEndFile ()

void	readMillePedeLogFile ()

void	readMillePedeResultFile ()

Private Attributes
int	binariesAmount_ {0}

std::string	dirName_

int	exitCode_ {-1}

std::string	exitMessage_ {""}

std::map< std::string, std::array< bool, 6 > >	fractionExceeded_

const bool	ignoreInactiveAlignables_

std::unordered_map< PclHLS, std::pair< int, int > >	indexHelper

const bool	isHG_

const std::string	millePedeEndFile_

const std::string	millePedeLogFile_

const std::string	millePedeResFile_

int	Nrec_ {0}

const std::shared_ptr< const PedeLabelerBase >	pedeLabeler_

const std::shared_ptr< const PixelTopologyMap >	pixelTopologyMap_

const std::shared_ptr< const SiPixelQuality >	quality_

const std::shared_ptr< const AlignPCLThresholdsHG >	theThresholds_

std::array< double, SIZE_LG_STRUCTS >	tXobs_ = std::array<double, SIZE_LG_STRUCTS>()

std::array< double, SIZE_HG_STRUCTS >	tXobs_HG_ = std::array<double, SIZE_HG_STRUCTS>()

std::array< double, SIZE_LG_STRUCTS >	tXobsErr_ = std::array<double, SIZE_LG_STRUCTS>()

std::array< double, SIZE_HG_STRUCTS >	tXobsErr_HG_ = std::array<double, SIZE_HG_STRUCTS>()

std::array< double, SIZE_LG_STRUCTS >	tYobs_ = std::array<double, SIZE_LG_STRUCTS>()

std::array< double, SIZE_HG_STRUCTS >	tYobs_HG_ = std::array<double, SIZE_HG_STRUCTS>()

std::array< double, SIZE_LG_STRUCTS >	tYobsErr_ = std::array<double, SIZE_LG_STRUCTS>()

std::array< double, SIZE_HG_STRUCTS >	tYobsErr_HG_ = std::array<double, SIZE_HG_STRUCTS>()

std::array< double, SIZE_LG_STRUCTS >	tZobs_ = std::array<double, SIZE_LG_STRUCTS>()

std::array< double, SIZE_HG_STRUCTS >	tZobs_HG_ = std::array<double, SIZE_HG_STRUCTS>()

std::array< double, SIZE_LG_STRUCTS >	tZobsErr_ = std::array<double, SIZE_LG_STRUCTS>()

std::array< double, SIZE_HG_STRUCTS >	tZobsErr_HG_ = std::array<double, SIZE_HG_STRUCTS>()

std::bitset< 4 >	updateBits_

bool	updateDB_ {false}

bool	vetoUpdateDB_ {false}

std::array< double, SIZE_LG_STRUCTS >	Xobs_ = std::array<double, SIZE_LG_STRUCTS>()

std::array< double, SIZE_HG_STRUCTS >	Xobs_HG_ = std::array<double, SIZE_HG_STRUCTS>()

std::array< double, SIZE_LG_STRUCTS >	XobsErr_ = std::array<double, SIZE_LG_STRUCTS>()

std::array< double, SIZE_HG_STRUCTS >	XobsErr_HG_ = std::array<double, SIZE_HG_STRUCTS>()

std::array< double, SIZE_LG_STRUCTS >	Yobs_ = std::array<double, SIZE_LG_STRUCTS>()

std::array< double, SIZE_HG_STRUCTS >	Yobs_HG_ = std::array<double, SIZE_HG_STRUCTS>()

std::array< double, SIZE_LG_STRUCTS >	YobsErr_ = std::array<double, SIZE_LG_STRUCTS>()

std::array< double, SIZE_HG_STRUCTS >	YobsErr_HG_ = std::array<double, SIZE_HG_STRUCTS>()

std::array< double, SIZE_LG_STRUCTS >	Zobs_ = std::array<double, SIZE_LG_STRUCTS>()

std::array< double, SIZE_HG_STRUCTS >	Zobs_HG_ = std::array<double, SIZE_HG_STRUCTS>()

std::array< double, SIZE_LG_STRUCTS >	ZobsErr_ = std::array<double, SIZE_LG_STRUCTS>()

std::array< double, SIZE_HG_STRUCTS >	ZobsErr_HG_ = std::array<double, SIZE_HG_STRUCTS>()

Static Private Attributes
static constexpr std::array< double, 6 >	multiplier_

Detailed Description

Definition at line 66 of file MillePedeFileReader.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Enumerator
SIZE_LG_STRUCTS
SIZE_HG_STRUCTS

Definition at line 82 of file MillePedeFileReader.h.

82 { SIZE_LG_STRUCTS = 6, SIZE_HG_STRUCTS = 820 };

MillePedeFileReader::SIZE_LG_STRUCTS

Definition: MillePedeFileReader.h:82

MillePedeFileReader::SIZE_HG_STRUCTS

Definition: MillePedeFileReader.h:82

◆ PclHLS

enum MillePedeFileReader::PclHLS : int

strongprivate

Enumerator
NotInPCL
TPEHalfCylinderXplusZminus
TPEHalfCylinderXminusZminus
TPBHalfBarrelXplus
TPBHalfBarrelXminus
TPEHalfCylinderXplusZplus
TPEHalfCylinderXminusZplus
TPBLadderLayer1
TPBLadderLayer2
TPBLadderLayer3
TPBLadderLayer4
TPEPanelDisk1
TPEPanelDisk2
TPEPanelDisk3
TPEPanelDiskM1
TPEPanelDiskM2
TPEPanelDiskM3

Definition at line 128 of file MillePedeFileReader.h.

                     : int {
     NotInPCL = -1,
     TPEHalfCylinderXplusZminus = 0,
     TPEHalfCylinderXminusZminus = 1,
     TPBHalfBarrelXplus = 2,
     TPBHalfBarrelXminus = 3,
     TPEHalfCylinderXplusZplus = 4,
     TPEHalfCylinderXminusZplus = 5,
     TPBLadderLayer1 = 6,
     TPBLadderLayer2 = 7,
     TPBLadderLayer3 = 8,
     TPBLadderLayer4 = 9,
     TPEPanelDisk1 = 10,
     TPEPanelDisk2 = 11,
     TPEPanelDisk3 = 12,
     TPEPanelDiskM1 = 13,
     TPEPanelDiskM2 = 14,
     TPEPanelDiskM3 = 15,
   };

Constructor & Destructor Documentation

◆ MillePedeFileReader()

MillePedeFileReader::MillePedeFileReader	(	const edm::ParameterSet &	config,
		const std::shared_ptr< const PedeLabelerBase > &	pedeLabeler,
		const std::shared_ptr< const AlignPCLThresholdsHG > &	theThresholds,
		const std::shared_ptr< const PixelTopologyMap > &	pixelTopologyMap,
		const std::shared_ptr< const SiPixelQuality > &	pixelQualityMap
	)

explicit

Definition at line 17 of file MillePedeFileReader.cc.

References dirName_.

     : pedeLabeler_(pedeLabeler),
       theThresholds_(theThresholds),
       pixelTopologyMap_(pixelTopologyMap),
       ignoreInactiveAlignables_(config.getParameter<bool>("ignoreInactiveAlignables")),
       quality_(pixelQualityMap),
       dirName_(config.getParameter<std::string>("fileDir")),
       millePedeEndFile_(config.getParameter<std::string>("millePedeEndFile")),
       millePedeLogFile_(config.getParameter<std::string>("millePedeLogFile")),
       millePedeResFile_(config.getParameter<std::string>("millePedeResFile")),
       isHG_(config.getParameter<bool>("isHG")) {
   if (!dirName_.empty() && dirName_.find_last_of('/') != dirName_.size() - 1)
     dirName_ += '/';  // may need '/'
 }

◆ ~MillePedeFileReader()

virtual MillePedeFileReader::~MillePedeFileReader ( )

virtualdefault

Member Function Documentation

◆ binariesAmount()

const int MillePedeFileReader::binariesAmount ( ) const

inline

Definition at line 116 of file MillePedeFileReader.h.

References binariesAmount_.

116 { return binariesAmount_; }

MillePedeFileReader::binariesAmount_

int binariesAmount_

Definition: MillePedeFileReader.h:206

◆ fillPSetDescription()

void MillePedeFileReader::fillPSetDescription ( edm::ParameterSetDescription & desc )

static

Definition at line 628 of file MillePedeFileReader.cc.

References submitPVResolutionJobs::desc, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by MillePedeDQMModule::fillDescriptions().

                                                                               {
   desc.add<std::string>("fileDir", std::string());
   desc.add<bool>("ignoreInactiveAlignables", true);
   desc.add<std::string>("millePedeEndFile", "millepede.end");
   desc.add<std::string>("millePedeLogFile", "millepede.log");
   desc.add<std::string>("millePedeResFile", "millepede.res");
   desc.add<bool>("isHG", false);
 }

◆ getHLS()

MillePedeFileReader::PclHLS MillePedeFileReader::getHLS ( const Alignable * alignable )

private

Definition at line 416 of file MillePedeFileReader.cc.

References Alignable::alignableObjectId(), Exception, Alignable::id(), NotInPCL, pedeLabeler_, align::TPBHalfBarrel, TPBHalfBarrelXminus, TPBHalfBarrelXplus, align::TPBLadder, TPBLadderLayer1, TPBLadderLayer2, TPBLadderLayer3, TPBLadderLayer4, align::TPEHalfCylinder, TPEHalfCylinderXminusZminus, TPEHalfCylinderXminusZplus, TPEHalfCylinderXplusZminus, TPEHalfCylinderXplusZplus, align::TPEPanel, TPEPanelDisk1, TPEPanelDisk2, TPEPanelDisk3, TPEPanelDiskM1, TPEPanelDiskM2, and TPEPanelDiskM3.

Referenced by isAlignableActive(), and readMillePedeResultFile().

                                                                                  {
   if (!alignable)
     return PclHLS::NotInPCL;
 
   const auto& tns = pedeLabeler_->alignableTracker()->trackerNameSpace();
   const align::ID id = alignable->id();
 
   switch (alignable->alignableObjectId()) {
     case align::TPBHalfBarrel:
       switch (tns.tpb().halfBarrelNumber(id)) {
         case 1:
           return PclHLS::TPBHalfBarrelXminus;
         case 2:
           return PclHLS::TPBHalfBarrelXplus;
         default:
           throw cms::Exception("LogicError")
               << "@SUB=MillePedeFileReader::getHLS\n"
               << "Found a pixel half-barrel number that should not exist: " << tns.tpb().halfBarrelNumber(id);
       }
     case align::TPEHalfCylinder:
       switch (tns.tpe().endcapNumber(id)) {
         case 1:
           switch (tns.tpe().halfCylinderNumber(id)) {
             case 1:
               return PclHLS::TPEHalfCylinderXminusZminus;
             case 2:
               return PclHLS::TPEHalfCylinderXplusZminus;
             default:
               throw cms::Exception("LogicError")
                   << "@SUB=MillePedeFileReader::getHLS\n"
                   << "Found a pixel half-cylinder number that should not exist: " << tns.tpe().halfCylinderNumber(id);
           }
         case 2:
           switch (tns.tpe().halfCylinderNumber(id)) {
             case 1:
               return PclHLS::TPEHalfCylinderXminusZplus;
             case 2:
               return PclHLS::TPEHalfCylinderXplusZplus;
             default:
               throw cms::Exception("LogicError")
                   << "@SUB=MillePedeFileReader::getHLS\n"
                   << "Found a pixel half-cylinder number that should not exist: " << tns.tpe().halfCylinderNumber(id);
           }
         default:
           throw cms::Exception("LogicError")
               << "@SUB=MillePedeFileReader::getHLS\n"
               << "Found a pixel endcap number that should not exist: " << tns.tpe().endcapNumber(id);
       }
     case align::TPBLadder:
       switch (tns.tpb().layerNumber(id)) {
         case 1:
           return PclHLS::TPBLadderLayer1;
         case 2:
           return PclHLS::TPBLadderLayer2;
         case 3:
           return PclHLS::TPBLadderLayer3;
         case 4:
           return PclHLS::TPBLadderLayer4;
         default:
           throw cms::Exception("LogicError")
               << "@SUB=MillePedeFileReader::getHLS\n"
               << "Found a pixel layer number that should not exist: " << tns.tpb().layerNumber(id);
       }
     case align::TPEPanel:
       switch (static_cast<signed int>((tns.tpe().endcapNumber(id) == 1) ? -1 * tns.tpe().halfDiskNumber(id)
                                                                         : tns.tpe().halfDiskNumber(id))) {
         case -3:
           return PclHLS::TPEPanelDiskM3;
         case -2:
           return PclHLS::TPEPanelDiskM2;
         case -1:
           return PclHLS::TPEPanelDiskM1;
         case 3:
           return PclHLS::TPEPanelDisk3;
         case 2:
           return PclHLS::TPEPanelDisk2;
         case 1:
           return PclHLS::TPEPanelDisk1;
         default:
           throw cms::Exception("LogicError")
               << "@SUB=MillePedeFileReader::getHLS\n"
               << "Found a pixel disk number that should not exist: "
               << static_cast<signed int>((tns.tpe().endcapNumber(id) == 1) ? -1 * tns.tpe().halfDiskNumber(id)
                                                                            : tns.tpe().halfDiskNumber(id));
       }
     default:
       return PclHLS::NotInPCL;
   }
 }

◆ getIndexForHG()

int MillePedeFileReader::getIndexForHG	(	align::ID	id,
		PclHLS	HLS
	)

private

Definition at line 578 of file MillePedeFileReader.cc.

References indexHelper, pedeLabeler_, TPBLadderLayer1, TPBLadderLayer2, TPBLadderLayer3, TPBLadderLayer4, TPEPanelDisk1, TPEPanelDisk2, TPEPanelDisk3, TPEPanelDiskM1, TPEPanelDiskM2, and TPEPanelDiskM3.

Referenced by readMillePedeResultFile().

                                                              {
   const auto& tns = pedeLabeler_->alignableTracker()->trackerNameSpace();
 
   switch (HLS) {
     case PclHLS::TPBLadderLayer1:
       return (tns.tpb().halfBarrelNumber(id) == 1) ? tns.tpb().ladderNumber(id) + indexHelper[HLS].first
                                                    : tns.tpb().ladderNumber(id) + indexHelper[HLS].second;
     case PclHLS::TPBLadderLayer2:
       return (tns.tpb().halfBarrelNumber(id) == 1) ? tns.tpb().ladderNumber(id) + indexHelper[HLS].first
                                                    : tns.tpb().ladderNumber(id) + indexHelper[HLS].second;
     case PclHLS::TPBLadderLayer3:
       return (tns.tpb().halfBarrelNumber(id) == 1) ? tns.tpb().ladderNumber(id) + indexHelper[HLS].first
                                                    : tns.tpb().ladderNumber(id) + indexHelper[HLS].second;
     case PclHLS::TPBLadderLayer4:
       return (tns.tpb().halfBarrelNumber(id) == 1) ? tns.tpb().ladderNumber(id) + indexHelper[HLS].first
                                                    : tns.tpb().ladderNumber(id) + indexHelper[HLS].second;
     case PclHLS::TPEPanelDisk1:
       return (tns.tpe().halfCylinderNumber(id) == 1)
                  ? (tns.tpe().bladeNumber(id) * 2 - (tns.tpe().panelNumber(id) % 2)) + indexHelper[HLS].first
                  : (tns.tpe().bladeNumber(id) * 2 - (tns.tpe().panelNumber(id) % 2)) + indexHelper[HLS].second;
     case PclHLS::TPEPanelDisk2:
       return (tns.tpe().halfCylinderNumber(id) == 1)
                  ? (tns.tpe().bladeNumber(id) * 2 - (tns.tpe().panelNumber(id) % 2)) + indexHelper[HLS].first
                  : (tns.tpe().bladeNumber(id) * 2 - (tns.tpe().panelNumber(id) % 2)) + indexHelper[HLS].second;
     case PclHLS::TPEPanelDisk3:
       return (tns.tpe().halfCylinderNumber(id) == 1)
                  ? (tns.tpe().bladeNumber(id) * 2 - (tns.tpe().panelNumber(id) % 2)) + indexHelper[HLS].first
                  : (tns.tpe().bladeNumber(id) * 2 - (tns.tpe().panelNumber(id) % 2)) + indexHelper[HLS].second;
     case PclHLS::TPEPanelDiskM1:
       return (tns.tpe().halfCylinderNumber(id) == 1)
                  ? (tns.tpe().bladeNumber(id) * 2 - (tns.tpe().panelNumber(id) % 2)) + indexHelper[HLS].first
                  : (tns.tpe().bladeNumber(id) * 2 - (tns.tpe().panelNumber(id) % 2)) + indexHelper[HLS].second;
     case PclHLS::TPEPanelDiskM2:
       return (tns.tpe().halfCylinderNumber(id) == 1)
                  ? (tns.tpe().bladeNumber(id) * 2 - (tns.tpe().panelNumber(id) % 2)) + indexHelper[HLS].first
                  : (tns.tpe().bladeNumber(id) * 2 - (tns.tpe().panelNumber(id) % 2)) + indexHelper[HLS].second;
     case PclHLS::TPEPanelDiskM3:
       return (tns.tpe().halfCylinderNumber(id) == 1)
                  ? (tns.tpe().bladeNumber(id) * 2 - (tns.tpe().panelNumber(id) % 2)) + indexHelper[HLS].first
                  : (tns.tpe().bladeNumber(id) * 2 - (tns.tpe().panelNumber(id) % 2)) + indexHelper[HLS].second;
     default:
       return -200;
   }
 }

◆ getResults()

const mpPCLresults MillePedeFileReader::getResults ( ) const

inline

Definition at line 118 of file MillePedeFileReader.h.

References exitCode_, exitMessage_, isHG_, Nrec_, updateBits_, updateDB_, and vetoUpdateDB_.

                                         {
     return mpPCLresults(updateDB_, vetoUpdateDB_, Nrec_, exitCode_, exitMessage_, updateBits_, isHG_);
   }

◆ getResultsHG()

const std::map<std::string, std::array<bool, 6> >& MillePedeFileReader::getResultsHG ( ) const

inline

Definition at line 122 of file MillePedeFileReader.h.

References fractionExceeded_.

122 { return fractionExceeded_; }

MillePedeFileReader::fractionExceeded_

std::map< std::string, std::array< bool, 6 > > fractionExceeded_

Definition: MillePedeFileReader.h:209

◆ getStringFromHLS()

std::string MillePedeFileReader::getStringFromHLS ( MillePedeFileReader::PclHLS HLS )

private

Definition at line 506 of file MillePedeFileReader.cc.

References Exception, TPBHalfBarrelXminus, TPBHalfBarrelXplus, TPBLadderLayer1, TPBLadderLayer2, TPBLadderLayer3, TPBLadderLayer4, TPEHalfCylinderXminusZminus, TPEHalfCylinderXminusZplus, TPEHalfCylinderXplusZminus, TPEHalfCylinderXplusZplus, TPEPanelDisk1, TPEPanelDisk2, TPEPanelDisk3, TPEPanelDiskM1, TPEPanelDiskM2, and TPEPanelDiskM3.

Referenced by isAlignableActive(), and readMillePedeResultFile().

                                                                              {
   switch (HLS) {
     case PclHLS::TPBHalfBarrelXminus:
       return "TPBHalfBarrelXminus";
     case PclHLS::TPBHalfBarrelXplus:
       return "TPBHalfBarrelXplus";
     case PclHLS::TPEHalfCylinderXminusZminus:
       return "TPEHalfCylinderXminusZminus";
     case PclHLS::TPEHalfCylinderXplusZminus:
       return "TPEHalfCylinderXplusZminus";
     case PclHLS::TPEHalfCylinderXminusZplus:
       return "TPEHalfCylinderXminusZplus";
     case PclHLS::TPEHalfCylinderXplusZplus:
       return "TPEHalfCylinderXplusZplus";
     case PclHLS::TPBLadderLayer1:
       return "TPBLadderLayer1";
     case PclHLS::TPBLadderLayer2:
       return "TPBLadderLayer2";
     case PclHLS::TPBLadderLayer3:
       return "TPBLadderLayer3";
     case PclHLS::TPBLadderLayer4:
       return "TPBLadderLayer4";
     case PclHLS::TPEPanelDisk1:
       return "TPEPanelDisk1";
     case PclHLS::TPEPanelDisk2:
       return "TPEPanelDisk2";
     case PclHLS::TPEPanelDisk3:
       return "TPEPanelDisk3";
     case PclHLS::TPEPanelDiskM1:
       return "TPEPanelDiskM1";
     case PclHLS::TPEPanelDiskM2:
       return "TPEPanelDiskM2";
     case PclHLS::TPEPanelDiskM3:
       return "TPEPanelDiskM3";
     default:
       //return "NotInPCL";
       throw cms::Exception("LogicError")
           << "@SUB=MillePedeFileReader::getStringFromHLS\n"
           << "Found an alignable structure not possible to map in the default AlignPCLThresholdsHG partitions";
   }
 }

◆ getThresholdMap()

const AlignPCLThresholdsHG::threshold_map MillePedeFileReader::getThresholdMap ( ) const

inline

Definition at line 114 of file MillePedeFileReader.h.

References theThresholds_.

114 { return theThresholds_.get()->getThreshold_Map(); }

MillePedeFileReader::theThresholds_

const std::shared_ptr< const AlignPCLThresholdsHG > theThresholds_

Definition: MillePedeFileReader.h:167

◆ getTXobs()

const std::array<double, SIZE_LG_STRUCTS>& MillePedeFileReader::getTXobs ( ) const

inline

Definition at line 86 of file MillePedeFileReader.h.

References tXobs_.

86 { return tXobs_; }

MillePedeFileReader::tXobs_

std::array< double, SIZE_LG_STRUCTS > tXobs_

Definition: MillePedeFileReader.h:217

◆ getTXobs_HG()

const std::array<double, SIZE_HG_STRUCTS>& MillePedeFileReader::getTXobs_HG ( ) const

inline

Definition at line 101 of file MillePedeFileReader.h.

References tXobs_HG_.

101 { return tXobs_HG_; }

MillePedeFileReader::tXobs_HG_

std::array< double, SIZE_HG_STRUCTS > tXobs_HG_

Definition: MillePedeFileReader.h:232

◆ getTXobsErr()

const std::array<double, SIZE_LG_STRUCTS>& MillePedeFileReader::getTXobsErr ( ) const

inline

Definition at line 87 of file MillePedeFileReader.h.

References tXobsErr_.

87 { return tXobsErr_; }

MillePedeFileReader::tXobsErr_

std::array< double, SIZE_LG_STRUCTS > tXobsErr_

Definition: MillePedeFileReader.h:218

◆ getTXobsErr_HG()

const std::array<double, SIZE_HG_STRUCTS>& MillePedeFileReader::getTXobsErr_HG ( ) const

inline

Definition at line 102 of file MillePedeFileReader.h.

References tXobsErr_HG_.

102 { return tXobsErr_HG_; }

MillePedeFileReader::tXobsErr_HG_

std::array< double, SIZE_HG_STRUCTS > tXobsErr_HG_

Definition: MillePedeFileReader.h:233

◆ getTYobs()

const std::array<double, SIZE_LG_STRUCTS>& MillePedeFileReader::getTYobs ( ) const

inline

Definition at line 91 of file MillePedeFileReader.h.

References tYobs_.

91 { return tYobs_; }

MillePedeFileReader::tYobs_

std::array< double, SIZE_LG_STRUCTS > tYobs_

Definition: MillePedeFileReader.h:222

◆ getTYobs_HG()

const std::array<double, SIZE_HG_STRUCTS>& MillePedeFileReader::getTYobs_HG ( ) const

inline

Definition at line 106 of file MillePedeFileReader.h.

References tYobs_HG_.

106 { return tYobs_HG_; }

MillePedeFileReader::tYobs_HG_

std::array< double, SIZE_HG_STRUCTS > tYobs_HG_

Definition: MillePedeFileReader.h:237

◆ getTYobsErr()

const std::array<double, SIZE_LG_STRUCTS>& MillePedeFileReader::getTYobsErr ( ) const

inline

Definition at line 92 of file MillePedeFileReader.h.

References tYobsErr_.

92 { return tYobsErr_; }

MillePedeFileReader::tYobsErr_

std::array< double, SIZE_LG_STRUCTS > tYobsErr_

Definition: MillePedeFileReader.h:223

◆ getTYobsErr_HG()

const std::array<double, SIZE_HG_STRUCTS>& MillePedeFileReader::getTYobsErr_HG ( ) const

inline

Definition at line 107 of file MillePedeFileReader.h.

References tYobsErr_HG_.

107 { return tYobsErr_HG_; }

MillePedeFileReader::tYobsErr_HG_

std::array< double, SIZE_HG_STRUCTS > tYobsErr_HG_

Definition: MillePedeFileReader.h:238

◆ getTZobs()

const std::array<double, SIZE_LG_STRUCTS>& MillePedeFileReader::getTZobs ( ) const

inline

Definition at line 96 of file MillePedeFileReader.h.

References tZobs_.

96 { return tZobs_; }

MillePedeFileReader::tZobs_

std::array< double, SIZE_LG_STRUCTS > tZobs_

Definition: MillePedeFileReader.h:227

◆ getTZobs_HG()

const std::array<double, SIZE_HG_STRUCTS>& MillePedeFileReader::getTZobs_HG ( ) const

inline

Definition at line 111 of file MillePedeFileReader.h.

References tZobs_HG_.

111 { return tZobs_HG_; }

MillePedeFileReader::tZobs_HG_

std::array< double, SIZE_HG_STRUCTS > tZobs_HG_

Definition: MillePedeFileReader.h:242

◆ getTZobsErr()

const std::array<double, SIZE_LG_STRUCTS>& MillePedeFileReader::getTZobsErr ( ) const

inline

Definition at line 97 of file MillePedeFileReader.h.

References tZobsErr_.

97 { return tZobsErr_; }

MillePedeFileReader::tZobsErr_

std::array< double, SIZE_LG_STRUCTS > tZobsErr_

Definition: MillePedeFileReader.h:228

◆ getTZobsErr_HG()

const std::array<double, SIZE_HG_STRUCTS>& MillePedeFileReader::getTZobsErr_HG ( ) const

inline

Definition at line 112 of file MillePedeFileReader.h.

References tZobsErr_HG_.

112 { return tZobsErr_HG_; }

MillePedeFileReader::tZobsErr_HG_

std::array< double, SIZE_HG_STRUCTS > tZobsErr_HG_

Definition: MillePedeFileReader.h:243

◆ getXobs()

const std::array<double, SIZE_LG_STRUCTS>& MillePedeFileReader::getXobs ( ) const

inline

Definition at line 84 of file MillePedeFileReader.h.

References Xobs_.

84 { return Xobs_; }

MillePedeFileReader::Xobs_

std::array< double, SIZE_LG_STRUCTS > Xobs_

Definition: MillePedeFileReader.h:215

◆ getXobs_HG()

const std::array<double, SIZE_HG_STRUCTS>& MillePedeFileReader::getXobs_HG ( ) const

inline

Definition at line 99 of file MillePedeFileReader.h.

References Xobs_HG_.

99 { return Xobs_HG_; }

MillePedeFileReader::Xobs_HG_

std::array< double, SIZE_HG_STRUCTS > Xobs_HG_

Definition: MillePedeFileReader.h:230

◆ getXobsErr()

const std::array<double, SIZE_LG_STRUCTS>& MillePedeFileReader::getXobsErr ( ) const

inline

Definition at line 85 of file MillePedeFileReader.h.

References XobsErr_.

85 { return XobsErr_; }

MillePedeFileReader::XobsErr_

std::array< double, SIZE_LG_STRUCTS > XobsErr_

Definition: MillePedeFileReader.h:216

◆ getXobsErr_HG()

const std::array<double, SIZE_HG_STRUCTS>& MillePedeFileReader::getXobsErr_HG ( ) const

inline

Definition at line 100 of file MillePedeFileReader.h.

References XobsErr_HG_.

100 { return XobsErr_HG_; }

MillePedeFileReader::XobsErr_HG_

std::array< double, SIZE_HG_STRUCTS > XobsErr_HG_

Definition: MillePedeFileReader.h:231

◆ getYobs()

const std::array<double, SIZE_LG_STRUCTS>& MillePedeFileReader::getYobs ( ) const

inline

Definition at line 89 of file MillePedeFileReader.h.

References Yobs_.

89 { return Yobs_; }

MillePedeFileReader::Yobs_

std::array< double, SIZE_LG_STRUCTS > Yobs_

Definition: MillePedeFileReader.h:220

◆ getYobs_HG()

const std::array<double, SIZE_HG_STRUCTS>& MillePedeFileReader::getYobs_HG ( ) const

inline

Definition at line 104 of file MillePedeFileReader.h.

References Yobs_HG_.

104 { return Yobs_HG_; }

MillePedeFileReader::Yobs_HG_

std::array< double, SIZE_HG_STRUCTS > Yobs_HG_

Definition: MillePedeFileReader.h:235

◆ getYobsErr()

const std::array<double, SIZE_LG_STRUCTS>& MillePedeFileReader::getYobsErr ( ) const

inline

Definition at line 90 of file MillePedeFileReader.h.

References YobsErr_.

90 { return YobsErr_; }

MillePedeFileReader::YobsErr_

std::array< double, SIZE_LG_STRUCTS > YobsErr_

Definition: MillePedeFileReader.h:221

◆ getYobsErr_HG()

const std::array<double, SIZE_HG_STRUCTS>& MillePedeFileReader::getYobsErr_HG ( ) const

inline

Definition at line 105 of file MillePedeFileReader.h.

References YobsErr_HG_.

105 { return YobsErr_HG_; }

MillePedeFileReader::YobsErr_HG_

std::array< double, SIZE_HG_STRUCTS > YobsErr_HG_

Definition: MillePedeFileReader.h:236

◆ getZobs()

const std::array<double, SIZE_LG_STRUCTS>& MillePedeFileReader::getZobs ( ) const

inline

Definition at line 94 of file MillePedeFileReader.h.

References Zobs_.

94 { return Zobs_; }

MillePedeFileReader::Zobs_

std::array< double, SIZE_LG_STRUCTS > Zobs_

Definition: MillePedeFileReader.h:225

◆ getZobs_HG()

const std::array<double, SIZE_HG_STRUCTS>& MillePedeFileReader::getZobs_HG ( ) const

inline

Definition at line 109 of file MillePedeFileReader.h.

References Zobs_HG_.

109 { return Zobs_HG_; }

MillePedeFileReader::Zobs_HG_

std::array< double, SIZE_HG_STRUCTS > Zobs_HG_

Definition: MillePedeFileReader.h:240

◆ getZobsErr()

const std::array<double, SIZE_LG_STRUCTS>& MillePedeFileReader::getZobsErr ( ) const

inline

Definition at line 95 of file MillePedeFileReader.h.

References ZobsErr_.

95 { return ZobsErr_; }

MillePedeFileReader::ZobsErr_

std::array< double, SIZE_LG_STRUCTS > ZobsErr_

Definition: MillePedeFileReader.h:226

◆ getZobsErr_HG()

const std::array<double, SIZE_HG_STRUCTS>& MillePedeFileReader::getZobsErr_HG ( ) const

inline

Definition at line 110 of file MillePedeFileReader.h.

References ZobsErr_HG_.

110 { return ZobsErr_HG_; }

MillePedeFileReader::ZobsErr_HG_

std::array< double, SIZE_HG_STRUCTS > ZobsErr_HG_

Definition: MillePedeFileReader.h:241

◆ initializeIndexHelper()

void MillePedeFileReader::initializeIndexHelper ( )

private

Definition at line 548 of file MillePedeFileReader.cc.

References indexHelper, pixelTopologyMap_, TPBLadderLayer1, TPBLadderLayer2, TPBLadderLayer3, TPBLadderLayer4, TPEPanelDisk1, TPEPanelDisk2, TPEPanelDisk3, TPEPanelDiskM1, TPEPanelDiskM2, and TPEPanelDiskM3.

Referenced by read().

                                                 {
   int currentSum = 0;
 
   indexHelper[PclHLS::TPBLadderLayer1] =
       std::make_pair(currentSum, currentSum + pixelTopologyMap_->getPXBLadders(1) / 2);
   currentSum += pixelTopologyMap_->getPXBLadders(1);
   indexHelper[PclHLS::TPBLadderLayer2] =
       std::make_pair(currentSum, currentSum + pixelTopologyMap_->getPXBLadders(2) / 2);
   currentSum += pixelTopologyMap_->getPXBLadders(2);
   indexHelper[PclHLS::TPBLadderLayer3] =
       std::make_pair(currentSum, currentSum + pixelTopologyMap_->getPXBLadders(3) / 2);
   currentSum += pixelTopologyMap_->getPXBLadders(3);
   indexHelper[PclHLS::TPBLadderLayer4] =
       std::make_pair(currentSum, currentSum + pixelTopologyMap_->getPXBLadders(4) / 2);
   currentSum += pixelTopologyMap_->getPXBLadders(4);
 
   indexHelper[PclHLS::TPEPanelDiskM3] = std::make_pair(currentSum, currentSum + pixelTopologyMap_->getPXFBlades(-3));
   currentSum += pixelTopologyMap_->getPXFBlades(-3) * 2;
   indexHelper[PclHLS::TPEPanelDiskM2] = std::make_pair(currentSum, currentSum + pixelTopologyMap_->getPXFBlades(-2));
   currentSum += pixelTopologyMap_->getPXFBlades(-2) * 2;
   indexHelper[PclHLS::TPEPanelDiskM1] = std::make_pair(currentSum, currentSum + pixelTopologyMap_->getPXFBlades(-1));
   currentSum += pixelTopologyMap_->getPXFBlades(-1) * 2;
 
   indexHelper[PclHLS::TPEPanelDisk1] = std::make_pair(currentSum, currentSum + pixelTopologyMap_->getPXFBlades(1));
   currentSum += pixelTopologyMap_->getPXFBlades(1) * 2;
   indexHelper[PclHLS::TPEPanelDisk2] = std::make_pair(currentSum, currentSum + pixelTopologyMap_->getPXFBlades(2));
   currentSum += pixelTopologyMap_->getPXFBlades(2) * 2;
   indexHelper[PclHLS::TPEPanelDisk3] = std::make_pair(currentSum, currentSum + pixelTopologyMap_->getPXFBlades(3));
 }

◆ isAlignableActive()

bool MillePedeFileReader::isAlignableActive	(	const Alignable *	alignable,
		const std::shared_ptr< const SiPixelQuality > &	pixelQual
	)

private

Definition at line 354 of file MillePedeFileReader.cc.

References Alignable::deepComponents(), hcalRecHitTable_cff::detId, spr::find(), getHLS(), getStringFromHLS(), RecoTauValidation_cfi::header, mod(), and MillePedeFileConverter_cfg::out.

Referenced by readMillePedeResultFile().

                                                                                                   {
   std::vector<DetId> detIds;
 
   // Get the list of deep components (lowest daughters) of the Alignable
   const auto& deepComponents = alignable->deepComponents();
 
   // Iterate through the deep components to retrieve their DetIds
   for (const auto& component : deepComponents) {
     DetId detId = component->geomDetId();
     if (detId != DetId(0)) {
       detIds.push_back(detId);
     }
   }
 
   // Counter for bad modules
   int badModuleCount = 0;
   int totalDetIds = detIds.size();
 
   const auto& theDisabledModules = pixelQual->getBadComponentList();
   std::vector<SiPixelQuality::disabledModuleType> theDisabledModuleInAlignable;
   for (const auto& mod : theDisabledModules) {
     if (std::find(detIds.begin(), detIds.end(), mod.DetID) != detIds.end()) {
       theDisabledModuleInAlignable.push_back(mod);
     }
   }
 
   // nothing left to do
   if (theDisabledModuleInAlignable.empty()) {
     return true;
   }
 
   bool header{false};
 
   std::stringstream out;
   for (const auto& mod : theDisabledModuleInAlignable) {
     if (!header)
       out << " Alignable = " << getStringFromHLS(getHLS(alignable));
     header = true;
     bool isBad = pixelQual->IsModuleBad(mod.DetID);
     std::bitset<16> bad_rocs(mod.BadRocs);
     if (isBad || bad_rocs.all()) {
       badModuleCount++;
     }
     out << " " << mod.DetID << " (" << (isBad || bad_rocs.all()) << ") , " << bad_rocs;
   }
   out << std::endl;
 
   if (badModuleCount > 0) {
     out << " " << badModuleCount << " modules are bad out of " << totalDetIds << std::endl;
     edm::LogPrint("MillePedeFileReader") << out.str();
   }
 
   // Return false if at least half of the detIds are bad
   if (badModuleCount >= (totalDetIds + 1) / 2) {
     return false;
   }
 
   // If less than half are bad, return true
   return true;
 }

◆ read()

void MillePedeFileReader::read ( )

Definition at line 36 of file MillePedeFileReader.cc.

References initializeIndexHelper(), isHG_, readMillePedeEndFile(), readMillePedeLogFile(), and readMillePedeResultFile().

Referenced by edmIntegrityCheck.PublishToFileSystem::get(), and MillePedeAlignmentAlgorithm::storeAlignments().

                                 {
   if (isHG_) {
     initializeIndexHelper();
   }
   readMillePedeEndFile();
   readMillePedeLogFile();
   readMillePedeResultFile();
 }

◆ readMillePedeEndFile()

void MillePedeFileReader::readMillePedeEndFile ( )

private

Definition at line 50 of file MillePedeFileReader.cc.

References dirName_, exitCode_, exitMessage_, mps_splice::line, millePedeEndFile_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by read().

                                                 {
   std::ifstream endFile;
   endFile.open((dirName_ + millePedeEndFile_).c_str());
 
   if (endFile.is_open()) {
     edm::LogInfo("MillePedeFileReader") << "Reading millepede end-file";
     std::string line;
     getline(endFile, line);
     std::string trash;
     if (line.find("-1") != std::string::npos) {
       getline(endFile, line);
       exitMessage_ = line;
       std::istringstream iss(line);
       iss >> exitCode_ >> trash;
       edm::LogInfo("MillePedeFileReader")
           << " Pede exit code is: " << exitCode_ << " (" << exitMessage_ << ")" << std::endl;
     } else {
       exitMessage_ = line;
       std::istringstream iss(line);
       iss >> exitCode_ >> trash;
       edm::LogInfo("MillePedeFileReader")
           << " Pede exit code is: " << exitCode_ << " (" << exitMessage_ << ")" << std::endl;
     }
   } else {
     edm::LogError("MillePedeFileReader") << "Could not read millepede end-file.";
     exitMessage_ = "no exit code found";
   }
 }

◆ readMillePedeLogFile()

void MillePedeFileReader::readMillePedeLogFile ( )

private

Definition at line 79 of file MillePedeFileReader.cc.

References binariesAmount_, dirName_, mps_splice::line, heppy_check::logFile, millePedeLogFile_, Nrec_, AlCaHLTBitMon_QueryRunRegistry::string, theThresholds_, and updateDB_.

Referenced by read().

                                                 {
   std::ifstream logFile;
   logFile.open((dirName_ + millePedeLogFile_).c_str());
 
   if (logFile.is_open()) {
     edm::LogInfo("MillePedeFileReader") << "Reading millepede log-file";
     std::string line;
 
     while (getline(logFile, line)) {
       std::string Nrec_string = "NREC =";
       std::string Binaries_string = "C_binary";
 
       if (line.find(Nrec_string) != std::string::npos) {
         std::istringstream iss(line);
         std::string trash;
         iss >> trash >> trash >> Nrec_;
 
         if (Nrec_ < theThresholds_->getNrecords()) {
           edm::LogInfo("MillePedeFileReader")
               << "Number of records used " << theThresholds_->getNrecords() << std::endl;
           updateDB_ = false;
         }
       }
 
       if (line.find(Binaries_string) != std::string::npos) {
         binariesAmount_ += 1;
       }
     }
   } else {
     edm::LogError("MillePedeFileReader") << "Could not read millepede log-file.";
 
     updateDB_ = false;
     Nrec_ = 0;
   }
 }

◆ readMillePedeResultFile()

void MillePedeFileReader::readMillePedeResultFile ( )

private

Definition at line 115 of file MillePedeFileReader.cc.

References funct::abs(), clustersummarymultiplicityprod_cfi::detLabel, dirName_, fractionExceeded_, AlignableObjectId::General, getHLS(), getIndexForHG(), getStringFromHLS(), mps_fire::i, EcalPhiSymFlatTableProducers_cfi::id, ignoreInactiveAlignables_, isAlignableActive(), isHG_, mps_splice::line, millePedeResFile_, multiplier_, NotInPCL, Nrec_, pedeLabeler_, quality_, contentValuesCheck::ss, AlCaHLTBitMon_QueryRunRegistry::string, DetId::subdetId(), AlignPCLThresholds::theta_X, AlignPCLThresholds::theta_Y, AlignPCLThresholds::theta_Z, theThresholds_, unpackBuffers-CaloStage2::token, align::TPBLadder, align::TPEPanel, tXobs_, tXobs_HG_, tXobsErr_, tXobsErr_HG_, tYobs_, tYobs_HG_, tYobsErr_, tYobsErr_HG_, tZobs_, tZobs_HG_, tZobsErr_, tZobsErr_HG_, updateBits_, updateDB_, vetoUpdateDB_, AlignPCLThresholds::X, Xobs_, Xobs_HG_, XobsErr_, XobsErr_HG_, AlignPCLThresholds::Y, Yobs_, Yobs_HG_, YobsErr_, YobsErr_HG_, AlignPCLThresholds::Z, Zobs_, Zobs_HG_, ZobsErr_, and ZobsErr_HG_.

Referenced by read().

                                                    {
   // cutoffs by coordinate and by alignable
   std::map<std::string, std::array<float, 6> > cutoffs_;
   std::map<std::string, std::array<float, 6> > significances_;
   std::map<std::string, std::array<float, 6> > thresholds_;
   std::map<std::string, std::array<float, 6> > errors_;
   std::map<std::string, std::array<float, 6> > fractions_;
 
   std::map<std::string, std::array<int, 6> > countsAbove_;
   std::map<std::string, std::array<int, 6> > countsTotal_;
 
   AlignableObjectId alignableObjectId{AlignableObjectId::Geometry::General};
 
   std::vector<std::string> alignables_ = theThresholds_->getAlignableList();
   for (auto& ali : alignables_) {
     cutoffs_[ali] = theThresholds_->getCut(ali);
     significances_[ali] = theThresholds_->getSigCut(ali);
     thresholds_[ali] = theThresholds_->getMaxMoveCut(ali);
     errors_[ali] = theThresholds_->getMaxErrorCut(ali);
 
     if (theThresholds_->hasFloatMap(ali)) {
       fractions_[ali] = theThresholds_->getFractionCut(ali);
       countsAbove_[ali] = {{0, 0, 0, 0, 0, 0}};
       countsTotal_[ali] = {{0, 0, 0, 0, 0, 0}};
     }
   }
 
   updateDB_ = false;
   vetoUpdateDB_ = false;
   std::ifstream resFile;
   resFile.open((dirName_ + millePedeResFile_).c_str());
 
   if (resFile.is_open()) {
     edm::LogInfo("MillePedeFileReader") << "Reading millepede result-file";
 
     std::string line;
     getline(resFile, line);  // drop first line
 
     while (getline(resFile, line)) {
       std::istringstream iss(line);
 
       std::vector<std::string> tokens;
       std::string token;
       while (iss >> token) {
         tokens.push_back(token);
       }
 
       auto alignableLabel = std::stoul(tokens[0]);
       const auto alignable = pedeLabeler_->alignableFromLabel(alignableLabel);
       auto det = getHLS(alignable);
       // check if the modules associated to the alignable are active
       const bool active = isAlignableActive(alignable, quality_);
       int detIndex = static_cast<int>(det);
       auto alignableIndex = alignableLabel % 10 - 1;
       std::string detLabel = getStringFromHLS(det);
 
       if (!active) {
         edm::LogPrint("MillePedeFileReader") << "Alignable :" << detLabel << " is inactive";
       }
 
       if (tokens.size() > 4 /*3*/) {
         countsTotal_[detLabel][alignableIndex]++;  //Count aligned modules/ladders per structure
         const auto paramNum = pedeLabeler_->paramNumFromLabel(alignableLabel);
         align::StructureType type = alignable->alignableObjectId();
         align::ID id = alignable->id();
 
         double ObsMove = std::stof(tokens[3]) * multiplier_[alignableIndex];
         double ObsErr = std::stof(tokens[4]) * multiplier_[alignableIndex];
 
         auto coord = static_cast<AlignPCLThresholdsHG::coordType>(alignableIndex);
 
         if (det != PclHLS::NotInPCL) {
           if (type != align::TPBLadder && type != align::TPEPanel) {
             switch (coord) {
               case AlignPCLThresholdsHG::X:
                 Xobs_[detIndex] = ObsMove;
                 XobsErr_[detIndex] = ObsErr;
                 break;
               case AlignPCLThresholdsHG::Y:
                 Yobs_[detIndex] = ObsMove;
                 YobsErr_[detIndex] = ObsErr;
                 break;
               case AlignPCLThresholdsHG::Z:
                 Zobs_[detIndex] = ObsMove;
                 ZobsErr_[detIndex] = ObsErr;
                 break;
               case AlignPCLThresholdsHG::theta_X:
                 tXobs_[detIndex] = ObsMove;
                 tXobsErr_[detIndex] = ObsErr;
                 break;
               case AlignPCLThresholdsHG::theta_Y:
                 tYobs_[detIndex] = ObsMove;
                 tYobsErr_[detIndex] = ObsErr;
                 break;
               case AlignPCLThresholdsHG::theta_Z:
                 tZobs_[detIndex] = ObsMove;
                 tZobsErr_[detIndex] = ObsErr;
                 break;
               default:
                 edm::LogError("MillePedeFileReader") << "Currently not able to handle DOF " << coord << std::endl;
                 break;
             }
           } else {
             auto hgIndex = getIndexForHG(id, det);
             switch (coord) {
               case AlignPCLThresholdsHG::X:
                 Xobs_HG_[hgIndex - 1] = ObsMove;
                 XobsErr_HG_[hgIndex - 1] = ObsErr;
                 break;
               case AlignPCLThresholdsHG::Y:
                 Yobs_HG_[hgIndex - 1] = ObsMove;
                 YobsErr_HG_[hgIndex - 1] = ObsErr;
                 break;
               case AlignPCLThresholdsHG::Z:
                 Zobs_HG_[hgIndex - 1] = ObsMove;
                 ZobsErr_HG_[hgIndex - 1] = ObsErr;
                 break;
               case AlignPCLThresholdsHG::theta_X:
                 tXobs_HG_[hgIndex - 1] = ObsMove;
                 tXobsErr_HG_[hgIndex - 1] = ObsErr;
                 break;
               case AlignPCLThresholdsHG::theta_Y:
                 tYobs_HG_[hgIndex - 1] = ObsMove;
                 tYobsErr_HG_[hgIndex - 1] = ObsErr;
                 break;
               case AlignPCLThresholdsHG::theta_Z:
                 tZobs_HG_[hgIndex - 1] = ObsMove;
                 tZobsErr_HG_[hgIndex - 1] = ObsErr;
                 break;
               default:
                 edm::LogError("MillePedeFileReader") << "Currently not able to handle DOF " << coord << std::endl;
                 break;
             }
           }
 
         } else {
           edm::LogError("MillePedeFileReader")
               << "Currently not able to handle coordinate: " << coord << " (" << paramNum << ")  "
               << Form(" %s with ID %d (subdet %d)", alignableObjectId.idToString(type), id, DetId(id).subdetId())
               << std::endl;
           continue;
         }
 
         edm::LogVerbatim("MillePedeFileReader")
             << " alignableLabel: " << alignableLabel << " with alignableIndex " << alignableIndex << " detIndex "
             << detIndex << "\n"
             << " i.e. detLabel: " << detLabel << " (" << coord << ")\n"
             << " has movement: " << ObsMove << " +/- " << ObsErr << "\n"
             << " cutoff (cutoffs_[" << detLabel << "][" << coord << "]): " << cutoffs_[detLabel][alignableIndex] << "\n"
             << " significance (significances_[" << detLabel << "][" << coord
             << "]): " << significances_[detLabel][alignableIndex] << "\n"
             << " error thresolds (errors_[" << detLabel << "][" << coord << "]): " << errors_[detLabel][alignableIndex]
             << "\n"
             << " max movement (thresholds_[" << detLabel << "][" << coord
             << "]): " << thresholds_[detLabel][alignableIndex] << "\n"
             << " fraction (fractions_[" << detLabel << "][" << coord << "]): " << fractions_[detLabel][alignableIndex]
             << "\n"
             << "=============" << std::endl;
 
         if (std::abs(ObsMove) > thresholds_[detLabel][alignableIndex]) {
           if (active || ignoreInactiveAlignables_) {
             edm::LogWarning("MillePedeFileReader")
                 << "Aborting payload creation."
                 << " Exceeding maximum thresholds for movement: " << std::abs(ObsMove) << " for " << detLabel << " ("
                 << coord << ")";
             updateBits_.set(0);
             vetoUpdateDB_ = true;
             continue;
           } else {
             edm::LogInfo("MillePedeFileReader")
                 << " Exceeding maximum thresholds for movement: " << std::abs(ObsMove) << " for " << detLabel << " ("
                 << coord << ") but continuing as the alignable is inactive!";
           }
 
         } else if (std::abs(ObsMove) > cutoffs_[detLabel][alignableIndex]) {
           updateBits_.set(1);
 
           if (std::abs(ObsErr) > errors_[detLabel][alignableIndex]) {
             edm::LogWarning("MillePedeFileReader") << "Aborting payload creation."
                                                    << " Exceeding maximum thresholds for error: " << std::abs(ObsErr)
                                                    << " for" << detLabel << "(" << coord << ")";
             updateBits_.set(2);
             vetoUpdateDB_ = true;
             continue;
           } else {
             if (std::abs(ObsMove / ObsErr) < significances_[detLabel][alignableIndex]) {
               updateBits_.set(3);
               continue;
             }
           }
           updateDB_ = true;
           if (!isHG_) {
             edm::LogInfo("MillePedeFileReader")
                 << "This correction: " << ObsMove << "+/-" << ObsErr << " for " << detLabel << "(" << coord
                 << ") will trigger a new Tracker Alignment payload!";
           }
           countsAbove_[detLabel][alignableIndex]++;
         }
       }
     }
   } else {
     edm::LogError("MillePedeFileReader") << "Could not read millepede result-file.";
 
     updateDB_ = false;
     Nrec_ = 0;
   }
 
   if (isHG_) {          // check fractionCut
     updateDB_ = false;  // reset booleans since fractionCut is considered for HG
     std::stringstream ss;
     for (auto& ali : alignables_) {
       ss << ali << std::endl;
       for (long unsigned int i = 0; i < countsTotal_[ali].size(); i++) {
         if (countsTotal_[ali][i] != 0 && fractions_[ali][i] != -1) {
           float fraction_ = countsAbove_[ali][i] / (1.0 * countsTotal_[ali][i]);
           ss << static_cast<AlignPCLThresholdsHG::coordType>(i) << ":   Fraction = " << fraction_
              << "   Fraction Threshold = " << fractions_[ali][i];
           if (fraction_ >= fractions_[ali][i]) {
             updateDB_ = true;
             ss << "   above fraction threshold" << std::endl;
             fractionExceeded_[ali][i] = true;
           } else {
             ss << std::endl;
             fractionExceeded_[ali][i] = false;
           }
         } else
           ss << "No entries available or no fraction thresholds defined" << std::endl;
       }
       ss << "===================" << std::endl;
     }
     if (updateDB_ && !vetoUpdateDB_) {
       ss << "Alignment will be updated" << std::endl;
     } else {
       ss << "Alignment will NOT be updated" << std::endl;
     }
     edm::LogWarning("MillePedeFileReader") << ss.str();
   }
 }

◆ storeAlignments()

bool MillePedeFileReader::storeAlignments ( )

Definition at line 45 of file MillePedeFileReader.cc.

References updateDB_, and vetoUpdateDB_.

Referenced by MillePedeAlignmentAlgorithm::storeAlignments().

45 { return (updateDB_ && !vetoUpdateDB_); }

MillePedeFileReader::vetoUpdateDB_

bool vetoUpdateDB_

Definition: MillePedeFileReader.h:195

MillePedeFileReader::updateDB_

bool updateDB_

Definition: MillePedeFileReader.h:194

Member Data Documentation

◆ binariesAmount_

int MillePedeFileReader::binariesAmount_ {0}

private

Definition at line 206 of file MillePedeFileReader.h.

Referenced by binariesAmount(), and readMillePedeLogFile().

◆ dirName_

std::string MillePedeFileReader::dirName_

private

Definition at line 179 of file MillePedeFileReader.h.

Referenced by MillePedeFileReader(), readMillePedeEndFile(), readMillePedeLogFile(), and readMillePedeResultFile().

◆ exitCode_

int MillePedeFileReader::exitCode_ {-1}

private

Definition at line 212 of file MillePedeFileReader.h.

Referenced by getResults(), and readMillePedeEndFile().

◆ exitMessage_

std::string MillePedeFileReader::exitMessage_ {""}

private

Definition at line 213 of file MillePedeFileReader.h.

Referenced by getResults(), and readMillePedeEndFile().

◆ fractionExceeded_

std::map<std::string, std::array<bool, 6> > MillePedeFileReader::fractionExceeded_

private

Definition at line 209 of file MillePedeFileReader.h.

Referenced by getResultsHG(), and readMillePedeResultFile().

◆ ignoreInactiveAlignables_

const bool MillePedeFileReader::ignoreInactiveAlignables_

private

Definition at line 173 of file MillePedeFileReader.h.

Referenced by readMillePedeResultFile().

◆ indexHelper

std::unordered_map<PclHLS, std::pair<int, int> > MillePedeFileReader::indexHelper

private

Definition at line 245 of file MillePedeFileReader.h.

Referenced by getIndexForHG(), and initializeIndexHelper().

◆ isHG_

const bool MillePedeFileReader::isHG_

private

Definition at line 196 of file MillePedeFileReader.h.

Referenced by getResults(), read(), and readMillePedeResultFile().

◆ millePedeEndFile_

const std::string MillePedeFileReader::millePedeEndFile_

private

Definition at line 182 of file MillePedeFileReader.h.

Referenced by readMillePedeEndFile().

◆ millePedeLogFile_

const std::string MillePedeFileReader::millePedeLogFile_

private

Definition at line 183 of file MillePedeFileReader.h.

Referenced by readMillePedeLogFile().

◆ millePedeResFile_

const std::string MillePedeFileReader::millePedeResFile_

private

Definition at line 184 of file MillePedeFileReader.h.

Referenced by readMillePedeResultFile().

◆ multiplier_

constexpr std::array< double, 6 > MillePedeFileReader::multiplier_

staticprivate

Initial value:

= {{10000.,      
                                                         10000.,      
                                                         10000.,      
                                                         1000000.,    
                                                         1000000.,    
                                                         1000000.}}

Definition at line 187 of file MillePedeFileReader.h.

Referenced by readMillePedeResultFile().

◆ Nrec_

int MillePedeFileReader::Nrec_ {0}

private

Definition at line 211 of file MillePedeFileReader.h.

Referenced by getResults(), readMillePedeLogFile(), and readMillePedeResultFile().

◆ pedeLabeler_

const std::shared_ptr<const PedeLabelerBase> MillePedeFileReader::pedeLabeler_

private

Definition at line 164 of file MillePedeFileReader.h.

Referenced by getHLS(), getIndexForHG(), and readMillePedeResultFile().

◆ pixelTopologyMap_

const std::shared_ptr<const PixelTopologyMap> MillePedeFileReader::pixelTopologyMap_

private

Definition at line 170 of file MillePedeFileReader.h.

Referenced by initializeIndexHelper().

◆ quality_

const std::shared_ptr<const SiPixelQuality> MillePedeFileReader::quality_

private

Definition at line 176 of file MillePedeFileReader.h.

Referenced by readMillePedeResultFile().

◆ theThresholds_

const std::shared_ptr<const AlignPCLThresholdsHG> MillePedeFileReader::theThresholds_

private

Definition at line 167 of file MillePedeFileReader.h.

Referenced by getThresholdMap(), readMillePedeLogFile(), and readMillePedeResultFile().

◆ tXobs_

std::array<double, SIZE_LG_STRUCTS> MillePedeFileReader::tXobs_ = std::array<double, SIZE_LG_STRUCTS>()

private

Definition at line 217 of file MillePedeFileReader.h.

Referenced by getTXobs(), and readMillePedeResultFile().

◆ tXobs_HG_

std::array<double, SIZE_HG_STRUCTS> MillePedeFileReader::tXobs_HG_ = std::array<double, SIZE_HG_STRUCTS>()

private

Definition at line 232 of file MillePedeFileReader.h.

Referenced by getTXobs_HG(), and readMillePedeResultFile().

◆ tXobsErr_

std::array<double, SIZE_LG_STRUCTS> MillePedeFileReader::tXobsErr_ = std::array<double, SIZE_LG_STRUCTS>()

private

Definition at line 218 of file MillePedeFileReader.h.

Referenced by getTXobsErr(), and readMillePedeResultFile().

◆ tXobsErr_HG_

std::array<double, SIZE_HG_STRUCTS> MillePedeFileReader::tXobsErr_HG_ = std::array<double, SIZE_HG_STRUCTS>()

private

Definition at line 233 of file MillePedeFileReader.h.

Referenced by getTXobsErr_HG(), and readMillePedeResultFile().

◆ tYobs_

std::array<double, SIZE_LG_STRUCTS> MillePedeFileReader::tYobs_ = std::array<double, SIZE_LG_STRUCTS>()

private

Definition at line 222 of file MillePedeFileReader.h.

Referenced by getTYobs(), and readMillePedeResultFile().

◆ tYobs_HG_

std::array<double, SIZE_HG_STRUCTS> MillePedeFileReader::tYobs_HG_ = std::array<double, SIZE_HG_STRUCTS>()

private

Definition at line 237 of file MillePedeFileReader.h.

Referenced by getTYobs_HG(), and readMillePedeResultFile().

◆ tYobsErr_

std::array<double, SIZE_LG_STRUCTS> MillePedeFileReader::tYobsErr_ = std::array<double, SIZE_LG_STRUCTS>()

private

Definition at line 223 of file MillePedeFileReader.h.

Referenced by getTYobsErr(), and readMillePedeResultFile().

◆ tYobsErr_HG_

std::array<double, SIZE_HG_STRUCTS> MillePedeFileReader::tYobsErr_HG_ = std::array<double, SIZE_HG_STRUCTS>()

private

Definition at line 238 of file MillePedeFileReader.h.

Referenced by getTYobsErr_HG(), and readMillePedeResultFile().

◆ tZobs_

std::array<double, SIZE_LG_STRUCTS> MillePedeFileReader::tZobs_ = std::array<double, SIZE_LG_STRUCTS>()

private

Definition at line 227 of file MillePedeFileReader.h.

Referenced by getTZobs(), and readMillePedeResultFile().

◆ tZobs_HG_

std::array<double, SIZE_HG_STRUCTS> MillePedeFileReader::tZobs_HG_ = std::array<double, SIZE_HG_STRUCTS>()

private

Definition at line 242 of file MillePedeFileReader.h.

Referenced by getTZobs_HG(), and readMillePedeResultFile().

◆ tZobsErr_

std::array<double, SIZE_LG_STRUCTS> MillePedeFileReader::tZobsErr_ = std::array<double, SIZE_LG_STRUCTS>()

private

Definition at line 228 of file MillePedeFileReader.h.

Referenced by getTZobsErr(), and readMillePedeResultFile().

◆ tZobsErr_HG_

std::array<double, SIZE_HG_STRUCTS> MillePedeFileReader::tZobsErr_HG_ = std::array<double, SIZE_HG_STRUCTS>()

private

Definition at line 243 of file MillePedeFileReader.h.

Referenced by getTZobsErr_HG(), and readMillePedeResultFile().

◆ updateBits_

std::bitset<4> MillePedeFileReader::updateBits_

private

Definition at line 203 of file MillePedeFileReader.h.

Referenced by getResults(), and readMillePedeResultFile().

◆ updateDB_

bool MillePedeFileReader::updateDB_ {false}

private

Definition at line 194 of file MillePedeFileReader.h.

Referenced by getResults(), readMillePedeLogFile(), readMillePedeResultFile(), and storeAlignments().

◆ vetoUpdateDB_

bool MillePedeFileReader::vetoUpdateDB_ {false}

private

Definition at line 195 of file MillePedeFileReader.h.

Referenced by getResults(), readMillePedeResultFile(), and storeAlignments().

◆ Xobs_

std::array<double, SIZE_LG_STRUCTS> MillePedeFileReader::Xobs_ = std::array<double, SIZE_LG_STRUCTS>()

private

Definition at line 215 of file MillePedeFileReader.h.

Referenced by getXobs(), and readMillePedeResultFile().

◆ Xobs_HG_

std::array<double, SIZE_HG_STRUCTS> MillePedeFileReader::Xobs_HG_ = std::array<double, SIZE_HG_STRUCTS>()

private

Definition at line 230 of file MillePedeFileReader.h.

Referenced by getXobs_HG(), and readMillePedeResultFile().

◆ XobsErr_

std::array<double, SIZE_LG_STRUCTS> MillePedeFileReader::XobsErr_ = std::array<double, SIZE_LG_STRUCTS>()

private

Definition at line 216 of file MillePedeFileReader.h.

Referenced by getXobsErr(), and readMillePedeResultFile().

◆ XobsErr_HG_

std::array<double, SIZE_HG_STRUCTS> MillePedeFileReader::XobsErr_HG_ = std::array<double, SIZE_HG_STRUCTS>()

private

Definition at line 231 of file MillePedeFileReader.h.

Referenced by getXobsErr_HG(), and readMillePedeResultFile().

◆ Yobs_

std::array<double, SIZE_LG_STRUCTS> MillePedeFileReader::Yobs_ = std::array<double, SIZE_LG_STRUCTS>()

private

Definition at line 220 of file MillePedeFileReader.h.

Referenced by getYobs(), and readMillePedeResultFile().

◆ Yobs_HG_

std::array<double, SIZE_HG_STRUCTS> MillePedeFileReader::Yobs_HG_ = std::array<double, SIZE_HG_STRUCTS>()

private

Definition at line 235 of file MillePedeFileReader.h.

Referenced by getYobs_HG(), and readMillePedeResultFile().

◆ YobsErr_

std::array<double, SIZE_LG_STRUCTS> MillePedeFileReader::YobsErr_ = std::array<double, SIZE_LG_STRUCTS>()

private

Definition at line 221 of file MillePedeFileReader.h.

Referenced by getYobsErr(), and readMillePedeResultFile().

◆ YobsErr_HG_

std::array<double, SIZE_HG_STRUCTS> MillePedeFileReader::YobsErr_HG_ = std::array<double, SIZE_HG_STRUCTS>()

private

Definition at line 236 of file MillePedeFileReader.h.

Referenced by getYobsErr_HG(), and readMillePedeResultFile().

◆ Zobs_

std::array<double, SIZE_LG_STRUCTS> MillePedeFileReader::Zobs_ = std::array<double, SIZE_LG_STRUCTS>()

private

Definition at line 225 of file MillePedeFileReader.h.

Referenced by getZobs(), and readMillePedeResultFile().

◆ Zobs_HG_

std::array<double, SIZE_HG_STRUCTS> MillePedeFileReader::Zobs_HG_ = std::array<double, SIZE_HG_STRUCTS>()

private

Definition at line 240 of file MillePedeFileReader.h.

Referenced by getZobs_HG(), and readMillePedeResultFile().

◆ ZobsErr_

std::array<double, SIZE_LG_STRUCTS> MillePedeFileReader::ZobsErr_ = std::array<double, SIZE_LG_STRUCTS>()

private

Definition at line 226 of file MillePedeFileReader.h.

Referenced by getZobsErr(), and readMillePedeResultFile().

◆ ZobsErr_HG_

std::array<double, SIZE_HG_STRUCTS> MillePedeFileReader::ZobsErr_HG_ = std::array<double, SIZE_HG_STRUCTS>()

private

Definition at line 241 of file MillePedeFileReader.h.

Referenced by getZobsErr_HG(), and readMillePedeResultFile().

Public Types

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Enumeration Documentation

◆ anonymous enum

◆ PclHLS

Constructor & Destructor Documentation

◆ MillePedeFileReader()

◆ ~MillePedeFileReader()

Member Function Documentation

◆ binariesAmount()

◆ fillPSetDescription()

◆ getHLS()

◆ getIndexForHG()

◆ getResults()

◆ getResultsHG()

◆ getStringFromHLS()

◆ getThresholdMap()

◆ getTXobs()

◆ getTXobs_HG()

◆ getTXobsErr()

◆ getTXobsErr_HG()

◆ getTYobs()

◆ getTYobs_HG()

◆ getTYobsErr()

◆ getTYobsErr_HG()

◆ getTZobs()

◆ getTZobs_HG()

◆ getTZobsErr()

◆ getTZobsErr_HG()

◆ getXobs()

◆ getXobs_HG()

◆ getXobsErr()

◆ getXobsErr_HG()

◆ getYobs()

◆ getYobs_HG()

◆ getYobsErr()

◆ getYobsErr_HG()

◆ getZobs()

◆ getZobs_HG()

◆ getZobsErr()

◆ getZobsErr_HG()

◆ initializeIndexHelper()

◆ isAlignableActive()

◆ read()

◆ readMillePedeEndFile()

◆ readMillePedeLogFile()

◆ readMillePedeResultFile()

◆ storeAlignments()

Member Data Documentation

◆ binariesAmount_

◆ dirName_

◆ exitCode_

◆ exitMessage_

◆ fractionExceeded_

◆ ignoreInactiveAlignables_

◆ indexHelper

◆ isHG_

◆ millePedeEndFile_

◆ millePedeLogFile_

◆ millePedeResFile_

◆ multiplier_

◆ Nrec_

◆ pedeLabeler_

◆ pixelTopologyMap_

◆ quality_

◆ theThresholds_

◆ tXobs_

◆ tXobs_HG_

◆ tXobsErr_

◆ tXobsErr_HG_

◆ tYobs_

◆ tYobs_HG_

◆ tYobsErr_

◆ tYobsErr_HG_