#include <HIPAlignmentAlgorithm.h>

Inheritance diagram for HIPAlignmentAlgorithm:

Public Member Functions
	HIPAlignmentAlgorithm (const edm::ParameterSet &cfg)
	Constructor. More...

void	initialize (const edm::EventSetup &setup, AlignableTracker tracker, AlignableMuon muon, AlignableExtras extras, AlignmentParameterStore store) override
	Call at beginning of job. More...

void	run (const edm::EventSetup &setup, const EventInfo &eventInfo) override
	Run the algorithm. More...

void	startNewLoop (void) override
	Called at start of new loop. More...

void	terminate (const edm::EventSetup &setup) override
	Call at end of job. More...

	~HIPAlignmentAlgorithm () override
	Destructor. More...

Public Member Functions inherited from AlignmentAlgorithmBase
virtual bool	addCalibrations (const Calibrations &)

bool	addCalibrations (const CalibrationsOwner &cals)

	AlignmentAlgorithmBase (const edm::ParameterSet &)
	Constructor. More...

virtual void	beginLuminosityBlock (const edm::EventSetup &setup)
	called at begin of luminosity block (no lumi block info passed yet) More...

virtual void	beginRun (const edm::Run &, const edm::EventSetup &, bool changed)
	called at begin of run More...

virtual void	endLuminosityBlock (const edm::EventSetup &setup)
	called at end of luminosity block (no lumi block info passed yet) More...

virtual void	endRun (const EndRunInfo &runInfo, const edm::EventSetup &setup)
	called at end of run - order of arguments like in EDProducer etc. More...

virtual bool	processesEvents ()
	Returns whether algorithm proccesses events in current configuration. More...

virtual bool	setParametersForRunRange (const RunRange &rr)

virtual bool	storeAlignments ()
	Returns whether algorithm produced results to be stored. More...

virtual bool	supportsCalibrations ()

virtual void	terminate ()
	Called at end of job (must be implemented in derived class) More...

virtual	~AlignmentAlgorithmBase ()
	Destructor. More...

Private Member Functions
void	bookRoot (void)

double	calcAPE (double *par, int iter, int function)

bool	calcParameters (Alignable *ali, int setDet, double start, double step)

void	collectMonitorTrees (const std::vector< std::string > &filenames)

void	collector (void)

void	fillAlignablesMonitor (const edm::EventSetup &setup)

HIPAlignableSpecificParameters *	findAlignableSpecs (const Alignable *ali)

bool	processHit1D (const AlignableDetOrUnitPtr &alidet, const Alignable ali, const HIPAlignableSpecificParameters alispecifics, const TrajectoryStateOnSurface &tsos, const TrackingRecHit *hit, double hitwt)

bool	processHit2D (const AlignableDetOrUnitPtr &alidet, const Alignable ali, const HIPAlignableSpecificParameters alispecifics, const TrajectoryStateOnSurface &tsos, const TrackingRecHit *hit, double hitwt)

int	readIterationFile (std::string filename)

void	setAlignmentPositionError (void)

void	writeIterationFile (std::string filename, int iter)

Private Attributes
std::unique_ptr< AlignableObjectId >	alignableObjectId_

double	col_cut

double	cos_cut

HIPAlignableSpecificParameters	defaultAlignableSpecs

const bool	doTrackHitMonitoring

int	ioerr

bool	isCollector

bool	IsCollision

int	m2_datatype

SurfaceDeformationFactory::Type	m2_dtype

align::ID	m2_Id

int	m2_Layer

int	m2_Nhit

unsigned int	m2_nsurfdef

align::StructureType	m2_ObjId

std::vector< float >	m2_surfDef

int	m2_Type

float	m2_Xpos

float	m2_Ypos

float	m2_Zpos

align::ID	m3_Id

align::StructureType	m3_ObjId

float	m3_par [6]

int	m_datatype

std::string	outfile2

std::string	outpath

bool	rewgtPerAli

std::string	salignedfile

double	Scale

std::vector< double >	SetScanDet

std::string	siterationfile

std::string	smisalignedfile

std::string	sparameterfile

std::string	ssurveyfile

std::string	struefile

const std::vector< std::string >	surveyResiduals_

std::string	suvarfile

std::string	suvarfilecore

std::unique_ptr< AlignableNavigator >	theAlignableDetAccessor

align::Alignables	theAlignables

TFile *	theAlignablesMonitorIORootFile

TTree *	theAlignablesMonitorTree

std::vector< HIPAlignableSpecificParameters >	theAlignableSpecifics

AlignmentParameterStore *	theAlignmentParameterStore

std::vector< std::pair< align::Alignables, std::vector< double > > >	theAPEParameters

std::vector< edm::ParameterSet >	theAPEParameterSet

bool	theApplyAPE

bool	theApplyCutsPerComponent

int	theCollectorNJobs

std::string	theCollectorPath

std::vector< edm::ParameterSet >	theCutsPerComponent

int	theDataGroup

std::unique_ptr< TFormula >	theEtaFormula

TTree *	theHitMonitorTree

AlignmentIORoot	theIO

std::vector< unsigned >	theIOVrangeSet

int	theIteration

std::vector< align::StructureType >	theLevels

HIPMonitorConfig	theMonitorConfig

bool	themultiIOV

TFile *	theSurveyIORootFile

TTree *	theSurveyTree

TFile *	theTrackHitMonitorIORootFile

TTree *	theTrackMonitorTree

bool	trackPs

bool	trackWt

bool	uniEta

std::string	uniEtaFormula

const bool	verbose

Additional Inherited Members
Public Types inherited from AlignmentAlgorithmBase
typedef std::pair< const Trajectory , const reco::Track >	ConstTrajTrackPair

typedef std::vector< ConstTrajTrackPair >	ConstTrajTrackPairCollection

using	RunNumber = align::RunNumber

using	RunRange = align::RunRange

Detailed Description

Definition at line 31 of file HIPAlignmentAlgorithm.h.

Constructor & Destructor Documentation

HIPAlignmentAlgorithm::HIPAlignmentAlgorithm ( const edm::ParameterSet & cfg )

Constructor.

Definition at line 45 of file HIPAlignmentAlgorithm.cc.

References col_cut, cos_cut, defaultAlignableSpecs, edm::ParameterSet::getParameter(), isCollector, IsCollision, HIPAlignableSpecificParameters::maxHitPull, HIPAlignableSpecificParameters::maxRelParError, HIPAlignableSpecificParameters::minNHits, HIPAlignableSpecificParameters::minRelParError, outfile2, outpath, rewgtPerAli, salignedfile, Scale, SetScanDet, siterationfile, smisalignedfile, sparameterfile, ssurveyfile, AlCaHLTBitMon_QueryRunRegistry::string, struefile, suvarfile, suvarfilecore, theAPEParameterSet, theApplyAPE, theApplyCutsPerComponent, theCollectorNJobs, theCollectorPath, theCutsPerComponent, theDataGroup, theEtaFormula, theIOVrangeSet, themultiIOV, trackPs, trackWt, uniEta, and uniEtaFormula.

     : AlignmentAlgorithmBase(cfg),
       verbose(cfg.getParameter<bool>("verbosity")),
       theMonitorConfig(cfg),
       doTrackHitMonitoring(theMonitorConfig.fillTrackMonitoring || theMonitorConfig.fillTrackHitMonitoring),
       defaultAlignableSpecs((Alignable*)nullptr),
       surveyResiduals_(cfg.getUntrackedParameter<std::vector<std::string>>("surveyResiduals")),
       theTrackHitMonitorIORootFile(nullptr),
       theTrackMonitorTree(nullptr),
       theHitMonitorTree(nullptr),
       theAlignablesMonitorIORootFile(nullptr),
       theAlignablesMonitorTree(nullptr),
       theSurveyIORootFile(nullptr),
       theSurveyTree(nullptr) {
   // parse parameters
   outpath = cfg.getParameter<std::string>("outpath");
   outfile2 = cfg.getParameter<std::string>("outfile2");
   struefile = cfg.getParameter<std::string>("trueFile");
   smisalignedfile = cfg.getParameter<std::string>("misalignedFile");
   salignedfile = cfg.getParameter<std::string>("alignedFile");
   siterationfile = cfg.getParameter<std::string>("iterationFile");
   suvarfilecore = cfg.getParameter<std::string>("uvarFile");
   suvarfile = suvarfilecore;
   sparameterfile = cfg.getParameter<std::string>("parameterFile");
   ssurveyfile = cfg.getParameter<std::string>("surveyFile");
 
   outfile2 = outpath + outfile2;  //Alignablewise tree
   struefile = outpath + struefile;
   smisalignedfile = outpath + smisalignedfile;
   salignedfile = outpath + salignedfile;
   siterationfile = outpath + siterationfile;
   suvarfile = outpath + suvarfile;
   sparameterfile = outpath + sparameterfile;
   ssurveyfile = outpath + ssurveyfile;
 
   // parameters for APE
   theApplyAPE = cfg.getParameter<bool>("applyAPE");
   theAPEParameterSet = cfg.getParameter<std::vector<edm::ParameterSet>>("apeParam");
 
   themultiIOV = cfg.getParameter<bool>("multiIOV");
   theIOVrangeSet = cfg.getParameter<std::vector<unsigned>>("IOVrange");
 
   defaultAlignableSpecs.minNHits = cfg.getParameter<int>("minimumNumberOfHits");
   ;
   defaultAlignableSpecs.minRelParError = cfg.getParameter<double>("minRelParameterError");
   defaultAlignableSpecs.maxRelParError = cfg.getParameter<double>("maxRelParameterError");
   defaultAlignableSpecs.maxHitPull = cfg.getParameter<double>("maxAllowedHitPull");
   theApplyCutsPerComponent = cfg.getParameter<bool>("applyCutsPerComponent");
   theCutsPerComponent = cfg.getParameter<std::vector<edm::ParameterSet>>("cutsPerComponent");
 
   // for collector mode (parallel processing)
   isCollector = cfg.getParameter<bool>("collectorActive");
   theCollectorNJobs = cfg.getParameter<int>("collectorNJobs");
   theCollectorPath = cfg.getParameter<std::string>("collectorPath");
 
   if (isCollector)
     edm::LogInfo("Alignment") << "@SUB=HIPAlignmentAlgorithm::HIPAlignmentAlgorithm"
                               << "Collector mode";
 
   trackPs = cfg.getParameter<bool>("UsePreSelection");
   theDataGroup = cfg.getParameter<int>("DataGroup");
   trackWt = cfg.getParameter<bool>("UseReweighting");
   Scale = cfg.getParameter<double>("Weight");
   uniEta = trackWt && cfg.getParameter<bool>("UniformEta");
   uniEtaFormula = cfg.getParameter<std::string>("UniformEtaFormula");
   if (uniEtaFormula.empty()) {
     edm::LogWarning("Alignment") << "@SUB=HIPAlignmentAlgorithm::HIPAlignmentAlgorithm"
                                  << "Uniform eta formula is empty! Resetting to 1.";
     uniEtaFormula = "1";
   }
   theEtaFormula = std::make_unique<TFormula>(uniEtaFormula.c_str());
   rewgtPerAli = trackWt && cfg.getParameter<bool>("ReweightPerAlignable");
   IsCollision = cfg.getParameter<bool>("isCollision");
   SetScanDet = cfg.getParameter<std::vector<double>>("setScanDet");
   col_cut = cfg.getParameter<double>("CLAngleCut");
   cos_cut = cfg.getParameter<double>("CSAngleCut");
 
   edm::LogInfo("Alignment") << "@SUB=HIPAlignmentAlgorithm::HIPAlignmentAlgorithm"
                             << "Constructed";
 }

HIPAlignmentAlgorithm::~HIPAlignmentAlgorithm ( )

inlineoverride

Member Function Documentation

void HIPAlignmentAlgorithm::bookRoot ( void )

private

Definition at line 1093 of file HIPAlignmentAlgorithm.cc.

References HIPTrackMonitorVariables::bookBranches(), HIPHitMonitorVariables::bookBranches(), doTrackHitMonitoring, HIPMonitorConfig::fillTrackHitMonitoring, HIPMonitorConfig::fillTrackMonitoring, HIPMonitorConfig::hitmonitorvars, isCollector, m2_datatype, m2_dtype, m2_Id, m2_Layer, m2_Nhit, m2_nsurfdef, m2_ObjId, m2_surfDef, m2_Type, m2_Xpos, m2_Ypos, m2_Zpos, m3_Id, m3_ObjId, m3_par, m_datatype, HIPMonitorConfig::outfile, outfile2, HIPMonitorVariables::setTree(), ssurveyfile, theAlignablesMonitorIORootFile, theAlignablesMonitorTree, theHitMonitorTree, theIteration, theLevels, theMonitorConfig, theSurveyIORootFile, theSurveyTree, theTrackHitMonitorIORootFile, theTrackMonitorTree, cond::persistency::GLOBAL_TAG::tname, and HIPMonitorConfig::trackmonitorvars.

Referenced by startNewLoop(), and ~HIPAlignmentAlgorithm().

                                          {
   // create ROOT files
   if (doTrackHitMonitoring && !isCollector) {
     theTrackHitMonitorIORootFile = TFile::Open(theMonitorConfig.outfile.c_str(), "update");
     theTrackHitMonitorIORootFile->cd();
     // book event-wise ROOT Tree
     if (theMonitorConfig.fillTrackMonitoring) {
       TString tname = Form("T1_%i", theIteration);
       theTrackMonitorTree = new TTree(tname, "Eventwise tree");
       //theTrackMonitorTree->Branch("Run",     &m_Run,     "Run/I");
       //theTrackMonitorTree->Branch("Event",   &m_Event,   "Event/I");
       theTrackMonitorTree->Branch("DataType", &m_datatype);
       theMonitorConfig.trackmonitorvars.setTree(theTrackMonitorTree);
       theMonitorConfig.trackmonitorvars.bookBranches();
     }
     // book hit-wise ROOT Tree
     if (theMonitorConfig.fillTrackHitMonitoring) {
       TString tname_hit = Form("T1_hit_%i", theIteration);
       theHitMonitorTree = new TTree(tname_hit, "Hitwise tree");
       theHitMonitorTree->Branch("DataType", &m_datatype);
       theMonitorConfig.hitmonitorvars.setTree(theHitMonitorTree);
       theMonitorConfig.hitmonitorvars.bookBranches();
     }
   }
 
   // book alignable-wise ROOT Tree
   if (isCollector) {
     TString tname = Form("T2_%i", theIteration);
     theAlignablesMonitorIORootFile = TFile::Open(outfile2.c_str(), "update");
     theAlignablesMonitorIORootFile->cd();
     theAlignablesMonitorTree = new TTree(tname, "Alignablewise tree");
     theAlignablesMonitorTree->Branch("Id", &m2_Id, "Id/i");
     theAlignablesMonitorTree->Branch("ObjId", &m2_ObjId, "ObjId/I");
     theAlignablesMonitorTree->Branch("Nhit", &m2_Nhit);
     theAlignablesMonitorTree->Branch("DataType", &m2_datatype);
     theAlignablesMonitorTree->Branch("Type", &m2_Type);
     theAlignablesMonitorTree->Branch("Layer", &m2_Layer);
     theAlignablesMonitorTree->Branch("Xpos", &m2_Xpos);
     theAlignablesMonitorTree->Branch("Ypos", &m2_Ypos);
     theAlignablesMonitorTree->Branch("Zpos", &m2_Zpos);
     theAlignablesMonitorTree->Branch("DeformationsType", &m2_dtype, "DeformationsType/I");
     theAlignablesMonitorTree->Branch("NumDeformations", &m2_nsurfdef);
     theAlignablesMonitorTree->Branch("Deformations", &m2_surfDef);
   }
 
   // book survey-wise ROOT Tree only if survey is enabled
   if (!theLevels.empty()) {
     TString tname = Form("T3_%i", theIteration);
     theSurveyIORootFile = TFile::Open(ssurveyfile.c_str(), "update");
     theSurveyIORootFile->cd();
     theSurveyTree = new TTree(tname, "Survey Tree");
     theSurveyTree->Branch("Id", &m3_Id, "Id/i");
     theSurveyTree->Branch("ObjId", &m3_ObjId, "ObjId/I");
     theSurveyTree->Branch("Par", &m3_par, "Par[6]/F");
     edm::LogInfo("Alignment") << "[HIPAlignmentAlgorithm::bookRoot] Survey trees booked.";
   }
   edm::LogInfo("Alignment") << "[HIPAlignmentAlgorithm::bookRoot] Root trees booked.";
 }

double HIPAlignmentAlgorithm::calcAPE	(	double *	par,
		int	iter,
		int	function
	)

private

Definition at line 1076 of file HIPAlignmentAlgorithm.cc.

References JetChargeProducer_cfi::exp, createfilelist::int, SiStripPI::max, and funct::pow().

Referenced by setAlignmentPositionError(), and ~HIPAlignmentAlgorithm().

                                                                          {
   double diter = (double)iter;
   if (function == 0)
     return std::max(par[1], par[0] + ((par[1] - par[0]) / par[2]) * diter);
   else if (function == 1)
     return std::max(0., par[0] * (exp(-pow(diter, par[1]) / par[2])));
   else if (function == 2) {
     int ipar2 = (int)par[2];
     int step = iter / ipar2;
     double dstep = (double)step;
     return std::max(0., par[0] - par[1] * dstep);
   } else
     assert(false);  // should have been caught in the constructor
 }

bool HIPAlignmentAlgorithm::calcParameters	(	Alignable *	ali,
		int	setDet,
		double	start,
		double	step
	)

private

Definition at line 1234 of file HIPAlignmentAlgorithm.cc.

References HIPUserVariables::alierr, Alignable::alignmentParameters(), HIPUserVariables::alipar, AlignmentParameters::cloneFromSelected(), defaultAlignableSpecs, findAlignableSpecs(), mps_fire::i, Alignable::id(), isCollector, HIPUserVariables::jtve, HIPUserVariables::jtvj, HIPAlignableSpecificParameters::maxRelParError, HIPAlignableSpecificParameters::minNHits, HIPAlignableSpecificParameters::minRelParError, HIPUserVariables::nhit, CalibrationSummaryClient_cfi::params, Alignable::setAlignmentParameters(), AlignmentParameters::setValid(), mathSSE::sqrt(), command_line::start, theApplyCutsPerComponent, theIteration, and AlignmentParameters::userVariables().

Referenced by terminate(), and ~HIPAlignmentAlgorithm().

                                                                                                 {
   edm::LogInfo("Alignment") << "@SUB=HIPAlignmentAlgorithm::calcParameters"
                             << "Begin: Processing detector " << ali->id();
 
   // Alignment parameters
   AlignmentParameters* par = ali->alignmentParameters();
   const HIPAlignableSpecificParameters* alispecifics = findAlignableSpecs(ali);
   // access user variables
   HIPUserVariables* uservar = dynamic_cast<HIPUserVariables*>(par->userVariables());
   int nhit = uservar->nhit;
   // The following variable is needed for the extended 1D/2D hit fix using
   // matrix shrinkage and expansion
   // int hitdim = uservar->hitdim;
 
   // Test nhits
   int minHitThreshold = (!theApplyCutsPerComponent ? defaultAlignableSpecs.minNHits : alispecifics->minNHits);
   if (!isCollector)
     minHitThreshold = 1;
   if (setDet == 0 && nhit < minHitThreshold) {
     edm::LogInfo("Alignment") << "@SUB=HIPAlignmentAlgorithm::calcParameters"
                               << "Skipping detector " << ali->id() << " because number of hits = " << nhit
                               << " <= " << minHitThreshold;
     par->setValid(false);
     return false;
   }
 
   AlgebraicSymMatrix jtvj = uservar->jtvj;
   AlgebraicVector jtve = uservar->jtve;
 
   // these are the alignment corrections+covariance (for selected params)
   int npar = jtve.num_row();
   AlgebraicVector params(npar);
   AlgebraicVector paramerr(npar);
   AlgebraicSymMatrix cov(npar);
 
   // errors of parameters
   if (isCollector) {
     if (setDet == 0) {
       int ierr;
       AlgebraicSymMatrix jtvjinv = jtvj.inverse(ierr);
       if (ierr != 0) {
         edm::LogError("Alignment") << "@SUB=HIPAlignmentAlgorithm::calcParameters"
                                    << "Matrix inversion failed!";
         return false;
       }
       params = -(jtvjinv * jtve);
       cov = jtvjinv;
 
       double minRelErrThreshold =
           (!theApplyCutsPerComponent ? defaultAlignableSpecs.minRelParError : alispecifics->minRelParError);
       double maxRelErrThreshold =
           (!theApplyCutsPerComponent ? defaultAlignableSpecs.maxRelParError : alispecifics->maxRelParError);
       for (int i = 0; i < npar; i++) {
         double relerr = 0;
         if (fabs(cov[i][i]) > 0.)
           paramerr[i] = sqrt(fabs(cov[i][i]));
         else
           paramerr[i] = params[i];
         if (params[i] != 0.)
           relerr = fabs(paramerr[i] / params[i]);
         if ((maxRelErrThreshold >= 0. && relerr > maxRelErrThreshold) || relerr < minRelErrThreshold) {
           edm::LogWarning("Alignment") << "@SUB=HIPAlignmentAlgorithm::calcParameters"
                                        << "RelError = " << relerr << " > " << maxRelErrThreshold << " or < "
                                        << minRelErrThreshold << ". Setting param = paramerr = 0 for component " << i;
           params[i] = 0;
           paramerr[i] = 0;
         }
       }
     } else {
       if (params.num_row() != 1) {
         edm::LogError("Alignment") << "@SUB=HIPAlignmentAlgorithm::calcParameters"
                                    << "For scanning, please only turn on one parameter! check common_cff_py.txt";
         return false;
       }
       if (theIteration == 1)
         params[0] = start;
       else
         params[0] = step;
       edm::LogWarning("Alignment") << "@SUB=HIPAlignmentAlgorithm::calcParameters"
                                    << "Parameters = " << params;
     }
   }
 
   uservar->alipar = params;
   uservar->alierr = paramerr;
 
   AlignmentParameters* parnew = par->cloneFromSelected(params, cov);
   ali->setAlignmentParameters(parnew);
   parnew->setValid(true);
 
   edm::LogInfo("Alignment") << "@SUB=HIPAlignmentAlgorithm::calcParameters"
                             << "End: Processing detector " << ali->id();
 
   return true;
 }

void HIPAlignmentAlgorithm::collectMonitorTrees ( const std::vector< std::string > & filenames )

private

Definition at line 1486 of file HIPAlignmentAlgorithm.cc.

References doTrackHitMonitoring, Exception, corrVsCorr::filename, HIPMonitorConfig::fillTrackHitMonitoring, HIPMonitorConfig::fillTrackMonitoring, isCollector, HIPMonitorConfig::outfile, AlCaHLTBitMon_QueryRunRegistry::string, theHitMonitorTree, theIteration, theMonitorConfig, theTrackHitMonitorIORootFile, and theTrackMonitorTree.

Referenced by collector(), and ~HIPAlignmentAlgorithm().

                                                                                      {
   if (!doTrackHitMonitoring)
     return;
   if (!isCollector)
     throw cms::Exception("LogicError") << "[HIPAlignmentAlgorithm::collectMonitorTrees] Called in non-collector mode."
                                        << std::endl;
 
   TString theTrackMonitorTreeName = Form("T1_%i", theIteration);
   TString theHitMonitorTreeName = Form("T1_hit_%i", theIteration);
 
   std::vector<TFile*> finputlist;
   TList* eventtrees = new TList;
   TList* hittrees = new TList;
   for (std::string const& filename : filenames) {
     TFile* finput = TFile::Open(filename.c_str(), "read");
     if (finput != nullptr) {
       TTree* tmptree;
       if (theMonitorConfig.fillTrackMonitoring) {
         tmptree = nullptr;
         tmptree = (TTree*)finput->Get(theTrackMonitorTreeName);
         if (tmptree != nullptr)
           eventtrees->Add(tmptree);
       }
       if (theMonitorConfig.fillTrackHitMonitoring) {
         tmptree = nullptr;
         tmptree = (TTree*)finput->Get(theHitMonitorTreeName);
         if (tmptree != nullptr)
           hittrees->Add((TTree*)finput->Get(theHitMonitorTreeName));
       }
       finputlist.push_back(finput);
     }
   }
 
   if (theTrackHitMonitorIORootFile != nullptr) {  // This should never happen
     edm::LogError("Alignment") << "@SUB=HIPAlignmentAlgorithm::collectMonitorTrees"
                                << "Monitor file is already open while it is not supposed to be!";
     delete theTrackMonitorTree;
     theTrackMonitorTree = nullptr;
     delete theHitMonitorTree;
     theHitMonitorTree = nullptr;
     theTrackHitMonitorIORootFile->Close();
   }
   theTrackHitMonitorIORootFile = TFile::Open(theMonitorConfig.outfile.c_str(), "update");
   theTrackHitMonitorIORootFile->cd();
   if (eventtrees->GetSize() > 0)
     theTrackMonitorTree = TTree::MergeTrees(eventtrees);
   if (hittrees->GetSize() > 0)
     theHitMonitorTree = TTree::MergeTrees(hittrees);
   // Leave it to HIPAlignmentAlgorithm::terminate to write the trees and close theTrackHitMonitorIORootFile
 
   delete hittrees;
   delete eventtrees;
   for (TFile*& finput : finputlist)
     finput->Close();
 
   // Rename the trees to standard names
   if (theTrackMonitorTree != nullptr)
     theTrackMonitorTree->SetName(theTrackMonitorTreeName);
   if (theHitMonitorTree != nullptr)
     theHitMonitorTree->SetName(theHitMonitorTreeName);
 }

void HIPAlignmentAlgorithm::collector ( void )

private

Definition at line 1331 of file HIPAlignmentAlgorithm.cc.

References HIPUserVariables::alichi2, HIPUserVariables::alindof, AlignmentParameterStore::attachUserVariables(), HIPUserVariables::clone(), collectMonitorTrees(), HIPUserVariables::datatype, doTrackHitMonitoring, ioerr, HIPUserVariables::jtve, HIPUserVariables::jtvj, HIPUserVariables::nhit, HIPMonitorConfig::outfilecore, HIPUserVariablesIORoot::readHIPUserVariables(), rewgtPerAli, str, AlCaHLTBitMon_QueryRunRegistry::string, suvarfilecore, theAlignables, theAlignmentParameterStore, theCollectorNJobs, theCollectorPath, theDataGroup, theIteration, theMonitorConfig, and AlignmentParameters::userVariables().

Referenced by startNewLoop(), and ~HIPAlignmentAlgorithm().

                                           {
   edm::LogInfo("Alignment") << "@SUB=HIPAlignmentAlgorithm::collector"
                             << "Called for iteration " << theIteration;
 
   std::vector<std::string> monitorFileList;
   HIPUserVariablesIORoot HIPIO;
 
   typedef int pawt_t;
   std::unordered_map<Alignable*, std::unordered_map<int, pawt_t>> ali_datatypecountpair_map;
   if (rewgtPerAli) {
     edm::LogInfo("Alignment") << "@SUB=HIPAlignmentAlgorithm::collector"
                               << "Per-alignable reweighting is turned on. Iterating over the parallel jobs to sum "
                                  "number of hits per alignable for each data type.";
     // Counting step for per-alignable reweighting
     for (int ijob = 1; ijob <= theCollectorNJobs; ijob++) {
       edm::LogInfo("Alignment") << "@SUB=HIPAlignmentAlgorithm::collector"
                                 << "Pre-reading uservar for job " << ijob;
 
       std::string str = std::to_string(ijob);
       std::string uvfile = theCollectorPath + "/job" + str + "/" + suvarfilecore;
 
       std::vector<AlignmentUserVariables*> uvarvec =
           HIPIO.readHIPUserVariables(theAlignables, uvfile.c_str(), theIteration, ioerr);
       if (uvarvec.size() != theAlignables.size())
         edm::LogWarning("Alignment") << "@SUB=HIPAlignmentAlgorithm::collector"
                                      << "Number of alignables = " << theAlignables.size()
                                      << " is not the same as number of user variables = " << uvarvec.size()
                                      << ". A mismatch might occur!";
       if (ioerr != 0) {
         edm::LogError("Alignment") << "@SUB=HIPAlignmentAlgorithm::collector"
                                    << "Could not read user variable files for job " << ijob << " in iteration "
                                    << theIteration;
         continue;
       }
       std::vector<AlignmentUserVariables*>::const_iterator iuvar =
           uvarvec.begin();  // This vector should have 1-to-1 correspondence with the alignables vector
       for (const auto& ali : theAlignables) {
         // No need for the user variables already attached to the alignables
         // Just count from what you read.
         HIPUserVariables* uvar = dynamic_cast<HIPUserVariables*>(*iuvar);
         if (uvar != nullptr) {
           int alijobdtype = uvar->datatype;
           pawt_t alijobnhits = uvar->nhit;
           if (ali_datatypecountpair_map.find(ali) == ali_datatypecountpair_map.end()) {  // This is a new alignable
             std::unordered_map<int, pawt_t> newmap;
             ali_datatypecountpair_map[ali] = newmap;
             ali_datatypecountpair_map[ali][alijobdtype] = alijobnhits;
           } else {  // Alignable already exists in the map
             std::unordered_map<int, pawt_t>& theMap = ali_datatypecountpair_map[ali];
             if (theMap.find(alijobdtype) == theMap.end())
               theMap[alijobdtype] = alijobnhits;
             else
               theMap[alijobdtype] += alijobnhits;
           }
           delete uvar;  // Delete new user variables as they are added
         }
         iuvar++;
       }  // End loop over alignables
     }    // End loop over subjobs
   }
 
   for (int ijob = 1; ijob <= theCollectorNJobs; ijob++) {
     edm::LogInfo("Alignment") << "@SUB=HIPAlignmentAlgorithm::collector"
                               << "Reading uservar for job " << ijob;
 
     std::string str = std::to_string(ijob);
     std::string uvfile = theCollectorPath + "/job" + str + "/" + suvarfilecore;
 
     std::vector<AlignmentUserVariables*> uvarvec =
         HIPIO.readHIPUserVariables(theAlignables, uvfile.c_str(), theIteration, ioerr);
     if (uvarvec.size() != theAlignables.size())
       edm::LogWarning("Alignment") << "@SUB=HIPAlignmentAlgorithm::collector"
                                    << "Number of alignables = " << theAlignables.size()
                                    << " is not the same as number of user variables = " << uvarvec.size()
                                    << ". A mismatch might occur!";
 
     if (ioerr != 0) {
       edm::LogError("Alignment") << "@SUB=HIPAlignmentAlgorithm::collector"
                                  << "Could not read user variable files for job " << ijob << " in iteration "
                                  << theIteration;
       continue;
     }
 
     // add
     std::vector<AlignmentUserVariables*> uvarvecadd;
     std::vector<AlignmentUserVariables*>::const_iterator iuvarnew = uvarvec.begin();
     for (const auto& ali : theAlignables) {
       AlignmentParameters* ap = ali->alignmentParameters();
 
       HIPUserVariables* uvarold = dynamic_cast<HIPUserVariables*>(ap->userVariables());
       HIPUserVariables* uvarnew = dynamic_cast<HIPUserVariables*>(*iuvarnew);
 
       HIPUserVariables* uvar = uvarold->clone();
       uvar->datatype =
           theDataGroup;  // Set the data type of alignable to that specified for the collector job (-2 by default)
 
       if (uvarnew != nullptr) {
         double peraliwgt = 1;
         if (rewgtPerAli) {
           int alijobdtype = uvarnew->datatype;
           if (ali_datatypecountpair_map.find(ali) != ali_datatypecountpair_map.end() &&
               ali_datatypecountpair_map[ali].find(alijobdtype) != ali_datatypecountpair_map[ali].end()) {
             peraliwgt = ali_datatypecountpair_map[ali][alijobdtype];
             unsigned int nNonZeroTypes = 0;
             pawt_t sumwgts = 0;
             for (auto it = ali_datatypecountpair_map[ali].cbegin(); it != ali_datatypecountpair_map[ali].cend(); ++it) {
               sumwgts += it->second;
               if (it->second != pawt_t(0))
                 nNonZeroTypes++;
             }
             edm::LogInfo("Alignment") << "@SUB=HIPAlignmentAlgorithm::collector"
                                       << "Reweighting detector " << ali->id() << " / " << ali->alignableObjectId()
                                       << " for data type " << alijobdtype << " by " << sumwgts << "/" << peraliwgt
                                       << "/" << nNonZeroTypes;
             peraliwgt = ((nNonZeroTypes == 0 || peraliwgt == double(0))
                              ? double(1)
                              : double((double(sumwgts)) / peraliwgt / (double(nNonZeroTypes))));
           } else if (ali_datatypecountpair_map.find(ali) != ali_datatypecountpair_map.end())
             edm::LogError("Alignment") << "@SUB=HIPAlignmentAlgorithm::collector"
                                        << "Could not find data type " << alijobdtype << " for detector " << ali->id()
                                        << " / " << ali->alignableObjectId();
           else
             edm::LogError("Alignment") << "@SUB=HIPAlignmentAlgorithm::collector"
                                        << "Could not find detector " << ali->id() << " / " << ali->alignableObjectId()
                                        << " in the map ali_datatypecountpair_map";
         }
 
         uvar->nhit = (uvarold->nhit) + (uvarnew->nhit);
         uvar->jtvj = (uvarold->jtvj) + peraliwgt * (uvarnew->jtvj);
         uvar->jtve = (uvarold->jtve) + peraliwgt * (uvarnew->jtve);
         uvar->alichi2 = (uvarold->alichi2) + peraliwgt * (uvarnew->alichi2);
         uvar->alindof = (uvarold->alindof) + (uvarnew->alindof);
 
         delete uvarnew;  // Delete new user variables as they are added
       }
 
       uvarvecadd.push_back(uvar);
       iuvarnew++;
     }
 
     theAlignmentParameterStore->attachUserVariables(theAlignables, uvarvecadd, ioerr);
 
     // fill Eventwise Tree
     if (doTrackHitMonitoring) {
       uvfile = theCollectorPath + "/job" + str + "/" + theMonitorConfig.outfilecore;
       monitorFileList.push_back(uvfile);
     }
   }  // end loop on jobs
 
   // Collect monitor (eventwise and hitwise) trees
   if (doTrackHitMonitoring)
     collectMonitorTrees(monitorFileList);
 }

void HIPAlignmentAlgorithm::fillAlignablesMonitor ( const edm::EventSetup & setup )

private

Definition at line 1154 of file HIPAlignmentAlgorithm.cc.

References HIPUserVariables::datatype, runTauDisplay::dtype, alignBH_cfg::fixed, edm::EventSetup::get(), AlignmentParameters::isValid(), SurfaceDeformationFactory::kNoDeformations, m2_datatype, m2_dtype, m2_Id, m2_Layer, m2_Nhit, m2_nsurfdef, m2_ObjId, m2_surfDef, m2_Type, m2_Xpos, m2_Ypos, m2_Zpos, HIPUserVariables::nhit, SurfaceDeformation::parameters(), AlignmentParameters::parameters(), edm::ESHandle< T >::product(), theAlignables, theAlignablesMonitorIORootFile, theAlignablesMonitorTree, theAlignmentParameterStore, SurfaceDeformation::type(), AlignmentParameterStore::typeAndLayer(), AlignmentParameters::userVariables(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by terminate(), and ~HIPAlignmentAlgorithm().

                                                                              {
   if (theAlignablesMonitorIORootFile == (TFile*)nullptr)
     return;
   using std::setw;
   theAlignablesMonitorIORootFile->cd();
 
   int naligned = 0;
 
   //Retrieve tracker topology from geometry
   edm::ESHandle<TrackerTopology> tTopoHandle;
   //  iSetup.get<IdealGeometryRecord>().get(tTopoHandle);
   iSetup.get<TrackerTopologyRcd>().get(tTopoHandle);
 
   const TrackerTopology* const tTopo = tTopoHandle.product();
 
   for (const auto& ali : theAlignables) {
     AlignmentParameters* dap = ali->alignmentParameters();
 
     // consider only those parameters classified as 'valid'
     if (dap->isValid()) {
       // get number of hits from user variable
       HIPUserVariables* uservar = dynamic_cast<HIPUserVariables*>(dap->userVariables());
       m2_Nhit = uservar->nhit;
       m2_datatype = uservar->datatype;
 
       // get type/layer
       std::pair<int, int> tl = theAlignmentParameterStore->typeAndLayer(ali, tTopo);
       m2_Type = tl.first;
       m2_Layer = tl.second;
 
       // get identifier (as for IO)
       m2_Id = ali->id();
       m2_ObjId = ali->alignableObjectId();
 
       // get position
       GlobalPoint pos = ali->surface().position();
       m2_Xpos = pos.x();
       m2_Ypos = pos.y();
       m2_Zpos = pos.z();
 
       m2_surfDef.clear();
       {
         std::vector<std::pair<int, SurfaceDeformation*>> dali_id_pairs;
         SurfaceDeformation* dali_obj = nullptr;
         SurfaceDeformationFactory::Type dtype = SurfaceDeformationFactory::kNoDeformations;
         std::vector<double> dali;
         if (1 == ali->surfaceDeformationIdPairs(dali_id_pairs)) {
           dali_obj = dali_id_pairs[0].second;
           dali = dali_obj->parameters();
           dtype = (SurfaceDeformationFactory::Type)dali_obj->type();
         }
         for (auto& dit : dali)
           m2_surfDef.push_back((float)dit);
         m2_dtype = dtype;
         m2_nsurfdef = m2_surfDef.size();
       }
 
       if (verbose) {
         AlgebraicVector pars = dap->parameters();
         edm::LogVerbatim("Alignment") << "------------------------------------------------------------------------\n"
                                       << " ALIGNABLE: " << setw(6) << naligned << '\n'
                                       << "hits: " << setw(4) << m2_Nhit << " type: " << setw(4) << m2_Type
                                       << " layer: " << setw(4) << m2_Layer << " id: " << setw(4) << m2_Id
                                       << " objId: " << setw(4) << m2_ObjId << '\n'
                                       << std::fixed << std::setprecision(5) << "x,y,z: " << setw(12) << m2_Xpos
                                       << setw(12) << m2_Ypos << setw(12) << m2_Zpos
                                       << "\nDeformations type, nDeformations: " << setw(12) << m2_dtype << setw(12)
                                       << m2_nsurfdef << '\n'
                                       << "params: " << setw(12) << pars[0] << setw(12) << pars[1] << setw(12) << pars[2]
                                       << setw(12) << pars[3] << setw(12) << pars[4] << setw(12) << pars[5];
       }
 
       naligned++;
       if (theAlignablesMonitorTree != nullptr)
         theAlignablesMonitorTree->Fill();
     }
   }
 }

HIPAlignableSpecificParameters * HIPAlignmentAlgorithm::findAlignableSpecs ( const Alignable * ali )

private

Definition at line 1549 of file HIPAlignmentAlgorithm.cc.

References Alignable::alignableObjectId(), defaultAlignableSpecs, Alignable::id(), and theAlignableSpecifics.

Referenced by calcParameters(), run(), and ~HIPAlignmentAlgorithm().

                                                                                               {
   if (ali != nullptr) {
     for (std::vector<HIPAlignableSpecificParameters>::iterator it = theAlignableSpecifics.begin();
          it != theAlignableSpecifics.end();
          it++) {
       if (it->matchAlignable(ali))
         return &(*it);
     }
     edm::LogInfo("Alignment") << "[HIPAlignmentAlgorithm::findAlignableSpecs] Alignment object with id " << ali->id()
                               << " / " << ali->alignableObjectId() << " could not be found. Returning default.";
   }
   return &defaultAlignableSpecs;
 }

void HIPAlignmentAlgorithm::initialize	(	const edm::EventSetup &	setup,
		AlignableTracker *	tracker,
		AlignableMuon *	muon,
		AlignableExtras *	extras,
		AlignmentParameterStore *	store
	)

overridevirtual

Call at beginning of job.

Implements AlignmentAlgorithmBase.

Definition at line 127 of file HIPAlignmentAlgorithm.cc.

Referenced by ~HIPAlignmentAlgorithm().

                                                                        {
   edm::LogInfo("Alignment") << "@SUB=HIPAlignmentAlgorithm::initialize"
                             << "Initializing...";
 
   alignableObjectId_ = std::make_unique<AlignableObjectId>(AlignableObjectId::commonObjectIdProvider(tracker, muon));
 
   for (const auto& level : surveyResiduals_)
     theLevels.push_back(alignableObjectId_->stringToId(level));
 
   edm::ESHandle<Alignments> globalPositionRcd;
 
   const edm::ValidityInterval& validity = setup.get<TrackerAlignmentRcd>().validityInterval();
   const edm::IOVSyncValue first1 = validity.first();
   unsigned int firstrun = first1.eventID().run();
   if (themultiIOV) {
     if (theIOVrangeSet.size() != 1) {
       bool findMatchIOV = false;
       for (unsigned int iovl = 0; iovl < theIOVrangeSet.size(); iovl++) {
         if (firstrun == theIOVrangeSet.at(iovl)) {
           std::string iovapp = std::to_string(firstrun);
           iovapp.append(".root");
           iovapp.insert(0, "_");
           salignedfile.replace(salignedfile.end() - 5, salignedfile.end(), iovapp);
           siterationfile.replace(siterationfile.end() - 5, siterationfile.end(), iovapp);
           //sparameterfile.replace(sparameterfile.end()-5, sparameterfile.end(),iovapp);
           if (isCollector) {
             outfile2.replace(outfile2.end() - 5, outfile2.end(), iovapp);
             ssurveyfile.replace(ssurveyfile.end() - 5, ssurveyfile.end(), iovapp);
             suvarfile.replace(suvarfile.end() - 5, suvarfile.end(), iovapp);
           }
 
           edm::LogInfo("Alignment") << "@SUB=HIPAlignmentAlgorithm::initialize"
                                     << "Found the IOV file matching IOV first run " << firstrun;
           findMatchIOV = true;
           break;
         }
       }
       if (!findMatchIOV)
         edm::LogError("Alignment") << "@SUB=HIPAlignmentAlgorithm::initialize"
                                    << "Didn't find the IOV file matching IOV first run " << firstrun
                                    << " from the validity interval";
     } else {
       std::string iovapp = std::to_string(theIOVrangeSet.at(0));
       iovapp.append(".root");
       iovapp.insert(0, "_");
       salignedfile.replace(salignedfile.end() - 5, salignedfile.end(), iovapp);
       siterationfile.replace(siterationfile.end() - 5, siterationfile.end(), iovapp);
     }
   }
 
   // accessor Det->AlignableDet
   theAlignableDetAccessor = std::make_unique<AlignableNavigator>(extras, tracker, muon);
   if (extras != nullptr)
     edm::LogInfo("Alignment") << "@SUB=HIPAlignmentAlgorithm::initialize"
                               << "AlignableNavigator initialized with AlignableExtras";
 
   // set alignmentParameterStore
   theAlignmentParameterStore = store;
 
   // get alignables
   theAlignables = theAlignmentParameterStore->alignables();
 
   // Config flags that specify different detectors
   {
     AlignmentParameterSelector selector(tracker, muon, extras);
 
     // APE parameters, clear if necessary
     theAPEParameters.clear();
     if (theApplyAPE) {
       for (std::vector<edm::ParameterSet>::const_iterator setiter = theAPEParameterSet.begin();
            setiter != theAPEParameterSet.end();
            ++setiter) {
         align::Alignables alignables;
 
         selector.clear();
         edm::ParameterSet selectorPSet = setiter->getParameter<edm::ParameterSet>("Selector");
         std::vector<std::string> alignParams = selectorPSet.getParameter<std::vector<std::string>>("alignParams");
         if (alignParams.size() == 1 && alignParams[0] == std::string("selected"))
           alignables = theAlignables;
         else {
           selector.addSelections(selectorPSet);
           alignables = selector.selectedAlignables();
         }
 
         std::vector<double> apeSPar = setiter->getParameter<std::vector<double>>("apeSPar");
         std::vector<double> apeRPar = setiter->getParameter<std::vector<double>>("apeRPar");
         std::string function = setiter->getParameter<std::string>("function");
 
         if (apeSPar.size() != 3 || apeRPar.size() != 3)
           throw cms::Exception("BadConfig") << "apeSPar and apeRPar must have 3 values each" << std::endl;
 
         for (std::vector<double>::const_iterator i = apeRPar.begin(); i != apeRPar.end(); ++i)
           apeSPar.push_back(*i);
 
         if (function == std::string("linear"))
           apeSPar.push_back(0);  // c.f. note in calcAPE
         else if (function == std::string("exponential"))
           apeSPar.push_back(1);  // c.f. note in calcAPE
         else if (function == std::string("step"))
           apeSPar.push_back(2);  // c.f. note in calcAPE
         else
           throw cms::Exception("BadConfig")
               << "APE function must be \"linear\", \"exponential\", or \"step\"." << std::endl;
 
         theAPEParameters.push_back(std::make_pair(alignables, apeSPar));
       }
     }
 
     // Relative error per component instead of overall relative error
     theAlignableSpecifics.clear();
     if (theApplyCutsPerComponent) {
       for (std::vector<edm::ParameterSet>::const_iterator setiter = theCutsPerComponent.begin();
            setiter != theCutsPerComponent.end();
            ++setiter) {
         align::Alignables alignables;
 
         selector.clear();
         edm::ParameterSet selectorPSet = setiter->getParameter<edm::ParameterSet>("Selector");
         std::vector<std::string> alignParams = selectorPSet.getParameter<std::vector<std::string>>("alignParams");
         if (alignParams.size() == 1 && alignParams[0] == std::string("selected"))
           alignables = theAlignables;
         else {
           selector.addSelections(selectorPSet);
           alignables = selector.selectedAlignables();
         }
 
         double minRelParError = setiter->getParameter<double>("minRelParError");
         double maxRelParError = setiter->getParameter<double>("maxRelParError");
         int minNHits = setiter->getParameter<int>("minNHits");
         double maxHitPull = setiter->getParameter<double>("maxHitPull");
         bool applyPixelProbCut = setiter->getParameter<bool>("applyPixelProbCut");
         bool usePixelProbXYOrProbQ = setiter->getParameter<bool>("usePixelProbXYOrProbQ");
         double minPixelProbXY = setiter->getParameter<double>("minPixelProbXY");
         double maxPixelProbXY = setiter->getParameter<double>("maxPixelProbXY");
         double minPixelProbQ = setiter->getParameter<double>("minPixelProbQ");
         double maxPixelProbQ = setiter->getParameter<double>("maxPixelProbQ");
         for (auto& ali : alignables) {
           HIPAlignableSpecificParameters alispecs(ali);
           alispecs.minRelParError = minRelParError;
           alispecs.maxRelParError = maxRelParError;
           alispecs.minNHits = minNHits;
           alispecs.maxHitPull = maxHitPull;
 
           alispecs.applyPixelProbCut = applyPixelProbCut;
           alispecs.usePixelProbXYOrProbQ = usePixelProbXYOrProbQ;
           alispecs.minPixelProbXY = minPixelProbXY;
           alispecs.maxPixelProbXY = maxPixelProbXY;
           alispecs.minPixelProbQ = minPixelProbQ;
           alispecs.maxPixelProbQ = maxPixelProbQ;
 
           theAlignableSpecifics.push_back(alispecs);
           edm::LogInfo("Alignment") << "@SUB=HIPAlignmentAlgorithm::initialize"
                                     << "Alignment specifics acquired for detector " << alispecs.id() << " / "
                                     << alispecs.objId() << ":\n"
                                     << " - minRelParError = " << alispecs.minRelParError << "\n"
                                     << " - maxRelParError = " << alispecs.maxRelParError << "\n"
                                     << " - minNHits = " << alispecs.minNHits << "\n"
                                     << " - maxHitPull = " << alispecs.maxHitPull << "\n"
                                     << " - applyPixelProbCut = " << alispecs.applyPixelProbCut << "\n"
                                     << " - usePixelProbXYOrProbQ = " << alispecs.usePixelProbXYOrProbQ << "\n"
                                     << " - minPixelProbXY = " << alispecs.minPixelProbXY << "\n"
                                     << " - maxPixelProbXY = " << alispecs.maxPixelProbXY << "\n"
                                     << " - minPixelProbQ = " << alispecs.minPixelProbQ << "\n"
                                     << " - maxPixelProbQ = " << alispecs.maxPixelProbQ;
         }
       }
     }
   }
 }

bool HIPAlignmentAlgorithm::processHit1D	(	const AlignableDetOrUnitPtr &	alidet,
		const Alignable *	ali,
		const HIPAlignableSpecificParameters *	alispecifics,
		const TrajectoryStateOnSurface &	tsos,
		const TrackingRecHit *	hit,
		double	hitwt
	)

private

Definition at line 519 of file HIPAlignmentAlgorithm.cc.

References HIPUserVariables::alichi2, Alignable::alignmentParameters(), HIPUserVariables::alindof, HIPUserVariables::datatype, defaultAlignableSpecs, HIPUserVariables::jtve, HIPUserVariables::jtvj, TrajectoryStateOnSurface::localError(), TrajectoryStateOnSurface::localPosition(), TrackingRecHit::localPosition(), TrackingRecHit::localPositionError(), HIPAlignableSpecificParameters::maxHitPull, HIPUserVariables::nhit, CalibrationSummaryClient_cfi::params, LocalTrajectoryError::positionError(), AlignmentParameters::selectedDerivatives(), mathSSE::sqrt(), theApplyCutsPerComponent, theDataGroup, AlignmentParameters::userVariables(), PV3DBase< T, PVType, FrameType >::x(), and LocalError::xx().

Referenced by run(), and ~HIPAlignmentAlgorithm().

                                                        {
   static const unsigned int hitDim = 1;
   if (hitwt == 0.)
     return false;
 
   // get trajectory impact point
   LocalPoint alvec = tsos.localPosition();
   AlgebraicVector pos(hitDim);
   pos[0] = alvec.x();
 
   // get impact point covariance
   AlgebraicSymMatrix ipcovmat(hitDim);
   ipcovmat[0][0] = tsos.localError().positionError().xx();
 
   // get hit local position and covariance
   AlgebraicVector coor(hitDim);
   coor[0] = hit->localPosition().x();
 
   AlgebraicSymMatrix covmat(hitDim);
   covmat[0][0] = hit->localPositionError().xx();
 
   // add hit and impact point covariance matrices
   covmat = covmat + ipcovmat;
 
   // calculate the x pull of this hit
   double xpull = 0.;
   if (covmat[0][0] != 0.)
     xpull = (pos[0] - coor[0]) / sqrt(fabs(covmat[0][0]));
 
   // get Alignment Parameters
   AlignmentParameters* params = ali->alignmentParameters();
   HIPUserVariables* uservar = dynamic_cast<HIPUserVariables*>(params->userVariables());
   uservar->datatype = theDataGroup;
   // get derivatives
   AlgebraicMatrix derivs2D = params->selectedDerivatives(tsos, alidet);
   // calculate user parameters
   int npar = derivs2D.num_row();
   AlgebraicMatrix derivs(npar, hitDim, 0);  // This is jT
 
   for (int ipar = 0; ipar < npar; ipar++) {
     for (unsigned int idim = 0; idim < hitDim; idim++) {
       derivs[ipar][idim] = derivs2D[ipar][idim];
     }
   }
 
   // invert covariance matrix
   int ierr;
   covmat.invert(ierr);
   if (ierr != 0) {
     edm::LogError("Alignment") << "@SUB=HIPAlignmentAlgorithm::processHit1D"
                                << "Cov. matrix inversion failed!";
     return false;
   }
 
   double maxHitPullThreshold =
       (!theApplyCutsPerComponent ? defaultAlignableSpecs.maxHitPull : alispecifics->maxHitPull);
   bool useThisHit = (maxHitPullThreshold < 0.);
   useThisHit |= (fabs(xpull) < maxHitPullThreshold);
   if (!useThisHit) {
     edm::LogInfo("Alignment") << "@SUB=HIPAlignmentAlgorithm::processHit2D"
                               << "Hit pull (x) " << xpull << " fails the cut " << maxHitPullThreshold;
     return false;
   }
 
   AlgebraicMatrix covtmp(covmat);
   AlgebraicMatrix jtvjtmp(derivs * covtmp * derivs.T());
   AlgebraicSymMatrix thisjtvj(npar);
   AlgebraicVector thisjtve(npar);
   thisjtvj.assign(jtvjtmp);
   thisjtve = derivs * covmat * (pos - coor);
 
   AlgebraicVector hitresidual(hitDim);
   hitresidual[0] = (pos[0] - coor[0]);
 
   AlgebraicMatrix hitresidualT;
   hitresidualT = hitresidual.T();
 
   uservar->jtvj += hitwt * thisjtvj;
   uservar->jtve += hitwt * thisjtve;
   uservar->nhit++;
 
   //for alignable chi squared
   float thischi2;
   thischi2 = hitwt * (hitresidualT * covmat * hitresidual)[0];
 
   if (verbose && (thischi2 / static_cast<float>(uservar->nhit)) > 10.)
     edm::LogWarning("Alignment") << "[HIPAlignmentAlgorithm::processHit1D] Added to Chi2 the number " << thischi2
                                  << " having " << uservar->nhit << " ndof"
                                  << ", X-resid " << hitresidual[0] << ", Cov^-1 matr (covmat):"
                                  << " [0][0] = " << covmat[0][0];
 
   uservar->alichi2 += thischi2;
   uservar->alindof += hitDim;
 
   return true;
 }

bool HIPAlignmentAlgorithm::processHit2D	(	const AlignableDetOrUnitPtr &	alidet,
		const Alignable *	ali,
		const HIPAlignableSpecificParameters *	alispecifics,
		const TrajectoryStateOnSurface &	tsos,
		const TrackingRecHit *	hit,
		double	hitwt
	)

private

Definition at line 621 of file HIPAlignmentAlgorithm.cc.

References HIPUserVariables::alichi2, Alignable::alignmentParameters(), HIPUserVariables::alindof, HIPUserVariables::datatype, defaultAlignableSpecs, HIPUserVariables::jtve, HIPUserVariables::jtvj, TrajectoryStateOnSurface::localError(), TrajectoryStateOnSurface::localPosition(), TrackingRecHit::localPosition(), TrackingRecHit::localPositionError(), HIPAlignableSpecificParameters::maxHitPull, HIPUserVariables::nhit, CalibrationSummaryClient_cfi::params, LocalTrajectoryError::positionError(), AlignmentParameters::selectedDerivatives(), mathSSE::sqrt(), theApplyCutsPerComponent, theDataGroup, AlignmentParameters::userVariables(), PV3DBase< T, PVType, FrameType >::x(), LocalError::xx(), LocalError::xy(), PV3DBase< T, PVType, FrameType >::y(), and LocalError::yy().

Referenced by run(), and ~HIPAlignmentAlgorithm().

                                                        {
   static const unsigned int hitDim = 2;
   if (hitwt == 0.)
     return false;
 
   // get trajectory impact point
   LocalPoint alvec = tsos.localPosition();
   AlgebraicVector pos(hitDim);
   pos[0] = alvec.x();
   pos[1] = alvec.y();
 
   // get impact point covariance
   AlgebraicSymMatrix ipcovmat(hitDim);
   ipcovmat[0][0] = tsos.localError().positionError().xx();
   ipcovmat[1][1] = tsos.localError().positionError().yy();
   ipcovmat[0][1] = tsos.localError().positionError().xy();
 
   // get hit local position and covariance
   AlgebraicVector coor(hitDim);
   coor[0] = hit->localPosition().x();
   coor[1] = hit->localPosition().y();
 
   AlgebraicSymMatrix covmat(hitDim);
   covmat[0][0] = hit->localPositionError().xx();
   covmat[1][1] = hit->localPositionError().yy();
   covmat[0][1] = hit->localPositionError().xy();
 
   // add hit and impact point covariance matrices
   covmat = covmat + ipcovmat;
 
   // calculate the x pull and y pull of this hit
   double xpull = 0.;
   double ypull = 0.;
   if (covmat[0][0] != 0.)
     xpull = (pos[0] - coor[0]) / sqrt(fabs(covmat[0][0]));
   if (covmat[1][1] != 0.)
     ypull = (pos[1] - coor[1]) / sqrt(fabs(covmat[1][1]));
 
   // get Alignment Parameters
   AlignmentParameters* params = ali->alignmentParameters();
   HIPUserVariables* uservar = dynamic_cast<HIPUserVariables*>(params->userVariables());
   uservar->datatype = theDataGroup;
   // get derivatives
   AlgebraicMatrix derivs2D = params->selectedDerivatives(tsos, alidet);
   // calculate user parameters
   int npar = derivs2D.num_row();
   AlgebraicMatrix derivs(npar, hitDim, 0);  // This is jT
 
   for (int ipar = 0; ipar < npar; ipar++) {
     for (unsigned int idim = 0; idim < hitDim; idim++) {
       derivs[ipar][idim] = derivs2D[ipar][idim];
     }
   }
 
   // invert covariance matrix
   int ierr;
   covmat.invert(ierr);
   if (ierr != 0) {
     edm::LogError("Alignment") << "@SUB=HIPAlignmentAlgorithm::processHit2D"
                                << "Cov. matrix inversion failed!";
     return false;
   }
 
   double maxHitPullThreshold =
       (!theApplyCutsPerComponent ? defaultAlignableSpecs.maxHitPull : alispecifics->maxHitPull);
   bool useThisHit = (maxHitPullThreshold < 0.);
   useThisHit |= (fabs(xpull) < maxHitPullThreshold && fabs(ypull) < maxHitPullThreshold);
   if (!useThisHit) {
     edm::LogInfo("Alignment") << "@SUB=HIPAlignmentAlgorithm::processHit2D"
                               << "Hit pull (x,y) " << xpull << " , " << ypull << " fails the cut "
                               << maxHitPullThreshold;
     return false;
   }
 
   AlgebraicMatrix covtmp(covmat);
   AlgebraicMatrix jtvjtmp(derivs * covtmp * derivs.T());
   AlgebraicSymMatrix thisjtvj(npar);
   AlgebraicVector thisjtve(npar);
   thisjtvj.assign(jtvjtmp);
   thisjtve = derivs * covmat * (pos - coor);
 
   AlgebraicVector hitresidual(hitDim);
   hitresidual[0] = (pos[0] - coor[0]);
   hitresidual[1] = (pos[1] - coor[1]);
 
   AlgebraicMatrix hitresidualT;
   hitresidualT = hitresidual.T();
 
   uservar->jtvj += hitwt * thisjtvj;
   uservar->jtve += hitwt * thisjtve;
   uservar->nhit++;
 
   //for alignable chi squared
   float thischi2;
   thischi2 = hitwt * (hitresidualT * covmat * hitresidual)[0];
 
   if (verbose && (thischi2 / static_cast<float>(uservar->nhit)) > 10.)
     edm::LogWarning("Alignment") << "[HIPAlignmentAlgorithm::processHit2D] Added to Chi2 the number " << thischi2
                                  << " having " << uservar->nhit << " ndof"
                                  << ", X-resid " << hitresidual[0] << ", Y-resid " << hitresidual[1]
                                  << ", Cov^-1 matr (covmat):"
                                  << " [0][0] = " << covmat[0][0] << " [0][1] = " << covmat[0][1]
                                  << " [1][0] = " << covmat[1][0] << " [1][1] = " << covmat[1][1];
 
   uservar->alichi2 += thischi2;
   uservar->alindof += hitDim;
 
   return true;
 }

int HIPAlignmentAlgorithm::readIterationFile ( std::string filename )

private

Definition at line 992 of file HIPAlignmentAlgorithm.cc.

References recoMuon::in, and mps_fire::result.

Referenced by startNewLoop(), and ~HIPAlignmentAlgorithm().

                                                                {
   int result;
 
   std::ifstream inIterFile(filename.c_str(), std::ios::in);
   if (!inIterFile) {
     edm::LogError("Alignment") << "[HIPAlignmentAlgorithm::readIterationFile] ERROR! "
                                << "Unable to open Iteration file";
     result = -1;
   } else {
     inIterFile >> result;
     edm::LogWarning("Alignment") << "[HIPAlignmentAlgorithm::readIterationFile] "
                                  << "Read last iteration number from file: " << result;
   }
   inIterFile.close();
 
   return result;
 }

void HIPAlignmentAlgorithm::run	(	const edm::EventSetup &	setup,
		const EventInfo &	eventInfo
	)

overridevirtual

Run the algorithm.

Implements AlignmentAlgorithmBase.

Definition at line 737 of file HIPAlignmentAlgorithm.cc.

Referenced by DTWorkflow.DTWorkflow::all(), Types.EventID::cppID(), Types.LuminosityBlockID::cppID(), o2olib.O2OTool::execute(), and ~HIPAlignmentAlgorithm().

                                                                                       {
   if (isCollector)
     return;
 
   TrajectoryStateCombiner tsoscomb;
 
   m_datatype = theDataGroup;
 
   // loop over tracks
   const ConstTrajTrackPairCollection& tracks = eventInfo.trajTrackPairs();
   for (ConstTrajTrackPairCollection::const_iterator it = tracks.begin(); it != tracks.end(); ++it) {
     const Trajectory* traj = (*it).first;
     const reco::Track* track = (*it).second;
 
     float pt = track->pt();
     float eta = track->eta();
     float phi = track->phi();
     float p = track->p();
     float chi2n = track->normalizedChi2();
     int nhit = track->numberOfValidHits();
     float d0 = track->d0();
     float dz = track->dz();
 
     int nhpxb = track->hitPattern().numberOfValidPixelBarrelHits();
     int nhpxf = track->hitPattern().numberOfValidPixelEndcapHits();
     int nhtib = track->hitPattern().numberOfValidStripTIBHits();
     int nhtob = track->hitPattern().numberOfValidStripTOBHits();
     int nhtid = track->hitPattern().numberOfValidStripTIDHits();
     int nhtec = track->hitPattern().numberOfValidStripTECHits();
 
     if (verbose)
       edm::LogInfo("Alignment") << "New track pt,eta,phi,chi2n,hits: " << pt << "," << eta << "," << phi << "," << chi2n
                                 << "," << nhit;
 
     double ihitwt = 1;
     double trkwt = 1;
     if (trackWt) {
       trkwt = Scale;
       // Reweight by the specified eta distribution
       if (uniEta)
         trkwt *= theEtaFormula->Eval(fabs(eta));
     }
     if (trackPs) {
       double r = gRandom->Rndm();
       if (trkwt < r)
         continue;
     } else if (trackWt)
       ihitwt = trkwt;
 
     // fill track parameters in root tree
     {
       theMonitorConfig.trackmonitorvars.m_Nhits.push_back(nhit);
       theMonitorConfig.trackmonitorvars.m_Pt.push_back(pt);
       theMonitorConfig.trackmonitorvars.m_P.push_back(p);
       theMonitorConfig.trackmonitorvars.m_Eta.push_back(eta);
       theMonitorConfig.trackmonitorvars.m_Phi.push_back(phi);
       theMonitorConfig.trackmonitorvars.m_Chi2n.push_back(chi2n);
       theMonitorConfig.trackmonitorvars.m_nhPXB.push_back(nhpxb);
       theMonitorConfig.trackmonitorvars.m_nhPXF.push_back(nhpxf);
       theMonitorConfig.trackmonitorvars.m_nhTIB.push_back(nhtib);
       theMonitorConfig.trackmonitorvars.m_nhTOB.push_back(nhtob);
       theMonitorConfig.trackmonitorvars.m_nhTID.push_back(nhtid);
       theMonitorConfig.trackmonitorvars.m_nhTEC.push_back(nhtec);
       theMonitorConfig.trackmonitorvars.m_d0.push_back(d0);
       theMonitorConfig.trackmonitorvars.m_dz.push_back(dz);
       theMonitorConfig.trackmonitorvars.m_wt.push_back(ihitwt);
     }
 
     std::vector<const TransientTrackingRecHit*> hitvec;
     std::vector<TrajectoryStateOnSurface> tsosvec;
 
     // loop over measurements
     std::vector<TrajectoryMeasurement> measurements = traj->measurements();
     for (std::vector<TrajectoryMeasurement>::iterator im = measurements.begin(); im != measurements.end(); ++im) {
       TrajectoryMeasurement meas = *im;
 
       // const TransientTrackingRecHit* ttrhit = &(*meas.recHit());
       // const TrackingRecHit *hit = ttrhit->hit();
       const TransientTrackingRecHit* hit = &(*meas.recHit());
 
       if (hit->isValid() && theAlignableDetAccessor->detAndSubdetInMap(hit->geographicalId())) {
         // this is the updated state (including the current hit)
         // TrajectoryStateOnSurface tsos=meas.updatedState();
         // combine fwd and bwd predicted state to get state
         // which excludes current hit
 
         if (eventInfo.clusterValueMap()) {
           // check from the PrescalingMap if the hit was taken.
           // If not skip to the next TM
           // bool hitTaken=false;
           AlignmentClusterFlag myflag;
 
           int subDet = hit->geographicalId().subdetId();
           //take the actual RecHit out of the Transient one
           const TrackingRecHit* rechit = hit->hit();
           if (subDet > 2) {  // AM: if possible use enum instead of hard-coded value
             const std::type_info& type = typeid(*rechit);
 
             if (type == typeid(SiStripRecHit1D)) {
               const SiStripRecHit1D* stripHit1D = dynamic_cast<const SiStripRecHit1D*>(rechit);
               if (stripHit1D) {
                 SiStripRecHit1D::ClusterRef stripclust(stripHit1D->cluster());
                 // myflag=PrescMap[stripclust];
                 myflag = (*eventInfo.clusterValueMap())[stripclust];
               } else
                 edm::LogError("HIPAlignmentAlgorithm")
                     << "ERROR in <HIPAlignmentAlgorithm::run>: Dynamic cast of Strip RecHit failed! "
                     << "TypeId of the RecHit: " << className(*hit);
             }  //end if type = SiStripRecHit1D
             else if (type == typeid(SiStripRecHit2D)) {
               const SiStripRecHit2D* stripHit2D = dynamic_cast<const SiStripRecHit2D*>(rechit);
               if (stripHit2D) {
                 SiStripRecHit2D::ClusterRef stripclust(stripHit2D->cluster());
                 // myflag=PrescMap[stripclust];
                 myflag = (*eventInfo.clusterValueMap())[stripclust];
               } else
                 edm::LogError("HIPAlignmentAlgorithm")
                     << "ERROR in <HIPAlignmentAlgorithm::run>: Dynamic cast of Strip RecHit failed! "
                     << "TypeId of the TTRH: " << className(*hit);
             }  //end if type == SiStripRecHit2D
           }    //end if hit from strips
           else {
             const SiPixelRecHit* pixelhit = dynamic_cast<const SiPixelRecHit*>(rechit);
             if (pixelhit) {
               SiPixelClusterRefNew pixelclust(pixelhit->cluster());
               // myflag=PrescMap[pixelclust];
               myflag = (*eventInfo.clusterValueMap())[pixelclust];
             } else
               edm::LogError("HIPAlignmentAlgorithm")
                   << "ERROR in <HIPAlignmentAlgorithm::run>: Dynamic cast of Pixel RecHit failed! "
                   << "TypeId of the TTRH: " << className(*hit);
           }  //end 'else' it is a pixel hit
           if (!myflag.isTaken())
             continue;
         }  //end if Prescaled Hits
 
         TrajectoryStateOnSurface tsos = tsoscomb.combine(meas.forwardPredictedState(), meas.backwardPredictedState());
 
         if (tsos.isValid()) {
           hitvec.push_back(hit);
           tsosvec.push_back(tsos);
         }
 
       }  //hit valid
     }
 
     // transform RecHit vector to AlignableDet vector
     std::vector<AlignableDetOrUnitPtr> alidetvec = theAlignableDetAccessor->alignablesFromHits(hitvec);
 
     // get concatenated alignment parameters for list of alignables
     CompositeAlignmentParameters aap = theAlignmentParameterStore->selectParameters(alidetvec);
 
     std::vector<TrajectoryStateOnSurface>::const_iterator itsos = tsosvec.begin();
     std::vector<const TransientTrackingRecHit*>::const_iterator ihit = hitvec.begin();
 
     // loop over vectors(hit,tsos)
     while (itsos != tsosvec.end()) {
       // get AlignableDet for this hit
       const GeomDet* det = (*ihit)->det();
       // int subDet= (*ihit)->geographicalId().subdetId();
       uint32_t nhitDim = (*ihit)->dimension();
 
       AlignableDetOrUnitPtr alidet = theAlignableDetAccessor->alignableFromGeomDet(det);
 
       // get relevant Alignable
       Alignable* ali = aap.alignableFromAlignableDet(alidet);
 
       if (ali != nullptr) {
         const HIPAlignableSpecificParameters* alispecifics = findAlignableSpecs(ali);
         const TrajectoryStateOnSurface& tsos = *itsos;
 
         //  LocalVector v = tsos.localDirection();
         //  double proj_z = v.dot(LocalVector(0,0,1));
 
         //In fact, sin_theta=Abs(mom_z)
         double mom_x = tsos.localDirection().x();
         double mom_y = tsos.localDirection().y();
         double mom_z = tsos.localDirection().z();
         double sin_theta = TMath::Abs(mom_z) / sqrt(pow(mom_x, 2) + pow(mom_y, 2) + pow(mom_z, 2));
         double angle = TMath::ASin(sin_theta);
         double alihitwt = ihitwt;
 
         //Make cut on hit impact angle, reduce collision hits perpendicular to modules
         if (IsCollision) {
           if (angle > col_cut)
             alihitwt = 0;
         } else {
           if (angle < cos_cut)
             alihitwt = 0;
         }
 
         // Fill hit monitor variables
         theMonitorConfig.hitmonitorvars.m_angle = angle;
         theMonitorConfig.hitmonitorvars.m_sinTheta = sin_theta;
         theMonitorConfig.hitmonitorvars.m_detId = ali->id();
 
         // Check pixel XY and Q probabilities
         if ((*ihit)->hit() != nullptr) {
           const SiPixelRecHit* pixhit = dynamic_cast<const SiPixelRecHit*>((*ihit)->hit());
           if (pixhit != nullptr) {
             theMonitorConfig.hitmonitorvars.m_hasHitProb = pixhit->hasFilledProb();
             if (theMonitorConfig.hitmonitorvars.m_hasHitProb) {
               // Prob X, Y are deprecated
               theMonitorConfig.hitmonitorvars.m_probXY = pixhit->probabilityXY();
               theMonitorConfig.hitmonitorvars.m_probQ = pixhit->probabilityQ();
               theMonitorConfig.hitmonitorvars.m_rawQualityWord = pixhit->rawQualityWord();
               if (alispecifics->applyPixelProbCut) {
                 bool probXYgood = (theMonitorConfig.hitmonitorvars.m_probXY >= alispecifics->minPixelProbXY &&
                                    theMonitorConfig.hitmonitorvars.m_probXY <= alispecifics->maxPixelProbXY);
                 bool probQgood = (theMonitorConfig.hitmonitorvars.m_probQ >= alispecifics->minPixelProbQ &&
                                   theMonitorConfig.hitmonitorvars.m_probQ <= alispecifics->maxPixelProbQ);
                 bool probXYQgood;
                 if (alispecifics->usePixelProbXYOrProbQ)
                   probXYQgood = (probXYgood || probQgood);
                 else
                   probXYQgood = (probXYgood && probQgood);
                 if (!probXYQgood)
                   alihitwt = 0;
               }
             }
           }
         }
 
         theMonitorConfig.hitmonitorvars.m_hitwt = alihitwt;
         bool hitProcessed = false;
         switch (nhitDim) {
           case 1:
             hitProcessed = processHit1D(alidet, ali, alispecifics, tsos, *ihit, alihitwt);
             break;
           case 2:
             hitProcessed = processHit2D(alidet, ali, alispecifics, tsos, *ihit, alihitwt);
             break;
           default:
             edm::LogError("HIPAlignmentAlgorithm")
                 << "ERROR in <HIPAlignmentAlgorithm::run>: Number of hit dimensions = " << nhitDim
                 << " is not supported!" << std::endl;
             break;
         }
         if (theMonitorConfig.fillTrackHitMonitoring && theMonitorConfig.checkNhits() && hitProcessed)
           theMonitorConfig.hitmonitorvars.fill();
       }
 
       itsos++;
       ihit++;
     }
   }  // end of track loop
 
   // fill eventwise root tree (with prescale defined in pset)
   if (theMonitorConfig.fillTrackMonitoring && theMonitorConfig.checkNevents())
     theMonitorConfig.trackmonitorvars.fill();
 }

void HIPAlignmentAlgorithm::setAlignmentPositionError ( void )

private

Definition at line 1025 of file HIPAlignmentAlgorithm.cc.

References calcAPE(), mps_fire::i, AlignmentParameterStore::setAlignmentPositionError(), theAlignmentParameterStore, theAPEParameters, theApplyAPE, and theIteration.

Referenced by startNewLoop(), and ~HIPAlignmentAlgorithm().

                                                           {
   // Check if user wants to override APE
   if (!theApplyAPE) {
     edm::LogInfo("Alignment") << "[HIPAlignmentAlgorithm::setAlignmentPositionError] No APE applied";
     return;  // NO APE APPLIED
   }
 
   edm::LogInfo("Alignment") << "[HIPAlignmentAlgorithm::setAlignmentPositionError] Apply APE!";
 
   double apeSPar[3], apeRPar[3];
   for (const auto& alipars : theAPEParameters) {
     const auto& alignables = alipars.first;
     const auto& pars = alipars.second;
 
     apeSPar[0] = pars[0];
     apeSPar[1] = pars[1];
     apeSPar[2] = pars[2];
     apeRPar[0] = pars[3];
     apeRPar[1] = pars[4];
     apeRPar[2] = pars[5];
 
     int function = pars[6];
 
     // Printout for debug
     printf("APE: %u alignables\n", (unsigned int)alignables.size());
     for (int i = 0; i < 21; ++i) {
       double apelinstest = calcAPE(apeSPar, i, 0);
       double apeexpstest = calcAPE(apeSPar, i, 1);
       double apestepstest = calcAPE(apeSPar, i, 2);
       double apelinrtest = calcAPE(apeRPar, i, 0);
       double apeexprtest = calcAPE(apeRPar, i, 1);
       double apesteprtest = calcAPE(apeRPar, i, 2);
       printf("APE: iter slin sexp sstep rlin rexp rstep: %5d %12.5f %12.5f %12.5f %12.5f %12.5f %12.5f \n",
              i,
              apelinstest,
              apeexpstest,
              apestepstest,
              apelinrtest,
              apeexprtest,
              apesteprtest);
     }
 
     // set APE
     double apeshift = calcAPE(apeSPar, theIteration, function);
     double aperot = calcAPE(apeRPar, theIteration, function);
     theAlignmentParameterStore->setAlignmentPositionError(alignables, apeshift, aperot);
   }
 }

void HIPAlignmentAlgorithm::startNewLoop ( void )

overridevirtual

Called at start of new loop.

Reimplemented from AlignmentAlgorithmBase.

Definition at line 302 of file HIPAlignmentAlgorithm.cc.

References AlignmentParameterStore::applyAlignableAbsolutePositions(), bookRoot(), collector(), ioerr, isCollector, AlignmentParameters::numSelected(), AlignmentIORoot::readAlignableAbsolutePositions(), readIterationFile(), salignedfile, setAlignmentPositionError(), AlignmentParameters::setUserVariables(), siterationfile, theAlignables, theAlignmentParameterStore, theIO, and theIteration.

Referenced by ~HIPAlignmentAlgorithm().

                                              {
   edm::LogInfo("Alignment") << "@SUB=HIPAlignmentAlgorithm::startNewLoop"
                             << "Begin";
 
   // iterate over all alignables and attach user variables
   for (const auto& it : theAlignables) {
     AlignmentParameters* ap = it->alignmentParameters();
     int npar = ap->numSelected();
     HIPUserVariables* userpar = new HIPUserVariables(npar);
     ap->setUserVariables(userpar);
   }
 
   // try to read in alignment parameters from a previous iteration
   AlignablePositions theAlignablePositionsFromFile =
       theIO.readAlignableAbsolutePositions(theAlignables, salignedfile.c_str(), -1, ioerr);
   int numAlignablesFromFile = theAlignablePositionsFromFile.size();
   if (numAlignablesFromFile == 0) {  // file not there: first iteration
     // set iteration number to 1 when needed
     if (isCollector)
       theIteration = 0;
     else
       theIteration = 1;
     edm::LogWarning("Alignment") << "@SUB=HIPAlignmentAlgorithm::startNewLoop"
                                  << "IO alignables file not found for iteration " << theIteration;
   } else {  // there have been previous iterations
     edm::LogInfo("Alignment") << "@SUB=HIPAlignmentAlgorithm::startNewLoop"
                               << "Alignables Read " << numAlignablesFromFile;
 
     // get iteration number from file
     theIteration = readIterationFile(siterationfile);
     // Where is the target for this?
     theIO.readAlignableAbsolutePositions(theAlignables, salignedfile.c_str(), theIteration, ioerr);
 
     // increase iteration
     if (ioerr == 0) {
       theIteration++;
       edm::LogWarning("Alignment") << "@SUB=HIPAlignmentAlgorithm::startNewLoop"
                                    << "Iteration increased by one and is now " << theIteration;
     }
 
     // now apply psotions of file from prev iteration
     edm::LogInfo("Alignment") << "@SUB=HIPAlignmentAlgorithm::startNewLoop"
                               << "Apply positions from file ...";
     theAlignmentParameterStore->applyAlignableAbsolutePositions(theAlignables, theAlignablePositionsFromFile, ioerr);
   }
 
   edm::LogWarning("Alignment") << "@SUB=HIPAlignmentAlgorithm::startNewLoop"
                                << "Current Iteration number: " << theIteration;
 
   // book root trees
   bookRoot();
 
   // set alignment position error
   setAlignmentPositionError();
 
   // run collector job if we are in parallel mode
   if (isCollector)
     collector();
 
   edm::LogInfo("Alignment") << "@SUB=HIPAlignmentAlgorithm::startNewLoop"
                             << "End";
 }

void HIPAlignmentAlgorithm::terminate ( const edm::EventSetup & setup )

overridevirtual

Call at end of job.

Implements AlignmentAlgorithmBase.

Definition at line 366 of file HIPAlignmentAlgorithm.cc.

References Alignable::alignmentParameters(), AlignmentParameterStore::applyParameters(), calcParameters(), fillAlignablesMonitor(), edm::EventSetup::get(), mps_fire::i, Alignable::id(), SurveyResidual::inverseCovariance(), ioerr, isCollector, HIPUserVariables::jtve, HIPUserVariables::jtvj, cmsLHEtoEOSManager::l, m3_Id, m3_ObjId, m3_par, HIPUserVariables::nhit, GloballyPositioned< T >::position(), edm::ESHandle< T >::product(), salignedfile, SurveyResidual::sensorResidual(), SetScanDet, AlignmentParameters::setValid(), siterationfile, Alignable::surface(), suvarfile, theAlignables, theAlignablesMonitorIORootFile, theAlignablesMonitorTree, theAlignmentParameterStore, theHitMonitorTree, theIO, theIteration, theLevels, theSurveyIORootFile, theSurveyTree, theTrackHitMonitorIORootFile, theTrackMonitorTree, AlignmentParameterStore::typeAndLayer(), AlignmentParameters::userVariables(), SurveyResidual::valid(), AlignmentIORoot::writeAlignableAbsolutePositions(), HIPUserVariablesIORoot::writeHIPUserVariables(), writeIterationFile(), and PV3DBase< T, PVType, FrameType >::z().

                                                                  {
   edm::LogWarning("Alignment") << "[HIPAlignmentAlgorithm] Terminating";
 
   // calculating survey residuals
   if (!theLevels.empty()) {
     edm::LogWarning("Alignment") << "[HIPAlignmentAlgorithm] Using survey constraint";
 
     unsigned int nAlignable = theAlignables.size();
     edm::ESHandle<TrackerTopology> tTopoHandle;
     iSetup.get<IdealGeometryRecord>().get(tTopoHandle);
     const TrackerTopology* const tTopo = tTopoHandle.product();
     for (unsigned int i = 0; i < nAlignable; ++i) {
       const Alignable* ali = theAlignables[i];
       AlignmentParameters* ap = ali->alignmentParameters();
       HIPUserVariables* uservar = dynamic_cast<HIPUserVariables*>(ap->userVariables());
       int nhit = uservar->nhit;
 
       // get position
       std::pair<int, int> tl = theAlignmentParameterStore->typeAndLayer(ali, tTopo);
       int tmp_Type = tl.first;
       int tmp_Layer = tl.second;
       GlobalPoint pos = ali->surface().position();
       float tmpz = pos.z();
       if (nhit < 1500 ||
           (tmp_Type == 5 && tmp_Layer == 4 && fabs(tmpz) > 90)) {  // FIXME: Needs revision for hardcoded consts
         for (unsigned int l = 0; l < theLevels.size(); ++l) {
           SurveyResidual res(*ali, theLevels[l], true);
 
           if (res.valid()) {
             AlgebraicSymMatrix invCov = res.inverseCovariance();
 
             // variable for tree
             AlgebraicVector sensResid = res.sensorResidual();
             m3_Id = ali->id();
             m3_ObjId = theLevels[l];
             m3_par[0] = sensResid[0];
             m3_par[1] = sensResid[1];
             m3_par[2] = sensResid[2];
             m3_par[3] = sensResid[3];
             m3_par[4] = sensResid[4];
             m3_par[5] = sensResid[5];
 
             uservar->jtvj += invCov;
             uservar->jtve += invCov * sensResid;
 
             if (theSurveyTree != nullptr)
               theSurveyTree->Fill();
           }
         }
       }
     }
   }
 
   // write user variables
   HIPUserVariablesIORoot HIPIO;
   // don't store userVariable in main, to save time
   if (!isCollector)
     HIPIO.writeHIPUserVariables(theAlignables, suvarfile.c_str(), theIteration, false, ioerr);
 
   // now calculate alignment corrections...
   int ialigned = 0;
   // iterate over alignment parameters
   for (const auto& ali : theAlignables) {
     AlignmentParameters* par = ali->alignmentParameters();
 
     if (SetScanDet.at(0) != 0) {
       edm::LogWarning("Alignment") << "********Starting Scan*********";
       edm::LogWarning("Alignment") << "det ID=" << SetScanDet.at(0) << ", starting position=" << SetScanDet.at(1)
                                    << ", step=" << SetScanDet.at(2) << ", currentDet = " << ali->id();
     }
 
     if ((SetScanDet.at(0) != 0) && (SetScanDet.at(0) != 1) && (ali->id() != SetScanDet.at(0)))
       continue;
 
     bool test = calcParameters(ali, SetScanDet.at(0), SetScanDet.at(1), SetScanDet.at(2));
     if (test) {
       if (dynamic_cast<AlignableDetUnit*>(ali) != nullptr) {
         std::vector<std::pair<int, SurfaceDeformation*>> pairs;
         ali->surfaceDeformationIdPairs(pairs);
         edm::LogInfo("Alignment") << "@SUB=HIPAlignmentAlgorithm::terminate"
                                   << "The alignable contains " << pairs.size() << " surface deformations";
       } else
         edm::LogInfo("Alignment") << "@SUB=HIPAlignmentAlgorithm::terminate"
                                   << "The alignable cannot contain surface deformations";
 
       theAlignmentParameterStore->applyParameters(ali);
       // set these parameters 'valid'
       ali->alignmentParameters()->setValid(true);
       // increase counter
       ialigned++;
     } else
       par->setValid(false);
   }
   //end looping over alignables
 
   edm::LogWarning("Alignment") << "[HIPAlignmentAlgorithm::terminate] Aligned units: " << ialigned;
 
   // fill alignable wise root tree
   fillAlignablesMonitor(iSetup);
 
   edm::LogWarning("Alignment") << "[HIPAlignmentAlgorithm] Writing aligned parameters to file: " << theAlignables.size()
                                << ", for Iteration " << theIteration;
 
   // write user variables
   if (isCollector)
     HIPIO.writeHIPUserVariables(theAlignables, suvarfile.c_str(), theIteration, false, ioerr);
 
   // write new absolute positions to disk
   theIO.writeAlignableAbsolutePositions(theAlignables, salignedfile.c_str(), theIteration, false, ioerr);
 
   // write alignment parameters to disk
   //theIO.writeAlignmentParameters(theAlignables,
   //                 sparameterfile.c_str(),theIteration,false,ioerr);
 
   // write iteration number to file
   writeIterationFile(siterationfile, theIteration);
 
   // write out trees and close root file
   // Survey tree
   if (theSurveyIORootFile != nullptr) {
     theSurveyIORootFile->cd();
     if (theSurveyTree != nullptr)
       theSurveyTree->Write();
     delete theSurveyTree;
     theSurveyTree = nullptr;
     theSurveyIORootFile->Close();
   }
   // Alignable-wise tree is only filled once at iteration 1
   if (theAlignablesMonitorIORootFile != nullptr) {
     theAlignablesMonitorIORootFile->cd();
     if (theAlignablesMonitorTree != nullptr)
       theAlignablesMonitorTree->Write();
     delete theAlignablesMonitorTree;
     theAlignablesMonitorTree = nullptr;
     theAlignablesMonitorIORootFile->Close();
   }
   // Eventwise and hitwise monitoring trees
   if (theTrackHitMonitorIORootFile != nullptr) {
     theTrackHitMonitorIORootFile->cd();
     if (theTrackMonitorTree != nullptr) {
       theTrackMonitorTree->Write();
       delete theTrackMonitorTree;
       theTrackMonitorTree = nullptr;
     }
     if (theHitMonitorTree != nullptr) {
       theHitMonitorTree->Write();
       delete theHitMonitorTree;
       theHitMonitorTree = nullptr;
     }
     theTrackHitMonitorIORootFile->Close();
   }
 }

void HIPAlignmentAlgorithm::writeIterationFile	(	std::string	filename,
		int	iter
	)

private

Definition at line 1011 of file HIPAlignmentAlgorithm.cc.

References MillePedeFileConverter_cfg::out.

Referenced by terminate(), and ~HIPAlignmentAlgorithm().

                                                                            {
   std::ofstream outIterFile((filename.c_str()), std::ios::out);
   if (!outIterFile)
     edm::LogError("Alignment") << "[HIPAlignmentAlgorithm::writeIterationFile] ERROR: Unable to write Iteration file";
   else {
     outIterFile << iter;
     edm::LogWarning("Alignment") << "[HIPAlignmentAlgorithm::writeIterationFile] writing iteration number to file: "
                                  << iter;
   }
   outIterFile.close();
 }

Member Data Documentation

std::unique_ptr<AlignableObjectId> HIPAlignmentAlgorithm::alignableObjectId_

private

Definition at line 84 of file HIPAlignmentAlgorithm.h.

Referenced by initialize().

double HIPAlignmentAlgorithm::col_cut

private

Definition at line 129 of file HIPAlignmentAlgorithm.h.

Referenced by HIPAlignmentAlgorithm(), and run().

double HIPAlignmentAlgorithm::cos_cut

private

Definition at line 129 of file HIPAlignmentAlgorithm.h.

Referenced by HIPAlignmentAlgorithm(), and run().

HIPAlignableSpecificParameters HIPAlignmentAlgorithm::defaultAlignableSpecs

private

Definition at line 116 of file HIPAlignmentAlgorithm.h.

Referenced by calcParameters(), findAlignableSpecs(), HIPAlignmentAlgorithm(), processHit1D(), and processHit2D().

const bool HIPAlignmentAlgorithm::doTrackHitMonitoring

private

Definition at line 99 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), collectMonitorTrees(), and collector().

int HIPAlignmentAlgorithm::ioerr

private

Definition at line 90 of file HIPAlignmentAlgorithm.h.

Referenced by collector(), startNewLoop(), and terminate().

bool HIPAlignmentAlgorithm::isCollector

private

Definition at line 123 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), calcParameters(), collectMonitorTrees(), HIPAlignmentAlgorithm(), initialize(), run(), startNewLoop(), and terminate().

bool HIPAlignmentAlgorithm::IsCollision

private

Definition at line 127 of file HIPAlignmentAlgorithm.h.

Referenced by HIPAlignmentAlgorithm(), and run().

int HIPAlignmentAlgorithm::m2_datatype

private

Definition at line 153 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), and fillAlignablesMonitor().

SurfaceDeformationFactory::Type HIPAlignmentAlgorithm::m2_dtype

private

Definition at line 155 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), and fillAlignablesMonitor().

align::ID HIPAlignmentAlgorithm::m2_Id

private

Definition at line 150 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), and fillAlignablesMonitor().

int HIPAlignmentAlgorithm::m2_Layer

private

Definition at line 152 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), and fillAlignablesMonitor().

int HIPAlignmentAlgorithm::m2_Nhit

private

Definition at line 152 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), and fillAlignablesMonitor().

unsigned int HIPAlignmentAlgorithm::m2_nsurfdef

private

Definition at line 156 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), and fillAlignablesMonitor().

align::StructureType HIPAlignmentAlgorithm::m2_ObjId

private

Definition at line 151 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), and fillAlignablesMonitor().

std::vector<float> HIPAlignmentAlgorithm::m2_surfDef

private

Definition at line 157 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), and fillAlignablesMonitor().

int HIPAlignmentAlgorithm::m2_Type

private

Definition at line 152 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), and fillAlignablesMonitor().

float HIPAlignmentAlgorithm::m2_Xpos

private

Definition at line 154 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), and fillAlignablesMonitor().

float HIPAlignmentAlgorithm::m2_Ypos

private

Definition at line 154 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), and fillAlignablesMonitor().

float HIPAlignmentAlgorithm::m2_Zpos

private

Definition at line 154 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), and fillAlignablesMonitor().

align::ID HIPAlignmentAlgorithm::m3_Id

private

Definition at line 160 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), and terminate().

align::StructureType HIPAlignmentAlgorithm::m3_ObjId

private

Definition at line 161 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), and terminate().

float HIPAlignmentAlgorithm::m3_par[6]

private

Definition at line 162 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), and terminate().

int HIPAlignmentAlgorithm::m_datatype

private

Definition at line 147 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), and run().

std::string HIPAlignmentAlgorithm::outfile2

private

Definition at line 101 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), HIPAlignmentAlgorithm(), and initialize().

std::string HIPAlignmentAlgorithm::outpath

private

Definition at line 101 of file HIPAlignmentAlgorithm.h.

Referenced by HIPAlignmentAlgorithm().

bool HIPAlignmentAlgorithm::rewgtPerAli

private

Definition at line 127 of file HIPAlignmentAlgorithm.h.

Referenced by collector(), and HIPAlignmentAlgorithm().

std::string HIPAlignmentAlgorithm::salignedfile

private

Definition at line 102 of file HIPAlignmentAlgorithm.h.

Referenced by HIPAlignmentAlgorithm(), initialize(), startNewLoop(), and terminate().

double HIPAlignmentAlgorithm::Scale

private

Definition at line 129 of file HIPAlignmentAlgorithm.h.

Referenced by HIPAlignmentAlgorithm(), and run().

std::vector<double> HIPAlignmentAlgorithm::SetScanDet

private

Definition at line 130 of file HIPAlignmentAlgorithm.h.

Referenced by HIPAlignmentAlgorithm(), and terminate().

std::string HIPAlignmentAlgorithm::siterationfile

private

Definition at line 102 of file HIPAlignmentAlgorithm.h.

Referenced by HIPAlignmentAlgorithm(), initialize(), startNewLoop(), and terminate().

std::string HIPAlignmentAlgorithm::smisalignedfile

private

Definition at line 102 of file HIPAlignmentAlgorithm.h.

Referenced by HIPAlignmentAlgorithm().

std::string HIPAlignmentAlgorithm::sparameterfile

private

Definition at line 101 of file HIPAlignmentAlgorithm.h.

Referenced by HIPAlignmentAlgorithm().

std::string HIPAlignmentAlgorithm::ssurveyfile

private

Definition at line 102 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), HIPAlignmentAlgorithm(), and initialize().

std::string HIPAlignmentAlgorithm::struefile

private

Definition at line 102 of file HIPAlignmentAlgorithm.h.

Referenced by HIPAlignmentAlgorithm().

const std::vector<std::string> HIPAlignmentAlgorithm::surveyResiduals_

private

Definition at line 134 of file HIPAlignmentAlgorithm.h.

Referenced by initialize().

std::string HIPAlignmentAlgorithm::suvarfile

private

Definition at line 101 of file HIPAlignmentAlgorithm.h.

Referenced by HIPAlignmentAlgorithm(), initialize(), and terminate().

std::string HIPAlignmentAlgorithm::suvarfilecore

private

Definition at line 101 of file HIPAlignmentAlgorithm.h.

Referenced by collector(), and HIPAlignmentAlgorithm().

std::unique_ptr<AlignableNavigator> HIPAlignmentAlgorithm::theAlignableDetAccessor

private

Definition at line 87 of file HIPAlignmentAlgorithm.h.

Referenced by initialize(), and run().

align::Alignables HIPAlignmentAlgorithm::theAlignables

private

Definition at line 86 of file HIPAlignmentAlgorithm.h.

Referenced by collector(), fillAlignablesMonitor(), initialize(), startNewLoop(), and terminate().

TFile* HIPAlignmentAlgorithm::theAlignablesMonitorIORootFile

private

Definition at line 141 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), fillAlignablesMonitor(), and terminate().

TTree* HIPAlignmentAlgorithm::theAlignablesMonitorTree

private

Definition at line 142 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), fillAlignablesMonitor(), and terminate().

std::vector<HIPAlignableSpecificParameters> HIPAlignmentAlgorithm::theAlignableSpecifics

private

Definition at line 120 of file HIPAlignmentAlgorithm.h.

Referenced by findAlignableSpecs(), and initialize().

AlignmentParameterStore* HIPAlignmentAlgorithm::theAlignmentParameterStore

private

Definition at line 85 of file HIPAlignmentAlgorithm.h.

Referenced by collector(), fillAlignablesMonitor(), initialize(), run(), setAlignmentPositionError(), startNewLoop(), and terminate().

std::vector<std::pair<align::Alignables, std::vector<double> > > HIPAlignmentAlgorithm::theAPEParameters

private

Definition at line 110 of file HIPAlignmentAlgorithm.h.

Referenced by initialize(), and setAlignmentPositionError().

std::vector<edm::ParameterSet> HIPAlignmentAlgorithm::theAPEParameterSet

private

Definition at line 109 of file HIPAlignmentAlgorithm.h.

Referenced by HIPAlignmentAlgorithm(), and initialize().

bool HIPAlignmentAlgorithm::theApplyAPE

private

Definition at line 108 of file HIPAlignmentAlgorithm.h.

Referenced by HIPAlignmentAlgorithm(), initialize(), and setAlignmentPositionError().

bool HIPAlignmentAlgorithm::theApplyCutsPerComponent

private

Definition at line 118 of file HIPAlignmentAlgorithm.h.

Referenced by calcParameters(), HIPAlignmentAlgorithm(), initialize(), processHit1D(), and processHit2D().

int HIPAlignmentAlgorithm::theCollectorNJobs

private

Definition at line 124 of file HIPAlignmentAlgorithm.h.

Referenced by collector(), and HIPAlignmentAlgorithm().

std::string HIPAlignmentAlgorithm::theCollectorPath

private

Definition at line 125 of file HIPAlignmentAlgorithm.h.

Referenced by collector(), and HIPAlignmentAlgorithm().

std::vector<edm::ParameterSet> HIPAlignmentAlgorithm::theCutsPerComponent

private

Definition at line 119 of file HIPAlignmentAlgorithm.h.

Referenced by HIPAlignmentAlgorithm(), and initialize().

int HIPAlignmentAlgorithm::theDataGroup

private

Definition at line 126 of file HIPAlignmentAlgorithm.h.

Referenced by collector(), HIPAlignmentAlgorithm(), processHit1D(), processHit2D(), and run().

std::unique_ptr<TFormula> HIPAlignmentAlgorithm::theEtaFormula

private

Definition at line 132 of file HIPAlignmentAlgorithm.h.

Referenced by HIPAlignmentAlgorithm(), and run().

TTree* HIPAlignmentAlgorithm::theHitMonitorTree

private

Definition at line 140 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), collectMonitorTrees(), and terminate().

AlignmentIORoot HIPAlignmentAlgorithm::theIO

private

Definition at line 89 of file HIPAlignmentAlgorithm.h.

Referenced by startNewLoop(), and terminate().

std::vector<unsigned> HIPAlignmentAlgorithm::theIOVrangeSet

private

Definition at line 105 of file HIPAlignmentAlgorithm.h.

Referenced by HIPAlignmentAlgorithm(), and initialize().

int HIPAlignmentAlgorithm::theIteration

private

Definition at line 91 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), calcParameters(), collectMonitorTrees(), collector(), setAlignmentPositionError(), startNewLoop(), and terminate().

std::vector<align::StructureType> HIPAlignmentAlgorithm::theLevels

private

Definition at line 135 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), initialize(), and terminate().

HIPMonitorConfig HIPAlignmentAlgorithm::theMonitorConfig

private

Definition at line 98 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), collectMonitorTrees(), collector(), and run().

bool HIPAlignmentAlgorithm::themultiIOV

private

Definition at line 104 of file HIPAlignmentAlgorithm.h.

Referenced by HIPAlignmentAlgorithm(), and initialize().

TFile* HIPAlignmentAlgorithm::theSurveyIORootFile

private

Definition at line 143 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), and terminate().

TTree* HIPAlignmentAlgorithm::theSurveyTree

private

Definition at line 144 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), and terminate().

TFile* HIPAlignmentAlgorithm::theTrackHitMonitorIORootFile

private

Definition at line 138 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), collectMonitorTrees(), and terminate().

TTree* HIPAlignmentAlgorithm::theTrackMonitorTree

private

Definition at line 139 of file HIPAlignmentAlgorithm.h.

Referenced by bookRoot(), collectMonitorTrees(), and terminate().

bool HIPAlignmentAlgorithm::trackPs

private

Definition at line 127 of file HIPAlignmentAlgorithm.h.

Referenced by HIPAlignmentAlgorithm(), and run().

bool HIPAlignmentAlgorithm::trackWt

private

Definition at line 127 of file HIPAlignmentAlgorithm.h.

Referenced by HIPAlignmentAlgorithm(), and run().

bool HIPAlignmentAlgorithm::uniEta

private

Definition at line 127 of file HIPAlignmentAlgorithm.h.

Referenced by HIPAlignmentAlgorithm(), and run().

std::string HIPAlignmentAlgorithm::uniEtaFormula

private

Definition at line 128 of file HIPAlignmentAlgorithm.h.

Referenced by HIPAlignmentAlgorithm().

const bool HIPAlignmentAlgorithm::verbose

private

Definition at line 96 of file HIPAlignmentAlgorithm.h.

Referenced by python.diff_provenance.difference::list_diff(), python.diffProv.difference::list_diff(), python.diff_provenance.difference::module_diff(), python.diffProv.difference::module_diff(), python.diff_provenance.difference::onefilemodules(), python.diffProv.difference::onefilemodules(), core.TriggerMatchAnalyzer.TriggerMatchAnalyzer::process(), core.SkimAnalyzerCount.SkimAnalyzerCount::process(), objects.VertexAnalyzer.VertexAnalyzer::process(), and confdbOfflineConverter.OfflineConverter::query().

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation