#include <Alignment/CSCOverlapsAlignmentAlgorithm/interface/CSCOverlapsAlignmentAlgorithm.h>

Inheritance diagram for CSCOverlapsAlignmentAlgorithm:

Public Member Functions
	CSCOverlapsAlignmentAlgorithm (const edm::ParameterSet &iConfig, edm::ConsumesCollector &)

void	initialize (const edm::EventSetup &iSetup, AlignableTracker alignableTracker, AlignableMuon alignableMuon, AlignableExtras alignableExtras, AlignmentParameterStore alignmentParameterStore) override
	Call at beginning of job (must be implemented in derived class) More...

void	run (const edm::EventSetup &iSetup, const EventInfo &eventInfo) override
	Run the algorithm (must be implemented in derived class) More...

void	terminate (const edm::EventSetup &iSetup) override
	Call at end of each loop (must be implemented in derived class) More...

	~CSCOverlapsAlignmentAlgorithm () override

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

bool	addCalibrations (const CalibrationsOwner &cals)

	AlignmentAlgorithmBase (const edm::ParameterSet &, const edm::ConsumesCollector &)
	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 void	startNewLoop ()

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...

Public Attributes
bool	m_combineME11

TH1F *	m_drdz

bool	m_errorFromRMS

bool	m_fiducial

TProfile *	m_fiducial_ME11

TProfile *	m_fiducial_ME12

TProfile *	m_fiducial_MEx1

TProfile *	m_fiducial_MEx2

TH1F *	m_hitsPerChamber

bool	m_makeHistograms

double	m_maxdrdz

int	m_minHitsPerChamber

int	m_minStationsInTrackRefits

int	m_minTracksPerOverlap

int	m_mode

TH2F *	m_occupancy

TH1F *	m_offsetResiduals

TH1F *	m_offsetResiduals_normalized

TH1F *	m_offsetResiduals_weighted

TH2F *	m_RPhipos_mem1

TH2F *	m_RPhipos_mem2

TH2F *	m_RPhipos_mem3

TH2F *	m_RPhipos_mem4

TH2F *	m_RPhipos_mep1

TH2F *	m_RPhipos_mep2

TH2F *	m_RPhipos_mep3

TH2F *	m_RPhipos_mep4

TH1F *	m_slope

TH1F *	m_slope_MEm1

TH1F *	m_slope_MEm2

TH1F *	m_slope_MEm3

TH1F *	m_slope_MEm4

TH1F *	m_slope_MEp1

TH1F *	m_slope_MEp2

TH1F *	m_slope_MEp3

TH1F *	m_slope_MEp4

bool	m_slopeFromTrackRefit

TH1F *	m_slopeResiduals

TH1F *	m_slopeResiduals_normalized

TH1F *	m_slopeResiduals_weighted

double	m_truncateOffsetResid

double	m_truncateSlopeResid

bool	m_useHitWeights

bool	m_useTrackWeights

TH2F *	m_XYpos_mem1

TH2F *	m_XYpos_mem2

TH2F *	m_XYpos_mem3

TH2F *	m_XYpos_mem4

TH2F *	m_XYpos_mep1

TH2F *	m_XYpos_mep2

TH2F *	m_XYpos_mep3

TH2F *	m_XYpos_mep4

Private Attributes
AlignableNavigator *	m_alignableNavigator

align::Alignables	m_alignables

AlignmentParameterStore *	m_alignmentParameterStore

const edm::ESGetToken< CSCGeometry, MuonGeometryRecord >	m_cscGeometryToken

bool	m_doAlignment

std::vector< CSCChamberFitter >	m_fitters

TH1F *	m_histP10

TH1F *	m_histP100

TH1F *	m_histP1000

double	m_maxRedChi2

double	m_minP

std::string	m_mode_string

const Propagator *	m_propagatorPointer

const edm::ESGetToken< Propagator, TrackingComponentsRecord >	m_propToken

std::map< std::pair< CSCDetId, CSCDetId >, CSCPairResidualsConstraint * >	m_quickChamberLookup

std::vector< std::string >	m_readTemporaryFiles

std::string	m_reportFileName

std::vector< CSCPairResidualsConstraint * >	m_residualsConstraints

TrackTransformer *	m_trackTransformer

const edm::ESGetToken< TransientTrackBuilder, TransientTrackRecord >	m_tthbToken

std::string	m_writeTemporaryFile

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

Description: <one line="" class="" summary>="">

Implementation: <Notes on="" implementation>="">

Definition at line 61 of file CSCOverlapsAlignmentAlgorithm.h.

Constructor & Destructor Documentation

◆ CSCOverlapsAlignmentAlgorithm()

CSCOverlapsAlignmentAlgorithm::CSCOverlapsAlignmentAlgorithm	(	const edm::ParameterSet &	iConfig,
		edm::ConsumesCollector &	iC
	)

Definition at line 3 of file CSCOverlapsAlignmentAlgorithm.cc.

References Exception, alignBH_cfg::fitters, edm::ParameterSet::getParameter(), mps_fire::i, CSCPairResidualsConstraint::kModePhiPos, CSCPairResidualsConstraint::kModePhiy, CSCPairResidualsConstraint::kModePhiz, CSCPairResidualsConstraint::kModeRadius, m_combineME11, m_drdz, m_fiducial_ME11, m_fiducial_ME12, m_fiducial_MEx1, m_fiducial_MEx2, m_fitters, m_histP10, m_histP100, m_histP1000, m_hitsPerChamber, m_makeHistograms, m_mode, m_mode_string, m_occupancy, m_offsetResiduals, m_offsetResiduals_normalized, m_offsetResiduals_weighted, M_PI, m_propagatorPointer, m_quickChamberLookup, m_residualsConstraints, m_RPhipos_mem1, m_RPhipos_mem2, m_RPhipos_mem3, m_RPhipos_mem4, m_RPhipos_mep1, m_RPhipos_mep2, m_RPhipos_mep3, m_RPhipos_mep4, m_slope, m_slope_MEm1, m_slope_MEm2, m_slope_MEm3, m_slope_MEm4, m_slope_MEp1, m_slope_MEp2, m_slope_MEp3, m_slope_MEp4, m_slopeFromTrackRefit, m_slopeResiduals, m_slopeResiduals_normalized, m_slopeResiduals_weighted, m_trackTransformer, m_XYpos_mem1, m_XYpos_mem2, m_XYpos_mem3, m_XYpos_mem4, m_XYpos_mep1, m_XYpos_mep2, m_XYpos_mep3, m_XYpos_mep4, TFileService::make(), AlCaHLTBitMon_QueryRunRegistry::string, and HLT_2022v12_cff::TrackTransformer.

     : AlignmentAlgorithmBase(iConfig, iC),
       m_minHitsPerChamber(iConfig.getParameter<int>("minHitsPerChamber")),
       m_maxdrdz(iConfig.getParameter<double>("maxdrdz")),
       m_fiducial(iConfig.getParameter<bool>("fiducial")),
       m_useHitWeights(iConfig.getParameter<bool>("useHitWeights")),
       m_slopeFromTrackRefit(iConfig.getParameter<bool>("slopeFromTrackRefit")),
       m_minStationsInTrackRefits(iConfig.getParameter<int>("minStationsInTrackRefits")),
       m_truncateSlopeResid(iConfig.getParameter<double>("truncateSlopeResid")),
       m_truncateOffsetResid(iConfig.getParameter<double>("truncateOffsetResid")),
       m_combineME11(iConfig.getParameter<bool>("combineME11")),
       m_useTrackWeights(iConfig.getParameter<bool>("useTrackWeights")),
       m_errorFromRMS(iConfig.getParameter<bool>("errorFromRMS")),
       m_minTracksPerOverlap(iConfig.getParameter<int>("minTracksPerOverlap")),
       m_makeHistograms(iConfig.getParameter<bool>("makeHistograms")),
       m_cscGeometryToken(iC.esConsumes<edm::Transition::BeginRun>()),
       m_propToken(iC.esConsumes(edm::ESInputTag(
           "",
           m_slopeFromTrackRefit
               ? iConfig.getParameter<edm::ParameterSet>("TrackTransformer").getParameter<std::string>("Propagator")
               : std::string("")))),
       m_tthbToken(iC.esConsumes(edm::ESInputTag("", "TransientTrackBuilder"))),
       m_mode_string(iConfig.getParameter<std::string>("mode")),
       m_reportFileName(iConfig.getParameter<std::string>("reportFileName")),
       m_minP(iConfig.getParameter<double>("minP")),
       m_maxRedChi2(iConfig.getParameter<double>("maxRedChi2")),
       m_writeTemporaryFile(iConfig.getParameter<std::string>("writeTemporaryFile")),
       m_readTemporaryFiles(iConfig.getParameter<std::vector<std::string> >("readTemporaryFiles")),
       m_doAlignment(iConfig.getParameter<bool>("doAlignment")) {
   if (m_mode_string == std::string("phiy"))
     m_mode = CSCPairResidualsConstraint::kModePhiy;
   else if (m_mode_string == std::string("phipos"))
     m_mode = CSCPairResidualsConstraint::kModePhiPos;
   else if (m_mode_string == std::string("phiz"))
     m_mode = CSCPairResidualsConstraint::kModePhiz;
   else if (m_mode_string == std::string("radius"))
     m_mode = CSCPairResidualsConstraint::kModeRadius;
   else
     throw cms::Exception("BadConfig") << "mode must be one of \"phiy\", \"phipos\", \"phiz\", \"radius\"" << std::endl;
 
   std::vector<edm::ParameterSet> fitters = iConfig.getParameter<std::vector<edm::ParameterSet> >("fitters");
   for (std::vector<edm::ParameterSet>::const_iterator fitter = fitters.begin(); fitter != fitters.end(); ++fitter) {
     m_fitters.push_back(CSCChamberFitter(*fitter, m_residualsConstraints));
   }
 
   for (std::vector<CSCPairResidualsConstraint*>::const_iterator residualsConstraint = m_residualsConstraints.begin();
        residualsConstraint != m_residualsConstraints.end();
        ++residualsConstraint) {
     (*residualsConstraint)->configure(this);
     m_quickChamberLookup[std::pair<CSCDetId, CSCDetId>((*residualsConstraint)->id_i(), (*residualsConstraint)->id_j())] =
         *residualsConstraint;
   }
 
   if (m_slopeFromTrackRefit) {
     m_trackTransformer = new TrackTransformer(iConfig.getParameter<edm::ParameterSet>("TrackTransformer"), iC);
   } else {
     m_trackTransformer = nullptr;
   }
 
   m_propagatorPointer = nullptr;
 
   if (m_makeHistograms) {
     edm::Service<TFileService> tFileService;
     m_histP10 = tFileService->make<TH1F>("P10", "", 100, 0, 10);
     m_histP100 = tFileService->make<TH1F>("P100", "", 100, 0, 100);
     m_histP1000 = tFileService->make<TH1F>("P1000", "", 100, 0, 1000);
 
     m_hitsPerChamber = tFileService->make<TH1F>("hitsPerChamber", "", 10, -0.5, 9.5);
 
     m_fiducial_ME11 = tFileService->make<TProfile>("fiducial_ME11", "", 100, 0.075, 0.100);
     m_fiducial_ME12 = tFileService->make<TProfile>("fiducial_ME12", "", 100, 0.080, 0.105);
     m_fiducial_MEx1 = tFileService->make<TProfile>("fiducial_MEx1", "", 100, 0.160, 0.210);
     m_fiducial_MEx2 = tFileService->make<TProfile>("fiducial_MEx2", "", 100, 0.080, 0.105);
 
     m_slope = tFileService->make<TH1F>("slope", "", 100, -0.5, 0.5);
     m_slope_MEp4 = tFileService->make<TH1F>("slope_MEp4", "", 100, -0.5, 0.5);
     m_slope_MEp3 = tFileService->make<TH1F>("slope_MEp3", "", 100, -0.5, 0.5);
     m_slope_MEp2 = tFileService->make<TH1F>("slope_MEp2", "", 100, -0.5, 0.5);
     m_slope_MEp1 = tFileService->make<TH1F>("slope_MEp1", "", 100, -0.5, 0.5);
     m_slope_MEm1 = tFileService->make<TH1F>("slope_MEm1", "", 100, -0.5, 0.5);
     m_slope_MEm2 = tFileService->make<TH1F>("slope_MEm2", "", 100, -0.5, 0.5);
     m_slope_MEm3 = tFileService->make<TH1F>("slope_MEm3", "", 100, -0.5, 0.5);
     m_slope_MEm4 = tFileService->make<TH1F>("slope_MEm4", "", 100, -0.5, 0.5);
 
     m_slopeResiduals = tFileService->make<TH1F>("slopeResiduals", "mrad", 300, -30., 30.);
     m_slopeResiduals_weighted = tFileService->make<TH1F>("slopeResiduals_weighted", "mrad", 300, -30., 30.);
     m_slopeResiduals_normalized = tFileService->make<TH1F>("slopeResiduals_normalized", "", 200, -20., 20.);
     m_offsetResiduals = tFileService->make<TH1F>("offsetResiduals", "mm", 300, -30., 30.);
     m_offsetResiduals_weighted = tFileService->make<TH1F>("offsetResiduals_weighted", "mm", 300, -30., 30.);
     m_offsetResiduals_normalized = tFileService->make<TH1F>("offsetResiduals_normalized", "", 200, -20., 20.);
 
     m_drdz = tFileService->make<TH1F>("drdz", "", 100, -0.5, 0.5);
 
     m_occupancy = tFileService->make<TH2F>("occupancy", "", 36, 1, 37, 20, 1, 21);
     for (int i = 1; i <= 36; i++) {
       std::stringstream pairname;
       pairname << i << "-";
       if (i + 1 == 37)
         pairname << 1;
       else
         pairname << (i + 1);
       m_occupancy->GetXaxis()->SetBinLabel(i, pairname.str().c_str());
     }
     m_occupancy->GetYaxis()->SetBinLabel(1, "ME-4/2");
     m_occupancy->GetYaxis()->SetBinLabel(2, "ME-4/1");
     m_occupancy->GetYaxis()->SetBinLabel(3, "ME-3/2");
     m_occupancy->GetYaxis()->SetBinLabel(4, "ME-3/1");
     m_occupancy->GetYaxis()->SetBinLabel(5, "ME-2/2");
     m_occupancy->GetYaxis()->SetBinLabel(6, "ME-2/1");
     m_occupancy->GetYaxis()->SetBinLabel(7, "ME-1/3");
     m_occupancy->GetYaxis()->SetBinLabel(8, "ME-1/2");
     if (!m_combineME11) {
       m_occupancy->GetYaxis()->SetBinLabel(9, "ME-1/1b");
       m_occupancy->GetYaxis()->SetBinLabel(10, "ME-1/1a");
       m_occupancy->GetYaxis()->SetBinLabel(11, "ME+1/1a");
       m_occupancy->GetYaxis()->SetBinLabel(12, "ME+1/1b");
     } else {
       m_occupancy->GetYaxis()->SetBinLabel(9, "ME-1/1");
       m_occupancy->GetYaxis()->SetBinLabel(10, "");
       m_occupancy->GetYaxis()->SetBinLabel(11, "");
       m_occupancy->GetYaxis()->SetBinLabel(12, "ME+1/1");
     }
     m_occupancy->GetYaxis()->SetBinLabel(13, "ME+1/2");
     m_occupancy->GetYaxis()->SetBinLabel(14, "ME+1/3");
     m_occupancy->GetYaxis()->SetBinLabel(15, "ME+2/1");
     m_occupancy->GetYaxis()->SetBinLabel(16, "ME+2/2");
     m_occupancy->GetYaxis()->SetBinLabel(17, "ME+3/1");
     m_occupancy->GetYaxis()->SetBinLabel(18, "ME+3/2");
     m_occupancy->GetYaxis()->SetBinLabel(19, "ME+4/1");
     m_occupancy->GetYaxis()->SetBinLabel(20, "ME+4/2");
 
     m_XYpos_mep1 = tFileService->make<TH2F>("XYpos_mep1", "Positions: ME+1", 140, -700., 700., 140, -700., 700.);
     m_XYpos_mep2 = tFileService->make<TH2F>("XYpos_mep2", "Positions: ME+2", 140, -700., 700., 140, -700., 700.);
     m_XYpos_mep3 = tFileService->make<TH2F>("XYpos_mep3", "Positions: ME+3", 140, -700., 700., 140, -700., 700.);
     m_XYpos_mep4 = tFileService->make<TH2F>("XYpos_mep4", "Positions: ME+4", 140, -700., 700., 140, -700., 700.);
     m_XYpos_mem1 = tFileService->make<TH2F>("XYpos_mem1", "Positions: ME-1", 140, -700., 700., 140, -700., 700.);
     m_XYpos_mem2 = tFileService->make<TH2F>("XYpos_mem2", "Positions: ME-2", 140, -700., 700., 140, -700., 700.);
     m_XYpos_mem3 = tFileService->make<TH2F>("XYpos_mem3", "Positions: ME-3", 140, -700., 700., 140, -700., 700.);
     m_XYpos_mem4 = tFileService->make<TH2F>("XYpos_mem4", "Positions: ME-4", 140, -700., 700., 140, -700., 700.);
     m_RPhipos_mep1 = tFileService->make<TH2F>("RPhipos_mep1", "Positions: ME+1", 144, -M_PI, M_PI, 21, 0., 700.);
     m_RPhipos_mep2 = tFileService->make<TH2F>("RPhipos_mep2", "Positions: ME+2", 144, -M_PI, M_PI, 21, 0., 700.);
     m_RPhipos_mep3 = tFileService->make<TH2F>("RPhipos_mep3", "Positions: ME+3", 144, -M_PI, M_PI, 21, 0., 700.);
     m_RPhipos_mep4 = tFileService->make<TH2F>("RPhipos_mep4", "Positions: ME+4", 144, -M_PI, M_PI, 21, 0., 700.);
     m_RPhipos_mem1 = tFileService->make<TH2F>("RPhipos_mem1", "Positions: ME-1", 144, -M_PI, M_PI, 21, 0., 700.);
     m_RPhipos_mem2 = tFileService->make<TH2F>("RPhipos_mem2", "Positions: ME-2", 144, -M_PI, M_PI, 21, 0., 700.);
     m_RPhipos_mem3 = tFileService->make<TH2F>("RPhipos_mem3", "Positions: ME-3", 144, -M_PI, M_PI, 21, 0., 700.);
     m_RPhipos_mem4 = tFileService->make<TH2F>("RPhipos_mem4", "Positions: ME-4", 144, -M_PI, M_PI, 21, 0., 700.);
   } else {
     m_histP10 = nullptr;
     m_histP100 = nullptr;
     m_histP1000 = nullptr;
     m_hitsPerChamber = nullptr;
     m_fiducial_ME11 = nullptr;
     m_fiducial_ME12 = nullptr;
     m_fiducial_MEx1 = nullptr;
     m_fiducial_MEx2 = nullptr;
     m_slope = nullptr;
     m_slope_MEp4 = nullptr;
     m_slope_MEp3 = nullptr;
     m_slope_MEp2 = nullptr;
     m_slope_MEp1 = nullptr;
     m_slope_MEm1 = nullptr;
     m_slope_MEm2 = nullptr;
     m_slope_MEm3 = nullptr;
     m_slope_MEm4 = nullptr;
     m_slopeResiduals = nullptr;
     m_slopeResiduals_weighted = nullptr;
     m_slopeResiduals_normalized = nullptr;
     m_offsetResiduals = nullptr;
     m_offsetResiduals_weighted = nullptr;
     m_offsetResiduals_normalized = nullptr;
     m_drdz = nullptr;
     m_occupancy = nullptr;
     m_XYpos_mep1 = nullptr;
     m_XYpos_mep2 = nullptr;
     m_XYpos_mep3 = nullptr;
     m_XYpos_mep4 = nullptr;
     m_XYpos_mem1 = nullptr;
     m_XYpos_mem2 = nullptr;
     m_XYpos_mem3 = nullptr;
     m_XYpos_mem4 = nullptr;
     m_RPhipos_mep1 = nullptr;
     m_RPhipos_mep2 = nullptr;
     m_RPhipos_mep3 = nullptr;
     m_RPhipos_mep4 = nullptr;
     m_RPhipos_mem1 = nullptr;
     m_RPhipos_mem2 = nullptr;
     m_RPhipos_mem3 = nullptr;
     m_RPhipos_mem4 = nullptr;
   }
 }

◆ ~CSCOverlapsAlignmentAlgorithm()

CSCOverlapsAlignmentAlgorithm::~CSCOverlapsAlignmentAlgorithm ( )

override

Definition at line 196 of file CSCOverlapsAlignmentAlgorithm.cc.

196 {}

Member Function Documentation

◆ initialize()

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

overridevirtual

Call at beginning of job (must be implemented in derived class)

Implements AlignmentAlgorithmBase.

Definition at line 198 of file CSCOverlapsAlignmentAlgorithm.cc.

References AlignmentParameterStore::alignables(), MuonSubdetId::CSC, Exception, geometryDiff::file, MillePedeFileConverter_cfg::fileName, edm::EventSetup::getData(), mps_fire::i, input, phase1PixelTopology::layer, m_alignableNavigator, m_alignables, m_alignmentParameterStore, m_cscGeometryToken, m_readTemporaryFiles, m_residualsConstraints, and DetId::Muon.

                                                                                                  {
   m_alignmentParameterStore = alignmentParameterStore;
   m_alignables = m_alignmentParameterStore->alignables();
 
   if (alignableTracker == nullptr)
     m_alignableNavigator = new AlignableNavigator(alignableMuon);
   else
     m_alignableNavigator = new AlignableNavigator(alignableTracker, alignableMuon);
 
   for (const auto& alignable : m_alignables) {
     DetId id = alignable->geomDetId();
     if (id.det() != DetId::Muon || id.subdetId() != MuonSubdetId::CSC || CSCDetId(id.rawId()).layer() != 0) {
       throw cms::Exception("BadConfig") << "Only CSC chambers may be alignable" << std::endl;
     }
 
     std::vector<bool> selector = alignable->alignmentParameters()->selector();
     for (std::vector<bool>::const_iterator i = selector.begin(); i != selector.end(); ++i) {
       if (!(*i))
         throw cms::Exception("BadConfig") << "All selector strings should be \"111111\"" << std::endl;
     }
   }
 
   const CSCGeometry* cscGeometry = &iSetup.getData(m_cscGeometryToken);
 
   for (std::vector<CSCPairResidualsConstraint*>::const_iterator residualsConstraint = m_residualsConstraints.begin();
        residualsConstraint != m_residualsConstraints.end();
        ++residualsConstraint) {
     (*residualsConstraint)->setZplane(cscGeometry);
   }
 
   if (!m_readTemporaryFiles.empty()) {
     std::vector<std::ifstream*> input;
     for (std::vector<std::string>::const_iterator fileName = m_readTemporaryFiles.begin();
          fileName != m_readTemporaryFiles.end();
          ++fileName) {
       input.push_back(new std::ifstream(fileName->c_str()));
     }
 
     for (std::vector<CSCPairResidualsConstraint*>::const_iterator residualsConstraint = m_residualsConstraints.begin();
          residualsConstraint != m_residualsConstraints.end();
          ++residualsConstraint) {
       (*residualsConstraint)->read(input, m_readTemporaryFiles);
     }
 
     for (std::vector<std::ifstream*>::const_iterator file = input.begin(); file != input.end(); ++file) {
       delete (*file);
     }
   }
 }

◆ run()

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

overridevirtual

Run the algorithm (must be implemented in derived class)

Implements AlignmentAlgorithmBase.

Definition at line 252 of file CSCOverlapsAlignmentAlgorithm.cc.

References TransientTrackBuilder::build(), CSCDetId::chamber(), MuonSubdetId::CSC, CSCDetId::endcap(), dumpTauVariables_cfi::eventInfo, edm::EventSetup::getData(), edm::EventSetup::getHandle(), m_combineME11, m_histP10, m_histP100, m_histP1000, m_makeHistograms, m_minP, m_propagatorPointer, m_propToken, m_quickChamberLookup, m_residualsConstraints, m_RPhipos_mem1, m_RPhipos_mem2, m_RPhipos_mem3, m_RPhipos_mem4, m_RPhipos_mep1, m_RPhipos_mep2, m_RPhipos_mep3, m_RPhipos_mep4, m_slopeFromTrackRefit, m_trackTransformer, m_tthbToken, m_XYpos_mem1, m_XYpos_mem2, m_XYpos_mem3, m_XYpos_mem4, m_XYpos_mep1, m_XYpos_mep2, m_XYpos_mep3, m_XYpos_mep4, genParticles_cff::map, Trajectory::measurements(), DetId::Muon, SiPixelPI::one, TrackCandidateProducer_cfi::propagator, CSCDetId::ring(), TrackTransformer::setServices(), relativeConstraints::station, CSCDetId::station(), HLT_2022v12_cff::track, and SiPixelPI::two.

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

                                                                                                {
   edm::ESHandle<Propagator> propagator;
   if (m_slopeFromTrackRefit) {
     iSetup.getHandle(m_propToken);
     if (m_propagatorPointer != &*propagator) {
       m_propagatorPointer = &*propagator;
 
       for (std::vector<CSCPairResidualsConstraint*>::const_iterator residualsConstraint =
                m_residualsConstraints.begin();
            residualsConstraint != m_residualsConstraints.end();
            ++residualsConstraint) {
         (*residualsConstraint)->setPropagator(m_propagatorPointer);
       }
     }
   }
 
   const TransientTrackBuilder* transientTrackBuilder = &iSetup.getData(m_tthbToken);
 
   if (m_trackTransformer != nullptr)
     m_trackTransformer->setServices(iSetup);
 
   const ConstTrajTrackPairCollection& trajtracks = eventInfo.trajTrackPairs();
   for (ConstTrajTrackPairCollection::const_iterator trajtrack = trajtracks.begin(); trajtrack != trajtracks.end();
        ++trajtrack) {
     const Trajectory* traj = (*trajtrack).first;
     const reco::Track* track = (*trajtrack).second;
 
     if (m_makeHistograms) {
       m_histP10->Fill(track->p());
       m_histP100->Fill(track->p());
       m_histP1000->Fill(track->p());
     }
     if (track->p() >= m_minP) {
       std::vector<TrajectoryMeasurement> measurements = traj->measurements();
       reco::TransientTrack transientTrack = transientTrackBuilder->build(track);
 
       std::map<int, std::map<CSCDetId, bool> > stationsToChambers;
       for (std::vector<TrajectoryMeasurement>::const_iterator measurement = measurements.begin();
            measurement != measurements.end();
            ++measurement) {
         DetId id = measurement->recHit()->geographicalId();
         if (id.det() == DetId::Muon && id.subdetId() == MuonSubdetId::CSC) {
           CSCDetId cscid(id.rawId());
           CSCDetId chamberId(cscid.endcap(), cscid.station(), cscid.ring(), cscid.chamber(), 0);
           if (m_combineME11 && cscid.station() == 1 && cscid.ring() == 4)
             chamberId = CSCDetId(cscid.endcap(), 1, 1, cscid.chamber(), 0);
           int station = (cscid.endcap() == 1 ? 1 : -1) * cscid.station();
 
           if (stationsToChambers.find(station) == stationsToChambers.end())
             stationsToChambers[station] = std::map<CSCDetId, bool>();
           stationsToChambers[station][chamberId] = true;
 
           if (m_makeHistograms) {
             GlobalPoint pos = measurement->recHit()->globalPosition();
             if (cscid.endcap() == 1 && cscid.station() == 1) {
               m_XYpos_mep1->Fill(pos.x(), pos.y());
               m_RPhipos_mep1->Fill(pos.phi(), pos.perp());
             }
             if (cscid.endcap() == 1 && cscid.station() == 2) {
               m_XYpos_mep2->Fill(pos.x(), pos.y());
               m_RPhipos_mep2->Fill(pos.phi(), pos.perp());
             }
             if (cscid.endcap() == 1 && cscid.station() == 3) {
               m_XYpos_mep3->Fill(pos.x(), pos.y());
               m_RPhipos_mep3->Fill(pos.phi(), pos.perp());
             }
             if (cscid.endcap() == 1 && cscid.station() == 4) {
               m_XYpos_mep4->Fill(pos.x(), pos.y());
               m_RPhipos_mep4->Fill(pos.phi(), pos.perp());
             }
             if (cscid.endcap() == 2 && cscid.station() == 1) {
               m_XYpos_mem1->Fill(pos.x(), pos.y());
               m_RPhipos_mem1->Fill(pos.phi(), pos.perp());
             }
             if (cscid.endcap() == 2 && cscid.station() == 2) {
               m_XYpos_mem2->Fill(pos.x(), pos.y());
               m_RPhipos_mem2->Fill(pos.phi(), pos.perp());
             }
             if (cscid.endcap() == 2 && cscid.station() == 3) {
               m_XYpos_mem3->Fill(pos.x(), pos.y());
               m_RPhipos_mem3->Fill(pos.phi(), pos.perp());
             }
             if (cscid.endcap() == 2 && cscid.station() == 4) {
               m_XYpos_mem4->Fill(pos.x(), pos.y());
               m_RPhipos_mem4->Fill(pos.phi(), pos.perp());
             }
           }
         }
       }
 
       std::map<CSCPairResidualsConstraint*, bool> residualsConstraints;
       for (std::map<int, std::map<CSCDetId, bool> >::const_iterator iter = stationsToChambers.begin();
            iter != stationsToChambers.end();
            ++iter) {
         for (std::map<CSCDetId, bool>::const_iterator one = iter->second.begin(); one != iter->second.end(); ++one) {
           for (std::map<CSCDetId, bool>::const_iterator two = one; two != iter->second.end(); ++two) {
             if (one != two) {
               std::map<std::pair<CSCDetId, CSCDetId>, CSCPairResidualsConstraint*>::const_iterator quick;
 
               quick = m_quickChamberLookup.find(std::pair<CSCDetId, CSCDetId>(one->first, two->first));
               if (quick != m_quickChamberLookup.end())
                 residualsConstraints[quick->second] = true;
 
               quick = m_quickChamberLookup.find(std::pair<CSCDetId, CSCDetId>(two->first, one->first));
               if (quick != m_quickChamberLookup.end())
                 residualsConstraints[quick->second] = true;
             }
           }
         }
       }
 
       for (std::map<CSCPairResidualsConstraint*, bool>::const_iterator residualsConstraint =
                residualsConstraints.begin();
            residualsConstraint != residualsConstraints.end();
            ++residualsConstraint) {
         residualsConstraint->first->addTrack(measurements, transientTrack, m_trackTransformer);
       }
     }
   }
 }

◆ terminate()

void CSCOverlapsAlignmentAlgorithm::terminate ( const edm::EventSetup & iSetup )

overridevirtual

Call at end of each loop (must be implemented in derived class)

Implements AlignmentAlgorithmBase.

Definition at line 373 of file CSCOverlapsAlignmentAlgorithm.cc.

References pfMETCorrectionType0_cfi::correction, CSCPairResidualsConstraint::kModeRadius, m_alignableNavigator, m_alignmentParameterStore, m_combineME11, m_doAlignment, m_fitters, m_makeHistograms, m_mode, m_reportFileName, m_residualsConstraints, m_writeTemporaryFile, convertSQLitetoXML_cfg::output, edmIntegrityCheck::report, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                          {
   // write residuals partial fits to temporary files for collection
   if (m_writeTemporaryFile != std::string("")) {
     std::ofstream output(m_writeTemporaryFile.c_str());
     for (std::vector<CSCPairResidualsConstraint*>::const_iterator residualsConstraint = m_residualsConstraints.begin();
          residualsConstraint != m_residualsConstraints.end();
          ++residualsConstraint) {
       (*residualsConstraint)->write(output);
     }
   }
 
   // write report for alignment results
   if (m_doAlignment) {
     std::ofstream report;
     bool writeReport = (m_reportFileName != std::string(""));
     if (writeReport) {
       report.open(m_reportFileName.c_str());
       report << "cscReports = []" << std::endl
              << std::endl
              << "class CSCChamberCorrection:" << std::endl
              << "    def __init__(self, name, detid, value):" << std::endl
              << "        self.name, self.detid, self.value = name, detid, value" << std::endl
              << std::endl
              << "class CSCErrorMode:" << std::endl
              << "    def __init__(self, error):" << std::endl
              << "        self.error = error" << std::endl
              << "        self.terms = {}" << std::endl
              << "        self.detids = {}" << std::endl
              << "    def addTerm(self, name, detid, coefficient):" << std::endl
              << "        self.terms[name] = coefficient" << std::endl
              << "        self.detids[name] = detid" << std::endl
              << std::endl
              << "class CSCConstraintResidual:" << std::endl
              << "    def __init__(self, i, j, before, uncert, residual, pull):" << std::endl
              << "        self.i, self.j, self.before, self.error, self.residual, self.pull = i, j, before, uncert, "
                 "residual, pull"
              << std::endl
              << std::endl
              << "class CSCFitterReport:" << std::endl
              << "    def __init__(self, name, oldchi2, newchi2):" << std::endl
              << "        self.name, self.oldchi2, self.newchi2 = name, oldchi2, newchi2" << std::endl
              << "        self.chamberCorrections = []" << std::endl
              << "        self.errorModes = []" << std::endl
              << "        self.constraintResiduals = []" << std::endl
              << std::endl
              << "    def addChamberCorrection(self, name, detid, value):" << std::endl
              << "        self.chamberCorrections.append(CSCChamberCorrection(name, detid, value))" << std::endl
              << std::endl
              << "    def addErrorMode(self, error):" << std::endl
              << "        self.errorModes.append(CSCErrorMode(error))" << std::endl
              << std::endl
              << "    def addErrorModeTerm(self, name, detid, coefficient):" << std::endl
              << "        self.errorModes[-1].addTerm(name, detid, coefficient)" << std::endl
              << std::endl
              << "    def addCSCConstraintResidual(self, i, j, before, uncert, residual, pull):" << std::endl
              << "        self.constraintResiduals.append(CSCConstraintResidual(i, j, before, uncert, residual, pull))"
              << std::endl
              << std::endl
              << "import re" << std::endl
              << "def nameToKey(name):" << std::endl
              << "    match = re.match(\"ME([\\+\\-])([1-4])/([1-4])/([0-9]{2})\", name)" << std::endl
              << "    if match is None: return None" << std::endl
              << "    endcap, station, ring, chamber = match.groups()" << std::endl
              << "    if endcap == \"+\": endcap = 1" << std::endl
              << "    else: endcap = 2" << std::endl
              << "    station = int(station)" << std::endl
              << "    ring = int(ring)" << std::endl
              << "    chamber = int(chamber)" << std::endl
              << "    return endcap, station, ring, chamber" << std::endl
              << std::endl;
     }
 
     for (std::vector<CSCChamberFitter>::const_iterator fitter = m_fitters.begin(); fitter != m_fitters.end();
          ++fitter) {
       if (m_mode == CSCPairResidualsConstraint::kModeRadius) {
         fitter->radiusCorrection(m_alignableNavigator, m_alignmentParameterStore, m_combineME11);
 
       } else {
         std::vector<CSCAlignmentCorrections*> corrections;
         fitter->fit(corrections);
 
         // corrections only exist if the fit was successful
         for (std::vector<CSCAlignmentCorrections*>::iterator correction = corrections.begin();
              correction != corrections.end();
              ++correction) {
           (*correction)->applyAlignment(m_alignableNavigator, m_alignmentParameterStore, m_mode, m_combineME11);
           if (m_makeHistograms)
             (*correction)->plot();
           if (writeReport)
             (*correction)->report(report);
         }
       }
     }
   }
 }

Member Data Documentation

◆ m_alignableNavigator

AlignableNavigator* CSCOverlapsAlignmentAlgorithm::m_alignableNavigator

private

Definition at line 150 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by initialize(), and terminate().

◆ m_alignables

align::Alignables CSCOverlapsAlignmentAlgorithm::m_alignables

private

Definition at line 149 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by initialize().

◆ m_alignmentParameterStore

AlignmentParameterStore* CSCOverlapsAlignmentAlgorithm::m_alignmentParameterStore

private

Definition at line 148 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by initialize(), and terminate().

◆ m_combineME11

bool CSCOverlapsAlignmentAlgorithm::m_combineME11

Definition at line 129 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack(), CSCOverlapsAlignmentAlgorithm(), CSCPairResidualsConstraint::dphidzFromTrack(), run(), and terminate().

◆ m_cscGeometryToken

const edm::ESGetToken<CSCGeometry, MuonGeometryRecord> CSCOverlapsAlignmentAlgorithm::m_cscGeometryToken

private

Definition at line 136 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by initialize().

◆ m_doAlignment

bool CSCOverlapsAlignmentAlgorithm::m_doAlignment

private

Definition at line 146 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by terminate().

◆ m_drdz

TH1F* CSCOverlapsAlignmentAlgorithm::m_drdz

Definition at line 100 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack(), and CSCOverlapsAlignmentAlgorithm().

◆ m_errorFromRMS

bool CSCOverlapsAlignmentAlgorithm::m_errorFromRMS

Definition at line 131 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::error().

◆ m_fiducial

bool CSCOverlapsAlignmentAlgorithm::m_fiducial

Definition at line 123 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack().

◆ m_fiducial_ME11

TProfile* CSCOverlapsAlignmentAlgorithm::m_fiducial_ME11

Definition at line 78 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and CSCPairResidualsConstraint::isFiducial().

◆ m_fiducial_ME12

TProfile* CSCOverlapsAlignmentAlgorithm::m_fiducial_ME12

Definition at line 79 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and CSCPairResidualsConstraint::isFiducial().

◆ m_fiducial_MEx1

TProfile* CSCOverlapsAlignmentAlgorithm::m_fiducial_MEx1

Definition at line 80 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and CSCPairResidualsConstraint::isFiducial().

◆ m_fiducial_MEx2

TProfile* CSCOverlapsAlignmentAlgorithm::m_fiducial_MEx2

Definition at line 81 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and CSCPairResidualsConstraint::isFiducial().

◆ m_fitters

std::vector<CSCChamberFitter> CSCOverlapsAlignmentAlgorithm::m_fitters

private

Definition at line 151 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and terminate().

◆ m_histP10

TH1F* CSCOverlapsAlignmentAlgorithm::m_histP10

private

Definition at line 158 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and run().

◆ m_histP100

TH1F* CSCOverlapsAlignmentAlgorithm::m_histP100

private

Definition at line 159 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and run().

◆ m_histP1000

TH1F* CSCOverlapsAlignmentAlgorithm::m_histP1000

private

Definition at line 160 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and run().

◆ m_hitsPerChamber

TH1F* CSCOverlapsAlignmentAlgorithm::m_hitsPerChamber

Definition at line 76 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack(), and CSCOverlapsAlignmentAlgorithm().

◆ m_makeHistograms

bool CSCOverlapsAlignmentAlgorithm::m_makeHistograms

Definition at line 133 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack(), CSCPairResidualsConstraint::configure(), CSCOverlapsAlignmentAlgorithm(), CSCPairResidualsConstraint::isFiducial(), run(), and terminate().

◆ m_maxdrdz

double CSCOverlapsAlignmentAlgorithm::m_maxdrdz

Definition at line 122 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack().

◆ m_maxRedChi2

double CSCOverlapsAlignmentAlgorithm::m_maxRedChi2

private

Definition at line 143 of file CSCOverlapsAlignmentAlgorithm.h.

◆ m_minHitsPerChamber

int CSCOverlapsAlignmentAlgorithm::m_minHitsPerChamber

Definition at line 121 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack(), and CSCPairResidualsConstraint::dphidzFromTrack().

◆ m_minP

double CSCOverlapsAlignmentAlgorithm::m_minP

private

Definition at line 142 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by run().

◆ m_minStationsInTrackRefits

int CSCOverlapsAlignmentAlgorithm::m_minStationsInTrackRefits

Definition at line 126 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::dphidzFromTrack().

◆ m_minTracksPerOverlap

int CSCOverlapsAlignmentAlgorithm::m_minTracksPerOverlap

Definition at line 132 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::valid().

◆ m_mode

int CSCOverlapsAlignmentAlgorithm::m_mode

Definition at line 120 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack(), CSCOverlapsAlignmentAlgorithm(), CSCPairResidualsConstraint::error(), terminate(), and CSCPairResidualsConstraint::value().

◆ m_mode_string

std::string CSCOverlapsAlignmentAlgorithm::m_mode_string

private

Definition at line 140 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm().

◆ m_occupancy

TH2F* CSCOverlapsAlignmentAlgorithm::m_occupancy

Definition at line 102 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack(), and CSCOverlapsAlignmentAlgorithm().

◆ m_offsetResiduals

TH1F* CSCOverlapsAlignmentAlgorithm::m_offsetResiduals

Definition at line 96 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack(), and CSCOverlapsAlignmentAlgorithm().

◆ m_offsetResiduals_normalized

TH1F* CSCOverlapsAlignmentAlgorithm::m_offsetResiduals_normalized

Definition at line 98 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack(), and CSCOverlapsAlignmentAlgorithm().

◆ m_offsetResiduals_weighted

TH1F* CSCOverlapsAlignmentAlgorithm::m_offsetResiduals_weighted

Definition at line 97 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack(), and CSCOverlapsAlignmentAlgorithm().

◆ m_propagatorPointer

const Propagator* CSCOverlapsAlignmentAlgorithm::m_propagatorPointer

private

Definition at line 156 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and run().

◆ m_propToken

const edm::ESGetToken<Propagator, TrackingComponentsRecord> CSCOverlapsAlignmentAlgorithm::m_propToken

private

Definition at line 137 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by run().

◆ m_quickChamberLookup

std::map<std::pair<CSCDetId, CSCDetId>, CSCPairResidualsConstraint *> CSCOverlapsAlignmentAlgorithm::m_quickChamberLookup

private

Definition at line 153 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and run().

◆ m_readTemporaryFiles

std::vector<std::string> CSCOverlapsAlignmentAlgorithm::m_readTemporaryFiles

private

Definition at line 145 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by initialize().

◆ m_reportFileName

std::string CSCOverlapsAlignmentAlgorithm::m_reportFileName

private

Definition at line 141 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by terminate().

◆ m_residualsConstraints

std::vector<CSCPairResidualsConstraint *> CSCOverlapsAlignmentAlgorithm::m_residualsConstraints

private

Definition at line 152 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), initialize(), run(), and terminate().

◆ m_RPhipos_mem1

TH2F* CSCOverlapsAlignmentAlgorithm::m_RPhipos_mem1

Definition at line 115 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and run().

◆ m_RPhipos_mem2

TH2F* CSCOverlapsAlignmentAlgorithm::m_RPhipos_mem2

Definition at line 116 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and run().

◆ m_RPhipos_mem3

TH2F* CSCOverlapsAlignmentAlgorithm::m_RPhipos_mem3

Definition at line 117 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and run().

◆ m_RPhipos_mem4

TH2F* CSCOverlapsAlignmentAlgorithm::m_RPhipos_mem4

Definition at line 118 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and run().

◆ m_RPhipos_mep1

TH2F* CSCOverlapsAlignmentAlgorithm::m_RPhipos_mep1

Definition at line 111 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and run().

◆ m_RPhipos_mep2

TH2F* CSCOverlapsAlignmentAlgorithm::m_RPhipos_mep2

Definition at line 112 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and run().

◆ m_RPhipos_mep3

TH2F* CSCOverlapsAlignmentAlgorithm::m_RPhipos_mep3

Definition at line 113 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and run().

◆ m_RPhipos_mep4

TH2F* CSCOverlapsAlignmentAlgorithm::m_RPhipos_mep4

Definition at line 114 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and run().

◆ m_slope

TH1F* CSCOverlapsAlignmentAlgorithm::m_slope

Definition at line 83 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack(), and CSCOverlapsAlignmentAlgorithm().

◆ m_slope_MEm1

TH1F* CSCOverlapsAlignmentAlgorithm::m_slope_MEm1

Definition at line 88 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack(), and CSCOverlapsAlignmentAlgorithm().

◆ m_slope_MEm2

TH1F* CSCOverlapsAlignmentAlgorithm::m_slope_MEm2

Definition at line 89 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack(), and CSCOverlapsAlignmentAlgorithm().

◆ m_slope_MEm3

TH1F* CSCOverlapsAlignmentAlgorithm::m_slope_MEm3

Definition at line 90 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack(), and CSCOverlapsAlignmentAlgorithm().

◆ m_slope_MEm4

TH1F* CSCOverlapsAlignmentAlgorithm::m_slope_MEm4

Definition at line 91 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack(), and CSCOverlapsAlignmentAlgorithm().

◆ m_slope_MEp1

TH1F* CSCOverlapsAlignmentAlgorithm::m_slope_MEp1

Definition at line 87 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack(), and CSCOverlapsAlignmentAlgorithm().

◆ m_slope_MEp2

TH1F* CSCOverlapsAlignmentAlgorithm::m_slope_MEp2

Definition at line 86 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack(), and CSCOverlapsAlignmentAlgorithm().

◆ m_slope_MEp3

TH1F* CSCOverlapsAlignmentAlgorithm::m_slope_MEp3

Definition at line 85 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack(), and CSCOverlapsAlignmentAlgorithm().

◆ m_slope_MEp4

TH1F* CSCOverlapsAlignmentAlgorithm::m_slope_MEp4

Definition at line 84 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack(), and CSCOverlapsAlignmentAlgorithm().

◆ m_slopeFromTrackRefit

bool CSCOverlapsAlignmentAlgorithm::m_slopeFromTrackRefit

Definition at line 125 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack(), CSCOverlapsAlignmentAlgorithm(), and run().

◆ m_slopeResiduals

TH1F* CSCOverlapsAlignmentAlgorithm::m_slopeResiduals

Definition at line 93 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack(), and CSCOverlapsAlignmentAlgorithm().

◆ m_slopeResiduals_normalized

TH1F* CSCOverlapsAlignmentAlgorithm::m_slopeResiduals_normalized

Definition at line 95 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack(), and CSCOverlapsAlignmentAlgorithm().

◆ m_slopeResiduals_weighted

TH1F* CSCOverlapsAlignmentAlgorithm::m_slopeResiduals_weighted

Definition at line 94 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack(), and CSCOverlapsAlignmentAlgorithm().

◆ m_trackTransformer

TrackTransformer* CSCOverlapsAlignmentAlgorithm::m_trackTransformer

private

Definition at line 155 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and run().

◆ m_truncateOffsetResid

double CSCOverlapsAlignmentAlgorithm::m_truncateOffsetResid

Definition at line 128 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack().

◆ m_truncateSlopeResid

double CSCOverlapsAlignmentAlgorithm::m_truncateSlopeResid

Definition at line 127 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack().

◆ m_tthbToken

const edm::ESGetToken<TransientTrackBuilder, TransientTrackRecord> CSCOverlapsAlignmentAlgorithm::m_tthbToken

private

Definition at line 138 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by run().

◆ m_useHitWeights

bool CSCOverlapsAlignmentAlgorithm::m_useHitWeights

Definition at line 124 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack(), and CSCPairResidualsConstraint::isFiducial().

◆ m_useTrackWeights

bool CSCOverlapsAlignmentAlgorithm::m_useTrackWeights

Definition at line 130 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCPairResidualsConstraint::addTrack().

◆ m_writeTemporaryFile

std::string CSCOverlapsAlignmentAlgorithm::m_writeTemporaryFile

private

Definition at line 144 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by terminate().

◆ m_XYpos_mem1

TH2F* CSCOverlapsAlignmentAlgorithm::m_XYpos_mem1

Definition at line 107 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and run().

◆ m_XYpos_mem2

TH2F* CSCOverlapsAlignmentAlgorithm::m_XYpos_mem2

Definition at line 108 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and run().

◆ m_XYpos_mem3

TH2F* CSCOverlapsAlignmentAlgorithm::m_XYpos_mem3

Definition at line 109 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and run().

◆ m_XYpos_mem4

TH2F* CSCOverlapsAlignmentAlgorithm::m_XYpos_mem4

Definition at line 110 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and run().

◆ m_XYpos_mep1

TH2F* CSCOverlapsAlignmentAlgorithm::m_XYpos_mep1

Definition at line 103 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and run().

◆ m_XYpos_mep2

TH2F* CSCOverlapsAlignmentAlgorithm::m_XYpos_mep2

Definition at line 104 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and run().

◆ m_XYpos_mep3

TH2F* CSCOverlapsAlignmentAlgorithm::m_XYpos_mep3

Definition at line 105 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and run().

◆ m_XYpos_mep4

TH2F* CSCOverlapsAlignmentAlgorithm::m_XYpos_mep4

Definition at line 106 of file CSCOverlapsAlignmentAlgorithm.h.

Referenced by CSCOverlapsAlignmentAlgorithm(), and run().

Public Member Functions

Public Attributes

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ CSCOverlapsAlignmentAlgorithm()

◆ ~CSCOverlapsAlignmentAlgorithm()

Member Function Documentation

◆ initialize()

◆ run()

◆ terminate()

Member Data Documentation

◆ m_alignableNavigator

◆ m_alignables

◆ m_alignmentParameterStore

◆ m_combineME11

◆ m_cscGeometryToken

◆ m_doAlignment

◆ m_drdz

◆ m_errorFromRMS

◆ m_fiducial

◆ m_fiducial_ME11

◆ m_fiducial_ME12

◆ m_fiducial_MEx1

◆ m_fiducial_MEx2

◆ m_fitters

◆ m_histP10

◆ m_histP100

◆ m_histP1000

◆ m_hitsPerChamber

◆ m_makeHistograms

◆ m_maxdrdz

◆ m_maxRedChi2

◆ m_minHitsPerChamber

◆ m_minP

◆ m_minStationsInTrackRefits

◆ m_minTracksPerOverlap

◆ m_mode

◆ m_mode_string

◆ m_occupancy

◆ m_offsetResiduals

◆ m_offsetResiduals_normalized

◆ m_offsetResiduals_weighted

◆ m_propagatorPointer

◆ m_propToken

◆ m_quickChamberLookup

◆ m_readTemporaryFiles

◆ m_reportFileName

◆ m_residualsConstraints

◆ m_RPhipos_mem1

◆ m_RPhipos_mem2

◆ m_RPhipos_mem3

◆ m_RPhipos_mem4

◆ m_RPhipos_mep1

◆ m_RPhipos_mep2

◆ m_RPhipos_mep3

◆ m_RPhipos_mep4

◆ m_slope

◆ m_slope_MEm1

◆ m_slope_MEm2

◆ m_slope_MEm3

◆ m_slope_MEm4

◆ m_slope_MEp1

◆ m_slope_MEp2

◆ m_slope_MEp3

◆ m_slope_MEp4

◆ m_slopeFromTrackRefit

◆ m_slopeResiduals

◆ m_slopeResiduals_normalized

◆ m_slopeResiduals_weighted

◆ m_trackTransformer

◆ m_truncateOffsetResid

◆ m_truncateSlopeResid

◆ m_tthbToken

◆ m_useHitWeights

◆ m_useTrackWeights

◆ m_writeTemporaryFile

◆ m_XYpos_mem1

◆ m_XYpos_mem2