#include <TrackerGeometryIntoNtuples.cc>

Inheritance diagram for TrackerGeometryIntoNtuples:

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

	~TrackerGeometryIntoNtuples () override

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

	EDAnalyzer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

	~EDAnalyzer () 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 &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

ESProxyIndex const *	esGetTokenIndices (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::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase &	operator= (EDConsumerBase &&)=default

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

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Types
enum	{ kMaxNumPar = 20 }

Private Member Functions
void	addBranches ()

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

Private Attributes
Float_t	deformationValues_ [kMaxNumPar]

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_

AlignableTracker *	theCurrentTracker

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (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 ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

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)

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

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

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

Detailed Description

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

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

Definition at line 74 of file TrackerGeometryIntoNtuples.cc.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

private

Enumerator
kMaxNumPar

Definition at line 101 of file TrackerGeometryIntoNtuples.cc.

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

Constructor & Destructor Documentation

◆ TrackerGeometryIntoNtuples()

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

explicit

Definition at line 123 of file TrackerGeometryIntoNtuples.cc.

     : 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");
 }

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

◆ ~TrackerGeometryIntoNtuples()

TrackerGeometryIntoNtuples::~TrackerGeometryIntoNtuples ( )

override

Definition at line 156 of file TrackerGeometryIntoNtuples.cc.

156 { delete theCurrentTracker; }

References theCurrentTracker.

Member Function Documentation

◆ addBranches()

void TrackerGeometryIntoNtuples::addBranches ( )

private

Definition at line 288 of file TrackerGeometryIntoNtuples.cc.

                                              {
   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");
 }

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

◆ analyze()

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

overrideprivatevirtual

Implements edm::EDAnalyzer.

Definition at line 163 of file TrackerGeometryIntoNtuples.cc.

                                                                                             {
   // retrieve tracker topology from geometry
   edm::ESHandle<TrackerTopology> tTopoHandle;
   iSetup.get<TrackerTopologyRcd>().get(tTopoHandle);
   const TrackerTopology* const tTopo = tTopoHandle.product();
  
   edm::LogInfo("beginJob") << "Begin Job";
  
   //accessing the initial geometry
   edm::ESHandle<GeometricDet> theGeometricDet;
   iSetup.get<IdealGeometryRecord>().get(theGeometricDet);
   edm::ESHandle<PTrackerParameters> ptp;
   iSetup.get<PTrackerParametersRcd>().get(ptp);
   TrackerGeomBuilderFromGeometricDet trackerBuilder;
   //currernt tracker
   TrackerGeometry* theCurTracker = trackerBuilder.build(&*theGeometricDet, *ptp, tTopo);
  
   //build the tracker
   edm::ESHandle<Alignments> alignments;
   edm::ESHandle<AlignmentErrorsExtended> alignmentErrors;
   edm::ESHandle<AlignmentSurfaceDeformations> surfaceDeformations;
  
   iSetup.get<TrackerAlignmentRcd>().get(alignments);
   iSetup.get<TrackerAlignmentErrorExtendedRcd>().get(alignmentErrors);
   iSetup.get<TrackerSurfaceDeformationRcd>().get(surfaceDeformations);
  
   //apply the latest alignments
   edm::ESHandle<Alignments> globalPositionRcd;
   iSetup.get<TrackerDigiGeometryRecord>().getRecord<GlobalPositionRcd>().get(globalPositionRcd);
   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();
   int detUnit(0);
   //\\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();
  
     ++detUnit;
     //\\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();
 }