#include <TrackerGeometryIntoNtuples.cc>

Inheritance diagram for TrackerGeometryIntoNtuples:

Public Member Functions
	TrackerGeometryIntoNtuples (const edm::ParameterSet &)

	~TrackerGeometryIntoNtuples () override

Public Member Functions inherited from edm::one::EDAnalyzer<>
	EDAnalyzer ()=default

	EDAnalyzer (const EDAnalyzer &)=delete

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

const EDAnalyzer &	operator= (const EDAnalyzer &)=delete

bool	wantsGlobalLuminosityBlocks () const noexcept final

bool	wantsGlobalRuns () const noexcept final

bool	wantsInputProcessBlocks () const noexcept final

bool	wantsProcessBlocks () const noexcept final

Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const noexcept

bool	wantsStreamRuns () const noexcept

	~EDAnalyzerBase () override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESResolverIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESResolverIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const *> const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Types
enum	{ kMaxNumPar = 20 }

Private Member Functions
void	addBranches ()

void	analyze (const edm::Event &iEvent, const edm::EventSetup &iSetup) override

Private Attributes
const edm::ESGetToken< AlignmentErrorsExtended, TrackerAlignmentErrorExtendedRcd >	aliErrorToken_

const edm::ESGetToken< Alignments, TrackerAlignmentRcd >	aliToken_

Float_t	deformationValues_ [kMaxNumPar]

const edm::ESGetToken< GeometricDet, IdealGeometryRecord >	geomDetToken_

const edm::ESGetToken< Alignments, GlobalPositionRcd >	gprToken_

double	m_alpha

double	m_beta

double	m_d1

double	m_d2

double	m_d3

int	m_dNpar

int	m_dtype

TFile *	m_file

double	m_gamma

std::string	m_outputFile

std::string	m_outputTreename

uint32_t	m_rawid

int	m_subdetid

TTree *	m_tree

TTree *	m_treeDeformations

TTree *	m_treeErrors

double	m_x

double	m_xx

double	m_xy

double	m_xz

double	m_y

double	m_yy

double	m_yz

double	m_z

double	m_zz

std::vector< double > *	mp_dpar

UInt_t	numDeformationValues_

const edm::ESGetToken< PTrackerAdditionalParametersPerDet, PTrackerAdditionalParametersPerDetRcd >	ptitpToken_

const edm::ESGetToken< PTrackerParameters, PTrackerParametersRcd >	ptpToken_

const edm::ESGetToken< AlignmentSurfaceDeformations, TrackerSurfaceDeformationRcd >	surfDefToken_

AlignableTracker *	theCurrentTracker

const edm::ESGetToken< TrackerTopology, TrackerTopologyRcd >	topoToken_

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Description: Takes a set of alignment constants and turns them into a ROOT file

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

Definition at line 76 of file TrackerGeometryIntoNtuples.cc.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

private

Enumerator
kMaxNumPar

Definition at line 114 of file TrackerGeometryIntoNtuples.cc.

114 { kMaxNumPar = 20 }; // slighly above 'two bowed surfaces' limit

TrackerGeometryIntoNtuples::kMaxNumPar

Definition: TrackerGeometryIntoNtuples.cc:114

Constructor & Destructor Documentation

◆ TrackerGeometryIntoNtuples()

TrackerGeometryIntoNtuples::TrackerGeometryIntoNtuples ( const edm::ParameterSet & iConfig )

explicit

Definition at line 136 of file TrackerGeometryIntoNtuples.cc.

References edm::ParameterSet::getUntrackedParameter(), m_file, m_outputFile, m_outputTreename, m_tree, m_treeDeformations, m_treeErrors, and AlCaHLTBitMon_QueryRunRegistry::string.

     : topoToken_(esConsumes()),
       geomDetToken_(esConsumes()),
       ptpToken_(esConsumes()),
       ptitpToken_(esConsumes()),
       aliToken_(esConsumes()),
       aliErrorToken_(esConsumes()),
       surfDefToken_(esConsumes()),
       gprToken_(esConsumes()),
       theCurrentTracker(nullptr),
       m_rawid(0),
       m_x(0.),
       m_y(0.),
       m_z(0.),
       m_alpha(0.),
       m_beta(0.),
       m_gamma(0.),
       m_subdetid(0),
       m_xx(0.),
       m_xy(0.),
       m_yy(0.),
       m_xz(0.),
       m_yz(0.),
       m_zz(0.),
       m_dNpar(0),
       m_d1(0.),
       m_d2(0.),
       m_d3(0.),
       m_dtype(0),
       mp_dpar(nullptr) {
   m_outputFile = iConfig.getUntrackedParameter<std::string>("outputFile");
   m_outputTreename = iConfig.getUntrackedParameter<std::string>("outputTreename");
   m_file = new TFile(m_outputFile.c_str(), "RECREATE");
   m_tree = new TTree(m_outputTreename.c_str(), m_outputTreename.c_str());
   m_treeDeformations = new TTree("alignTreeDeformations", "alignTreeDeformations");
   //char errorTreeName[256];
   //snprintf(errorTreeName, sizeof(errorTreeName), "%sErrors", m_outputTreename);
   //m_treeErrors = new TTree(errorTreeName,errorTreeName);
   m_treeErrors = new TTree("alignTreeErrors", "alignTreeErrors");
 }

◆ ~TrackerGeometryIntoNtuples()

TrackerGeometryIntoNtuples::~TrackerGeometryIntoNtuples ( )

override

Definition at line 177 of file TrackerGeometryIntoNtuples.cc.

References theCurrentTracker.

177 { delete theCurrentTracker; }

TrackerGeometryIntoNtuples::theCurrentTracker

AlignableTracker * theCurrentTracker

Definition: TrackerGeometryIntoNtuples.cc:99

Member Function Documentation

◆ addBranches()

void TrackerGeometryIntoNtuples::addBranches ( )

private

Definition at line 309 of file TrackerGeometryIntoNtuples.cc.

References m_alpha, m_beta, m_dNpar, m_dtype, m_gamma, m_rawid, m_subdetid, m_tree, m_treeDeformations, m_treeErrors, m_x, m_xx, m_xy, m_xz, m_y, m_yy, m_yz, m_z, m_zz, and mp_dpar.

Referenced by analyze().

                                              {
   m_tree->Branch("rawid", &m_rawid, "rawid/I");
   m_tree->Branch("x", &m_x, "x/D");
   m_tree->Branch("y", &m_y, "y/D");
   m_tree->Branch("z", &m_z, "z/D");
   m_tree->Branch("alpha", &m_alpha, "alpha/D");
   m_tree->Branch("beta", &m_beta, "beta/D");
   m_tree->Branch("gamma", &m_gamma, "gamma/D");
 
   m_treeDeformations->Branch("irawid", &m_rawid, "irawid/I");
   m_treeDeformations->Branch("subdetid", &m_subdetid, "subdetid/I");
   m_treeDeformations->Branch("dNpar", &m_dNpar, "dNpar/I");
   //m_treeDeformations->Branch("d1", &m_d1, "d1/D");
   //m_treeDeformations->Branch("d2", &m_d2, "d2/D");
   //m_treeDeformations->Branch("d3", &m_d3, "d3/D");
   m_treeDeformations->Branch("dtype", &m_dtype);
   m_treeDeformations->Branch("dpar", "std::vector<double>", &mp_dpar);
 
   m_treeErrors->Branch("rawid", &m_rawid, "rawid/I");
   m_treeErrors->Branch("subdetid", &m_subdetid, "subdetid/I");
   m_treeErrors->Branch("xx", &m_xx, "xx/D");
   m_treeErrors->Branch("yy", &m_yy, "yy/D");
   m_treeErrors->Branch("zz", &m_zz, "zz/D");
   m_treeErrors->Branch("xy", &m_xy, "xy/D");
   m_treeErrors->Branch("xz", &m_xz, "xz/D");
   m_treeErrors->Branch("yz", &m_yz, "yz/D");
 
   //m_tree->Branch("NumDeform",    &numDeformationValues_, "NumDeform/i");
   //m_tree->Branch("DeformValues", deformationValues_,     "DeformValues[NumDeform]/F");
 }

◆ analyze()

void TrackerGeometryIntoNtuples::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 193 of file TrackerGeometryIntoNtuples.cc.

References addBranches(), aliErrorToken_, AlignableTracker::alignments(), PixelBaryCentreAnalyzer_cfg::alignments, aliToken_, GeometryAligner::applyAlignments(), GeometryAligner::attachSurfaceDeformations(), TrackerGeomBuilderFromGeometricDet::build(), align::DetectorGlobalPosition(), ALCARECOPPSCalTrackBasedSel_cff::detid, TrackerGeometry::detUnits(), geomDetToken_, edm::EventSetup::getData(), gprToken_, mps_fire::i, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, Alignments::m_align, m_alpha, m_beta, m_d1, m_d2, m_d3, m_dNpar, m_dtype, m_file, m_gamma, m_rawid, m_subdetid, m_tree, m_treeDeformations, m_treeErrors, m_x, m_xx, m_xy, m_xz, m_y, m_yy, m_yz, m_z, m_zz, mp_dpar, ptitpToken_, ptpToken_, idealTransformation::rotation, surfDefToken_, theCurrentTracker, topoToken_, and DetId::Tracker.

                                                                                             {
   // retrieve tracker topology from geometry
   const TrackerTopology* const tTopo = &iSetup.getData(topoToken_);
 
   edm::LogInfo("beginJob") << "Begin Job";
 
   //accessing the initial geometry
   const GeometricDet* theGeometricDet = &iSetup.getData(geomDetToken_);
   const PTrackerParameters* ptp = &iSetup.getData(ptpToken_);
   const PTrackerAdditionalParametersPerDet* ptitp = &iSetup.getData(ptitpToken_);
 
   TrackerGeomBuilderFromGeometricDet trackerBuilder;
   //currernt tracker
   TrackerGeometry* theCurTracker = trackerBuilder.build(theGeometricDet, ptitp, *ptp, tTopo);
 
   //build the tracker
   const Alignments* alignments = &iSetup.getData(aliToken_);
   const AlignmentErrorsExtended* alignmentErrors = &iSetup.getData(aliErrorToken_);
   const AlignmentSurfaceDeformations* surfaceDeformations = &iSetup.getData(surfDefToken_);
 
   //apply the latest alignments
   const Alignments* globalPositionRcd = &iSetup.getData(gprToken_);
   GeometryAligner aligner;
   aligner.applyAlignments<TrackerGeometry>(&(*theCurTracker),
                                            alignments,
                                            alignmentErrors,
                                            align::DetectorGlobalPosition(*globalPositionRcd, DetId(DetId::Tracker)));
   aligner.attachSurfaceDeformations<TrackerGeometry>(&(*theCurTracker), &(*surfaceDeformations));
 
   theCurrentTracker = new AlignableTracker(&(*theCurTracker), tTopo);
 
   Alignments* theAlignments = theCurrentTracker->alignments();
   //AlignmentErrorsExtended* theAlignmentErrorsExtended = theCurrentTracker->alignmentErrors();
 
   //alignments
   addBranches();
   for (std::vector<AlignTransform>::const_iterator i = theAlignments->m_align.begin();
        i != theAlignments->m_align.end();
        ++i) {
     m_rawid = i->rawId();
     CLHEP::Hep3Vector translation = i->translation();
     m_x = translation.x();
     m_y = translation.y();
     m_z = translation.z();
 
     CLHEP::HepRotation rotation = i->rotation();
     m_alpha = rotation.getPhi();
     m_beta = rotation.getTheta();
     m_gamma = rotation.getPsi();
     m_tree->Fill();
 
     //DetId detid(m_rawid);
     //if (detid.subdetId() > 2){
     //
     //std::cout << " panel: " << tTopo->pxfPanel( m_rawid ) << ", module: " << tTopo->pxfModule( m_rawid ) << std::endl;
     //if ((tTopo->pxfPanel( m_rawid ) == 1) && (tTopo->pxfModule( m_rawid ) == 4)) std::cout << m_rawid << ", ";
     //std::cout << m_rawid << std::setprecision(9) <<  " " << m_x << " " << m_y << " " << m_z;
     //std::cout << std::setprecision(9) << " " << m_alpha << " " << m_beta << " " << m_gamma << std::endl;
     //}
   }
 
   delete theAlignments;
 
   std::vector<AlignTransformErrorExtended> alignErrors = alignmentErrors->m_alignError;
   for (std::vector<AlignTransformErrorExtended>::const_iterator i = alignErrors.begin(); i != alignErrors.end(); ++i) {
     m_rawid = i->rawId();
     CLHEP::HepSymMatrix errMatrix = i->matrix();
     DetId detid(m_rawid);
     m_subdetid = detid.subdetId();
     m_xx = errMatrix[0][0];
     m_xy = errMatrix[0][1];
     m_xz = errMatrix[0][2];
     m_yy = errMatrix[1][1];
     m_yz = errMatrix[1][2];
     m_zz = errMatrix[2][2];
     m_treeErrors->Fill();
   }
 
   // Get GeomDetUnits for the current tracker
   auto const& detUnits = theCurTracker->detUnits();
   //\\for (unsigned int iDet = 0; iDet < detUnits.size(); ++iDet) {
   for (auto iunit = detUnits.begin(); iunit != detUnits.end(); ++iunit) {
     DetId detid = (*iunit)->geographicalId();
     m_rawid = detid.rawId();
     m_subdetid = detid.subdetId();
 
     //\\GeomDetUnit* geomDetUnit = detUnits.at(iDet) ;
     auto geomDetUnit = *iunit;
 
     // Get SurfaceDeformation for this GeomDetUnit
     if (geomDetUnit->surfaceDeformation()) {
       std::vector<double> surfaceDeformParams = (geomDetUnit->surfaceDeformation())->parameters();
       //edm::LogInfo("surfaceDeformParamsSize") << " surfaceDeformParams size  = " << surfaceDeformParams.size() << std::endl ;
       m_dNpar = surfaceDeformParams.size();
       m_dtype = (geomDetUnit->surfaceDeformation())->type();
       m_d1 = surfaceDeformParams.at(0);
       m_d2 = surfaceDeformParams.at(1);
       m_d3 = surfaceDeformParams.at(2);
       mp_dpar->clear();
       for (std::vector<double>::const_iterator it = surfaceDeformParams.begin(); it != surfaceDeformParams.end();
            ++it) {
         mp_dpar->push_back((*it));
         //edm::LogInfo("surfaceDeformParamsContent") << " surfaceDeformParam = " << (*it) << std::endl ;
       }
       m_treeDeformations->Fill();
     }
   }
 
   //write out
   m_file->cd();
   m_tree->Write();
   m_treeDeformations->Write();
   m_treeErrors->Write();
   m_file->Close();
 }

◆ fillDescriptions()

void TrackerGeometryIntoNtuples::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 179 of file TrackerGeometryIntoNtuples.cc.

References edm::ConfigurationDescriptions::addWithDefaultLabel(), submitPVResolutionJobs::desc, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                             {
   edm::ParameterSetDescription desc;
   desc.setComment(
       "Validates alignment payloads by comparing the relative position and orientations of tracker modules");
   desc.addUntracked<std::string>("outputFile", {});
   desc.addUntracked<std::string>("outputTreename", {});
   descriptions.addWithDefaultLabel(desc);
 }