 |
ATLAS Offline Software
|
|
| def | cmp (x, y) |
| |
| def | asinh (x) |
| | helper methods ---------------------------------------------------------— More...
|
| |
| def | toiter (beg, end) |
| |
| def | toiter1 (c) |
| |
| def | nolist (f) |
| |
| def | nolist_nmax (f) |
| |
| def | tonone (x) |
| |
| def | asint (x) |
| |
| def | asint32 (x) |
| |
| def | safe_float_vector (v) |
| |
| def | signalstate (o, state) |
| |
| def | daz (f) |
| |
| def | formatItemUsingLong (x) |
| |
| def | boolvec (v) |
| |
| def | typename (t) |
| |
| def | fix_neg0 (x, thresh=0) |
| | library methods ---------------------------------------------------------— More...
|
| |
| def | dump_H3V (v, f) |
| |
| def | dump_HLV (v, f) |
| |
| def | dump_Fourvec (v, f, parens=1) |
| |
| def | dump_Threevec (v, f) |
| |
| def | dump_Twovec (v, f) |
| |
| def | dump_AmgMatrix (m, f, thresh=1e-38) |
| |
| def | dump_AmgVector (m, f, thresh=1e-38, prec=3) |
| |
| def | dump_EL (l, f) |
| |
| def | dump_ParticleBase (e, f) |
| |
| def | dump_ParticleImpl (p, f) |
| |
| def | dump_EMConvert (d, f) |
| |
| def | dump_EMBremFit (d, f) |
| |
| def | dump_EMTrackMatch (d, f) |
| |
| def | dump_EMShower (d, f) |
| |
| def | uf (x) |
| |
| def | dump_EMErrorDetail (d, f) |
| |
| def | dump_EMTrackFit (d, f) |
| |
| def | dump_egamma (e, f) |
| |
| def | dump_Electron (e, f) |
| |
| def | dump_Photon (e, f) |
| |
| def | dump_EnergyLoss (p, f) |
| |
| def | dump_CaloEnergy (p, f) |
| |
| def | dump_Muon (m, f) |
| |
| def | dump_TauDetail (t, f) |
| |
| def | dump_Tau1P3PDetails (t, f) |
| |
| def | dump_TauRecDetails (t, f) |
| |
| def | dump_Tau1P3PExtraDetails (t, f) |
| |
| def | dump_TauRecExtraDetails (t, f) |
| |
| def | dump_TauPi0Candidate (t, f) |
| |
| def | dump_TauPi0Cluster (t, f) |
| |
| def | dump_TauPi0Details (t, f) |
| |
| def | dump_TauCommonDetails (t, f) |
| |
| def | dump_vvelccell (c, f) |
| |
| def | dump_vvdouble (c, f) |
| |
| def | dump_TauCommonExtraDetails (t, f) |
| |
| def | dump_TauJet (t, f) |
| |
| def | dump_BaseTagInfo (info, f) |
| |
| def | dump_TruthInfo (info, f) |
| |
| def | dump_SLTrueInfo (info, f) |
| |
| def | dump_SoftLeptonTruthInfo (info, f) |
| |
| def | dump_SecVtxInfo (info, f) |
| |
| def | dump_IPTrackInfo (info, f) |
| |
| def | dump_IPInfoPlus (info, f) |
| |
| def | dump_IPInfoBase (info, f) |
| |
| def | dump_SVInfoBase (info, f) |
| |
| def | dump_SVTrackInfo (info, f) |
| |
| def | dump_SVInfoPlus (info, f) |
| |
| def | dump_MultiSVInfoPlus (info, f) |
| |
| def | dump_JetProbInfoBase (info, f) |
| |
| def | dump_SETrackInfo (info, f) |
| |
| def | dump_SoftElectronInfo (info, f) |
| |
| def | dump_JetFitterTagInfo (info, f) |
| |
| def | dump_TrackCountingInfo (info, f) |
| |
| def | dump_AtlfInfo (info, f) |
| |
| def | dump_SMTrackInfo (info, f) |
| |
| def | dump_SoftMuonInfo (info, f) |
| |
| def | dump_GbbNNTagInfo (info, f) |
| |
| def | dump_JetConstituent (info, f) |
| |
| def | dump_TrackConstituents (info, f) |
| |
| def | dump_ElectronConstituent (info, f) |
| |
| def | dump_MuonConstituent (info, f) |
| |
| def | dump_ParticleJet (j, f) |
| |
| def | dump_TruthParticle (p, f) |
| |
| def | dump_TrackParticleTruth (p, f) |
| |
| def | dump_TrackParticleTruthCollection (c, f) |
| |
| def | dump_SubDetHitStatistics (s, f) |
| |
| def | dump_TruthTrajectory (t, f) |
| |
| def | dump_DetailedTrackTruthCollection (c, f) |
| |
| def | dump_FitQuality (info, f) |
| |
| def | dump_TrackSummary (info, f) |
| |
| def | dump_Surface (info, f) |
| |
| def | dump_PerigeeSurface (info, f) |
| |
| def | dump_PlaneSurface (info, f) |
| |
| def | dump_StraightLineSurface (info, f) |
| |
| def | dump_CylinderSurface (info, f) |
| |
| def | dump_DiscSurface (info, f) |
| |
| def | dump_LineSaggingDescriptor (info, f) |
| |
| def | dump_SaggedLineSurface (info, f) |
| |
| def | dump_surface (p, f) |
| |
| def | dump_associatedSurface (p, f) |
| |
| def | dump_ParametersBase (info, f) |
| |
| def | dump_CurvilinearParameters (info, f) |
| |
| def | dump_parameters (p, f) |
| |
| def | dump_TrackParticle (p, f) |
| |
| def | dump_LocalParameters (p, f) |
| |
| def | dump_MeasurementBase (p, f) |
| |
| def | dump_RIO_OnTrack (p, f) |
| |
| def | dump_SiClusterOnTrack (p, f) |
| |
| def | dump_PixelClusterOnTrack (p, f) |
| |
| def | dump_SCT_ClusterOnTrack (p, f) |
| |
| def | dump_TRT_DriftCircleOnTrack (p, f) |
| |
| def | dump_MdtDriftCircleOnTrack (p, f) |
| |
| def | dump_CompetingRIOsOnTrack (p, f) |
| |
| def | dump_MuonClusterOnTrack (p, f) |
| |
| def | dump_CompetingMuonClustersOnTrack (p, f) |
| |
| def | dump_RpcClusterOnTrack (p, f) |
| |
| def | dump_Attribute (p, f) |
| |
| def | dump_AttributeList (p, f) |
| |
| def | dump_InDetTime (p, f) |
| |
| def | dump_IDCInDetBSErrContainer (p, f) |
| |
| def | dump_TRT_BSErrContainer (p, f) |
| |
| def | dump_LArFebHeader (p, f) |
| |
| def | dump_LArRawChannel (p, f) |
| |
| def | dump_TrigMonROB (p, f) |
| |
| def | dump_TrigMonRoi (p, f) |
| |
| def | dump_TrigMonAlg (p, f) |
| |
| def | dump_TrigMonSeq (p, f) |
| |
| def | dump_TrigMonTE (p, f) |
| |
| def | dump_TrigMonEvent (p, f) |
| |
| def | dump_TrigConfSig (p, f) |
| |
| def | dump_TrigConfChain (p, f) |
| |
| def | dump_TrigConfAlg (p, f) |
| |
| def | dump_TrigConfSeq (p, f) |
| |
| def | dump_TrigMonConfig (p, f) |
| |
| def | dump_BunchConfKey (p, f) |
| |
| def | dump_AFP_RawCollectionHead (p, f) |
| |
| def | dump_AFP_RawDataCommonHead (p, f) |
| |
| def | dump_AFP_SiRawData (p, f) |
| |
| def | dump_AFP_SiRawCollection (p, f) |
| |
| def | dump_AFP_ToFRawData (p, f) |
| |
| def | dump_AFP_ToFRawCollection (p, f) |
| |
| def | dump_AFP_RawContainer (p, f) |
| |
| def | dump_ALFA_RawData (p, f) |
| |
| def | dump_ALFA_RawDataCollection (p, f) |
| |
| def | dump_ALFA_RawDataContainer (p, f) |
| |
| def | dump_TrigT2ZdcSignals (p, f) |
| |
| def | dump_TauDetailsContainer (p, f) |
| |
| def | dump_egDetailContainer (p, f) |
| |
| def | dump_JetMomentMapCollection (p, f) |
| |
| def | dump_JetKeyDescriptorCollection (p, f) |
| |
| def | dump_LArFebErrorSummary (p, f) |
| |
| def | dump_ClusterSplitProbabilityContainer (p, f) |
| |
| def | dump_InDetSimData (p, f) |
| |
| def | dump_InDetSimDataCollection (p, f) |
| |
| def | dump_PRD_MultiTruthCollection (p, f) |
| |
| def | dump_TrackTruthCollection (p, f) |
| |
| def | dump_LArTTL1 (p, f) |
| |
| def | dump_ComTime (p, f) |
| |
| def | dump_vector (p, f) |
| |
| def | dump_TgcClusterOnTrack (p, f) |
| |
| def | dump_sTgcClusterOnTrack (p, f) |
| |
| def | dump_MMClusterOnTrack (p, f) |
| |
| def | dump_CscClusterOnTrack (p, f) |
| |
| def | dump_PseudoMeasurementOnTrack (p, f) |
| |
| def | dump_measurement (p, f) |
| |
| def | dump_MaterialEffectsBase (p, f) |
| |
| def | dump_ScatteringAngles (p, f) |
| |
| def | dump_MaterialEffectsOnTrack (p, f) |
| |
| def | dump_materialeffects (p, f) |
| |
| def | dump_AlignmentEffectsOnTrack (p, f) |
| |
| def | dump_TrackStateOnSurface (p, f) |
| |
| def | dump_TrackInfo (p, f) |
| |
| def | dump_Track (p, f) |
| |
| def | dump_Segment (p, f) |
| |
| def | dump_MissingET (m, f) |
| |
| def | dump_MissingETSig (m, f) |
| |
| def | dump_MissingETSigHypo (h, f) |
| |
| def | dump_MissingETSigObject (m, f) |
| |
| def | dump_MissingEtCalo (m, f) |
| |
| def | dump_MissingEtTruth (m, f) |
| |
| def | dump_CaloCluster (c, f) |
| |
| def | dump_CaloClusters_sorted (l, f, nmax=None) |
| |
| def | dump_CaloCellLink (l, f) |
| |
| def | dump_CaloClusterCellLink (l, f) |
| |
| def | dump_CaloCell (l, f) |
| |
| def | dump_Vertex (v, f) |
| |
| def | dump_RecVertex (v, f) |
| |
| def | dump_ITrackLink (l, f) |
| |
| def | dump_LinkToTrack (l, f) |
| |
| def | dump_LinkToTrackParticleBase (l, f) |
| |
| def | dump_VxTrackAtVertex (t, f) |
| |
| def | dump_MVFVxTrackAtVertex (t, f) |
| |
| def | dump_VxCandidate1 (v, f) |
| |
| def | dump_MvfFitInfo (v, f) |
| |
| def | dump_MVFVxCandidate (v, f) |
| |
| def | dump_VxCandidate (v, f) |
| |
| def | dump_EventID (e, f) |
| |
| def | dump_EventType (e, f) |
| |
| def | dump_TriggerInfo (e, f) |
| |
| def | dump_EventInfo (e, f) |
| |
| def | dump_PileUpEventInfo (e, f) |
| |
| def | dump_EventStreamInfo (e, f) |
| |
| def | _gen_attr (e, a, typ) |
| |
| def | _gen_vecattr (e, a, typ) |
| |
| def | _gen_barcode (p) |
| |
| def | _genevent_particles_size (e) |
| |
| def | _genevent_vertices_size (e) |
| |
| def | _genevent_particles (e) |
| |
| def | _genevent_vertices (e) |
| |
| def | _genevent_signal_process_vertex (e) |
| |
| def | _genvertex_particles_in_size (e) |
| |
| def | _genvertex_particles_out_size (e) |
| |
| def | barcodes (beg, end, sz) |
| |
| def | genvertex_in_barcodes (v) |
| |
| def | genvertex_out_barcodes (v) |
| |
| def | dump_GenVertex (v, f) |
| |
| def | dump_GenParticle (p, f) |
| |
| def | dump_GenEvent (e, f) |
| |
| def | dump_CTP_Decision (t, f) |
| |
| def | dump_Muon_ROI (m, f) |
| |
| def | dump_EmTau_ROI (m, f) |
| |
| def | dump_Jet_ROI (m, f) |
| |
| def | dump_JetET_ROI (m, f) |
| |
| def | dump_EnergySum_ROI (m, f) |
| |
| def | dump_LVL1_ROI (t, f) |
| |
| def | dump_GenericResult (t, f) |
| |
| def | dump_HLTResult (t, f) |
| |
| def | dump_HLTResultMT (p, f) |
| |
| def | dump_Lvl1Result (t, f) |
| |
| def | dump_TrigDecision (t, f) |
| |
| def | dump_HLTTriggerElement (e, f) |
| |
| def | dump_HLTSignature (s, f) |
| |
| def | dump_HLTStreamTag (s, f) |
| |
| def | dump_HLTChain (c, f) |
| |
| def | dump_HLTSequence (s, f) |
| |
| def | dump_HLTAODConfigData (d, f) |
| |
| def | dump_L1DataBaseclass (c, f) |
| |
| def | dump_CTPConfig (c, f) |
| |
| def | dump_Lvl1AODConfigData (d, f) |
| |
| def | dump_Lvl1AODPrescaleConfigData (d, f) |
| |
| def | dump_TrackRecord (t, f) |
| |
| def | dump_DetStatus (s, f) |
| |
| def | dump_DetStatusMap (m, f) |
| |
| def | dump_TrigInDetTrackTruth (t, f) |
| |
| def | dump_TrigInDetTrackFitPar (p, f) |
| |
| def | dump_TrigInDetTrack (t, f) |
| |
| def | _tmcmp (x, y) |
| |
| def | dump_TrigInDetTrackTruthMap (m, f) |
| |
| def | safe_assocs (a, obj, coll, f) |
| |
| def | dump_Assocs (a, f, colltype) |
| |
| def | dump_INav4MomAssocs (a, f) |
| |
| def | dump_TrackParticleAssocs (a, f) |
| |
| def | dump_ElectronMuonTopoInfo (a, f) |
| |
| def | dump_MuonSpShower (m, f) |
| |
| def | dump_JetAssociationBase (a, f) |
| |
| def | dump_ElectronAssociation (a, f) |
| |
| def | dump_PhotonAssociation (a, f) |
| |
| def | dump_MuonAssociation (a, f) |
| |
| def | dump_TrackAssociation (a, f) |
| |
| def | dump_ISvxAssociation (a, f) |
| |
| def | _infoType (i) |
| |
| def | dump_Jet (j, f) |
| |
| def | dump_ExtendedVxCandidate (c, f) |
| |
| def | dump_V0Hypothesis (h, f) |
| |
| def | dump_V0Candidate (v, f) |
| |
| def | dump_TrigVertex (v, f) |
| |
| def | dump_clist (l, f) |
| |
| def | dump_TrigTrackCounts (t, f) |
| |
| def | dump_TrigTrackCounts_nolist (t, f) |
| |
| def | dump_TrigTau (t, f) |
| |
| def | dump_TrigTau_nolist (t, f) |
| |
| def | dump_TrigCaloCluster (c, f) |
| |
| def | dump_TrigEMCluster (c, f) |
| |
| def | dump_TrigEMCluster_nolist (c, f) |
| |
| def | dump_TrigElectron (p, f) |
| |
| def | dump_TrigPhoton (p, f) |
| |
| def | dump_TrigInDetTrackCollection (t, f) |
| |
| def | dump_TrigEFBjet (j, f) |
| |
| def | dump_TrigEFBphys (j, f) |
| |
| def | dump_TrigL2Bjet (j, f) |
| |
| def | dump_TrigL2Bphys (j, f) |
| |
| def | dump_TrigMissingET (m, f) |
| |
| def | dump_TrigMissingET_nolist (m, f) |
| |
| def | dump_RoiDescriptor (d, f) |
| |
| def | dump_TrigRoiDescriptor (d, f) |
| |
| def | dump_TrigRoiDescriptor_nolist (d, f) |
| |
| def | dump_Trig3Momentum (m, f) |
| |
| def | dump_TrigT2Jet (j, f) |
| |
| def | dump_TrigT2Jet_nolist (j, f) |
| |
| def | dump_TrigTauClusterDetails (t, f) |
| |
| def | dump_TrigTauCluster (t, f) |
| |
| def | dump_TrigTauCluster_nolist (t, f) |
| |
| def | dump_TrigHisto (h, f) |
| |
| def | dump_TrigHisto1D (h, f) |
| |
| def | dump_TrigHisto2D (h, f) |
| |
| def | dump_TrigSpacePointCounts (c, f) |
| |
| def | dump_TrigSpacePointCounts_nolist (c, f) |
| |
| def | dump_TrigTauTracksInfo (t, f) |
| |
| def | dump_TrigTauTracksInfo_nolist (t, f) |
| |
| def | dump_MuonFeature (m, f) |
| |
| def | dump_MuonFeature_nolist (m, f) |
| |
| def | dump_MuonFeatureDetails (m, f) |
| |
| def | dump_TileMuFeature (m, f) |
| |
| def | dump_TileTrackMuFeature (m, f) |
| |
| def | dump_CombinedMuonFeature (m, f) |
| |
| def | dump_CombinedMuonFeature_nolist (m, f) |
| |
| def | dump_TrigMuonEF (m, f) |
| |
| def | dump_TileMu (m, f) |
| |
| def | dump_CaloClusterMomentStore (m, f) |
| |
| def | dump_CaloSamplingData (s, f) |
| |
| def | dump_CaloShower (s, f) |
| |
| def | dump_CaloTowerContainer (t, f) |
| |
| def | dump_CaloTopoTowerContainer (t, f) |
| |
| def | dump_CaloCalibrationHit (t, f) |
| |
| def | dump_LArHit (t, f) |
| |
| def | dump_TileHit (t, f) |
| |
| def | dump_HepMcParticleLink (p, f) |
| |
| def | dump_SiHit (t, f) |
| |
| def | dump_TRTUncompressedHit (t, f) |
| |
| def | dump_TrigT2MbtsBits (t, f) |
| |
| def | dump_CosmicMuon (m, f) |
| |
| def | dump_MdtTrackSegment (t, f) |
| |
| def | dump_IsoMuonFeature (m, f) |
| |
| def | dump_TrigMuonEFTrack (t, f) |
| |
| def | dump_TrigMuonEFInfoTrack (t, f) |
| |
| def | dump_TrigMuonEFInfo (t, f) |
| |
| def | dump_RingerRings (r, f) |
| |
| def | dump_TrigTrtHitCounts (p, f) |
| |
| def | dump_TrigRNNOutput (p, f) |
| |
| def | dump_InDetLowBetaCandidate (p, f) |
| |
| def | dump_LArNoisyROSummary (p, f) |
| |
| def | dump_SkimDecision (p, f) |
| |
| def | dump_RawInfoSummaryForTag (p, f) |
| |
| def | dump_MissingETComposition (m, f) |
| |
| def | dump_ChamberT0s (m, f) |
| |
| def | dump_TrigMuonClusterFeature (m, f) |
| |
| def | dump_TrigPassBits (b, f) |
| |
| def | dump_TrigOperationalInfo (b, f) |
| |
| def | dump_TrigVertexCounts (v, f) |
| |
| def | dump_TrigMuonEFIsolation (m, f) |
| |
| def | dump_TrigPassFlags (m, f) |
| |
| def | dump_eflowObject (e, f) |
| |
| def | dump_eflowObjectContainer (c, f) |
| |
| def | dump_RecoTimingObj (c, f) |
| |
| def | dump_TrigConfKeys (p, f) |
| |
| def | dump_IdentContIndex (p, f) |
| |
| def | dump_PrepRawData (p, f) |
| |
| def | dump_MuonCluster (p, f) |
| |
| def | dump_CscPrepData (p, f) |
| |
| def | dump_CscStripPrepData (p, f) |
| |
| def | dump_TgcPrepData (p, f) |
| |
| def | dump_TgcCoinData (p, f) |
| |
| def | dump_MdtPrepData (p, f) |
| |
| def | dump_RpcPrepData (p, f) |
| |
| def | dump_RpcCoinData (p, f) |
| |
| def | dump_SiWidth (p, f) |
| |
| def | dump_SiCluster (p, f) |
| |
| def | dump_PixelCluster (p, f) |
| |
| def | dump_SCT_Cluster (p, f) |
| |
| def | dump_TRT_DriftCircle (p, f) |
| |
| def | dump_InDetRawData (p, f) |
| |
| def | dump_PixelRDORawData (p, f) |
| |
| def | dump_TRT_RDORawData (p, f) |
| |
| def | dump_SCT_RDORawData (p, f) |
| |
| def | dump_IDC (payload_dumper, p, f, extra_idc_dumper=None) |
| |
| def | dump_CscPrepDataContainer (p, f) |
| |
| def | dump_CscStripPrepDataContainer (p, f) |
| |
| def | dump_RpcCoinDataContainer (p, f) |
| |
| def | dump_RpcPrepDataContainer (p, f) |
| |
| def | dump_TgcPrepDataContainer (p, f) |
| |
| def | dump_TgcCoinDataContainer (p, f) |
| |
| def | dump_MdtPrepDataContainer (p, f) |
| |
| def | dump_PixelClusterContainer (p, f) |
| |
| def | dump_SCT_ClusterContainer (p, f) |
| |
| def | dump_TRT_DriftCircleContainer (p, f) |
| |
| def | dump_PixelRawDataContainer (p, f) |
| |
| def | dump_TRT_RawDataContainer (p, f) |
| |
| def | dump_SCT_RawDataContainer (p, f) |
| |
| def | dump_CscMcData (p, f) |
| |
| def | dump_CscSimData (p, f) |
| |
| def | dump_CscSimDataCollection (p, f) |
| |
| def | dump_MuonMcData (p, f) |
| |
| def | dump_MuonSimData (p, f) |
| |
| def | dump_MuonSimDataCollection (p, f) |
| |
| def | dump_PixelGangedClusterAmbiguities (p, f) |
| |
| def | dump_TileRawData (p, f) |
| |
| def | dump_TileDigits (p, f) |
| |
| def | dump_TileDigitsContainer (p, f) |
| |
| def | dump_TileRawChannel (data, f) |
| |
| def | dump_TileRawDataCollection (data, f) |
| |
| def | dump_TileRawChannelCollection (data, f) |
| |
| def | dump_TileRawChannelContainer (data, f) |
| |
| def | dump_TileBeamElemContainer (data, f) |
| |
| def | dump_TileL2 (p, f) |
| |
| def | dump_TileTTL1 (p, f) |
| |
| def | dump_TileMuonReceiverObj (p, f) |
| |
| def | dump_CMMCPHits (p, f) |
| |
| def | dump_CMMEtSums (p, f) |
| |
| def | dump_CMMJetHits (p, f) |
| |
| def | dump_CMMRoI (p, f) |
| |
| def | dump_CPMHits (p, f) |
| |
| def | dump_CPMRoI (p, f) |
| |
| def | dump_CPMTower (p, f) |
| |
| def | dump_CTP_RDO (p, f) |
| |
| def | dump_MuCTPI_RDO (p, f) |
| |
| def | dump_JEMEtSums (p, f) |
| |
| def | dump_JEMHits (p, f) |
| |
| def | dump_JEMRoI (p, f) |
| |
| def | dump_JetElement (p, f) |
| |
| def | dump_ROIBHeader (p, f) |
| |
| def | dump_ROIBTrailer (p, f) |
| |
| def | dump_MuCTPIRoI (p, f) |
| |
| def | dump_MuCTPIResult (p, f) |
| |
| def | dump_CTPRoI (p, f) |
| |
| def | dump_CTPResult (p, f) |
| |
| def | dump_JetEnergyRoI (p, f) |
| |
| def | dump_JetEnergyResult (p, f) |
| |
| def | dump_EMTauRoI (p, f) |
| |
| def | dump_EMTauResult (p, f) |
| |
| def | dump_L1TopoRDO (p, f) |
| |
| def | dump_L1TopoResult (p, f) |
| |
| def | dump_RoIBResult (p, f) |
| |
| def | dump_TriggerTower (p, f) |
| |
| def | dump_LUCID_RawData (p, f) |
| |
| def | dump_BCM_RDO (p, f) |
| |
| def | dump_BCM_RDO_Collection (p, f) |
| |
| def | dump_CSCSimHit (p, f) |
| |
| def | dump_MDTSimHit (p, f) |
| |
| def | dump_RPCSimHit (p, f) |
| |
| def | dump_TGCSimHit (p, f) |
| |
| def | dump_LArDigit (p, f) |
| |
| def | dump_ZdcRawData (p, f) |
| |
| def | dump_ZdcDigits (p, f) |
| |
| def | dump_EventBookkeeper (p, f, level=0) |
| |
| def | dump_RpcFiredChannel (p, f) |
| |
| def | dump_RpcCoinMatrix (p, f) |
| |
| def | dump_RpcPadContainer (p, f) |
| |
| def | dump_RpcSLTriggerHit (p, f) |
| |
| def | dump_RpcSectorLogic (p, f) |
| |
| def | dump_CscRawData (p, f) |
| |
| def | dump_CscRawDataContainer (p, f) |
| |
| def | dump_TgcRawData (p, f) |
| |
| def | dump_TgcBitmask (p, f, lab, fields) |
| |
| def | dump_TgcRdo_Errors (p, f) |
| |
| def | dump_TgcRdo_RodStatus (p, f) |
| |
| def | dump_TgcRdo_LocalStatus (p, f) |
| |
| def | dump_TgcRdo (p, f) |
| |
| def | dump_TgcRdoContainer (p, f) |
| |
| def | dump_MdtAmtHit (p, f) |
| |
| def | dump_MdtCsmContainer (p, f) |
| |
| def | dump_STGC_RawData (p, f) |
| |
| def | dump_STGC_RawDataContainer (p, f) |
| |
| def | dump_MM_RawData (p, f) |
| |
| def | dump_MM_RawDataContainer (p, f) |
| |
| def | dump_NSW_PadTriggerData (p, f) |
| |
| def | dump_NSW_PadTriggerDataContainer (p, f) |
| |
| def | dump_ZdcLucrod_Data (p, f) |
| |
| def | dump_xAODTruthParticleLink (p, f) |
| |
| def | format_int (x) |
| |
| def | format_float (x) |
| |
| def | format_float_vector (v) |
| |
| def | format_dl (x) |
| |
| def | format_el (x) |
| |
| def | format_obj (x, name=None) |
| |
| def | generic_dump_auxitem (x, auxid, f) |
| |
| def | dump_auxitem (x, auxid, f=sys.stdout) |
| |
| def | dump_auxdata (x, exclude=None, f=sys.stdout) |
| |
| def | dump_xAOD (o, f) |
| |
| def | dump_xAODObject (o, f) |
| |
| def | dump_xAODObjectNL (o, f) |
| |
| def | dump_list (l, f, dumper, nmax=None) |
| |
| def | get_dumper_fct (klass, ofile=sys.stdout, nmax=None) |
| |
|
| string | __doc__ = """python library to dump various EDM classes""" |
| |
| string | __version__ = "$Revision: 1.32 $" |
| |
| string | __author__ = "Scott Snyder, Sebastien Binet" |
| |
| int | etcone10 = 0 |
| |
| int | nucone10 = 8 |
| |
| | JetAssociationBase = getattr (cppyy.gbl, 'JetAssociationBase', None) |
| |
| | Analysis = getattr (cppyy.gbl, 'Analysis', None) |
| |
| | Muon = getattr (Analysis, 'Muon', None) if Analysis else None |
| |
| | jetAssocNull = cppyy.bind_object(cppyy.nullptr, JetAssociationBase) if JetAssociationBase else None |
| |
| | muonNull = cppyy.bind_object(cppyy.nullptr, Muon) if Muon else None |
| |
| | InDet = getattr (cppyy.gbl, 'InDet', None) |
| |
| | InDetLowBetaCandidate = getattr (InDet, 'InDetLowBetaCandidate', None) |
| |
| | InDetLowBetaCandidateNull = cppyy.bind_object(cppyy.nullptr, InDetLowBetaCandidate) if InDetLowBetaCandidate else None |
| |
| | Trk = getattr (cppyy.gbl, 'Trk', None) |
| |
| | FitQuality = getattr (Trk, 'FitQuality', None) |
| |
| | fitQualityNull = cppyy.bind_object(cppyy.nullptr, FitQuality) if FitQuality else None |
| |
| | char_accessor_ = getattr (ROOT, 'SG::ConstAccessor<char>') |
| |
| | uchar_accessor_ = getattr (ROOT, 'SG::ConstAccessor<unsigned char>') |
| |
| list | tlist |
| |
| dictionary | accessors |
| |
| string | aname = 'SG::ConstAccessor<' + t |
| |
| dictionary | atomic_accessors |
| |
| list | dumpspecs |
| |
◆ _gen_attr()
| def python.Dumpers._gen_attr |
( |
|
e, |
|
|
|
a, |
|
|
|
typ |
|
) |
| |
|
private |
Definition at line 2750 of file Dumpers.py.
2751 fn = getattr(e, a,
None)
2754 v = e.attribute_as_string(a)
2755 if v ==
'':
return None
◆ _gen_barcode()
| def python.Dumpers._gen_barcode |
( |
|
p | ) |
|
|
private |
◆ _gen_vecattr()
| def python.Dumpers._gen_vecattr |
( |
|
e, |
|
|
|
a, |
|
|
|
typ |
|
) |
| |
|
private |
Definition at line 2757 of file Dumpers.py.
2758 fn = getattr(e, a,
None)
2761 return [typ(x)
for x
in e.attribute_as_string(a).
split()]
◆ _genevent_particles()
| def python.Dumpers._genevent_particles |
( |
|
e | ) |
|
|
private |
Definition at line 2772 of file Dumpers.py.
2773 if hasattr(e,
'particles_begin'):
2774 return toiter (e.particles_begin(), e.particles_end())
2775 return e.particles()
◆ _genevent_particles_size()
| def python.Dumpers._genevent_particles_size |
( |
|
e | ) |
|
|
private |
Definition at line 2764 of file Dumpers.py.
2765 if hasattr(e,
'particles_size'):
2766 return e.particles_size()
2767 return e.particles().
size()
◆ _genevent_signal_process_vertex()
| def python.Dumpers._genevent_signal_process_vertex |
( |
|
e | ) |
|
|
private |
Definition at line 2780 of file Dumpers.py.
2781 if hasattr(e,
'signal_process_vertex'):
2782 return e.signal_process_vertex()
2783 for v
in e.vertices():
2784 if v.attribute_as_string(
'signal_process_vertex') ==
'1':
◆ _genevent_vertices()
| def python.Dumpers._genevent_vertices |
( |
|
e | ) |
|
|
private |
Definition at line 2776 of file Dumpers.py.
2777 if hasattr(e,
'vertices_begin'):
2778 return toiter (e.vertices_begin(), e.vertices_end())
◆ _genevent_vertices_size()
| def python.Dumpers._genevent_vertices_size |
( |
|
e | ) |
|
|
private |
Definition at line 2768 of file Dumpers.py.
2769 if hasattr(e,
'vertices_size'):
2770 return e.vertices_size()
2771 return e.vertices().
size()
◆ _genvertex_particles_in_size()
| def python.Dumpers._genvertex_particles_in_size |
( |
|
e | ) |
|
|
private |
Definition at line 2787 of file Dumpers.py.
2788 if hasattr(e,
'particles_in_size'):
2789 return e.particles_in_size()
2790 return e.particles_in().
size()
◆ _genvertex_particles_out_size()
| def python.Dumpers._genvertex_particles_out_size |
( |
|
e | ) |
|
|
private |
Definition at line 2791 of file Dumpers.py.
2792 if hasattr(e,
'particles_out_size'):
2793 return e.particles_out_size()
2794 return e.particles_out().
size()
◆ _infoType()
| def python.Dumpers._infoType |
( |
|
i | ) |
|
|
private |
◆ _tmcmp()
| def python.Dumpers._tmcmp |
( |
|
x, |
|
|
|
y |
|
) |
| |
|
private |
Definition at line 3351 of file Dumpers.py.
3353 if x[0].nrMatches() > 0:
3354 xbc = x[0].bestSiMatch().
barcode()
3356 if y[0].nrMatches() > 0:
3357 ybc = y[0].bestSiMatch().
barcode()
3363 return cmp (x[1].chi2, y[1].chi2)
◆ asinh()
| def python.Dumpers.asinh |
( |
|
x | ) |
|
helper methods ---------------------------------------------------------—
Definition at line 88 of file Dumpers.py.
89 arg = math_sqrt (x*x+1) - x
92 return - math_log (arg)
◆ asint()
| def python.Dumpers.asint |
( |
|
x | ) |
|
◆ asint32()
| def python.Dumpers.asint32 |
( |
|
x | ) |
|
◆ barcodes()
| def python.Dumpers.barcodes |
( |
|
beg, |
|
|
|
end, |
|
|
|
sz |
|
) |
| |
Definition at line 2797 of file Dumpers.py.
2802 while beg != end
and sz > 0:
2806 out.append (x.barcode())
◆ boolvec()
| def python.Dumpers.boolvec |
( |
|
v | ) |
|
◆ cmp()
| def python.Dumpers.cmp |
( |
|
x, |
|
|
|
y |
|
) |
| |
Definition at line 36 of file Dumpers.py.
37 return (x > y) - (x < y)
◆ daz()
| def python.Dumpers.daz |
( |
|
f | ) |
|
◆ dump_AFP_RawCollectionHead()
| def python.Dumpers.dump_AFP_RawCollectionHead |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1914 of file Dumpers.py.
1915 fprint (f, p.lvl1Id(), p.link(), p.frontendFlag(), p.bcId(), p.robId())
◆ dump_AFP_RawContainer()
| def python.Dumpers.dump_AFP_RawContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1951 of file Dumpers.py.
1952 fprint (f, p.lvl1Id(), p.bcId(), p.lumiBlock(),
1953 p.timeStamp(), p.timeStampNS())
1954 fprint (f,
'\n si collections')
1955 for c
in p.collectionsSi():
1957 dump_AFP_SiRawCollection (c, f)
1958 fprint (f,
'\n tof collections')
1959 for c
in p.collectionsToF():
1961 dump_AFP_ToFRawCollection (c, f)
◆ dump_AFP_RawDataCommonHead()
| def python.Dumpers.dump_AFP_RawDataCommonHead |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1918 of file Dumpers.py.
1919 fprint (f, p.hitDiscConfig(), p.link())
◆ dump_AFP_SiRawCollection()
| def python.Dumpers.dump_AFP_SiRawCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1927 of file Dumpers.py.
1928 dump_AFP_RawCollectionHead (p, f)
1929 for r
in p.dataRecords():
1931 dump_AFP_SiRawData (r, f)
◆ dump_AFP_SiRawData()
| def python.Dumpers.dump_AFP_SiRawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1922 of file Dumpers.py.
1923 dump_AFP_RawDataCommonHead (p, f)
1924 fprint (f, p.column(), p.row(), p.timeOverThreshold())
◆ dump_AFP_ToFRawCollection()
| def python.Dumpers.dump_AFP_ToFRawCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1943 of file Dumpers.py.
1944 dump_AFP_RawCollectionHead (p, f)
1945 for r
in p.dataRecords():
1947 dump_AFP_ToFRawData (r, f)
◆ dump_AFP_ToFRawData()
| def python.Dumpers.dump_AFP_ToFRawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1934 of file Dumpers.py.
1935 dump_AFP_RawDataCommonHead (p, f)
1936 fprint (f, p.header(), p.edge(), p.channel())
1938 fprint (f, p.delayedTrigger(), p.triggerPattern())
1940 fprint (f, p.time(), p.pulseLength())
◆ dump_ALFA_RawData()
| def python.Dumpers.dump_ALFA_RawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1965 of file Dumpers.py.
1966 fprint (f, p.GetWordId_PMF(), p.GetPMFId_PMF(), p.GetMBId_PMF(),
1967 p.GetEventCount_PMF(), p.Get_bit16(), p.Get_bit18(),
1968 p.Get_bit26_27(), p.Get_bit24_27(), p.Get_error_bit17(),
1969 list(p.HitChan()), list (p.dataWords()))
◆ dump_ALFA_RawDataCollection()
| def python.Dumpers.dump_ALFA_RawDataCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1973 of file Dumpers.py.
1974 fprint (f,
'collection')
1975 fprint (f,
'mb', p.GetMBId_POT(),
'mrod', p.GetMrodId_POT(),
1976 'ec', p.GetEventCount_POT(),
1977 'scid', p.Get_scaler_POT(),
1978 'adc', p.Get_ADC1_POT(), p.Get_ADC2_POT(),
1979 'err', p.GetTrigSyncErr(),
1980 'pat', boolvec (p.Get_pattern_POT()))
1981 fprint (f,
'\n data')
1982 for r
in p.Get_POT_DATA():
1984 dump_ALFA_RawData (r, f)
1985 fprint (f,
'\n contents')
1988 dump_ALFA_RawData (r, f)
◆ dump_ALFA_RawDataContainer()
| def python.Dumpers.dump_ALFA_RawDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1993 of file Dumpers.py.
1994 if p.is_FullEVmarker(): fprint (f,
'fullev')
1995 if p.is_ROBmarker(): fprint (f,
'rob')
1996 if p.is_RODmarker(): fprint (f,
'rod')
1997 fprint (f,
'sd/mrod/l1/ecr/bc', p.subdetId(), p.mrodId(), p.lvl1Id(),
1998 p.ecrId(), p.bcId())
1999 fprint (f,
'\n run/typ/tt/evtyp', p.runNum(), p.runType(),
2000 p.trigtypeId(), p.DetEventType(),
2001 'ts', p.GetTimeStamp(), p.GetTimeStampns(),
2002 p.GetLumiBlock(), p.GetBCId())
2003 fprint (f,
'\n lvl1',
boolvec(p.GetLvl1Pattern_POT()))
2004 fprint (f,
'\n lvl2',
boolvec(p.GetLvl2Pattern_POT()))
2005 fprint (f,
'\n ef',
boolvec(p.GetEFPattern_POT()))
2008 dump_ALFA_RawDataCollection (c, f)
◆ dump_AlignmentEffectsOnTrack()
| def python.Dumpers.dump_AlignmentEffectsOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2226 of file Dumpers.py.
2228 fprint (f,
'(null)')
2230 fprint (f, p.deltaTranslation(), p.sigmaDeltaTrranslation(), p.deltaAngle(), p.sigmaDeltaAngle())
2231 for t
in p.vectorOfAffectedTSOS():
2232 fprint (f,
'\n ts ')
2233 dump_parameters (t.trackparameters(), f)
2234 fprint (f,
'\n sf ')
2235 dump_Surface (p.associatedSurface(), f)
◆ dump_AmgMatrix()
| def python.Dumpers.dump_AmgMatrix |
( |
|
m, |
|
|
|
f, |
|
|
|
thresh = 1e-38 |
|
) |
| |
Definition at line 304 of file Dumpers.py.
306 for r
in range(m.rows()):
308 for c
in range(m.cols()):
310 if abs(v) < thresh: v = 0
311 fprint (f,
'%#6.3g' % v)
◆ dump_AmgVector()
| def python.Dumpers.dump_AmgVector |
( |
|
m, |
|
|
|
f, |
|
|
|
thresh = 1e-38, |
|
|
|
prec = 3 |
|
) |
| |
Definition at line 316 of file Dumpers.py.
318 fprint (f,
'(null vector)')
321 for r
in range(m.rows()):
323 if abs(v) < thresh: v = 0
324 fprint (f,
'%#6.*g' % (prec, v))
◆ dump_associatedSurface()
| def python.Dumpers.dump_associatedSurface |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1542 of file Dumpers.py.
1543 if hasattr(p,
'hasSurface')
and not p.hasSurface():
1546 dump_surface (p.associatedSurface(), f)
◆ dump_Assocs()
| def python.Dumpers.dump_Assocs |
( |
|
a, |
|
|
|
f, |
|
|
|
colltype |
|
) |
| |
Definition at line 3411 of file Dumpers.py.
3412 bo = a.beginObject()
3416 obj = a.getObject(bo)
3418 errflag = safe_assocs (a, obj, coll, f)
3419 l.append ((obj, coll, errflag))
3422 l.sort (key=
lambda a: a[0].
pt(), reverse=
True)
3424 for obj, coll, errflag
in l:
3425 fprint (f,
'\n',
typename(obj.__class__))
3426 dump_Fourvec (obj, f)
3432 fprint (f,
' [Got invalid EL error]')
◆ dump_AtlfInfo()
| def python.Dumpers.dump_AtlfInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1230 of file Dumpers.py.
1231 dump_BaseTagInfo (info, f)
1232 fprint (f, info.isBTagged(), info.isTauTagged(), info.isTau1PTagged(),
1233 info.isTau3PTagged(), info.LightHypoCalFactor(),
1234 info.TauHypoCalFactor(), info.Tau1P3PHypoCalFactor(),
1235 info.BHypoCalFactor(),
1236 info.deltaRMinTo(
"b"),
1237 info.deltaRMinTo(
"c"),
1238 info.deltaRMinTo(
"t"))
◆ dump_Attribute()
| def python.Dumpers.dump_Attribute |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1724 of file Dumpers.py.
1725 if isinstance (p, str):
1728 ss = ROOT.std.ostringstream()
1729 p.toOutputStream (ss)
1730 fprint (f, ss.str())
◆ dump_AttributeList()
| def python.Dumpers.dump_AttributeList |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1733 of file Dumpers.py.
1737 ss = ROOT.std.ostringstream()
1743 if s[0] ==
'{': s = s[1:]
1744 if s[-1] ==
'}': s = s[:-1]
1745 for a
in s.split(
','):
1746 fprint (f,
' ', a,
'\n')
◆ dump_auxdata()
| def python.Dumpers.dump_auxdata |
( |
|
x, |
|
|
|
exclude = None, |
|
|
|
f = sys.stdout |
|
) |
| |
Definition at line 5672 of file Dumpers.py.
5673 reg=ROOT.SG.AuxTypeRegistry.instance()
5674 if cppyy.addressof (x) == 0:
5675 fprint (f,
'<null pointer>', x,
type(x))
5678 auxids = ROOT.PyDumper.Utils.getAuxIDVector (x)
5682 auxids = [(reg.getName(id), id)
for id
in auxids]
5684 for name, auxid
in auxids:
5685 if exclude
and name
in exclude:
continue
5686 if name.endswith (
'_linked'):
continue
5687 fprint (f, name +
': ')
5688 dump_auxitem (x, auxid, f)
◆ dump_auxitem()
| def python.Dumpers.dump_auxitem |
( |
|
x, |
|
|
|
auxid, |
|
|
|
f = sys.stdout |
|
) |
| |
Definition at line 5627 of file Dumpers.py.
5628 if hasattr (x,
'container'):
5629 auxdata = x.container().getConstStore().
getData(auxid)
5632 fprint (f,
'<unavailable>')
5637 fprint (f,
'<unavailable 4>')
5640 reg=ROOT.SG.AuxTypeRegistry.instance()
5641 tname = reg.getTypeName (auxid)
5642 atomic = reg.getFlags (auxid) & ROOT.SG.AuxVarFlags.Atomic
5644 ac_cl = atomic_accessors.get (tname)
5646 ac_cl = accessors.get (tname)
5648 if not ac_cl
and tname.startswith (
'SG::JaggedVecElt<'):
5649 ac_cl = getattr (ROOT,
'SG::ConstAccessor<' + tname +
' >')
5651 accessors[tname] = ac_cl
5653 if not ac_cl
and tname.startswith (
'SG::PackedLink<')
or tname.startswith (
'std::vector<SG::PackedLink<'):
5654 ac_cl = getattr (ROOT,
'SG::ConstAccessor<' + tname +
' >')
5656 accessors[tname] = ac_cl
5660 ac = ac_cl(reg.getName(auxid))
5665 val =
'<unavailable 5>'
5668 generic_dump_auxitem (x, auxid, f)
◆ dump_BaseTagInfo()
| def python.Dumpers.dump_BaseTagInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1036 of file Dumpers.py.
1037 fprint (f,
' '.join ([
'%f'%x
for x
in info.tagLikelihood()]),
1038 info.weight(), info.isValid())
◆ dump_BCM_RDO()
| def python.Dumpers.dump_BCM_RDO |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5178 of file Dumpers.py.
5179 fprint (f,
'[', p.getWord1(), p.getWord2(),
']')
◆ dump_BCM_RDO_Collection()
| def python.Dumpers.dump_BCM_RDO_Collection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5183 of file Dumpers.py.
5184 fprint (f, p.getChannel())
◆ dump_BunchConfKey()
| def python.Dumpers.dump_BunchConfKey |
( |
|
p, |
|
|
|
f |
|
) |
| |
◆ dump_CaloCalibrationHit()
| def python.Dumpers.dump_CaloCalibrationHit |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4228 of file Dumpers.py.
4229 fprint (f, t.cellID().getString(), t.particleID(),
4230 [t.energy(i)
for i
in range(4)])
◆ dump_CaloCell()
| def python.Dumpers.dump_CaloCell |
( |
|
l, |
|
|
|
f |
|
) |
| |
Definition at line 2556 of file Dumpers.py.
2557 fprint (f, l.ID().getString())
2558 if l.__class__ == PyAthena.TileCell:
2559 fprint (f,
'%.2f %.2f %d %d %d ' % (l.ene1(), l.time1(), l.qual1(), l.qbit1(), l.gain1()))
2560 fprint (f,
'%.2f %.2f %d %d %d ' % (l.ene2(), l.time2(), l.qual2(), l.qbit2(), l.gain2()))
2562 fprint (f,
'%.2f %.2f %d %d %d ' % (l.energy(), l.time(), l.quality(), l.provenance(), l.gain()))
◆ dump_CaloCellLink()
| def python.Dumpers.dump_CaloCellLink |
( |
|
l, |
|
|
|
f |
|
) |
| |
Definition at line 2533 of file Dumpers.py.
2538 el = beg.getElement()
2539 if last != el.dataID():
2542 fprint (f, el.index())
◆ dump_CaloCluster()
| def python.Dumpers.dump_CaloCluster |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 2484 of file Dumpers.py.
2487 fprint (f,
"%3d %f %f %f %f %f %d %d %d" %
2488 (c.getClusterSize(),
2497 fprint (f, c.getRecoStatus().getStatusWord())
2498 beg = c.beginMoment()
2501 fprint (f,
'\n mom %d %f' % (c.getMomentType(beg),
2502 c.getMomentValue(beg)))
2505 for i
in range (c.nSamples()):
2506 fprint (f,
'\n %2d %d %d %d %f %f %f %f %f %f %f %f %f %f %f' %
2508 c.is_valid_sampling(i),
◆ dump_CaloClusterCellLink()
| def python.Dumpers.dump_CaloClusterCellLink |
( |
|
l, |
|
|
|
f |
|
) |
| |
Definition at line 2547 of file Dumpers.py.
2551 fprint (f,
'%d/%f' % (beg.index(), beg.weight()))
◆ dump_CaloClusterMomentStore()
| def python.Dumpers.dump_CaloClusterMomentStore |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4165 of file Dumpers.py.
4169 fprint (f,
'\n ', beg.getMomentType(), beg.getMoment().getValue())
◆ dump_CaloClusters_sorted()
| def python.Dumpers.dump_CaloClusters_sorted |
( |
|
l, |
|
|
|
f, |
|
|
|
nmax = None |
|
) |
| |
Definition at line 2526 of file Dumpers.py.
2528 ll.sort (key=
lambda a: a.pt(), reverse=
True)
2529 dump_list (ll, f, dump_CaloCluster, nmax=nmax)
◆ dump_CaloEnergy()
| def python.Dumpers.dump_CaloEnergy |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 613 of file Dumpers.py.
614 dump_EnergyLoss (p, f)
615 fprint (f,
'%d %f %f %f %f' %
618 p.caloLRLikelihood(),
619 p.fsrCandidateEnergy(),
621 fprint (f, p.deltaEParam(), p.sigmaMinusDeltaEParam(), p.sigmaPlusDeltaEParam(), p.deltaEMeas(), p.sigmaDeltaEMeas())
622 fprint (f,
'\n deposits:')
623 for d
in p.depositInCalo():
624 fprint (f,
" (%d %f %f)" %
625 (d.subCaloId(), d.energyDeposited(), d.muonEnergyLoss()))
◆ dump_CaloSamplingData()
| def python.Dumpers.dump_CaloSamplingData |
( |
|
s, |
|
|
|
f |
|
) |
| |
Definition at line 4174 of file Dumpers.py.
4175 nsamp = s.getNumberOfSamplings()
4176 for i
in range(
min(10, s.getNumberOfVariableTypes())):
4178 slist = [s.retrieveData(i, samp)
for samp
in range(nsamp)]
4179 fprint (f,
'\n ', i, slist)
◆ dump_CaloShower()
| def python.Dumpers.dump_CaloShower |
( |
|
s, |
|
|
|
f |
|
) |
| |
Definition at line 4183 of file Dumpers.py.
4184 fprint (f,
' moments:')
4185 dump_CaloClusterMomentStore (s.getMomentStore(), f)
4186 fprint (f,
'\n sampling data:')
4187 dump_CaloSamplingData (s.getSamplingStore(), f)
◆ dump_CaloTopoTowerContainer()
| def python.Dumpers.dump_CaloTopoTowerContainer |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4200 of file Dumpers.py.
4202 dump_CaloTowerContainer (t, f)
4203 fprint (f,
' ', t.GetMinimumCellEnergy(),
4204 t.GetMinimumClusterEnergy(),
4205 t.GetUseCellWeights(),
4209 t.GetCellESignificanceThreshold(),
4210 t.GetCaloSelection())
4211 ci = t.GetCaloIndices()
4213 fprint (f, [ci[i]
for i
in range(ci.size())])
4216 if l.isValid(): fprintln (f, l.dataID())
4217 else: fprintln (f,
'(null)')
4221 if t.GetCellToClusterMap():
4222 fprintln (f,
' ', t.GetCellToClusterMap().
size())
4224 fprintln (f,
' (null)')
◆ dump_CaloTowerContainer()
| def python.Dumpers.dump_CaloTowerContainer |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4192 of file Dumpers.py.
4194 fprintln (f, t.neta(), t.etamin(), t.deta(),
4195 t.nphi(), t.phimin(), t.dphi())
◆ dump_ChamberT0s()
| def python.Dumpers.dump_ChamberT0s |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4429 of file Dumpers.py.
4430 for p
in m.getAllT0s():
4431 fprintln (f,
' ', p.first.getString(), p.second)
◆ dump_clist()
| def python.Dumpers.dump_clist |
( |
|
l, |
|
|
|
f |
|
) |
| |
Definition at line 3678 of file Dumpers.py.
3686 fprint (f,
'%f, ' % last)
3688 fprint (f,
'%d*%f, ' % (n, last))
3695 fprint (f,
'%f, ' % last)
3697 fprint (f,
'%d*%f, ' % (n, last))
◆ dump_ClusterSplitProbabilityContainer()
| def python.Dumpers.dump_ClusterSplitProbabilityContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2049 of file Dumpers.py.
2050 for x
in p.splitProbMap():
2051 fprint (f,
'\n ', x.first, x.second.first, x.second.second, x.second.isSplit())
◆ dump_CMMCPHits()
| def python.Dumpers.dump_CMMCPHits |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4959 of file Dumpers.py.
4960 fprint (f, p.crate(), p.dataID(), p.peak(),
4961 formatItemUsingLong (
list(p.HitsVec0())),
4962 formatItemUsingLong (
list(p.HitsVec1())),
4963 list(p.ErrorVec0()),
4964 list(p.ErrorVec1()))
◆ dump_CMMEtSums()
| def python.Dumpers.dump_CMMEtSums |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4968 of file Dumpers.py.
4969 fprint (f, p.crate(), p.dataID(), p.peak(),
4970 formatItemUsingLong (
list(p.EtVec())),
4971 formatItemUsingLong (
list(p.ExVec())),
4972 formatItemUsingLong (
list(p.EyVec())),
4973 list(p.EtErrorVec()),
4974 list(p.ExErrorVec()),
4975 list(p.EyErrorVec()))
◆ dump_CMMJetHits()
| def python.Dumpers.dump_CMMJetHits |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4979 of file Dumpers.py.
4980 fprint (f, p.crate(), p.dataID(), p.peak(),
4981 formatItemUsingLong (
list(p.HitsVec())),
◆ dump_CMMRoI()
| def python.Dumpers.dump_CMMRoI |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4987 of file Dumpers.py.
4988 fprint (f, p.jetEtRoiWord(),
◆ dump_CombinedMuonFeature()
| def python.Dumpers.dump_CombinedMuonFeature |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4135 of file Dumpers.py.
4138 fprint (f, m.pt(), m.eta(), m.phi(), m.m(), m.sigma_pt())
4139 if m.IDTrackLink().
isValid()
and m.IDTrack():
4141 dump_TrigInDetTrack (PyTrigInDetTrack(m.IDTrack()), f)
4142 if m.muFastTrackLink().
isValid()
and m.muFastTrack():
4143 fprint (f,
'\n fast')
4144 dump_MuonFeature (m.muFastTrack(), f)
◆ dump_CombinedMuonFeature_nolist()
| def python.Dumpers.dump_CombinedMuonFeature_nolist |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4149 of file Dumpers.py.
4150 dump_CombinedMuonFeature (m, f)
◆ dump_CompetingMuonClustersOnTrack()
| def python.Dumpers.dump_CompetingMuonClustersOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1706 of file Dumpers.py.
1707 dump_CompetingRIOsOnTrack (p, f)
1708 dump_AmgVector (p.globalPosition(), f)
1709 dump_associatedSurface (p, f)
1710 for r
in p.containedROTs():
1711 fprint (f,
'\n mc ')
1712 dump_MuonClusterOnTrack (r, f)
◆ dump_CompetingRIOsOnTrack()
| def python.Dumpers.dump_CompetingRIOsOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1690 of file Dumpers.py.
1691 dump_MeasurementBase (p, f)
1692 fprint (f, p.indexOfMaxAssignProb())
1693 sz = p.numberOfContainedROTs()
1694 fprint (f, [p.assignmentProbability(i)
for i
in range(sz)])
◆ dump_ComTime()
| def python.Dumpers.dump_ComTime |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2100 of file Dumpers.py.
2101 fprint (f, p.getTTCTime(), p.getTime())
2102 dump_H3V (p.GetCounterPosition(), f)
2103 dump_H3V (p.GetcosThetaDirection(), f)
◆ dump_CosmicMuon()
| def python.Dumpers.dump_CosmicMuon |
( |
|
m, |
|
|
|
f |
|
) |
| |
◆ dump_CPMHits()
| def python.Dumpers.dump_CPMHits |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4995 of file Dumpers.py.
4996 fprint (f, p.crate(), p.module(), p.peak(),
4997 formatItemUsingLong (
list(p.HitsVec0())),
4998 formatItemUsingLong (
list(p.HitsVec1())))
◆ dump_CPMRoI()
| def python.Dumpers.dump_CPMRoI |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5002 of file Dumpers.py.
5003 fprint (f, p.roiWord())
◆ dump_CPMTower()
| def python.Dumpers.dump_CPMTower |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5007 of file Dumpers.py.
5008 fprint (f, p.eta(), p.phi(), p.peak(),
5009 list(p.emEnergyVec()),
5010 list(p.hadEnergyVec()),
5011 list(p.emErrorVec()),
5012 list(p.hadErrorVec()))
◆ dump_CscClusterOnTrack()
| def python.Dumpers.dump_CscClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2140 of file Dumpers.py.
2141 dump_MuonClusterOnTrack (p, f)
2142 dump_EL (p.prepRawDataLink(), f)
2143 fprint (f, p.status(), p.timeStatus(), p.time())
2144 if p.detectorElement():
2145 fprint (f, p.detectorElement().identifyHash().
value())
2147 fprint (f,
'(null detEl)')
◆ dump_CscMcData()
| def python.Dumpers.dump_CscMcData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4770 of file Dumpers.py.
4771 fprint (f, p.energy(), p.ypos(), p.zpos(), p.charge())
◆ dump_CscPrepData()
| def python.Dumpers.dump_CscPrepData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4538 of file Dumpers.py.
4539 dump_MuonCluster (p, f)
4540 fprint (f, p.charge(), p.time(), p.status(), p.timeStatus())
4541 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_CscPrepDataContainer()
| def python.Dumpers.dump_CscPrepDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4693 of file Dumpers.py.
4694 dump_IDC (dump_CscPrepData, p, f)
◆ dump_CscRawData()
| def python.Dumpers.dump_CscRawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5291 of file Dumpers.py.
5292 fprint (f, p.address(), p.hashId(), p.identify(), p.rpuID(),
5293 p.time(), p.width(), p.isTimeComputed(),
list(p.samples()))
◆ dump_CscRawDataContainer()
| def python.Dumpers.dump_CscRawDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5297 of file Dumpers.py.
5298 dump_IDC (dump_CscRawData, p, f,
5299 extra_idc_dumper =
lambda p, f: \
5300 fprint (f, p.identify(), p.rodId(), p.subDetectorId(),
5301 p.samplingPhase(), p.triggerType(), p.firstBitSummary(),
5302 p.eventType(), p.scaAddress(),
5303 list(p.rpuID()), [ord(c)
for c
in p.dataType()]))
◆ dump_CscSimData()
| def python.Dumpers.dump_CscSimData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4775 of file Dumpers.py.
4776 fprint (f, p.word())
4777 for d
in p.getdeposits():
4778 dump_HepMcParticleLink (d.first, f)
4779 dump_CscMcData (d.second, f)
◆ dump_CscSimDataCollection()
| def python.Dumpers.dump_CscSimDataCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4784 of file Dumpers.py.
4786 fprint (f, elt.first.getString())
4787 dump_CscSimData (elt.second, f)
◆ dump_CSCSimHit()
| def python.Dumpers.dump_CSCSimHit |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5190 of file Dumpers.py.
5191 fprint (f, p.CSCid(), p.globalTime(), p.energyDeposit())
5192 dump_Threevec (p.getHitStart(), f)
5193 dump_Threevec (p.getHitEnd(), f)
5194 fprint (f, p.particleID(), p.kineticEnergy())
5195 dump_HepMcParticleLink (p.particleLink(), f)
◆ dump_CscStripPrepData()
| def python.Dumpers.dump_CscStripPrepData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4545 of file Dumpers.py.
4546 dump_MuonCluster (p, f)
4547 fprint (f, p.timeOfFirstSample(), p.samplingPhase(), p.samplingTime())
4548 fprint (f,
list(p.sampleCharges()))
4549 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_CscStripPrepDataContainer()
| def python.Dumpers.dump_CscStripPrepDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4699 of file Dumpers.py.
4700 dump_IDC (dump_CscStripPrepData, p, f)
◆ dump_CTP_Decision()
| def python.Dumpers.dump_CTP_Decision |
( |
|
t, |
|
|
|
f |
|
) |
| |
◆ dump_CTP_RDO()
| def python.Dumpers.dump_CTP_RDO |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5017 of file Dumpers.py.
5018 fprint (f, p.getCTPVersionNumber(),
5019 p.getCTPVersion().getVersionNumber(),
5020 formatItemUsingLong (
list(p.getDataWords())),
5021 p.getL1AcceptBunchPosition(),
5023 p.getNumberOfBunches(),
5024 p.getNumberOfAdditionalWords())
◆ dump_CTPConfig()
| def python.Dumpers.dump_CTPConfig |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 3169 of file Dumpers.py.
3170 dump_L1DataBaseclass (c, f)
◆ dump_CTPResult()
| def python.Dumpers.dump_CTPResult |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5093 of file Dumpers.py.
5094 dump_ROIBHeader (p.header(), f)
5095 for r
in p.roIVec():
5097 dump_ROIBTrailer (p.trailer(), f)
◆ dump_CTPRoI()
| def python.Dumpers.dump_CTPRoI |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5088 of file Dumpers.py.
5089 fprint (f, p.roIWord())
◆ dump_CurvilinearParameters()
| def python.Dumpers.dump_CurvilinearParameters |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1564 of file Dumpers.py.
1565 dump_ParametersBase (info, f)
1566 fprint (f,
'\n curvilinear')
1567 fprint (f, info.cIdentifier())
1568 mat = info.measurementFrame()
1569 dump_AmgVector (mat.col(0), f)
1570 dump_AmgVector (mat.col(1), f)
1571 dump_AmgVector (mat.col(2), f)
◆ dump_CylinderSurface()
| def python.Dumpers.dump_CylinderSurface |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1497 of file Dumpers.py.
1498 dump_Surface (info, f)
◆ dump_DetailedTrackTruthCollection()
| def python.Dumpers.dump_DetailedTrackTruthCollection |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 1422 of file Dumpers.py.
1423 fprint (f,
' ', c.trackCollectionLink().
key(), c.size())
1425 fprint (f,
'\n %3d' % p.first.index(),
' common ')
1426 dump_SubDetHitStatistics (p.second.statsCommon(), f)
1427 fprint (f,
'\n ',
' track ')
1428 dump_SubDetHitStatistics (p.second.statsTrack(), f)
1429 fprint (f,
'\n ',
' truth ')
1430 dump_SubDetHitStatistics (p.second.statsTruth(), f)
1431 fprint (f,
'\n ',
' trajectory ')
1432 dump_TruthTrajectory (p.second.trajectory(), f)
◆ dump_DetStatus()
| def python.Dumpers.dump_DetStatus |
( |
|
s, |
|
|
|
f |
|
) |
| |
Definition at line 3234 of file Dumpers.py.
3235 fprintln (f, s.code(),
◆ dump_DetStatusMap()
| def python.Dumpers.dump_DetStatusMap |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 3244 of file Dumpers.py.
3247 dump_DetStatus (e.second, f)
◆ dump_DiscSurface()
| def python.Dumpers.dump_DiscSurface |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1502 of file Dumpers.py.
1503 dump_Surface (info, f)
◆ dump_eflowObject()
| def python.Dumpers.dump_eflowObject |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 4476 of file Dumpers.py.
4478 fprint (f, e.eflowType(), e.isValid(), e.d0(), e.z0(),
4479 e.getPassEOverPCheck(), e.getIsSubtracted(),
4480 e.getIsDuplicated(), e.getCaloRecoStatus().getStatusWord())
4481 for i
in range(e.numTrack()):
4482 fprint (f,
'\n tk: ')
4483 dump_EL (e.trackLink(i), f)
4484 for i
in range(e.numClus()):
4485 fprint (f,
'\n cl: ')
4486 dump_EL (e.clusLink(i), f)
4487 fprint (f,
'\n mu: ')
4488 dump_EL (e.muonLink(), f)
4489 fprint (f,
'\n cv: ')
4490 dump_EL (e.conversionLink(), f)
◆ dump_eflowObjectContainer()
| def python.Dumpers.dump_eflowObjectContainer |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 4495 of file Dumpers.py.
4496 print (c.missET(), c.sumET(), c.pTx(), c.pTy(), c.numEf(),
4497 c.numPhot(), c.numEle(), c.numMuo(), c.isValid(),
4498 c.circularity(), c.thrust(), c.oblateness(),
4500 dump_list (c, f, dump_eflowObject)
◆ dump_egamma()
| def python.Dumpers.dump_egamma |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 547 of file Dumpers.py.
549 dump_ParticleImpl (e, f)
550 fprint (f,
"\n %d %d %d" % (e.author(), e.isem(), e.isemse()))
551 if e.clusterElementLink().
isValid():
552 fprint (f,
'\n cl: %2d:' % e.clusterElementLink().
index())
553 dump_Fourvec (e.cluster(), f)
554 for i
in range(e.nTrackParticles()):
555 tp = e.trackParticleElementLink(i)
557 fprint (f,
'\n tp: %2d:' %tp.index())
558 dump_Fourvec (e.trackParticle(i), f)
559 for i
in range(e.nConversions()):
560 cv = e.conversionElementLink(i)
562 fprint (f,
'\n cv: %2d:' % cv.index())
563 dump_Threevec (e.conversion(i).recVertex().position(), f)
564 for i
in range (e.nDetails()):
565 if e.detailElementLink(i).
isValid():
567 fprint (f,
'\n %s: ' % d.className())
568 if isinstance (d, PyAthena.EMConvert):
569 dump_EMConvert (d, f)
570 elif isinstance (d, PyAthena.EMBremFit):
571 dump_EMBremFit (d, f)
572 elif isinstance (d, PyAthena.EMTrackMatch):
573 dump_EMTrackMatch (d, f)
574 elif isinstance (d, PyAthena.EMShower):
576 elif isinstance (d, PyAthena.EMErrorDetail):
577 dump_EMErrorDetail (d, f)
578 elif isinstance (d, PyAthena.EMTrackFit):
579 dump_EMTrackFit (d, f)
583 fprint (f,
'\n Detail link %d not valid; skipped.' % i)
585 pid = PyAthena.egammaPIDObs
587 pid = PyAthena.egammaPID
588 fprint (f,
'\n pid: %g %g %f %g %f %f' %
589 (e.egammaID(pid.ElectronWeight), e.egammaID(pid.BgWeight),
590 e.egammaID(pid.NeuralNet), e.egammaID(pid.Hmatrix),
591 e.egammaID(pid.IsolationLikelihood_jets),
592 e.egammaID(pid.IsolationLikelihood_HQDelectrons)))
◆ dump_egDetailContainer()
| def python.Dumpers.dump_egDetailContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2024 of file Dumpers.py.
2025 fprint (f,
'(Dumped as a part of egamma)')
◆ dump_EL()
| def python.Dumpers.dump_EL |
( |
|
l, |
|
|
|
f |
|
) |
| |
Definition at line 329 of file Dumpers.py.
332 pos2 = nm.rfind (
'>')
333 nm = nm[pos1+1:pos2].strip()
337 nm = nm +
'/%s[%d]' % (l.dataID(), l.index())
◆ dump_Electron()
| def python.Dumpers.dump_Electron |
( |
|
e, |
|
|
|
f |
|
) |
| |
◆ dump_ElectronAssociation()
| def python.Dumpers.dump_ElectronAssociation |
( |
|
a, |
|
|
|
f |
|
) |
| |
Definition at line 3471 of file Dumpers.py.
3472 dump_JetAssociationBase (a, f)
3475 fprint (f, a.getElectronWeight (ele))
3476 dump_Fourvec (ele, f)
◆ dump_ElectronConstituent()
| def python.Dumpers.dump_ElectronConstituent |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1286 of file Dumpers.py.
1288 dump_Fourvec (info.electron(), f)
1289 fprint (f, info.getElectronWeight (info.electron()))
◆ dump_ElectronMuonTopoInfo()
| def python.Dumpers.dump_ElectronMuonTopoInfo |
( |
|
a, |
|
|
|
f |
|
) |
| |
Definition at line 3446 of file Dumpers.py.
3447 fprint (f, a.RoiWord(), a.DeltaPhi(), a.DeltaR(), a.InvMass(),
3448 a.ElecValid(), a.OppositeCharge(), a.VertexState())
◆ dump_EMBremFit()
| def python.Dumpers.dump_EMBremFit |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 379 of file Dumpers.py.
381 iperr = d.bremInvpTerr()
383 if iperr==-999: iperr = 0
386 if br == -999: br = 0
387 if bx == -999: bx = 0
390 if nt == -999: nt = 0
391 if nr == -999: nr = 0
394 if d0 == -999: d0 = 0
395 if phi0 == -999: phi0 = 0
396 fprint (f,
"%f %f %f %f %f %2d %2d %2d %2d %f %f" %
397 (ip*1e6, br, bx, iperr*1e6,
398 d.bremClusterRadius(), d.bremFitStatus(), d.bremErrorFlag(),
400 fprint (f, d.bremZ0(), d.bremDzDr(), d.bremNZ(), d.bremFitChi2())
◆ dump_EMConvert()
| def python.Dumpers.dump_EMConvert |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 375 of file Dumpers.py.
376 fprint (f, d.convTrackMatch(), d.convAngleMatch())
◆ dump_EMErrorDetail()
| def python.Dumpers.dump_EMErrorDetail |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 442 of file Dumpers.py.
443 fprint (f, d.linkIndex())
445 uf(d.EMconvertedphoton_perigee_d0()),
446 uf(d.EMconvertedphoton_perigee_z0()),
447 uf(d.EMconvertedphoton_perigee_phi0()),
448 uf(d.EMconvertedphoton_perigee_theta()),
449 uf(d.EMconvertedphoton_perigee_eta()),
450 uf(d.EMconvertedphoton_perigee_momentum()),
451 uf(d.EMconvertedphoton_perigee_Covd0d0 ()),
452 uf(d.EMconvertedphoton_perigee_Covd0z0 ()),
453 uf(d.EMconvertedphoton_perigee_Covd0phi ()),
454 uf(d.EMconvertedphoton_perigee_Covd0theta ()),
455 uf(d.EMconvertedphoton_perigee_Covz0z0 ()),
456 uf(d.EMconvertedphoton_perigee_Covz0phi ()),
457 uf(d.EMconvertedphoton_perigee_Covz0theta ()),
458 uf(d.EMconvertedphoton_perigee_Covphiphi ()),
459 uf(d.EMconvertedphoton_perigee_Covphitheta ()),
460 uf(d.EMconvertedphoton_perigee_Covthetatheta ()))
462 uf(d.EMtrack_perigee_d0 ()),
463 uf(d.EMtrack_perigee_phi0 ()),
464 uf(d.EMtrack_perigee_z0 ()),
465 uf(d.EMtrack_perigee_theta ()),
466 uf(d.EMtrack_perigee_eta ()),
467 uf(d.EMtrack_perigee_momentum ()),
468 uf(d.EMtrack_perigee_Covd0d0 ()),
469 uf(d.EMtrack_perigee_Covd0z0 ()),
470 uf(d.EMtrack_perigee_Covd0phi ()),
471 uf(d.EMtrack_perigee_Covd0theta ()),
472 uf(d.EMtrack_perigee_Covz0z0 ()),
473 uf(d.EMtrack_perigee_Covz0phi ()),
474 uf(d.EMtrack_perigee_Covz0theta ()),
475 uf(d.EMtrack_perigee_Covphiphi ()),
476 uf(d.EMtrack_perigee_Covphitheta ()),
477 uf(d.EMtrack_perigee_Covthetatheta ()))
479 uf(d.EMphoton_eta ()),
480 uf(d.EMphoton_phi0 ()),
481 uf(d.EMphoton_Eclus ()),
482 uf(d.EMphoton_Covetaeta ()),
483 uf(d.EMphoton_Covetaphi ()),
484 uf(d.EMphoton_CovetaEclus ()),
485 uf(d.EMphoton_Covphiphi ()),
486 uf(d.EMphoton_CovphiEclus ()),
487 uf(d.EMphoton_CovEclusEclus ()))
489 uf(d.EMtrack_comb_Covd0d0 ()),
490 uf(d.EMtrack_comb_Covd0z0 ()),
491 uf(d.EMtrack_comb_Covd0phi ()),
492 uf(d.EMtrack_comb_Covd0eta ()),
493 uf(d.EMtrack_comb_Covd0P ()),
494 uf(d.EMtrack_comb_Covz0z0 ()),
495 uf(d.EMtrack_comb_Covz0phi ()),
496 uf(d.EMtrack_comb_Covz0eta ()),
497 uf(d.EMtrack_comb_Covz0P ()),
498 uf(d.EMtrack_comb_Covphiphi ()),
499 uf(d.EMtrack_comb_Covphieta ()),
500 uf(d.EMtrack_comb_CovphiP ()),
501 uf(d.EMtrack_comb_Covetaeta ()),
502 uf(d.EMtrack_comb_CovetaP ()),
503 uf(d.EMtrack_comb_CovPP ()))
◆ dump_EMShower()
| def python.Dumpers.dump_EMShower |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 410 of file Dumpers.py.
412 if weta1 < -10: weta1 = 0
414 if pos7 < -10: pos7 = 0
416 if not hasattr(d,
'etconoisedR04Sig2'):
417 d.etconoisedR04Sig2 = d.etconoise20
418 d.etconoisedR04Sig3 = d.etconoise30
419 fprint (f, d.e011(), d.e033(), d.ethad1(),
420 d.ethad(), d.ehad1(), d.f1(), d.f3(), d.f1core(), d.f3core(),
421 d.e233(), d.e235(), d.e255(), d.e237(), d.e277(), d.e333(),
422 d.e335(), d.e337(), d.e377(), weta1, d.weta2(), d.e2ts1(),
423 d.e2tsts1(), d.fracs1(), d.widths1(), d.widths2(),
424 d.poscs1(), d.poscs2(), d.asy1(), d.pos(), pos7, d.barys1(),
425 d.wtots1(), d.emins1(), d.emaxs1(), d.etcone(), d.etcone20(),
426 d.etcone30(), d.etcone40(),
427 d.etconoisedR04Sig2(), d.etconoisedR04Sig3(),
429 if hasattr (d,
'e131'):
430 fprint (f, d.e131(), d.e1153(), d.iso())
432 fprint (f, d.e132(), d.e1152(), d.r33over37allcalo())
◆ dump_EmTau_ROI()
| def python.Dumpers.dump_EmTau_ROI |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2949 of file Dumpers.py.
2951 fprint (f,
"%d %f %f %f %f %f %f %d" %
2960 for (n,v)
in zip (m.getThresholdNames(), m.getThresholdValues()):
◆ dump_EMTauResult()
| def python.Dumpers.dump_EMTauResult |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5119 of file Dumpers.py.
5120 dump_ROIBHeader (p.header(), f)
5121 for r
in p.roIVec():
5122 dump_EMTauRoI (r, f)
5123 dump_ROIBTrailer (p.trailer(), f)
◆ dump_EMTauRoI()
| def python.Dumpers.dump_EMTauRoI |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5114 of file Dumpers.py.
5115 fprint (f, p.roIWord())
◆ dump_EMTrackFit()
| def python.Dumpers.dump_EMTrackFit |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 507 of file Dumpers.py.
509 d.track_perigee_d0 (),
510 d.track_perigee_phi0 (),
511 d.track_perigee_qOverP(),
512 d.track_perigee_z0 (),
513 d.track_perigee_theta (),
514 d.track_perigee_Covd0d0 (),
515 d.track_perigee_Covd0z0 (),
516 d.track_perigee_Covd0phi (),
517 d.track_perigee_Covd0theta (),
518 d.track_perigee_Covd0qOverP (),
519 d.track_perigee_Covz0z0 (),
520 d.track_perigee_Covz0phi (),
521 d.track_perigee_Covz0theta (),
522 d.track_perigee_Covz0qOverP (),
523 d.track_perigee_Covphiphi (),
524 d.track_perigee_Covphitheta (),
525 d.track_perigee_CovphiqOverP (),
526 d.track_perigee_Covthetatheta (),
527 d.track_perigee_CovthetaqOverP (),
528 d.track_perigee_CovqOverPqOverP ())
530 d.track_LastM_loc1 (),
531 d.track_LastM_loc2 (),
532 d.track_LastM_phi (),
533 d.track_LastM_theta (),
534 d.track_LastM_qOverP (),
535 d.bremTrackAuthor (),
541 d.bremMaterialTraversed (),
◆ dump_EMTrackMatch()
| def python.Dumpers.dump_EMTrackMatch |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 403 of file Dumpers.py.
404 fprint (f,
"%f %f %4d %4d" %
405 (d.deltaEta(2), d.deltaPhi(2),
406 d.trackNumber(), d.tracksInBroadWindow()))
407 fprint (f, d.trackRefit(), d.isPrimary())
◆ dump_EnergyLoss()
| def python.Dumpers.dump_EnergyLoss |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 604 of file Dumpers.py.
608 fprint (f, p.deltaE(), p.sigmaDeltaE(), p.sigmaMinusDeltaE(), p.sigmaPlusDeltaE())
609 fprint (f, p.meanIoni(), p.sigmaIoni(), p.meanRad(), p.sigmaRad(), p.length())
◆ dump_EnergySum_ROI()
| def python.Dumpers.dump_EnergySum_ROI |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2986 of file Dumpers.py.
2987 fprint (f,
"%d %d %d %f %f %f %f %f %d %d %d %d %d %d" %
3000 m.getThrPatSummET(),
3001 m.getThrPatMissET()))
3002 fprint (f, [t
for t
in m.getThresholds()])
◆ dump_EventBookkeeper()
| def python.Dumpers.dump_EventBookkeeper |
( |
|
p, |
|
|
|
f, |
|
|
|
level = 0 |
|
) |
| |
Definition at line 5244 of file Dumpers.py.
5245 fprint (f, p.getName(), p.getDescription(), p.getInputStream(), p.getOutputStream(), p.getLogic(), p.getNAcceptedEvents(), p.getNWeightedAcceptedEvents(), p.getCycle())
5246 for c
in list(p.getChildrenEventBookkeepers()):
5247 fprint (f,
'\n ' + (
' '*level))
5248 dump_EventBookkeeper (c, f, level+1)
◆ dump_EventID()
| def python.Dumpers.dump_EventID |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 2689 of file Dumpers.py.
2690 fprint (f,
'%9d %9d %9d %9d %9d %9d' %
2694 e.time_stamp_ns_offset(),
2696 e.bunch_crossing_id()))
◆ dump_EventInfo()
| def python.Dumpers.dump_EventInfo |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 2714 of file Dumpers.py.
2715 fprint (f, e.clID())
2716 dump_EventID (e.event_ID(), f)
2718 fprint (f, e.actualInteractionsPerCrossing(), e.averageInteractionsPerCrossing())
2719 for i
in range(ROOT.EventInfo.nDets):
2720 fprint (f,
'\n det', i, e.eventFlags(i), e.errorState(i))
2722 dump_EventType (e.event_type(), f)
2724 dump_TriggerInfo (e.trigger_info(), f)
◆ dump_EventStreamInfo()
| def python.Dumpers.dump_EventStreamInfo |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 2737 of file Dumpers.py.
2738 fprint (f,
'nevents: ', e.getNumberOfEvents())
2741 fprint (f,
'\nproc tags: ',
list(e.getProcessingTags()))
2742 fprint (f,
'\nitem list: ',
formatItemUsingLong([(p.first, p.second)
for p
in e.getItemList()]))
2743 for typ
in list(e.getEventTypes()):
2745 dump_EventType (typ, f)
◆ dump_EventType()
| def python.Dumpers.dump_EventType |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 2700 of file Dumpers.py.
2701 fprint (f, e.typeToString(), e.user_type(), e.mc_event_weight())
◆ dump_ExtendedVxCandidate()
| def python.Dumpers.dump_ExtendedVxCandidate |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 3633 of file Dumpers.py.
3634 dump_VxCandidate1 (c, f)
3636 if c.fullCovariance():
3637 dump_AmgMatrix (c.fullCovariance(), f)
◆ dump_FitQuality()
| def python.Dumpers.dump_FitQuality |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1436 of file Dumpers.py.
1438 fprint (f,
'(null)')
1440 fprint (f,
'%f %f' % (info.chiSquared(), info.doubleNumberDoF()))
◆ dump_Fourvec()
| def python.Dumpers.dump_Fourvec |
( |
|
v, |
|
|
|
f, |
|
|
|
parens = 1 |
|
) |
| |
Definition at line 233 of file Dumpers.py.
234 ParticleImpl_EEtaPhiM = getattr(PyAthena,
'ParticleImpl<NavigableTerminalNode,P4ImplEEtaPhiM,ParticleEvent::Base>')
238 if isinstance(v, (PyAthena.P4EEtaPhiMBase, ParticleImpl_EEtaPhiM, PyAthena.xAOD.IParticle))
or \
239 isinstance(vmom, PyAthena.P4BaseEEtaPhiM):
246 elif isinstance (v, PyAthena.P4PtEtaPhiMBase)
or \
247 isinstance (vmom, PyAthena.P4BasePtEtaPhiM):
251 elif isinstance (v, PyAthena.P4IPtCotThPhiMBase)
or \
252 isinstance (vmom, PyAthena.P4BaseIPtCotThPhiM):
258 if ipt == 0
and m == 0
and cotth == 0
and v.phi() == 0:
262 aux = math_hypot(1, cotth)
263 eta = math_log ((aux-cotth) / (aux+cotth))
272 m2 = v.e()**2 - v.px()**2 - v.py()**2 - v.pz()**2
274 m = - math_sqrt (-m2)
279 pt = math_hypot (v.px(), v.py())
286 eta = asinh (v.pz() / pt)
289 if parens: fprint (f,
'(')
290 fprint (f,
"%f %f %f %f" % (pt, eta, v.phi(), m))
291 if parens: fprint (f,
')')
◆ dump_GbbNNTagInfo()
| def python.Dumpers.dump_GbbNNTagInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1256 of file Dumpers.py.
1257 dump_BaseTagInfo (info, f)
1258 fprint (f, info.nMatchingTracks(), info.trkJetWidth(),
1259 info.trkJetMaxDeltaR())
◆ dump_GenericResult()
| def python.Dumpers.dump_GenericResult |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3026 of file Dumpers.py.
3027 fprint (f,
"%d %d %d" %
◆ dump_GenEvent()
| def python.Dumpers.dump_GenEvent |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 2894 of file Dumpers.py.
2895 fprint (f,
'%d %d %f %f %f %d %d' %
2903 fprint (f,
'\n wt', [w
for w
in e.weights()], \
2908 dump_GenVertex (sv, f)
2913 dump_GenVertex (v, f)
2920 dump_GenParticle (p, f)
◆ dump_GenParticle()
| def python.Dumpers.dump_GenParticle |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2855 of file Dumpers.py.
2856 fprint (f,
"%d %5s %d %d" %
2858 PDG.pdgid_to_name(p.pdg_id()),
2859 p.parent_event().event_number(),
2861 if p.production_vertex():
2862 s =
str(_gen_barcode (p.production_vertex())) +
'('
2863 parts = genvertex_in_barcodes (p.production_vertex())
2864 for bc
in parts: s +=
'%d ' % bc
2865 if len(parts) > 3: s +=
'...'
2871 s = str (_gen_barcode (p.end_vertex())) +
'(->'
2872 parts = genvertex_out_barcodes (p.end_vertex())
2873 for bc
in parts: s +=
'%d ' % bc
2874 if len(parts) > 3: s +=
'...'
2879 dump_HLV (p.momentum(), f)
2880 if hasattr (p,
'polarization'):
2881 pol = p.polarization()
2882 poltheta = fix_neg0 (pol.theta())
2883 fprint (f,
"%f %f" % (poltheta, pol.phi()))
2884 if pol.normal3d().theta() != 0
or pol.normal3d().phi() != 0:
2885 fprint (f,
"%f %f" %
2886 (pol.normal3d().theta(), pol.normal3d().phi()))
2888 poltheta = fix_neg0 (
_gen_attr(p,
'theta', float))
2890 fprint (f,
"%f %f" % (poltheta, polphi))
◆ dump_GenVertex()
| def python.Dumpers.dump_GenVertex |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 2828 of file Dumpers.py.
2829 fprint (f,
"%d %d %d %d %d" %
2830 (v.status()
if hasattr(v,
'status')
else v.id(),
2832 v.parent_event().event_number(),
2835 dump_Threevec (v.position(), f)
2836 fprint (f,
'%f ' % v.position().
t())
2837 if not hasattr(v,
'weights'):
2839 elif v.weights().
size() == 0:
2842 ww =
list(v.weights())
2843 fprintln (f, [w
for w
in ww])
◆ dump_H3V()
| def python.Dumpers.dump_H3V |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 203 of file Dumpers.py.
204 fprint (f,
"(%f %f %f)" %
205 (v.perp(),v.eta(),v.phi()))
◆ dump_HepMcParticleLink()
| def python.Dumpers.dump_HepMcParticleLink |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4246 of file Dumpers.py.
4247 fprint (f, p.barcode(), p.eventIndex())
◆ dump_HLTAODConfigData()
| def python.Dumpers.dump_HLTAODConfigData |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 3152 of file Dumpers.py.
3155 for c
in d.getChainList().
chains():
3157 dump_HLTChain (c, f)
3158 for c
in d.getSequenceList().sequences():
3160 dump_HLTSequence (c, f)
◆ dump_HLTChain()
| def python.Dumpers.dump_HLTChain |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 3121 of file Dumpers.py.
3122 fprint (f, c.chain_name(),
3126 c.lower_chain_name(),
3127 c.lower_chain_counter(),
3131 c.lower_chain_hash_id())
3132 for s
in c.signatureList():
3133 dump_HLTSignature (s, f)
3134 fprint (f, [t.bit()
for t
in c.triggerTypeList()])
3135 for s
in c.streamTagList():
3136 dump_HLTStreamTag (s, f)
3137 fprint (f, [s
for s
in c.groupList()])
◆ dump_HLTResult()
| def python.Dumpers.dump_HLTResult |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3035 of file Dumpers.py.
3036 dump_GenericResult (t, f)
3037 fprint (f,
"%d %d %d %d %d %d %d %d %d %d %d %d" %
3038 (t.getHLTResultClassVersion(),
3041 t.getHLTStatus().code,
3042 t.getLvlConverterStatus().code,
3045 t.getNumOfSatisfiedSigs(),
3046 t.isCreatedOutsideHLT(),
3047 t.isHLTResultTruncated(),
3051 fprint (f, [i
for i
in t.partSizes()])
3052 fprint (f, [i
for i
in t.getNavigationResult()])
3053 fprint (f, [i
for i
in t.getChainResult()])
3054 fprint (f, [i
for i
in t.getNavigationResultCuts()])
◆ dump_HLTResultMT()
| def python.Dumpers.dump_HLTResultMT |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 3059 of file Dumpers.py.
3060 fprint (f,
'version', p.getVersion())
3061 fprint (f,
'\n streamtags',
list(p.getStreamTags()))
3064 fprint (f,
'\n hltbits',
list(p.getHltBitsAsWords()))
3065 fprint (f,
'\n data size', p.getSerialisedData().
size())
3067 fprint (f,
'\n status',
list(p.getStatus()))
3068 fprint (f,
'\n trunc', p.severeTruncation(),
list(p.getTruncatedModuleIds()))
◆ dump_HLTSequence()
| def python.Dumpers.dump_HLTSequence |
( |
|
s, |
|
|
|
f |
|
) |
| |
Definition at line 3141 of file Dumpers.py.
3143 dump_HLTTriggerElement (s.outputTE(), f)
3144 dump_HLTTriggerElement (s.topoStartTE(), f)
3145 for t
in s.inputTEs():
3146 dump_HLTTriggerElement (t, f)
3147 fprint (f, [a
for a
in s.algorithms()],
')')
◆ dump_HLTSignature()
| def python.Dumpers.dump_HLTSignature |
( |
|
s, |
|
|
|
f |
|
) |
| |
Definition at line 3102 of file Dumpers.py.
3103 fprint (f,
'(', s.signature_counter(),
3106 for e
in s.outputTEs():
3107 dump_HLTTriggerElement (e, f)
◆ dump_HLTStreamTag()
| def python.Dumpers.dump_HLTStreamTag |
( |
|
s, |
|
|
|
f |
|
) |
| |
◆ dump_HLTTriggerElement()
| def python.Dumpers.dump_HLTTriggerElement |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 3097 of file Dumpers.py.
3098 fprint (f, e.id(), e.name())
◆ dump_HLV()
| def python.Dumpers.dump_HLV |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 208 of file Dumpers.py.
209 m2 = v.e()**2 - v.px()**2 - v.py()**2 - v.pz()**2
211 m2 = fix_neg0 (m2, 1e-3)
213 m = - math_sqrt (-m2)
219 pt = math_hypot (v.px(), v.py())
226 eta = asinh (v.pz() / pt)
228 fprint (f,
"(%f %f %f %f)" %
229 (v.perp(),eta,v.phi(), m))
◆ dump_IDC()
| def python.Dumpers.dump_IDC |
( |
|
payload_dumper, |
|
|
|
p, |
|
|
|
f, |
|
|
|
extra_idc_dumper = None |
|
) |
| |
Definition at line 4663 of file Dumpers.py.
4663 def dump_IDC (payload_dumper, p, f, extra_idc_dumper = None):
4666 if hasattr(beg.__class__,
'__preinc__'):
4667 nextfunc = beg.__preinc__
4668 elif hasattr(beg.__class__,
'__next__'):
4669 nextfunc = beg.__next__
4674 if hasattr (coll,
'identifyHash'):
4675 hash = coll.identifyHash().
value()
4677 hash = coll.identifierHash().
value()
4678 fprint (f,
'IDC', beg.hashId().
value(), hash, coll.size())
4679 if hasattr (coll,
'type'):
4680 fprint (f, coll.type())
4681 if extra_idc_dumper:
4682 extra_idc_dumper (coll, f)
4685 payload_dumper (x, f)
◆ dump_IDCInDetBSErrContainer()
| def python.Dumpers.dump_IDCInDetBSErrContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1756 of file Dumpers.py.
1757 for x
in p.getAll():
1758 fprint (f,
'\n ', x.first, x.second)
◆ dump_IdentContIndex()
| def python.Dumpers.dump_IdentContIndex |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4515 of file Dumpers.py.
4516 fprint (f, p.collHash(), p.objIndex())
◆ dump_INav4MomAssocs()
| def python.Dumpers.dump_INav4MomAssocs |
( |
|
a, |
|
|
|
f |
|
) |
| |
Definition at line 3437 of file Dumpers.py.
3438 return dump_Assocs (a, f, PyAthena.DataVector(PyAthena.INavigable4Momentum))
◆ dump_InDetLowBetaCandidate()
| def python.Dumpers.dump_InDetLowBetaCandidate |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4367 of file Dumpers.py.
4368 if p == InDetLowBetaCandidateNull:
4369 fprint (f,
'(null)')
4371 if hasattr (p,
'getTRTInverseBeta'):
4372 fprint (f, p.getTRTCorrBitsOverThreshold(),
4373 p.getTRTInverseBeta(),
4374 p.getTRTInverseBetaError(),
4375 p.getTRTNLastBits())
4377 fprint (f, p.getTRTCorrBitsOverThreshold(),
4378 p.getTRTTrailingEdge(),
4379 p.getTRTTrailingEdgeError(),
4380 p.getTRTNLastBits())
4381 others = (p.getTRTdEdx(),
4382 p.getTRTLikelihoodBeta(),
4383 p.getTRTLikelihoodError(),
4384 p.getTRTHighTbits(),)
4385 if max(others)!=0
or min(others) != 0:
4386 for o
in others: fprint (f, o)
◆ dump_InDetRawData()
| def python.Dumpers.dump_InDetRawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4640 of file Dumpers.py.
4641 fprint (f, p.identify().getString(), p.getWord())
◆ dump_InDetSimData()
| def python.Dumpers.dump_InDetSimData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2055 of file Dumpers.py.
2057 fprint (f,
'(null)')
2059 fprint (f, p.word())
2060 for d
in p.getdeposits():
2062 dump_HepMcParticleLink (d.first, f)
2063 fprint (f, d.second)
◆ dump_InDetSimDataCollection()
| def python.Dumpers.dump_InDetSimDataCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2068 of file Dumpers.py.
2069 getData = ROOT.InDetSimDataHelpers.getData
2070 for id
in ROOT.InDetSimDataHelpers.identifiers(p):
2071 fprint (f,
'\n ', id.getString())
2072 dump_InDetSimData (getData (p, id), f)
◆ dump_InDetTime()
| def python.Dumpers.dump_InDetTime |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1750 of file Dumpers.py.
1751 fprint (f, p.first, p.second)
◆ dump_IPInfoBase()
| def python.Dumpers.dump_IPInfoBase |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1112 of file Dumpers.py.
1113 dump_BaseTagInfo (info, f)
1114 fprint (f, info.nbTracks())
◆ dump_IPInfoPlus()
| def python.Dumpers.dump_IPInfoPlus |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1103 of file Dumpers.py.
1104 dump_BaseTagInfo (info, f)
1105 fprint (f,
' %d' % info.numTrackInfo())
1106 for i
in range(info.numTrackInfo()):
1108 dump_IPTrackInfo (info.getTrackInfo(i), f)
◆ dump_IPTrackInfo()
| def python.Dumpers.dump_IPTrackInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1088 of file Dumpers.py.
1089 dump_Fourvec (info.track(), f)
1090 fprint (f,
' %d %s %d %f %f %f %f %f %f %f' %
1091 (info.trackGrade().gradeNumber(),
1092 info.trackGrade().gradeString(),
1095 info.d0Significance(),
1097 info.z0Significance(),
1098 info.trackWeight2D(),
1099 info.trackWeight3D(),
1100 info.trackProbJP()))
◆ dump_IsoMuonFeature()
| def python.Dumpers.dump_IsoMuonFeature |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4306 of file Dumpers.py.
4308 fprint (f,
'\n ', m.getEtInnerConeEC(), m.getEtOuterConeEC(),
4309 m.getEtInnerConeHC(), m.getEtOuterConeHC())
4310 fprint (f,
'\n ', m.getNTracksCone(), m.getSumPtTracksCone(),
4311 m.getPtMuTracksCone())
4312 fprint (f,
'\n ', m.getRoiIdMu(), m.getPtMu(), m.getEtaMu(),
4313 m.getPhiMu(), m.getLArWeight(), m.getTileWeight())
◆ dump_ISvxAssociation()
| def python.Dumpers.dump_ISvxAssociation |
( |
|
a, |
|
|
|
f |
|
) |
| |
Definition at line 3509 of file Dumpers.py.
3510 dump_JetAssociationBase (a, f)
3513 for v
in vi.vertices():
3514 dump_Threevec (v.position(), f)
◆ dump_ITrackLink()
| def python.Dumpers.dump_ITrackLink |
( |
|
l, |
|
|
|
f |
|
) |
| |
Definition at line 2578 of file Dumpers.py.
2582 pm = trk.trackParameters()
2583 if pm
and len(pm) > 0:
2585 dump_parameters (perigee, f)
◆ dump_JEMEtSums()
| def python.Dumpers.dump_JEMEtSums |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5036 of file Dumpers.py.
5037 fprint (f, p.crate(), p.module(), p.peak(),
5038 formatItemUsingLong (
list(p.EtVec())),
5039 formatItemUsingLong (
list(p.ExVec())),
5040 formatItemUsingLong (
list(p.EyVec())))
◆ dump_JEMHits()
| def python.Dumpers.dump_JEMHits |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5044 of file Dumpers.py.
5045 fprint (f, p.crate(), p.module(), p.peak(),
5046 formatItemUsingLong (
list(p.JetHitsVec())))
◆ dump_JEMRoI()
| def python.Dumpers.dump_JEMRoI |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5050 of file Dumpers.py.
5051 fprint (f, p.roiWord())
◆ dump_Jet()
| def python.Dumpers.dump_Jet |
( |
|
j, |
|
|
|
f |
|
) |
| |
Definition at line 3521 of file Dumpers.py.
3522 if j.e() == 0
and j.phi() == 0
and j.eta() == 0:
3523 with signalstate (j, PyAthena.P4SignalState.JETEMSCALE):
3524 dump_ParticleImpl (j, f)
3526 dump_ParticleImpl (j, f)
3527 fprint (f,
'\n %s %f' %
3529 j.getFlavourTagWeight(),))
3531 tower_constituents_p =
False
3532 if j.firstConstituent() != j.lastConstituent():
3533 if isinstance (j.getContainer(j.firstConstituent()),
3534 PyAthena.CaloTowerContainer):
3535 tower_constituents_p =
True
3536 elif j.firstConstituent().__deref__():
3537 ss =
asint(j.constituentSignalState())
3538 j.setConstituentSignalState (PyAthena.P4SignalState.CALIBRATED)
3539 dump_HLV (j.constituent_sum4Mom(), f)
3540 j.setConstituentSignalState (ss)
3541 fprint (f, [x
for x
in j.combinedLikelihood()])
3542 fprint (f,
'\n moms ')
3543 for mk
in j.getMomentKeys():
3544 if mk
in [
'Timing',
'LArQuality']:
continue
3545 mom = j.getMoment (mk,
False)
3547 fprint (f, mk, j.getMoment (mk,
True))
3548 if hasattr(j,
'getJetTime'):
3549 fprint (f,
'\n timing ', j.getJetTime(),
3550 ' qual ', j.getJetQuality())
3552 fprint (f,
'\n timing ', j.getMoment(
'Timing',
True),
3553 ' qual ', j.getMoment(
'LArQuality',
True))
3554 fprint (f,
'\n assoc ')
3555 for ak
in j.getAssociationKeys():
3556 ass = j.getAssociationBase(ak)
3557 if ass == jetAssocNull :
continue
3558 fprint (f,
'\n ', ak)
3559 if isinstance (ass, PyAthena.Analysis.ElectronAssociation):
3560 dump_ElectronAssociation (ass, f)
3561 elif isinstance (ass, PyAthena.Analysis.PhotonAssociation):
3562 dump_PhotonAssociation (ass, f)
3563 elif isinstance (ass, PyAthena.Analysis.MuonAssociation):
3564 dump_MuonAssociation (ass, f)
3565 elif isinstance (ass, PyAthena.Analysis.TrackAssociation):
3566 dump_TrackAssociation (ass, f)
3567 elif isinstance (ass, PyAthena.Analysis.ISvxAssociation):
3568 dump_ISvxAssociation (ass, f)
3571 ti = j.jetTagInfoVector()
3572 fprint (f,
'\n tag info:')
3576 ti.sort (key=_infoType)
3579 fprint (f,
'\n (null)')
3581 fprint (f,
'\n %s %s: %f: '
3582 % (info.infoType(),
typename(info.__class__), j.getFlavourTagWeight (info.infoType())))
3583 if isinstance (info, PyAthena.Analysis.TruthInfo):
3584 dump_TruthInfo (info, f)
3585 elif isinstance (info, PyAthena.Analysis.SoftLeptonTruthInfo):
3586 dump_SoftLeptonTruthInfo (info, f)
3587 elif isinstance (info, PyAthena.Analysis.SecVtxInfo):
3588 dump_SecVtxInfo (info, f)
3589 elif isinstance (info, PyAthena.Analysis.IPInfoPlus):
3590 dump_IPInfoPlus (info, f)
3591 elif isinstance (info, PyAthena.Analysis.IPInfoBase):
3592 dump_IPInfoBase (info, f)
3593 elif isinstance (info, PyAthena.Analysis.SVInfoBase):
3594 dump_SVInfoBase (info, f)
3595 elif isinstance (info, PyAthena.Analysis.SVInfoPlus):
3596 dump_SVInfoPlus (info, f)
3597 elif isinstance (info, PyAthena.Analysis.MultiSVInfoPlus):
3598 dump_MultiSVInfoPlus (info, f)
3599 elif isinstance (info, PyAthena.Analysis.JetProbInfoBase):
3600 dump_JetProbInfoBase (info, f)
3601 elif isinstance (info, PyAthena.Analysis.SoftElectronInfo):
3602 dump_SoftElectronInfo (info, f)
3603 elif isinstance (info, PyAthena.Analysis.JetFitterTagInfo):
3604 dump_JetFitterTagInfo (info, f)
3605 elif (hasattr (PyAthena.Analysis,
'TrackCountingInfo')
and
3606 isinstance (info, PyAthena.Analysis.TrackCountingInfo)):
3607 dump_TrackCountingInfo (info, f)
3608 elif isinstance (info, PyAthena.Analysis.AtlfInfo):
3609 dump_AtlfInfo (info, f)
3610 elif isinstance (info, PyAthena.Analysis.SoftMuonInfo):
3611 dump_SoftMuonInfo (info, f)
3612 elif info.__class__
is PyAthena.Analysis.BaseTagInfo:
3613 dump_BaseTagInfo (info, f)
3614 elif info.__class__
is PyAthena.Analysis.GbbNNTagInfo:
3615 dump_GbbNNTagInfo (info, f)
3618 if tower_constituents_p:
3619 fprint (f,
'\n (not dumping tower constituents)')
3621 fprint (f,
'\n constituents:')
3622 for c
in toiter (j.firstConstituent(), j.lastConstituent()):
3628 fprint (f, j.getWeight (c))
◆ dump_Jet_ROI()
| def python.Dumpers.dump_Jet_ROI |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2965 of file Dumpers.py.
2967 fprint (f,
"%d %d %f %f %f" %
2973 for (n,v)
in zip (m.getThresholdNames(), m.getThresholdValues()):
◆ dump_JetAssociationBase()
| def python.Dumpers.dump_JetAssociationBase |
( |
|
a, |
|
|
|
f |
|
) |
| |
◆ dump_JetConstituent()
| def python.Dumpers.dump_JetConstituent |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1263 of file Dumpers.py.
1264 fprint (f, [info.energyInSample(i)
for i
in range(8)],
1265 info.energyInCryostat(), info.wtCryo(), info.jet())
◆ dump_JetElement()
| def python.Dumpers.dump_JetElement |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5055 of file Dumpers.py.
5056 fprint (f, p.eta(), p.phi(), p.key(), p.peak(),
5057 list(p.emEnergyVec()),
5058 list(p.hadEnergyVec()),
5059 list(p.emErrorVec()),
5060 list(p.hadErrorVec()),
5061 list(p.linkErrorVec()))
◆ dump_JetEnergyResult()
| def python.Dumpers.dump_JetEnergyResult |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5106 of file Dumpers.py.
5107 dump_ROIBHeader (p.header(), f)
5108 for r
in p.roIVec():
5109 dump_JetEnergyRoI (r, f)
5110 dump_ROIBTrailer (p.trailer(), f)
◆ dump_JetEnergyRoI()
| def python.Dumpers.dump_JetEnergyRoI |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5101 of file Dumpers.py.
5102 fprint (f, p.roIWord())
◆ dump_JetET_ROI()
| def python.Dumpers.dump_JetET_ROI |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2978 of file Dumpers.py.
2979 fprint (f,
"%d %d" %
2981 m.getThrPattern(),))
2982 fprint (f, [t
for t
in m.getThresholds()])
◆ dump_JetFitterTagInfo()
| def python.Dumpers.dump_JetFitterTagInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1205 of file Dumpers.py.
1206 dump_BaseTagInfo (info, f)
1207 fprint (f,
'%d %d %d %f %f %f %f %f' %
1209 info.nSingleTracks(),
1210 info.nTracksAtVtx(),
1211 info.energyFraction(),
1213 info.significance3d(),
◆ dump_JetKeyDescriptorCollection()
| def python.Dumpers.dump_JetKeyDescriptorCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2036 of file Dumpers.py.
2037 fprint (f,
'(Dumped as a part of jets)')
◆ dump_JetMomentMapCollection()
| def python.Dumpers.dump_JetMomentMapCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2030 of file Dumpers.py.
2031 fprint (f,
'(Dumped as a part of jets)')
◆ dump_JetProbInfoBase()
| def python.Dumpers.dump_JetProbInfoBase |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1182 of file Dumpers.py.
1183 dump_BaseTagInfo (info, f)
1184 fprint (f, info.nbTracks())
◆ dump_L1DataBaseclass()
| def python.Dumpers.dump_L1DataBaseclass |
( |
|
c, |
|
|
|
f |
|
) |
| |
◆ dump_L1TopoRDO()
| def python.Dumpers.dump_L1TopoRDO |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5127 of file Dumpers.py.
5128 fprint (f, p.getSourceID(),
5129 list(p.getErrors()),
5130 list(p.getDataWords()),
5131 list(p.getStatusWords()))
◆ dump_L1TopoResult()
| def python.Dumpers.dump_L1TopoResult |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5135 of file Dumpers.py.
5136 dump_ROIBHeader (p.header(), f)
5137 dump_L1TopoRDO (p.rdo(), f)
5138 dump_ROIBTrailer (p.trailer(), f)
◆ dump_LArDigit()
| def python.Dumpers.dump_LArDigit |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5225 of file Dumpers.py.
5226 fprint (f, p.channelID().getString(), p.gain(),
list(p.samples()))
◆ dump_LArFebErrorSummary()
| def python.Dumpers.dump_LArFebErrorSummary |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2042 of file Dumpers.py.
2043 for x
in p.get_all_febs():
2044 fprint (f,
'\n ', x.first, x.second)
◆ dump_LArFebHeader()
| def python.Dumpers.dump_LArFebHeader |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1773 of file Dumpers.py.
1774 fprint (f,
'feb', p.FEBId().getString(), p.FebELVL1Id(), p.FebBCId(),
1775 'febh', p.FormatVersion(), p.SourceId(),
1776 p.RunNumber(), p.ELVL1Id(), p.BCId(), p.LVL1TigType(),
1778 'dsp', p.DspCodeVersion(), p.DspEventCounter(),
1779 'res', p.RodResults1Size(), p.RodResults2Size(), p.RodRawDataSize(),
1780 p.NbSamples(), p.NbSweetCells1(), p.NbSweetCells2(),
1781 p.OnlineChecksum(), p.OfflineChecksum(), p.RodStatus(),
1783 list(p.FebCtrl1()),
list(p.FebCtrl2()),
list(p.FebCtrl3()))
◆ dump_LArHit()
| def python.Dumpers.dump_LArHit |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4234 of file Dumpers.py.
4235 fprint (f, t.cellID().getString(), t.energy(), t.time())
◆ dump_LArNoisyROSummary()
| def python.Dumpers.dump_LArNoisyROSummary |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4391 of file Dumpers.py.
4392 fprintln (f,
' noisy febs', [id.getString()
for id
in p.get_noisy_febs()])
◆ dump_LArRawChannel()
| def python.Dumpers.dump_LArRawChannel |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1787 of file Dumpers.py.
1788 fprint (f, p.identify().getString(), p.energy(), p.time(),
1789 p.quality(), p.provenance(), p.gain())
◆ dump_LArTTL1()
| def python.Dumpers.dump_LArTTL1 |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2093 of file Dumpers.py.
2094 fprint (f, p.ttOnlineID().getString(), p.ttOfflineID().getString(),
◆ dump_LineSaggingDescriptor()
| def python.Dumpers.dump_LineSaggingDescriptor |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1507 of file Dumpers.py.
1508 os = ROOT.ostringstream()
1510 s = os.str().replace (
'\n',
';')
◆ dump_LinkToTrack()
| def python.Dumpers.dump_LinkToTrack |
( |
|
l, |
|
|
|
f |
|
) |
| |
Definition at line 2589 of file Dumpers.py.
2590 dump_ITrackLink (l, f)
2591 fprint (f,
'\n ', l.isValid(), l.index(), l.dataID())
◆ dump_LinkToTrackParticleBase()
| def python.Dumpers.dump_LinkToTrackParticleBase |
( |
|
l, |
|
|
|
f |
|
) |
| |
Definition at line 2595 of file Dumpers.py.
2596 dump_ITrackLink (l, f)
2597 fprint (f, l.isValid(), l.index(), l.dataID())
◆ dump_list()
| def python.Dumpers.dump_list |
( |
|
l, |
|
|
|
f, |
|
|
|
dumper, |
|
|
|
nmax = None |
|
) |
| |
Definition at line 5712 of file Dumpers.py.
5712 def dump_list (l, f, dumper, nmax = None):
5715 if nmax
is not None and i >= nmax:
break
◆ dump_LocalParameters()
| def python.Dumpers.dump_LocalParameters |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1627 of file Dumpers.py.
1628 dump_AmgVector (p, f)
1629 fprint (f, p.parameterKey())
◆ dump_LUCID_RawData()
| def python.Dumpers.dump_LUCID_RawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5170 of file Dumpers.py.
5171 fprint (f, p.getStatus(),
5172 p.getWord0(), p.getWord1(), p.getWord2() , p.getWord3(),
5173 p.getWord0p(), p.getWord1p(), p.getWord2p(), p.getWord3p(),
5174 p.getWord0n(), p.getWord1n(), p.getWord2n(), p.getWord3n())
◆ dump_LVL1_ROI()
| def python.Dumpers.dump_LVL1_ROI |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3007 of file Dumpers.py.
3008 for m
in t.getMuonROIs():
3010 dump_Muon_ROI (m, f)
3011 for m
in t.getEmTauROIs():
3013 dump_EmTau_ROI (m, f)
3014 for m
in t.getJetROIs():
3017 for m
in t.getJetEtROIs():
3019 dump_JetET_ROI (m, f)
3020 for m
in t.getEnergySumROIs():
3022 dump_EnergySum_ROI (m, f)
◆ dump_Lvl1AODConfigData()
| def python.Dumpers.dump_Lvl1AODConfigData |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 3193 of file Dumpers.py.
3194 fprint (f, d.masterKey())
3195 fprint (f,
'\nit', [s
for s
in d.getItems()])
3196 fprint (f,
'\nmu', [s
for s
in d.getMuonThresholds()])
3197 fprint (f,
'\nem', [s
for s
in d.getEMTauThresholds()])
3198 fprint (f,
'\njt', [s
for s
in d.getJetThresholds()])
3199 fprint (f,
'\nfj', [s
for s
in d.getForwardJetThresholds()])
3200 fprint (f,
'\net', [s
for s
in d.getTotalEtThresholds()])
3201 fprint (f,
'\nje', [s
for s
in d.getJetEtThresholds()])
3202 fprint (f,
'\nms', [s
for s
in d.getMissingEtThresholds()])
3205 dump_CTPConfig (d.ctpConfig(), f)
3209 if d.thresholdConfig():
3210 fprint (f, d.thresholdConfig())
◆ dump_Lvl1AODPrescaleConfigData()
| def python.Dumpers.dump_Lvl1AODPrescaleConfigData |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 3217 of file Dumpers.py.
3218 fprint (f, d.masterKey())
3219 fprint (f, [i
for i
in d.getPrescales()])
◆ dump_Lvl1Result()
| def python.Dumpers.dump_Lvl1Result |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3073 of file Dumpers.py.
3074 fprint (f, t.isConfigured(),
3076 t.anyActiveL1ItemAfterVeto(),
3078 fprint (f,
'\n ', [i
for i
in t.itemsPassed()])
3079 fprint (f,
'\n ', [i
for i
in t.itemsBeforePrescale()])
3080 fprint (f,
'\n ', [i
for i
in t.itemsAfterPrescale()])
3081 fprint (f,
'\n ', [i
for i
in t.itemsAfterVeto()])
◆ dump_materialeffects()
| def python.Dumpers.dump_materialeffects |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2215 of file Dumpers.py.
2217 fprint (f,
'(null)')
2220 fprint (f, nm +
': ')
2221 if nm ==
'Trk::MaterialEffectsOnTrack':
2222 dump_MaterialEffectsOnTrack (p, f)
◆ dump_MaterialEffectsBase()
| def python.Dumpers.dump_MaterialEffectsBase |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2193 of file Dumpers.py.
2194 fprint (f, p.dumpType(), p.thicknessInX0())
2195 dump_associatedSurface (p, f)
◆ dump_MaterialEffectsOnTrack()
| def python.Dumpers.dump_MaterialEffectsOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2208 of file Dumpers.py.
2209 dump_MaterialEffectsBase (p, f)
2210 dump_ScatteringAngles (p.scatteringAngles(), f)
2211 dump_EnergyLoss (p.energyLoss(), f)
◆ dump_MdtAmtHit()
| def python.Dumpers.dump_MdtAmtHit |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5407 of file Dumpers.py.
5408 fprint (f, p.tdcId(), p.channelId(), p.leading(), p.coarse(), p.fine(),
5409 p.width(), p.isMasked(),
list(p.dataWords()))
◆ dump_MdtCsmContainer()
| def python.Dumpers.dump_MdtCsmContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5413 of file Dumpers.py.
5414 dump_IDC (dump_MdtAmtHit, p, f,
5415 extra_idc_dumper =
lambda p, f: \
5416 fprint (f, p.identify().getString(),
5417 p.SubDetId(), p.MrodId(), p.CsmId()))
◆ dump_MdtDriftCircleOnTrack()
| def python.Dumpers.dump_MdtDriftCircleOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1679 of file Dumpers.py.
1680 dump_RIO_OnTrack (p, f)
1681 dump_AmgVector (p.globalPosition(), f, thresh=1e-8)
1682 dump_EL (p.prepRawDataLink(), f)
1683 fprint (f, p.status(), p.localAngle(), p.positionAlongWire())
1685 fprint (f, p.detectorElement().identifyHash().
value())
1686 dump_StraightLineSurface (p.associatedSurface(), f)
◆ dump_MdtPrepData()
| def python.Dumpers.dump_MdtPrepData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4585 of file Dumpers.py.
4586 dump_MuonCluster (p, f)
4587 fprint (f, p.tdc(), p.adc(), p.status())
4588 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_MdtPrepDataContainer()
| def python.Dumpers.dump_MdtPrepDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4729 of file Dumpers.py.
4730 dump_IDC (dump_MdtPrepData, p, f)
◆ dump_MDTSimHit()
| def python.Dumpers.dump_MDTSimHit |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5199 of file Dumpers.py.
5200 fprint (f, p.MDTid(), p.globalTime(), p.driftRadius())
5201 dump_Threevec (p.localPosition(), f)
5202 fprint (f, p.stepLength(), p.energyDeposit(), p.particleEncoding(), p.kineticEnergy())
5203 dump_HepMcParticleLink (p.particleLink(), f)
◆ dump_MdtTrackSegment()
| def python.Dumpers.dump_MdtTrackSegment |
( |
|
t, |
|
|
|
f |
|
) |
| |
◆ dump_measurement()
| def python.Dumpers.dump_measurement |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2158 of file Dumpers.py.
2160 fprint (f,
'(null)')
2163 fprint (f, nm +
': ')
2164 if nm ==
'InDet::PixelClusterOnTrack':
2165 dump_PixelClusterOnTrack (p, f)
2166 elif nm ==
'InDet::SCT_ClusterOnTrack':
2167 dump_SCT_ClusterOnTrack (p, f)
2168 elif nm ==
'InDet::TRT_DriftCircleOnTrack':
2169 dump_TRT_DriftCircleOnTrack (p, f)
2170 elif nm ==
'Muon::MdtDriftCircleOnTrack':
2171 dump_MdtDriftCircleOnTrack (p, f)
2172 elif nm ==
'Muon::MdtDriftCircleOnTrack':
2173 dump_MdtDriftCircleOnTrack (p, f)
2174 elif nm ==
'Muon::CompetingMuonClustersOnTrack':
2175 dump_CompetingMuonClustersOnTrack (p, f)
2176 elif nm ==
'Muon::RpcClusterOnTrack':
2177 dump_RpcClusterOnTrack (p, f)
2178 elif nm ==
'Muon::TgcClusterOnTrack':
2179 dump_TgcClusterOnTrack (p, f)
2180 elif nm ==
'Muon::sTgcClusterOnTrack':
2181 dump_sTgcClusterOnTrack (p, f)
2182 elif nm ==
'Muon::MMClusterOnTrack':
2183 dump_MMClusterOnTrack (p, f)
2184 elif nm ==
'Muon::CscClusterOnTrack':
2185 dump_CscClusterOnTrack (p, f)
2186 elif nm ==
'Trk::PseudoMeasurementOnTrack':
2187 dump_PseudoMeasurementOnTrack (p, f)
◆ dump_MeasurementBase()
| def python.Dumpers.dump_MeasurementBase |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1633 of file Dumpers.py.
1634 dump_LocalParameters (p.localParameters(), f)
1635 dump_AmgMatrix (p.localCovariance(), f)
◆ dump_MissingET()
| def python.Dumpers.dump_MissingET |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2298 of file Dumpers.py.
2299 fprint (f,
'%d %f %f %f %f %f' %
2309 fprint (f,
'\n %d %f %f %f' %
◆ dump_MissingEtCalo()
| def python.Dumpers.dump_MissingEtCalo |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2459 of file Dumpers.py.
2460 dump_MissingET (m, f)
2461 fprintln (f,
' ', m.calibType())
2463 fprintln (f,
' %d %d %f %f %f' %
◆ dump_MissingETComposition()
| def python.Dumpers.dump_MissingETComposition |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4413 of file Dumpers.py.
4414 for p
in toiter1 (m):
4415 fprint (f,
' ',
typename(p.__class__))
4417 fprint (f,
'(null)')
4422 fprint (f,
' [', w.wet(), w.wpx(), w.wpy(), w.statusWord(),
']')
4423 except RuntimeError:
◆ dump_MissingETSig()
| def python.Dumpers.dump_MissingETSig |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2319 of file Dumpers.py.
2320 fprint (f,
"%f %f" %
2323 fprint (f,
"\n %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f" %
2340 fprint (f,
"\n %f %f %f %f %f %f %f %f" %
2349 fprint (f,
"\n %f %f %f %f" %
◆ dump_MissingETSigHypo()
| def python.Dumpers.dump_MissingETSigHypo |
( |
|
h, |
|
|
|
f |
|
) |
| |
Definition at line 2357 of file Dumpers.py.
2363 fprint (f,
"%d %d %d %d %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %d %d %d" %
2392 dump_Fourvec (h.getObject(), f)
2394 fprint (f,
'\n %d %f %f %f %f %f' %
2401 fprint (f,
'\n ', [x
for x
in toiter1(h)])
◆ dump_MissingETSigObject()
| def python.Dumpers.dump_MissingETSigObject |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2405 of file Dumpers.py.
2407 fprint (f,
" %d %d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f %f " %
2408 (m.isValidDefault(),
2413 m.getDefaultType().
type(),
2416 m.getType(0).
type(),
2428 fprint (f,
'\n %f %f %f %f %f %f %f %d %d %d' %
2440 fprint (f,
'\n ', [i
for i
in m.types()])
2442 fprint (f,
'\n %d %f %f %f %f %f' %
2450 [x
for x
in toiter1 (m.getExcess())],
2451 [x
for x
in toiter1 (m.getDeficit())])
2452 dump_MissingETSigHypo (m.getHypo(), f)
2453 dump_MissingETSigHypo (m.getDefaultHypo(), f)
2454 dump_MissingETSigHypo (m.getHypo(0), f)
◆ dump_MissingEtTruth()
| def python.Dumpers.dump_MissingEtTruth |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2473 of file Dumpers.py.
2474 dump_MissingET (m, f)
2476 fprintln (f,
' %d %f %f %f' %
◆ dump_MM_RawData()
| def python.Dumpers.dump_MM_RawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5432 of file Dumpers.py.
5433 fprint (f, p.identify().getString(), p.channel(), p.relBcid(),
5434 p.time(), p.charge(),
5435 p.timeAndChargeInCounts())
◆ dump_MM_RawDataContainer()
| def python.Dumpers.dump_MM_RawDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5439 of file Dumpers.py.
5440 dump_IDC (dump_MM_RawData, p, f)
◆ dump_MMClusterOnTrack()
| def python.Dumpers.dump_MMClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2128 of file Dumpers.py.
2129 dump_MuonClusterOnTrack (p, f)
2130 dump_EL (p.prepRawDataLink(), f)
2131 fprint (f, p.detectorElement().identifyHash().
value())
2132 fprint (f,
'\n stripDriftDists: ',
list(p.stripDriftDists()))
2133 fprint (f,
'\n stripDriftDistErrors:')
2134 for m
in p.stripDriftDistErrors():
2136 dump_AmgMatrix (m, f)
◆ dump_MuCTPI_RDO()
| def python.Dumpers.dump_MuCTPI_RDO |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5029 of file Dumpers.py.
5031 formatItemUsingLong (
list(p.getAllCandidateMultiplicities())),
5032 formatItemUsingLong (
list(p.dataWord())))
◆ dump_MuCTPIResult()
| def python.Dumpers.dump_MuCTPIResult |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5080 of file Dumpers.py.
5081 dump_ROIBHeader (p.header(), f)
5082 for r
in p.roIVec():
5083 dump_MuCTPIRoI (r, f)
5084 dump_ROIBTrailer (p.trailer(), f)
◆ dump_MuCTPIRoI()
| def python.Dumpers.dump_MuCTPIRoI |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5075 of file Dumpers.py.
5076 fprint (f, p.roIWord())
◆ dump_MultiSVInfoPlus()
| def python.Dumpers.dump_MultiSVInfoPlus |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1155 of file Dumpers.py.
1156 dump_BaseTagInfo (info, f)
1157 fprint (f, info.getNGTrackInJet(),
1158 info.getNGTrackInSvx(),
1162 fprint (f,
'\n verts: ')
1163 for i
in range (info.numVtxInfo()):
1164 fprint (f,
'\n %d: ' % i)
1165 vx = info.getVtxInfo(i)
1166 fprint (f, vx.getMass(), vx.getPt(), vx.getEta(), vx.getPhi(),
1167 vx.getEnergyFraction(), vx.getNormDist(), vx.numTrackInfo())
1168 fprint (f,
'\n vert: ')
1169 dump_RecVertex (vx.getRecSvx(), f)
1170 fprint (f,
'\n tracks: ')
1173 ti = [vx.getTrackInfo(i)
for i
in range(vx.numTrackInfo())]
1174 ti.sort (key=
lambda a: a.track().
pt(), reverse=
True)
1175 i = vx.numTrackInfo()-1
1177 fprint (f,
'\n %d: ' % i)
1178 dump_SVTrackInfo (tt, f)
◆ dump_Muon()
| def python.Dumpers.dump_Muon |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 629 of file Dumpers.py.
630 dump_ParticleImpl (m, f)
631 fprint (f,
' %1d' % m.author())
632 if m.inDetTrackLink().
isValid():
633 fprint (f,
'\n idtp: %2d:' % m.inDetTrackLink().
index())
634 dump_Fourvec (m.inDetTrackParticle(), f)
636 if hasattr(m,
'muonSpTrackLink')
and m.muonSpTrackLink().
isValid():
637 fprint (f,
'\n sptp: %2d:' % m.muonSpTrackLink().
index())
638 dump_Fourvec (m.muonSpectrometerTrackParticle(), f)
639 if m.muonExtrapTrackLink().
isValid():
640 fprint (f,
'\n mxtp: %2d:' % m.muonExtrapTrackLink().
index())
641 dump_Fourvec (m.muonExtrapolatedTrackParticle(), f)
642 if m.innerExtrapTrackLink().
isValid():
643 fprint (f,
'\n ixtp: %2d:' % m.innerExtrapTrackLink().
index())
644 dump_Fourvec (m.innerExtrapolatedTrackParticle(), f)
645 if m.combinedTrackLink().
isValid():
646 fprint (f,
'\n cmtp: %2d:' % m.combinedTrackLink().
index())
647 dump_Fourvec (m.combinedMuonTrackParticle(), f)
649 fprint (f,
'\n cl: %2d:' % m.clusterLink().
index())
650 dump_Fourvec (m.cluster(), f)
651 fprint (f,
'\n a: %f %f %d %f %d %f %d' %
652 (m.matchChi2(), m.matchChi2OverDoF(), m.matchNumberDoF(),
653 m.fitChi2(), m.fitNumberDoF(), m.fitChi2OverDoF(),
655 fprint (f,
'\n b: %d %d %d %d %d %d %d %d %d %d %d %d' %
656 (m.numberOfInnermostPixelLayerHits(),
657 m.numberOfPixelHits(),
660 m.numberOfTRTHighThresholdHits(),
661 m.numberOfInnermostPixelLayerSharedHits(),
662 m.numberOfPixelSharedHits(),
663 m.numberOfPixelHoles(),
664 m.numberOfSCTSharedHits(),
665 m.numberOfSCTHoles(),
666 m.numberOfTRTOutliers(),
667 m.numberOfTRTHighThresholdOutliers()))
668 fprint (f,
'\n c: %d %d %d %d %d %d %d %d %d %d %d %d %d %d' %
669 (m.numberOfMDTHits(),
670 m.numberOfMDTHoles(),
671 m.numberOfCSCEtaHits(),
672 m.numberOfCSCEtaHoles(),
673 m.numberOfCSCPhiHits(),
674 m.numberOfCSCPhiHoles(),
675 m.numberOfRPCEtaHits(),
676 m.numberOfRPCEtaHoles(),
677 m.numberOfRPCPhiHits(),
678 m.numberOfRPCPhiHoles(),
679 m.numberOfTGCEtaHits(),
680 m.numberOfTGCEtaHoles(),
681 m.numberOfTGCPhiHits(),
682 m.numberOfTGCPhiHoles()))
683 fprint (f,
'\n d: %d %d %f %f %f %f %f %f' %
684 (m.numberOfGangedPixels(),
685 m.numberOfOutliersOnTrack(),
687 m.segmentChi2OverDoF(),
692 fprint (f,
'\n e: %f %f %d %d' %
693 (m.parameter(etcone10),
694 m.parameter(nucone10),
695 m.alsoFoundByLowPt(),
696 m.alsoFoundByCaloMuonId()))
697 fprint (f,
'\n f:', [i
for i
in m.associatedEtaDigits()])
698 fprint (f,
'\n h:', [i
for i
in m.associatedPhiDigits()])
699 fprint (f,
'\n i:', [i
for i
in m.segmentEtaDigits()])
700 fprint (f,
'\n j:', [i
for i
in m.segmentPhiDigits()])
701 caloe = m.caloEnergyLoss()
704 dump_CaloEnergy (caloe, f)
◆ dump_Muon_ROI()
| def python.Dumpers.dump_Muon_ROI |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2932 of file Dumpers.py.
2934 fprint (f,
"%d %s %f %d %d %d %d %d %d %d %d" %
2940 m.getSectorAddress(),
2941 m.isFirstCandidate(),
2942 m.isMoreCandInRoI(),
2943 m.isMoreCandInSector(),
◆ dump_MuonAssociation()
| def python.Dumpers.dump_MuonAssociation |
( |
|
a, |
|
|
|
f |
|
) |
| |
Definition at line 3489 of file Dumpers.py.
3490 dump_JetAssociationBase (a, f)
3493 fprint (f, a.getMuonWeight (muo))
3494 dump_Fourvec (muo, f)
◆ dump_MuonCluster()
| def python.Dumpers.dump_MuonCluster |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4532 of file Dumpers.py.
4533 dump_PrepRawData (p, f)
4534 dump_AmgVector (p.globalPosition(), f, thresh=1e-8, prec=4)
◆ dump_MuonClusterOnTrack()
| def python.Dumpers.dump_MuonClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1698 of file Dumpers.py.
1699 dump_RIO_OnTrack (p, f)
1700 dump_AmgVector (p.globalPosition(), f, 1e-12, 4)
1701 fprint (f, p.positionAlongStrip())
◆ dump_MuonConstituent()
| def python.Dumpers.dump_MuonConstituent |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1295 of file Dumpers.py.
1297 dump_Fourvec (info.muon(), f)
1298 fprint (f, info.getMuonWeight (info.muon()))
◆ dump_MuonFeature()
| def python.Dumpers.dump_MuonFeature |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 3975 of file Dumpers.py.
3976 fprint (f,
' ', m.roiId(), m.saddress(), m.pt(), m.radius(),
3977 m.eta(), m.phi(), m.dir_phi(), m.zeta(), m.dir_zeta(), m.beta(),
3978 m.sp1_r(), m.sp1_z(), m.sp1_slope(),
3979 m.sp2_r(), m.sp2_z(), m.sp2_slope(),
3980 m.sp3_r(), m.sp3_z(), m.sp3_slope(),
3981 m.br_radius(), m.br_sagitta(), m.ec_alpha(), m.ec_beta(),
3982 m.dq_var1(), m.dq_var2(), m.algoId())
◆ dump_MuonFeature_nolist()
| def python.Dumpers.dump_MuonFeature_nolist |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 3985 of file Dumpers.py.
3986 dump_MuonFeature (m, f)
◆ dump_MuonFeatureDetails()
| def python.Dumpers.dump_MuonFeatureDetails |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 3990 of file Dumpers.py.
3991 fprint (f, m.extension_capacity(),
3992 m.max_rob_capacity(),
3993 m.max_csm_capacity(),
3994 m.max_lvl1_emu_capacity(),
3995 m.max_rpc_hits_capacity(),
3996 m.max_tgc_hits_capacity(),
3997 m.max_mdt_hits_capacity(),
3998 m.id(), m.te_id(), m.error())
4000 m.lvl1_id(), m.lumi_block(), m.muondetmask(),
4001 m.roi_id(), m.roi_system(), m.roi_subsystem(),
4002 m.roi_sector(), m.roi_number(), m.roi_threshold(),
4003 daz(m.roi_eta()),
daz(m.roi_phi()),
4004 m.rpc_pad_error(), m.tgc_rdo_error())
4006 m.rpc1_x(), m.rpc1_y(), m.rpc1_z(),
4007 m.rpc2_x(), m.rpc2_y(), m.rpc2_z(),
4008 m.rpc3_x(), m.rpc3_y(), m.rpc3_z())
4010 m.tgc_Mid1_eta(), m.tgc_Mid1_phi(), m.tgc_Mid1_r(), m.tgc_Mid1_z(),
4011 m.tgc_Mid2_eta(), m.tgc_Mid2_phi(), m.tgc_Mid2_r(), m.tgc_Mid2_z(),
4012 m.tgc_Mid_rho_chi2(), m.tgc_Mid_rho_N(),
4013 m.tgc_Mid_phi_chi2(), m.tgc_Mid_phi_N())
4015 m.tgc_Inn_eta(), m.tgc_Inn_phi(),
4016 m.tgc_Inn_r(), m.tgc_Inn_z(),
4017 m.tgc_Inn_rho_std(), m.tgc_Inn_rho_N(),
4018 m.tgc_Inn_phi_std(), m.tgc_Inn_phi_N(),
4021 m.mdt_Inner_slope(),
4022 m.mdt_Inner_intercept(),
4025 m.mdt_Inner_fit_chi(),
4026 m.mdt_Middle_slope(),
4027 m.mdt_Middle_intercept(),
4030 m.mdt_Middle_fit_chi(),
4031 m.mdt_Outer_slope(),
4032 m.mdt_Outer_intercept(),
4035 m.mdt_Outer_fit_chi())
4037 m.Address(), m.Sagitta(), m.Radius(), m.Slope(), m.Intercept(),
4038 m.Alpha(), m.Beta(), m.DeltaR(), m.Speed_over_c(),
4039 m.PhiMap(), m.Phi(), m.PhiDir(), m.Pt(), m.Charge())
4047 m.eta_high_0_lay0(),
4048 m.eta_high_1_lay0(),
4049 m.eta_high_0_lay1(),
4050 m.eta_high_1_lay1(),
4057 m.phi_high_0_lay0(),
4058 m.phi_high_1_lay0(),
4059 m.phi_high_0_lay1(),
4060 m.phi_high_1_lay1())
4062 fprint (f,
'\n ', formatItemUsingLong (
list(m.rob_id())))
4063 fprint (f,
'\n ', formatItemUsingLong (
list(m.csm_id())))
4064 fprint (f,
'\n ', formatItemUsingLong (
list(m.csm_size())))
4065 fprint (f,
'\n ', formatItemUsingLong (
list(m.csm_error())))
4066 fprint (f,
'\n ', formatItemUsingLong (
list(m.removed_rob_id())))
4067 fprint (f,
'\n ', formatItemUsingLong (
list(m.removed_csm_id())))
4068 fprint (f,
'\n ', formatItemUsingLong (
list(m.lvl1_emulation())))
4069 fprint (f,
'\n ', formatItemUsingLong (
list(m.pad_hit_onlineId())))
4070 fprint (f,
'\n ', formatItemUsingLong (
list(m.pad_hit_code())))
4080 fprint (f,
'\n ', formatItemUsingLong (
list(m.tgc_Inn_rho_hit_in_seg())))
4085 fprint (f,
'\n ', formatItemUsingLong (
list(m.tgc_Inn_phi_hit_in_seg())))
4090 fprint (f,
'\n ', formatItemUsingLong (
list(m.tgc_Mid_rho_hit_in_seg())))
4095 fprint (f,
'\n ', formatItemUsingLong (
list(m.tgc_Mid_phi_hit_in_seg())))
4096 fprint (f,
'\n ', formatItemUsingLong (
list(m.mdt_onlineId())))
4097 fprint (f,
'\n ', formatItemUsingLong (
list(m.mdt_offlineId())))
4104 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension0())))
4105 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension1())))
4106 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension2())))
4107 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension3())))
4108 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension4())))
4109 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension5())))
4110 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension6())))
4111 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension7())))
4112 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension8())))
4113 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension9())))
◆ dump_MuonMcData()
| def python.Dumpers.dump_MuonMcData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4792 of file Dumpers.py.
4793 fprint (f, p.firstEntry(), p.secondEntry())
◆ dump_MuonSimData()
| def python.Dumpers.dump_MuonSimData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4797 of file Dumpers.py.
4798 fprint (f, p.word())
4799 dump_AmgVector (p.globalPosition(), f)
4800 for d
in p.getdeposits():
4801 dump_HepMcParticleLink (d.first, f)
4802 dump_MuonMcData (d.second, f)
◆ dump_MuonSimDataCollection()
| def python.Dumpers.dump_MuonSimDataCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4807 of file Dumpers.py.
4809 fprint (f, elt.first.getString())
4810 dump_MuonSimData (elt.second, f)
◆ dump_MuonSpShower()
| def python.Dumpers.dump_MuonSpShower |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 3452 of file Dumpers.py.
3453 fprint (f,
"%f %f %d %d %d %d %d %d %d" %
3456 m.numberOfTriggerHits(),
3457 m.numberOfInnerHits(),
3458 m.numberOfMiddleHits(),
3459 m.numberOfOuterHits(),
3460 m.numberOfInnerSegments(),
3461 m.numberOfMiddleSegments(),
3462 m.numberOfOuterSegments()))
◆ dump_MvfFitInfo()
| def python.Dumpers.dump_MvfFitInfo |
( |
|
v, |
|
|
|
f |
|
) |
| |
◆ dump_MVFVxCandidate()
| def python.Dumpers.dump_MVFVxCandidate |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 2667 of file Dumpers.py.
2668 dump_VxCandidate1 (v, f)
2669 fprint (f,
'\n ', v.isInitialized(),
'fi')
2670 dump_MvfFitInfo (v.vertexFitInfo(), f)
◆ dump_MVFVxTrackAtVertex()
| def python.Dumpers.dump_MVFVxTrackAtVertex |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 2636 of file Dumpers.py.
2637 dump_VxTrackAtVertex (t, f)
2638 fprint (f,
'\n ',
tonone(t.linkToVertices()))
◆ dump_NSW_PadTriggerData()
| def python.Dumpers.dump_NSW_PadTriggerData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5444 of file Dumpers.py.
5445 fprint (f, p.getSourceid(), p.getFlags(), p.getEc(), p.getFragid(),
5446 p.getSecid(), p.getSpare(), p.getOrbit(), p.getBcid(), p.getL1id(),
5447 p.getOrbitid(), p.getOrbit1(), p.getStatus(),
5448 p.getNumberOfHits(), p.getNumberOfPfebs(), p.getNumberOfTriggers(),
5449 p.getNumberOfBcids(),
5450 list(p.getHitRelBcids()),
5451 list(p.getHitPfebs()),
5452 list(p.getHitTdsChannels()),
5453 list(p.getHitVmmChannels()),
5454 list(p.getHitVmms()),
5455 list(p.getHitPadChannels()),
5456 list(p.getPfebAddrs()),
5457 list(p.getPfebNChannels()),
5458 list(p.getPfebDisconnecteds()),
5459 list(p.getTriggerBandIds()),
5460 list(p.getTriggerPhiIds()),
5461 list(p.getTriggerRelBcids()),
5462 list(p.getBcidRels()),
5463 list(p.getBcidStatuses()),
5464 list(p.getBcidMultZeros()),
5465 list(p.getBcidMultiplicities()))
◆ dump_NSW_PadTriggerDataContainer()
| def python.Dumpers.dump_NSW_PadTriggerDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5469 of file Dumpers.py.
5473 dump_NSW_PadTriggerData (beg.cptr(), f)
◆ dump_parameters()
| def python.Dumpers.dump_parameters |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1575 of file Dumpers.py.
1579 if typename(p.__class__).startswith (
'DataModel_detail::ElementProxy<'):
1583 elif (
typename(p.__class__).startswith (
'Trk::ParametersT<')
or
1584 typename(p.__class__).startswith (
'Trk::ParametersBase<')):
1585 dump_ParametersBase (p, f)
1586 elif typename(p.__class__).startswith (
'Trk::CurvilinearParametersT<'):
1587 dump_CurvilinearParameters (p, f)
◆ dump_ParametersBase()
| def python.Dumpers.dump_ParametersBase |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1550 of file Dumpers.py.
1551 dump_AmgVector (info.parameters(), f)
1552 dump_Threevec (info.momentum(), f)
1553 dump_Threevec (info.position(), f)
1554 dump_Twovec (info.localPosition(), f)
1555 fprint (f,
"%f" % (info.charge(),))
1556 if info.covariance():
1557 fprint (f,
'\n cov')
1558 dump_AmgMatrix (info.covariance(), f)
1560 dump_associatedSurface (info, f)
◆ dump_ParticleBase()
| def python.Dumpers.dump_ParticleBase |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 342 of file Dumpers.py.
343 dump_Fourvec (e, f, 0)
344 orig = e.originLink()
346 charge =
"%f" % e.charge()
349 fprint (f,
" %1d %1d %4d %s" %
350 (e.dataType(), e.hasPdgId(),
asint32(e.pdgId()), charge))
352 fprint (f,
"%1d"%orig.index())
353 dump_Threevec (e.origin().position(), f)
355 fprint (f,
"(no orig)")
◆ dump_ParticleImpl()
| def python.Dumpers.dump_ParticleImpl |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 359 of file Dumpers.py.
360 dump_Fourvec (p, f, 0)
366 fprint (f,
' %d %s %5d ' %
367 (p.dataType(), c,
asint32(p.pdgId())))
369 dump_Threevec (p.origin().position(), f)
371 fprint (f,
"(no orig)")
◆ dump_ParticleJet()
| def python.Dumpers.dump_ParticleJet |
( |
|
j, |
|
|
|
f |
|
) |
| |
Definition at line 1303 of file Dumpers.py.
1304 dump_ParticleBase (j, f)
1305 fprint (f,
'\n %s %f %f' %
1309 fprint (f, [x
for x
in j.combinedLikelihood()])
1310 ti = j.jetTagInfoVector()
1312 fprint (f,
'\n %s: ' % info.infoType())
1313 if isinstance (info, PyAthena.Analysis.TruthInfo):
1314 dump_TruthInfo (info, f)
1315 elif isinstance (info, PyAthena.Analysis.SoftLeptonTruthInfo):
1316 dump_SoftLeptonTruthInfo (info, f)
1317 elif isinstance (info, PyAthena.Analysis.SecVtxInfo):
1318 dump_SecVtxInfo (info, f)
1319 elif isinstance (info, PyAthena.Analysis.IPInfoPlus):
1320 dump_IPInfoPlus (info, f)
1321 elif isinstance (info, PyAthena.Analysis.IPInfoBase):
1322 dump_IPInfoBase (info, f)
1323 elif isinstance (info, PyAthena.Analysis.SVInfoBase):
1324 dump_SVInfoBase (info, f)
1325 elif isinstance (info, PyAthena.Analysis.JetProbInfoBase):
1326 dump_JetProbInfoBase (info, f)
1327 elif isinstance (info, PyAthena.Analysis.SoftElectronInfo):
1328 dump_SoftElectronInfo (info, f)
1329 elif isinstance (info, PyAthena.Analysis.JetFitterTagInfo):
1330 dump_JetFitterTagInfo (info, f)
1331 elif isinstance (info, PyAthena.Analysis.BaseTagInfo):
1332 dump_BaseTagInfo (info, f)
1336 for c
in j.constituentKeys():
1337 fprint (f,
'\n %s: ' % c)
1338 info = j.constituent (c)
1339 if isinstance (info, PyAthena.Analysis.JetConstituent):
1340 dump_JetConstituent (info, f)
1341 elif isinstance (info, PyAthena.Analysis.TrackConstituents):
1342 dump_TrackConstituents (info, f)
1343 elif isinstance (info, PyAthena.Analysis.ElectronConstituent):
1344 dump_ElectronConstituent (info, f)
1345 elif isinstance (info, PyAthena.Analysis.MuonConstituent):
1346 dump_MuonConstituent (info, f)
◆ dump_PerigeeSurface()
| def python.Dumpers.dump_PerigeeSurface |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1482 of file Dumpers.py.
1483 dump_Surface (info, f)
◆ dump_Photon()
| def python.Dumpers.dump_Photon |
( |
|
e, |
|
|
|
f |
|
) |
| |
◆ dump_PhotonAssociation()
| def python.Dumpers.dump_PhotonAssociation |
( |
|
a, |
|
|
|
f |
|
) |
| |
Definition at line 3480 of file Dumpers.py.
3481 dump_JetAssociationBase (a, f)
3484 fprint (f, a.getPhotonWeight (gam))
3485 dump_Fourvec (gam, f)
◆ dump_PileUpEventInfo()
| def python.Dumpers.dump_PileUpEventInfo |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 2729 of file Dumpers.py.
2730 dump_EventInfo (e, f)
2731 for (i,s)
in enumerate (toiter (e.beginSubEvt(), e.endSubEvt())):
2732 fprint (f,
'\n subevt', i, s.time(), s.index(), s.BCID(), s.type())
◆ dump_PixelCluster()
| def python.Dumpers.dump_PixelCluster |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4619 of file Dumpers.py.
4620 dump_SiCluster (p, f)
4621 fprint (f, p.omegax(), p.omegay(), list (p.totList()))
4622 fprint (f, p.totalToT(),
list(p.chargeList()), p.totalCharge())
4623 fprint (f, p.isFake(), p.isAmbiguous(), p.LVL1A(), p.splitInfoRaw(), p.tooBigToBeSplit())
◆ dump_PixelClusterContainer()
| def python.Dumpers.dump_PixelClusterContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4735 of file Dumpers.py.
4736 dump_IDC (dump_PixelCluster, p, f)
◆ dump_PixelClusterOnTrack()
| def python.Dumpers.dump_PixelClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1652 of file Dumpers.py.
1653 dump_SiClusterOnTrack (p, f)
1654 dump_EL (p.prepRawDataLink(), f)
1655 fprint (f, p.hasClusterAmbiguity(), p.isFake(), p.energyLoss())
1656 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_PixelGangedClusterAmbiguities()
| def python.Dumpers.dump_PixelGangedClusterAmbiguities |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4816 of file Dumpers.py.
4818 dump_SiCluster (elt.first, f)
4819 dump_SiCluster (elt.second, f)
◆ dump_PixelRawDataContainer()
| def python.Dumpers.dump_PixelRawDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4753 of file Dumpers.py.
4754 dump_IDC (dump_PixelRDORawData, p, f)
◆ dump_PixelRDORawData()
| def python.Dumpers.dump_PixelRDORawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4645 of file Dumpers.py.
4646 dump_InDetRawData (p, f)
4647 fprint (f, p.getToT(), p.getBCID(), p.getLVL1A(), p.getLVL1ID())
◆ dump_PlaneSurface()
| def python.Dumpers.dump_PlaneSurface |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1487 of file Dumpers.py.
1488 dump_Surface (info, f)
◆ dump_PRD_MultiTruthCollection()
| def python.Dumpers.dump_PRD_MultiTruthCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2077 of file Dumpers.py.
2078 for x
in ROOT.TrkTruthDataHelpers.getData (p):
2079 fprint (f,
'\n ', x.first.getString())
2080 dump_HepMcParticleLink (x.second, f)
◆ dump_PrepRawData()
| def python.Dumpers.dump_PrepRawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4520 of file Dumpers.py.
4521 fprint (f, p.identify().getString())
4522 dump_IdentContIndex (p.getHashAndIndex(), f)
4523 dump_AmgVector (p.localPosition(), f)
4524 dump_AmgMatrix (p.localCovariance(), f)
4526 for i
in p.rdoList():
4527 fprint (f, i.getString())
◆ dump_PseudoMeasurementOnTrack()
| def python.Dumpers.dump_PseudoMeasurementOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2151 of file Dumpers.py.
2152 dump_MeasurementBase (p, f)
2153 dump_AmgVector (p.globalPosition(), f)
2154 dump_associatedSurface (p, f)
◆ dump_RawInfoSummaryForTag()
| def python.Dumpers.dump_RawInfoSummaryForTag |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4405 of file Dumpers.py.
4407 if a.startswith (
'get'):
4408 fprintln (f, a[3:]+
':', getattr(p, a)())
◆ dump_RecoTimingObj()
| def python.Dumpers.dump_RecoTimingObj |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 4504 of file Dumpers.py.
4505 fprintln (f, list (c))
◆ dump_RecVertex()
| def python.Dumpers.dump_RecVertex |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 2571 of file Dumpers.py.
2573 dump_FitQuality (v.fitQuality(), f)
2574 dump_AmgMatrix (v.covariancePosition(), f)
◆ dump_RingerRings()
| def python.Dumpers.dump_RingerRings |
( |
|
r, |
|
|
|
f |
|
) |
| |
◆ dump_RIO_OnTrack()
| def python.Dumpers.dump_RIO_OnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1639 of file Dumpers.py.
1640 dump_MeasurementBase (p, f)
1641 fprint (f, p.identify().getString())
◆ dump_ROIBHeader()
| def python.Dumpers.dump_ROIBHeader |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5065 of file Dumpers.py.
5066 fprint (f, formatItemUsingLong (
list(p.header())))
◆ dump_RoIBResult()
| def python.Dumpers.dump_RoIBResult |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5143 of file Dumpers.py.
5144 fprint (f,
'MuCTPI:')
5145 dump_MuCTPIResult (p.muCTPIResult(), f)
5146 fprint (f,
'\nCTP:')
5147 dump_CTPResult (p.cTPResult(), f)
5148 for r
in p.jetEnergyResult():
5149 fprint (f,
'\nJetEnergy:')
5151 for r
in p.eMTauResult():
5152 fprint (f,
'\nEMTau:')
5154 for r
in p.l1TopoResult():
5155 fprint (f,
'\nL1Topo:')
◆ dump_ROIBTrailer()
| def python.Dumpers.dump_ROIBTrailer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5070 of file Dumpers.py.
5071 fprint (f, formatItemUsingLong (
list(p.trailer())))
◆ dump_RoiDescriptor()
| def python.Dumpers.dump_RoiDescriptor |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 3852 of file Dumpers.py.
3854 d.version(), d.isFullscan(),
3855 d.eta(), d.etaPlus(), d.etaMinus(),
3856 d.phi(), d.phiPlus(), d.phiMinus(),
3857 d.zed(), d.zedPlus(), d.zedMinus(),
3858 d.composite(), d.manageConstituents(), d.size(),
3859 formatItemUsingLong ([d.at(i).
roiId()
for i
in range(d.size())]))
◆ dump_RpcClusterOnTrack()
| def python.Dumpers.dump_RpcClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1716 of file Dumpers.py.
1717 dump_MuonClusterOnTrack (p, f)
1718 dump_EL (p.prepRawDataLink(), f)
1719 fprint (f, p.time())
1720 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_RpcCoinData()
| def python.Dumpers.dump_RpcCoinData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4598 of file Dumpers.py.
4599 dump_RpcPrepData (p, f)
4600 fprint (f, p.ijk(), p.threshold(), p.overlap(), p.parentCmId(), p.parentPadId(), p.parentSectorId())
◆ dump_RpcCoinDataContainer()
| def python.Dumpers.dump_RpcCoinDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4705 of file Dumpers.py.
4706 dump_IDC (dump_RpcCoinData, p, f)
◆ dump_RpcCoinMatrix()
| def python.Dumpers.dump_RpcCoinMatrix |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5257 of file Dumpers.py.
5258 fprint (f, p.identify().getString(), p.onlineId(), p.crc(), p.fel1Id(), p.febcId())
5261 dump_RpcFiredChannel (chan, f)
◆ dump_RpcFiredChannel()
| def python.Dumpers.dump_RpcFiredChannel |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5252 of file Dumpers.py.
5253 fprint (f,
'RpcFiredChannel', p.bcid(), p.time(), p.ijk(), p.channel(), p.ovl(), p.thr())
◆ dump_RpcPadContainer()
| def python.Dumpers.dump_RpcPadContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5266 of file Dumpers.py.
5267 dump_IDC (dump_RpcCoinMatrix, p, f,
5268 extra_idc_dumper =
lambda p, f: \
5269 fprint (f, p.identify().getString(), p.onlineId(), p.lvl1Id(), p.bcId(),
5270 p.sector(), p.status(), p.errorCode()))
◆ dump_RpcPrepData()
| def python.Dumpers.dump_RpcPrepData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4592 of file Dumpers.py.
4593 fprint (f, p.time(), p.ambiguityFlag())
4594 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_RpcPrepDataContainer()
| def python.Dumpers.dump_RpcPrepDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4711 of file Dumpers.py.
4712 dump_IDC (dump_RpcPrepData, p, f)
◆ dump_RpcSectorLogic()
| def python.Dumpers.dump_RpcSectorLogic |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5280 of file Dumpers.py.
5281 fprint (f, p.sectorId(), p.fel1Id(), p.bcid(), p.errorCode(), p.crc(),
5282 p.hasMoreThan2TriggerCand(),
5283 list (p.counters()),
5284 list (p.triggerRates()))
5287 dump_RpcSLTriggerHit (hit, f)
◆ dump_RPCSimHit()
| def python.Dumpers.dump_RPCSimHit |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5207 of file Dumpers.py.
5208 fprint (f, p.RPCid(), p.globalTime())
5209 dump_Threevec (p.localPosition(), f)
5210 dump_Threevec (p.postLocalPosition(), f)
5211 fprint (f, p.stepLength(), p.energyDeposit(), p.particleEncoding(), p.kineticEnergy())
5212 dump_HepMcParticleLink (p.particleLink(), f)
◆ dump_RpcSLTriggerHit()
| def python.Dumpers.dump_RpcSLTriggerHit |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5274 of file Dumpers.py.
5275 fprint (f,
'hit', p.rowinBcid(), p.padId(), p.ptId(), p.roi(),
5276 p.outerPlane(), p.overlapPhi(), p.overlapEta(),
5277 p.triggerBcid(), p.isInput())
◆ dump_SaggedLineSurface()
| def python.Dumpers.dump_SaggedLineSurface |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1515 of file Dumpers.py.
1516 dump_StraightLineSurface (info, f)
1518 dump_LineSaggingDescriptor (info.distortionDescriptor())
◆ dump_ScatteringAngles()
| def python.Dumpers.dump_ScatteringAngles |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2199 of file Dumpers.py.
2203 fprint (f,
daz(p.deltaPhi()),
daz(p.deltaTheta()))
2204 fprint (f, p.sigmaDeltaPhi(), p.sigmaDeltaTheta())
◆ dump_SCT_Cluster()
| def python.Dumpers.dump_SCT_Cluster |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4627 of file Dumpers.py.
4628 dump_SiCluster (p, f)
4629 fprint (f, p.hitsInThirdTimeBin())
◆ dump_SCT_ClusterContainer()
| def python.Dumpers.dump_SCT_ClusterContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4741 of file Dumpers.py.
4742 dump_IDC (dump_SCT_Cluster, p, f)
◆ dump_SCT_ClusterOnTrack()
| def python.Dumpers.dump_SCT_ClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1660 of file Dumpers.py.
1661 dump_SiClusterOnTrack (p, f)
1662 dump_EL (p.prepRawDataLink(), f)
1663 fprint (f, p.positionAlongStrip())
1664 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_SCT_RawDataContainer()
| def python.Dumpers.dump_SCT_RawDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4765 of file Dumpers.py.
4766 dump_IDC (dump_SCT_RDORawData, p, f)
◆ dump_SCT_RDORawData()
| def python.Dumpers.dump_SCT_RDORawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4657 of file Dumpers.py.
4658 dump_InDetRawData (p, f)
4659 fprint (f, p.getGroupSize())
◆ dump_SecVtxInfo()
| def python.Dumpers.dump_SecVtxInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1073 of file Dumpers.py.
1074 dump_BaseTagInfo (info, f)
1075 fprint (f,
'\n %d %d %d %d %f %f %f %f %f' %
1077 info.numSelTracksForFit(),
1079 info.NumberOfG2TrackVertices(),
1081 info.rphidistance(),
1084 info.energyFraction()))
1085 return dump_Threevec (info.secVertexPos().position(), f)
◆ dump_Segment()
| def python.Dumpers.dump_Segment |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2288 of file Dumpers.py.
2289 dump_MeasurementBase (p, f)
2290 fprint (f, p.author())
2291 dump_FitQuality (p.fitQuality(), f)
2292 for x
in p.containedMeasurements():
2293 dump_measurement (x, f)
◆ dump_SETrackInfo()
| def python.Dumpers.dump_SETrackInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1188 of file Dumpers.py.
1189 dump_Fourvec (info.electron(), f)
1190 fprint (f,
'%f %f' % (info.d0Value(), info.pTrel()),
1191 [x
for x
in info.tagLikelihood()])
◆ dump_SiCluster()
| def python.Dumpers.dump_SiCluster |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4610 of file Dumpers.py.
4611 dump_PrepRawData (p, f)
4612 fprint (f, p.gangedPixel())
4613 dump_AmgVector (p.globalPosition(), f)
4614 dump_SiWidth (p.width(), f)
4615 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_SiClusterOnTrack()
| def python.Dumpers.dump_SiClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1645 of file Dumpers.py.
1646 dump_RIO_OnTrack (p, f)
1647 fprint (f, p.idDE().
value(), p.isBroadCluster())
1648 dump_AmgVector (p.globalPosition(), f)
◆ dump_SiHit()
| def python.Dumpers.dump_SiHit |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4251 of file Dumpers.py.
4252 fprint (f, t.identify())
4253 dump_Threevec (t.localStartPosition(), f)
4254 dump_Threevec (t.localEndPosition(), f)
4255 fprint (f, t.energyLoss(), t.meanTime(), t.truthBarcode())
4256 dump_HepMcParticleLink (t.particleLink(), f)
◆ dump_SiWidth()
| def python.Dumpers.dump_SiWidth |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4604 of file Dumpers.py.
4605 dump_AmgVector (p.colRow(), f)
4606 dump_AmgVector (p.widthPhiRZ(), f)
◆ dump_SkimDecision()
| def python.Dumpers.dump_SkimDecision |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4399 of file Dumpers.py.
4400 fprint (f, p.getName(), p.isAccepted())
◆ dump_SLTrueInfo()
| def python.Dumpers.dump_SLTrueInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1052 of file Dumpers.py.
1053 fprint (f,
'%d %d %d %d %d %d ' %
1060 dump_H3V (info.momentum(), f)
1062 dump_H3V (info.prodvtx(), f)
◆ dump_SMTrackInfo()
| def python.Dumpers.dump_SMTrackInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1242 of file Dumpers.py.
1243 dump_ParticleImpl (info.muon(), f)
1244 fprint (f, info.d0Value(), info.pTrel(),
list(info.tagLikelihood()))
◆ dump_SoftElectronInfo()
| def python.Dumpers.dump_SoftElectronInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1195 of file Dumpers.py.
1196 dump_BaseTagInfo (info, f)
1197 fprint (f,
' '.
join([
'%f'%x
for x
in info.vectorTrackProb()]),
1198 info.nTrackProb(), info.numTrackInfo())
1199 for i
in range(info.numTrackInfo()):
1201 dump_SETrackInfo (info.getTrackInfo(i), f)
◆ dump_SoftLeptonTruthInfo()
| def python.Dumpers.dump_SoftLeptonTruthInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1065 of file Dumpers.py.
1066 dump_BaseTagInfo (info, f)
1067 for i
in range (info.numSLTrueInfo()):
1069 dump_SLTrueInfo (info.getSLTrueInfo(i), f)
◆ dump_SoftMuonInfo()
| def python.Dumpers.dump_SoftMuonInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1248 of file Dumpers.py.
1249 dump_BaseTagInfo (info, f)
1250 for i
in range (info.numTrackInfo()):
1252 dump_SMTrackInfo (info.getTrackInfo(i), f)
◆ dump_STGC_RawData()
| def python.Dumpers.dump_STGC_RawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5421 of file Dumpers.py.
5422 fprint (f, p.identify().getString(), p.bcTag(), p.time(), p.tdo(), p.charge(),
5423 p.isDead(), p.timeAndChargeInCounts())
◆ dump_STGC_RawDataContainer()
| def python.Dumpers.dump_STGC_RawDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5427 of file Dumpers.py.
5428 dump_IDC (dump_STGC_RawData, p, f)
◆ dump_sTgcClusterOnTrack()
| def python.Dumpers.dump_sTgcClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2121 of file Dumpers.py.
2122 dump_MuonClusterOnTrack (p, f)
2123 dump_EL (p.prepRawDataLink(), f)
2124 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_StraightLineSurface()
| def python.Dumpers.dump_StraightLineSurface |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1492 of file Dumpers.py.
1493 dump_Surface (info, f)
◆ dump_SubDetHitStatistics()
| def python.Dumpers.dump_SubDetHitStatistics |
( |
|
s, |
|
|
|
f |
|
) |
| |
◆ dump_Surface()
| def python.Dumpers.dump_Surface |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1453 of file Dumpers.py.
1454 fprint (f,
typename(info.__class__) +
':')
1455 dump_Threevec (info.center(), f)
1456 dump_Threevec (PyAthena.Trk.Surface.normal (info), f)
1457 if (isinstance (info, PyAthena.Trk.DiscSurface)
and
1458 typename(info.bounds().__class__).find (
'NoBounds') >= 0):
1459 bd_class = info.bounds().__class__
1460 fprint (f,
'(no bounds)')
1461 elif (isinstance (info, PyAthena.Trk.CylinderSurface)
and
1462 (
not info.hasBounds()
or not info.bounds())):
1463 fprint (f,
'(no bounds)')
1464 bd_class = PyAthena.Trk.CylinderBounds
1466 dump_Threevec (info.globalReferencePoint(), f)
1467 bd_class = info.bounds().__class__
1468 if isinstance (info, PyAthena.Trk.CylinderSurface):
1469 dump_AmgVector (info.rotSymmetryAxis(), f)
1471 dump_AmgMatrix (info.transform().
matrix(), f, thresh=1e-8)
1473 layer = tonone (info.associatedLayer())
1475 layer = typename (info.associatedLayer().__class__)
1476 fprint (f,
'\n ly', layer)
1477 fprint (f,
'\n bd',
typename(bd_class))
1479 info.associatedDetectorElementIdentifier().getString())
◆ dump_surface()
| def python.Dumpers.dump_surface |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1522 of file Dumpers.py.
1525 elif isinstance (p, PyAthena.Trk.PerigeeSurface):
1526 dump_PerigeeSurface (p, f)
1527 elif isinstance (p, PyAthena.Trk.PlaneSurface):
1528 dump_PlaneSurface (p, f)
1529 elif isinstance (p, PyAthena.Trk.StraightLineSurface):
1530 dump_StraightLineSurface (p, f)
1531 elif isinstance (p, PyAthena.Trk.CylinderSurface):
1532 dump_CylinderSurface (p, f)
1533 elif isinstance (p, PyAthena.Trk.DiscSurface):
1534 dump_DiscSurface (p, f)
1535 elif isinstance (p, PyAthena.Trk.SaggedLineSurface):
1536 dump_SaggedLineSurface (p, f)
◆ dump_SVInfoBase()
| def python.Dumpers.dump_SVInfoBase |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1118 of file Dumpers.py.
1119 dump_BaseTagInfo (info, f)
◆ dump_SVInfoPlus()
| def python.Dumpers.dump_SVInfoPlus |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1132 of file Dumpers.py.
1133 dump_BaseTagInfo (info, f)
1134 fprint (f, info.getNGTrackInJet(),
1135 info.getNGTrackInSvx(),
1138 info.getEnergyFraction(),
1140 info.numTrackInfo())
1141 fprint (f,
'\n vert: ')
1142 dump_RecVertex (info.getRecSvx(), f)
1143 fprint (f,
'\n tracks: ')
1146 ti = [info.getTrackInfo(i)
for i
in range(info.numTrackInfo())]
1147 ti.sort (key=
lambda a: a.track().
pt(), reverse=
True)
1148 i = info.numTrackInfo()-1
1150 fprint (f,
'\n %d: ' % i)
1151 dump_SVTrackInfo (tt, f)
◆ dump_SVTrackInfo()
| def python.Dumpers.dump_SVTrackInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
◆ dump_Tau1P3PDetails()
| def python.Dumpers.dump_Tau1P3PDetails |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 715 of file Dumpers.py.
716 dump_TauDetail (t, f)
717 fprint (f,
' %f %1d %f %f %1d %1d %f %f %f %f' %
722 t.nAssocTracksCore(),
723 t.nAssocTracksIsol(),
729 fprint (f,
' %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f' %
730 (t.isolationFraction(),
737 t.etChrgHADoverPttot(),
744 t.etResChrgEMTrk(0)))
746 dump_HLV (t.sumEM(), f)
748 dump_Threevec (t.secVertex().position(), f)
749 if t.cellEM012Cluster():
750 dump_Fourvec (t.cellEM012Cluster(), f)
751 for i
in range(t.numPi0()):
752 fprint (f,
'\n pi: ')
753 dump_Fourvec (t.pi0 (i), f)
◆ dump_Tau1P3PExtraDetails()
| def python.Dumpers.dump_Tau1P3PExtraDetails |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 779 of file Dumpers.py.
780 dump_TauDetail (t, f)
781 fprint (f, t.sumPTTracks())
786 for tr
in range(t.ntrack()):
787 for s
in range(t.nsamp()):
788 fprint (f,
'\n ', tr, s,
789 t.etaTrackCaloSamp(tr,s), t.phiTrackCaloSamp(tr,s))
◆ dump_TauCommonDetails()
| def python.Dumpers.dump_TauCommonDetails |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 849 of file Dumpers.py.
850 dump_TauDetail (t, f)
851 fprint (f, t.ipZ0SinThetaSigLeadTrk(), t.etOverPtLeadTrk(),
852 t.leadTrkPt(), t.ipSigLeadTrk(), t.ipSigLeadLooseTrk(),
853 t.etOverPtLeadLooseTrk(), t.leadLooseTrkPt(), t.chrgLooseTrk(),
854 t.massTrkSys(), t.trkWidth2())
856 fprint (f, t.trFlightPathSig(), t.etEflow(), t.seedCalo_EMRadius(),
857 t.seedCalo_hadRadius(), t.seedCalo_etEMAtEMScale(),
858 t.seedCalo_etHadAtEMScale(), t.seedCalo_isolFrac(),
859 t.seedCalo_centFrac(), t.seedCalo_stripWidth2(), t.seedCalo_nStrip())
861 fprint (f, t.seedCalo_etEMCalib(), t.seedCalo_etHadCalib(),
862 t.seedCalo_eta(), t.seedCalo_phi(), t.seedCalo_nIsolLooseTrk(),
863 t.seedTrk_EMRadius(), t.seedTrk_isolFrac(),
864 t.seedTrk_etChrgHadOverSumTrkPt(), t.seedTrk_isolFracWide(),
865 t.seedTrk_etHadAtEMScale())
867 fprint (f, t.seedTrk_etEMAtEMScale(), t.seedTrk_etEMCL(),
868 t.seedTrk_etChrgEM(), t.seedTrk_etNeuEM(),
869 t.seedTrk_etResNeuEM(), t.seedTrk_hadLeakEt(),
870 t.seedTrk_sumEMCellEtOverLeadTrkPt(), t.seedTrk_secMaxStripEt(),
871 t.seedTrk_stripWidth2(), t.seedTrk_nStrip())
873 fprint (f, t.seedTrk_etChrgHad(), t.seedTrk_nOtherCoreTrk(),
874 t.seedTrk_nIsolTrk(), t.seedTrk_etIsolEM(), t.seedTrk_etIsolHad())
875 fprint (f,
'\n %d loose tracks' % t.nLooseTrk())
876 looseTrks = t.looseTrk()
877 for i
in range(looseTrks.size()):
879 fprint (f,
'\n ', el.index(), el.dataID(),
880 t.seedTrk_etChrgEM01Trk(i), t.seedTrk_etResChrgEMTrk(i))
881 fprint (f,
'\n %d pi0s' % t.nPi0())
883 for i
in range(vec.size()):
886 fprint (f,
'\n ', el.dataID(), el.e())
887 fprint (f,
'\n pi0 sum:')
888 dump_HLV (t.sumPi0Vec(), f)
889 cl = t.cellEM012ClusterLink()
890 fprint (f,
'\n cluster:')
892 fprint (f, cl.index(), cl.dataID())
894 fprintln (f,
'(invalid)')
895 fprint (f,
'\n secvertex:')
897 dump_RecVertex (t.secVtx(), f)
◆ dump_TauCommonExtraDetails()
| def python.Dumpers.dump_TauCommonExtraDetails |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 928 of file Dumpers.py.
929 dump_TauDetail (t, f)
930 fprint (f, t.sumPtLooseTrk(), t.sumPtTrk(), t.seedCalo_nEMCell(),
931 t.seedCalo_stripEt(), t.seedCalo_EMCentFrac(),
932 t.seedCalo_sumCellEnergy(), t.seedCalo_sumEMCellEnergy())
934 dump_vvelccell (t.closestEtaTrkVertCell(), f)
936 dump_vvelccell (t.closestPhiTrkVertCell(), f)
938 dump_vvelccell (t.closestEtaTrkCell(), f)
940 dump_vvelccell (t.closestPhiTrkCell(), f)
942 dump_vvdouble (t.etaTrkCaloSamp(), f)
944 dump_vvdouble (t.phiTrkCaloSamp(), f)
946 dump_vvdouble (t.etaLooseTrkCaloSamp(), f)
948 dump_vvdouble (t.phiLooseTrkCaloSamp(), f)
◆ dump_TauDetail()
| def python.Dumpers.dump_TauDetail |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 708 of file Dumpers.py.
710 if nm.startswith(
'Analysis::'):
712 fprint (f,
'%s:' % nm)
◆ dump_TauDetailsContainer()
| def python.Dumpers.dump_TauDetailsContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2018 of file Dumpers.py.
2019 fprint (f,
'(Dumped as a part of Analysis::TauJetContainer)')
◆ dump_TauJet()
| def python.Dumpers.dump_TauJet |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 952 of file Dumpers.py.
953 dump_ParticleImpl (t, f)
954 fprint (f,
' %1d' % (t.author(),))
957 fprint (f,
'\n cl: %2d:' % t.clusterLink().
index())
958 dump_Fourvec (t.cluster(), f)
959 if t.cellClusterLink().
isValid():
962 fprint (f,
'\n ce: ')
963 dump_Fourvec (t.cellCluster(), f)
965 fprint (f,
'\n je: %2d:' % t.jetLink().
index())
967 if j.e() == 0
and j.phi() == 0
and j.eta() == 0:
968 with signalstate (j, PyAthena.P4SignalState.JETEMSCALE):
972 for i
in range (t.numTrack()):
973 el = t.trackLinkVector()[i]
975 fprint (f,
'\n t%d: %2d:' % (i,el.index()))
976 dump_Fourvec (t.track(i), f)
978 TJP = PyAthena.TauJetParameters
980 fprint (f,
'\n pid: %f %f %f %d %d %d' %
981 (pid.discriminant(0),
984 pid.flag (TJP.ElectronFlag),
985 pid.flag (TJP.EgammaFlag),
986 pid.flag (TJP.MuonFlag)))
987 if hasattr (TJP,
'TauCutLoose'):
988 flags = [TJP.TauCutLoose,
997 if hasattr (TJP,
'TauRecOld'):
998 flags.append (TJP.TauRecOld)
999 if hasattr (TJP,
'Tau1P3POld'):
1000 flags.append (TJP.Tau1P3POld)
1001 fprint (f,
'\n ', [pid.isTau(ff)
for ff
in flags])
1003 fprint (f,
'\n ', pid.isTau())
1004 for i
in range (t.nDetails()):
1006 if t.detailElementLink(i).
isValid():
1008 if (hasattr (PyAthena.Analysis,
'Tau1P3PDetails')
and
1009 isinstance (d, PyAthena.Analysis.Tau1P3PDetails)):
1010 dump_Tau1P3PDetails (d, f)
1011 elif (hasattr (PyAthena.Analysis,
'TauRecDetails')
and
1012 isinstance (d, PyAthena.Analysis.TauRecDetails)):
1013 dump_TauRecDetails (d, f)
1014 elif (hasattr (PyAthena.Analysis,
'Tau1P3PExtraDetails')
and
1015 isinstance (d, PyAthena.Analysis.Tau1P3PExtraDetails)):
1016 dump_Tau1P3PExtraDetails (d, f)
1017 elif (hasattr (PyAthena.Analysis,
'TauRecExtraDetails')
and
1018 isinstance (d, PyAthena.Analysis.TauRecExtraDetails)):
1019 dump_TauRecExtraDetails (d, f)
1020 elif (hasattr (PyAthena.Analysis,
'TauPi0Details')
and
1021 isinstance (d, PyAthena.Analysis.TauPi0Details)):
1022 dump_TauPi0Details (d, f)
1023 elif isinstance (d, PyAthena.Analysis.TauCommonDetails):
1024 dump_TauCommonDetails (d, f)
1025 elif isinstance (d, PyAthena.Analysis.TauCommonExtraDetails):
1026 dump_TauCommonExtraDetails (d, f)
1028 fprint (f, t.detailName(i), d,
'(not dumped)')
1029 fprint (f,
'\n p: %f %f %f' %
◆ dump_TauPi0Candidate()
| def python.Dumpers.dump_TauPi0Candidate |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 801 of file Dumpers.py.
802 dump_HLV (t.hlv(), f)
804 for c
in t.pi0ClusterVec():
805 fprint (f, c.clusterLink().
index(),
', ')
◆ dump_TauPi0Cluster()
| def python.Dumpers.dump_TauPi0Cluster |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 810 of file Dumpers.py.
811 fprint (f, t.clusterLink().
index(),
821 t.asymmetryInEM1WRTTrk(),
826 t.firstEtaWRTClusterPosition_EM1(),
827 t.firstEtaWRTClusterPosition_EM2(),
828 t.secondEtaWRTClusterPosition_EM1(),
829 t.secondEtaWRTClusterPosition_EM2(),
◆ dump_TauPi0Details()
| def python.Dumpers.dump_TauPi0Details |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 835 of file Dumpers.py.
836 dump_TauDetail (t, f)
837 dump_HLV (t.visTauhlv(), f)
838 fprint (f,
' candidates')
839 for c
in t.pi0CandidateVector():
841 dump_TauPi0Candidate (c, f)
842 fprint (f,
' clusters')
843 for c
in t.pi0ClusterVector():
845 dump_TauPi0Cluster (c, f)
◆ dump_TauRecDetails()
| def python.Dumpers.dump_TauRecDetails |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 757 of file Dumpers.py.
758 dump_TauDetail (t, f)
760 fprint (f,
'%f %f %f %f %2d %f %f %f' %
762 t.isolationFraction(),
763 t.centralityFraction(),
770 for i
in range(t.numTrack()):
771 fprint (f,
'(%f %f) ' % (t.trackCaloEta(i), t.trackCaloPhi(i)))
773 dump_HLV (t.sumEM(), f)
775 dump_Threevec (t.secVertex().position(), f)
◆ dump_TauRecExtraDetails()
| def python.Dumpers.dump_TauRecExtraDetails |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 793 of file Dumpers.py.
794 dump_TauDetail (t, f)
795 fprint (f, t.numEMCells(), t.stripET(), t.emCentralityFraction(),
796 t.etHadAtEMScale(), t.etEMAtEMScale(), t.energy(), t.emEnergy(),
797 t.sumPTTracks(), t.seedType(),
tonone(t.analysisHelper()))
◆ dump_TgcBitmask()
| def python.Dumpers.dump_TgcBitmask |
( |
|
p, |
|
|
|
f, |
|
|
|
lab, |
|
|
|
fields |
|
) |
| |
Definition at line 5335 of file Dumpers.py.
5339 if getattr (p, ff): mask += val
5341 fprint (f, lab, hex (mask))
◆ dump_TgcClusterOnTrack()
| def python.Dumpers.dump_TgcClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2114 of file Dumpers.py.
2115 dump_MuonClusterOnTrack (p, f)
2116 dump_EL (p.prepRawDataLink(), f)
2117 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_TgcCoinData()
| def python.Dumpers.dump_TgcCoinData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4560 of file Dumpers.py.
4561 fprint (f, p.type(), p.channelIdIn().getString(), p.channelIdOut().getString(), p.identifyHash().
value())
4562 dump_IdentContIndex (p.getHashAndIndex(), f)
4563 fprint (f, p.isAside(), p.phi(), p.isInner(), p.isForward(), p.isStrip(), p.trackletId(), p.trackletIdStrip())
4564 fprint (f, p.widthIn(), p.widthOut())
4565 fprint (f, p.delta(), p.roi(), p.pt(), p.veto(), p.sub(), p.inner(), p.isPositiveDeltaR())
4566 if p.channelIdIn().get_compact() != 0:
4567 dump_AmgVector (p.posIn(), f, thresh=1e-8)
4568 dump_AmgVector (p.globalposIn(), f, thresh=1e-8)
4569 if p.channelIdOut().get_compact() != 0:
4570 dump_AmgVector (p.posOut(), f, thresh=1e-8)
4571 dump_AmgVector (p.globalposOut(), f, thresh=1e-8)
4573 dump_AmgMatrix (p.errMat(), f)
4574 if p.detectorElementIn():
4575 fprint (f, p.detectorElementIn().identifyHash().
value())
4577 fprint (f,
'(null detel)')
4578 if p.detectorElementOut():
4579 fprint (f, p.detectorElementOut().identifyHash().
value())
4581 fprint (f,
'(null detel)')
◆ dump_TgcCoinDataContainer()
| def python.Dumpers.dump_TgcCoinDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4723 of file Dumpers.py.
4724 dump_IDC (dump_TgcCoinData, p, f)
◆ dump_TgcPrepData()
| def python.Dumpers.dump_TgcPrepData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4553 of file Dumpers.py.
4554 dump_MuonCluster (p, f)
4555 fprint (f, p.getBcBitMap())
4556 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_TgcPrepDataContainer()
| def python.Dumpers.dump_TgcPrepDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4717 of file Dumpers.py.
4718 dump_IDC (dump_TgcPrepData, p, f)
◆ dump_TgcRawData()
| def python.Dumpers.dump_TgcRawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5307 of file Dumpers.py.
5308 fprint (f, p.bcTag(),
5310 p.subDetectorId(), p.rodId(), p.sswId(),
5311 p.slbId(), p.l1Id(), p.bcId(), p.slbType(),
5313 p.bitpos(), p.tracklet(), p.isAdjacent(),
5315 p.type(), p.isForward(), p.index(), p.position(),
5316 p.delta(), p.segment(), p.subMatrix(),
5318 p.sector(), p.chip(), p.isHipt(), p.hitId(), p.hsub(),
5319 p.isStrip(), p.inner(),
5321 p.cand3plus(), p.isMuplus(), p.threshold(), p.isOverlap(),
5322 p.isVeto(), p.roi(), p.innerflag(), p.coinflag(),
5324 p.nsweta(), p.nswphi(), p.nswsl(), p.nswcand(), p.nswdtheta(),
5325 p.nswphires(), p.nswlowres(), p.nswid(),
5327 p.rpceta(), p.rpcphi(), p.rpcflag(), p.rpcdeta(), p.rpcdphi(),
5329 p.ei(), p.fi(), p.cid(),
5331 p.tmdbmod(), p.tmdbbcid())
◆ dump_TgcRdo()
| def python.Dumpers.dump_TgcRdo |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5391 of file Dumpers.py.
5392 fprint (f, p.version(), p.identify(),
5393 p.subDetectorId(), p.rodId(), p.triggerType(),
5394 p.bcId(), p.l1Id(), p.orbit())
5395 dump_TgcRdo_Errors (p.errors(), f)
5396 dump_TgcRdo_RodStatus (p.rodStatus(), f)
5397 dump_TgcRdo_LocalStatus (p.localStatus(), f)
◆ dump_TgcRdo_Errors()
| def python.Dumpers.dump_TgcRdo_Errors |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5343 of file Dumpers.py.
5344 dump_TgcBitmask (p, f,
'err',
◆ dump_TgcRdo_LocalStatus()
| def python.Dumpers.dump_TgcRdo_LocalStatus |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5382 of file Dumpers.py.
5383 dump_TgcBitmask (p, f,
'local',
5385 'mergedTrackletBCs',
◆ dump_TgcRdo_RodStatus()
| def python.Dumpers.dump_TgcRdo_RodStatus |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5351 of file Dumpers.py.
5352 dump_TgcBitmask (p, f,
'rod',
◆ dump_TgcRdoContainer()
| def python.Dumpers.dump_TgcRdoContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5401 of file Dumpers.py.
5402 dump_IDC (dump_TgcRawData, p, f,
5403 extra_idc_dumper = dump_TgcRdo)
◆ dump_TGCSimHit()
| def python.Dumpers.dump_TGCSimHit |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5216 of file Dumpers.py.
5217 fprintln (f, p.TGCid(), p.globalTime())
5218 dump_Threevec (p.localPosition(), f)
5219 dump_Threevec (p.localDireCos(), f)
5220 fprint (f, p.stepLength(), p.energyDeposit(), p.particleEncoding(), p.kineticEnergy())
5221 dump_HepMcParticleLink (p.particleLink(), f)
◆ dump_Threevec()
| def python.Dumpers.dump_Threevec |
( |
|
v, |
|
|
|
f |
|
) |
| |
◆ dump_TileBeamElemContainer()
| def python.Dumpers.dump_TileBeamElemContainer |
( |
|
data, |
|
|
|
f |
|
) |
| |
Definition at line 4922 of file Dumpers.py.
4923 fprintln (f, data.get_unit(), data.get_type(), data.get_bsflags())
4928 fprint (f,
'Coll', beg.hashId().
value(), coll.size())
◆ dump_TileDigits()
| def python.Dumpers.dump_TileDigits |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4829 of file Dumpers.py.
4830 dump_TileRawData (p, f)
4831 fprint (f,
list(p.get_digits()))
◆ dump_TileDigitsContainer()
| def python.Dumpers.dump_TileDigitsContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4836 of file Dumpers.py.
4837 fprint (f, p.get_unit(), p.get_type(), p.get_bsflags())
4838 fprint (f, p.hashFunc().
max(), p.hashFunc().
offset(), p.hashFunc().
type())
4842 if hasattr(beg.__class__,
'__preinc__'):
4843 nextfunc = beg.__preinc__
4844 elif hasattr(beg.__class__,
'__next__'):
4845 nextfunc = beg.__next__
4851 beg.hashId().
value(),
4852 list(coll.getFragChipCRCWords()),
4853 list(coll.getFragChipCRCWordsHigh()),
4854 list(coll.getFragChipHeaderWords()),
4855 list(coll.getFragChipHeaderWordsHigh()),
4857 coll.getFragBCID(), coll.getFragSize())
4860 dump_TileDigits (x, f)
◆ dump_TileHit()
| def python.Dumpers.dump_TileHit |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4239 of file Dumpers.py.
4241 fprint (f, t.identify().getString(), [t.energy(i)
for i
in range(sz)],
4242 [t.time(i)
for i
in range(sz)])
◆ dump_TileL2()
| def python.Dumpers.dump_TileL2 |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4936 of file Dumpers.py.
4937 fprint (f, p.identify(), p.phi(0), p.cosphi(), p.sinphi())
4938 fprint (f, [p.sumE(i)
for i
in range(p.NsumE())])
4939 fprint (f, [p.eta(i)
for i
in range(p.NMuons())])
4940 fprint (f, [p.enemu0(i)
for i
in range(p.NMuons())])
4941 fprint (f, [p.enemu1(i)
for i
in range(p.NMuons())])
4942 fprint (f, [p.enemu2(i)
for i
in range(p.NMuons())])
4943 fprint (f, formatItemUsingLong ([p.qual(i)
for i
in range(p.NMuons())]))
4944 fprint (f, formatItemUsingLong ([p.val(i)
for i
in range(p.Ndata())]))
◆ dump_TileMu()
| def python.Dumpers.dump_TileMu |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4160 of file Dumpers.py.
4161 fprint (f, m.eta(), m.phi(), m.quality(),
list(m.enedep()))
◆ dump_TileMuFeature()
| def python.Dumpers.dump_TileMuFeature |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4117 of file Dumpers.py.
4118 fprint (f,
' ', m.eta(), m.phi(), m.quality(),
list(m.enedep()))
◆ dump_TileMuonReceiverObj()
| def python.Dumpers.dump_TileMuonReceiverObj |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4953 of file Dumpers.py.
4954 fprint (f, p.GetID(), list (p.GetDecision()),
4955 list(p.GetThresholds()),
list(p.GetEne()),
list(p.GetTime()))
◆ dump_TileRawChannel()
| def python.Dumpers.dump_TileRawChannel |
( |
|
data, |
|
|
|
f |
|
) |
| |
Definition at line 4867 of file Dumpers.py.
4868 dump_TileRawData (data, f)
4869 fprint (f, [data.amplitude(i)
for i
in range(data.size())])
4870 fprint (f, [data.time(i)
for i
in range(data.sizeTime())])
4871 fprint (f, [data.quality(i)
for i
in range(data.sizeQuality())])
4872 fprint (f, data.pedestal())
◆ dump_TileRawChannelCollection()
| def python.Dumpers.dump_TileRawChannelCollection |
( |
|
data, |
|
|
|
f |
|
) |
| |
Definition at line 4889 of file Dumpers.py.
4890 fprint (f,
'\n ', data.getFragGlobalCRC(),
4891 data.getFragDSPBCID(),
4893 data.getFragMemoryPar(),
4894 data.getFragSstrobe(),
4895 data.getFragDstrobe(),
4896 data.getFragHeaderBit(),
4897 data.getFragHeaderPar(),
4898 data.getFragSampleBit(),
4899 data.getFragSamplePar(),
4900 data.getFragFEChipMask(),
4901 data.getFragRODChipMask())
4902 dump_TileRawDataCollection (data, f)
◆ dump_TileRawChannelContainer()
| def python.Dumpers.dump_TileRawChannelContainer |
( |
|
data, |
|
|
|
f |
|
) |
| |
Definition at line 4907 of file Dumpers.py.
4908 fprintln (f, data.get_unit(), data.get_type(), data.get_bsflags())
4913 fprint (f,
'Coll', beg.hashId().
value(), coll.size())
4914 dump_TileRawChannelCollection (coll, f)
◆ dump_TileRawData()
| def python.Dumpers.dump_TileRawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4824 of file Dumpers.py.
4825 fprint (f, p.identify().getString())
◆ dump_TileRawDataCollection()
| def python.Dumpers.dump_TileRawDataCollection |
( |
|
data, |
|
|
|
f |
|
) |
| |
Definition at line 4877 of file Dumpers.py.
4878 fprint (f,
'\n ', data.identify(),
4881 data.getDetEvType(),
4885 dump_TileRawChannel (x, f)
◆ dump_TileTrackMuFeature()
| def python.Dumpers.dump_TileTrackMuFeature |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4122 of file Dumpers.py.
4124 fprint (f, m.PtTR_Trk(), m.EtaTR_Trk(), m.PhiTR_Trk(), m.Typ_IDTrk())
4125 fprint (f,
'\n ', m.pt(), m.eta(), m.phi(), m.m())
4126 fprint (f,
'\n ', m.TileMuLink().
isValid())
4128 fprintln (f, m.TileMuLink().dataID(), m.TileMuLink().
index())
4129 fprint (f,
'\n ', m.IDScanLink().
isValid())
4131 fprintln (f, m.IDScanLink().dataID(), m.IDScanLink().
index())
◆ dump_TileTTL1()
| def python.Dumpers.dump_TileTTL1 |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4948 of file Dumpers.py.
4949 fprint (f, p.identify().getString(),
list(p.fsamples()))
◆ dump_Track()
| def python.Dumpers.dump_Track |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2259 of file Dumpers.py.
2261 pm = p.trackParameters()
2262 for i
in range(len(pm)):
2264 dump_parameters (pm[i], f)
2266 for x
in p.measurementsOnTrack():
2268 dump_measurement (x, f)
2270 for x
in p.outliersOnTrack():
2272 dump_measurement (x, f)
2274 for x
in p.trackStateOnSurfaces():
2276 dump_TrackStateOnSurface (x, f)
2277 fprint (f,
'\n pp ')
2278 dump_parameters (p.perigeeParameters(), f)
2279 fprint (f,
'\n fq ')
2280 dump_FitQuality (p.fitQuality(), f)
2281 fprint (f,
'\n tm ')
2282 dump_TrackSummary (p.trackSummary(), f)
2283 fprint (f,
'\n ti ')
2284 dump_TrackInfo (p.info(), f)
◆ dump_TrackAssociation()
| def python.Dumpers.dump_TrackAssociation |
( |
|
a, |
|
|
|
f |
|
) |
| |
Definition at line 3498 of file Dumpers.py.
3499 dump_JetAssociationBase (a, f)
3500 fprint (f, a.nTracks())
3502 ROOT.SetOwnership (tr,
True)
3504 fprint (f, a.getTrackWeight (t))
◆ dump_TrackConstituents()
| def python.Dumpers.dump_TrackConstituents |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1276 of file Dumpers.py.
1278 ROOT.SetOwnership (tr,
True)
1280 fprint (f,
'\n tr: ')
1282 fprint (f, info.getTrackWeight(t))
◆ dump_TrackCountingInfo()
| def python.Dumpers.dump_TrackCountingInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1219 of file Dumpers.py.
1220 dump_BaseTagInfo (info, f)
1221 fprint (f,
'%d %f %f %f %f' %
1224 info.d0sig_abs_2nd(),
1226 info.d0sig_abs_3rd()))
◆ dump_TrackInfo()
| def python.Dumpers.dump_TrackInfo |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2252 of file Dumpers.py.
2253 fprint (f, p.trackFitter(), p.particleHypothesis())
2255 fprint (f, p.patternRecognition().
to_string())
◆ dump_TrackParticle()
| def python.Dumpers.dump_TrackParticle |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1593 of file Dumpers.py.
1596 if p.trackParameters().
size() > 0
and p.trackParameters()[-1]:
1597 dp = p.definingParameters()
1599 fprint (f,
"%f" % p.charge())
1602 fprint (f,
"%1d" % p.particleOriginType())
1607 vx = p.reconstructedVertex()
1609 dump_Threevec (vx.recVertex().position(), f)
1611 fprint (f, tonone (vx))
1612 if p.fitQuality() != fitQualityNull:
1614 dump_FitQuality (p.fitQuality(), f)
1615 if p.trackSummary():
1617 dump_TrackSummary (p.trackSummary(), f)
1619 dump_parameters (dp, f)
1621 for x
in p.trackParameters():
1623 dump_parameters (x, f)
◆ dump_TrackParticleAssocs()
| def python.Dumpers.dump_TrackParticleAssocs |
( |
|
a, |
|
|
|
f |
|
) |
| |
Definition at line 3442 of file Dumpers.py.
3443 return dump_Assocs (a, f, PyAthena.Rec.TrackParticleContainer)
◆ dump_TrackParticleTruth()
| def python.Dumpers.dump_TrackParticleTruth |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1387 of file Dumpers.py.
1388 fprint (f,
'%4d %f' % (p.particleLink().
barcode(), p.probability()))
1389 gp = p.particleLink().cptr()
1391 dump_HLV (gp.momentum(), f)
1393 fprint (f,
' (no part)')
◆ dump_TrackParticleTruthCollection()
| def python.Dumpers.dump_TrackParticleTruthCollection |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 1398 of file Dumpers.py.
1399 fprintln (f,
' ', c.trackParticleContainerLink().
isValid())
1400 elclass = PyAthena.ElementLink (PyAthena.Rec.TrackParticleContainer)
1401 for i
in range (c.size()):
1404 cont = PyAthena.Rec.TrackParticleContainer()
1405 el.toIndexedElement (cont, i)
1406 dump_TrackParticleTruth (c[PyAthena.Rec.TrackParticleTruthKey(el)], f)
◆ dump_TrackRecord()
| def python.Dumpers.dump_TrackRecord |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3223 of file Dumpers.py.
3224 dump_H3V (t.GetPosition(), f)
3225 dump_H3V (t.GetMomentum(), f)
3226 fprint (f, t.GetEnergy(),
◆ dump_TrackStateOnSurface()
| def python.Dumpers.dump_TrackStateOnSurface |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2239 of file Dumpers.py.
2240 dump_FitQuality (p.fitQualityOnSurface(), f)
2241 fprint (f,
'\n pm ')
2242 dump_parameters (p.trackParameters(), f)
2243 fprint (f,
'\n ms ')
2244 dump_measurement (p.measurementOnTrack(), f)
2245 fprint (f,
'\n me ')
2246 dump_materialeffects (p.materialEffectsOnTrack(), f)
2247 fprint (f,
'\n ae ')
2248 dump_AlignmentEffectsOnTrack (p.alignmentEffectsOnTrack(), f)
◆ dump_TrackSummary()
| def python.Dumpers.dump_TrackSummary |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1444 of file Dumpers.py.
1446 fprint (f,
'(null)')
1448 fprint (f, [info.get(i)
for i
in range(32)],
1449 [info.isHit(i)
for i
in range(21)])
◆ dump_TrackTruthCollection()
| def python.Dumpers.dump_TrackTruthCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2085 of file Dumpers.py.
2087 fprint (f,
'\n ', x.first.index())
2088 dump_HepMcParticleLink (x.second.particleLink(), f)
2089 fprint (f, x.second.probability())
◆ dump_Trig3Momentum()
| def python.Dumpers.dump_Trig3Momentum |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 3872 of file Dumpers.py.
3873 fprint (f, m.e(), m.eta(), m.phi(), m.inCone(), m.caloSample())
◆ dump_TrigCaloCluster()
| def python.Dumpers.dump_TrigCaloCluster |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 3727 of file Dumpers.py.
3728 fprint (f, c.rawEnergy(), c.rawEt(), c.rawEta(), c.rawPhi(), c.RoIword(),
3729 c.nCells(), c.quality())
3730 fprint (f,
'\n ', [c.rawEnergy(i)
for i
in range(25)])
◆ dump_TrigConfAlg()
| def python.Dumpers.dump_TrigConfAlg |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1873 of file Dumpers.py.
1874 ss = ROOT.ostringstream()
1876 fprint (f, p.index(), ss.str())
◆ dump_TrigConfChain()
| def python.Dumpers.dump_TrigConfChain |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1856 of file Dumpers.py.
1857 fprint (f, p.getName(), p.getChainName(), p.getLowerName(),
1858 p.getId(), p.getCounter(),
1859 p.getLowerId(), p.getLowerCounter(),
1860 p.getLevelId(), p.getPrescale(), p.getPassThrough())
1861 fprint (f,
'\n lower ids',
list(p.getLowerIds()))
1862 fprint (f,
'\n stream ps',
list(p.getStreamPS()))
1863 fprint (f,
'\n stream name',
list(p.getStream()))
1864 fprint (f,
'\n group',
list(p.getGroup()))
1865 fprint (f,
'\n EB hypo',
list(p.getEBHypo()))
1866 fprint (f,
'\n sigs')
1867 for s
in p.getSignature():
1869 dump_TrigConfSig (s, f)
◆ dump_TrigConfKeys()
| def python.Dumpers.dump_TrigConfKeys |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4510 of file Dumpers.py.
4511 fprint (f, p.smk(), p.l1psk(), p.hltpsk())
◆ dump_TrigConfSeq()
| def python.Dumpers.dump_TrigConfSeq |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1879 of file Dumpers.py.
1880 fprint (f, p.getName(), p.getIndex(), p.getId(), p.getTopoTE())
1881 fprint (f,
'\n algs')
1882 for a
in p.getAlg():
1884 dump_TrigConfAlg (a, f)
1885 fprint (f,
'\n input TE',
list(p.getInputTEs()))
◆ dump_TrigConfSig()
| def python.Dumpers.dump_TrigConfSig |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1851 of file Dumpers.py.
1852 fprint (f, p.getCounter(), p.getLogic(), p.getLabel(),
1853 list(p.getOutputTEs()))
◆ dump_TrigDecision()
| def python.Dumpers.dump_TrigDecision |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3086 of file Dumpers.py.
3087 fprint (f, t.masterKey())
3089 dump_Lvl1Result (t.getL1Result(), f)
3091 dump_HLTResult (t.getL2Result(), f)
3093 dump_HLTResult (t.getEFResult(), f)
◆ dump_TrigEFBjet()
| def python.Dumpers.dump_TrigEFBjet |
( |
|
j, |
|
|
|
f |
|
) |
| |
Definition at line 3776 of file Dumpers.py.
3778 fprint (f, j.isValid(), j.roiId())
3779 fprint (f,
'\n ', j.prmVtx(), j.xComb(), j.xIP1D(), j.xIP2D(),
3780 j.xIP3D(), j.xCHI2(), j.xSV(), j.xMVtx(), j.xEVtx(), j.xNVtx())
3781 fprint (f,
'\n ',
tonone(j.TrackCollection()),
3782 tonone(j.PrmVertexCollection()),
3783 tonone(j.SecVertexCollection()))
◆ dump_TrigEFBphys()
| def python.Dumpers.dump_TrigEFBphys |
( |
|
j, |
|
|
|
f |
|
) |
| |
Definition at line 3787 of file Dumpers.py.
3788 fprint (f, j.roiId(), j.particleType(), j.eta(), j.phi(),
3789 j.mass(), j.fitmass(), j.fitchi2(), j.fitndof(),
3790 j.fitx(), j.fity(), j.fitz())
3791 if j.pSecondDecay():
3792 fprint (f,
'\n second:')
3793 dump_TrigEFBphys (j.pSecondDecay(), f)
3794 vec = j.trackVector()
3795 for i
in range(len(vec)):
3797 fprint (f,
'\n tv:')
3799 fprint (f, t.dataID(), t.index())
3801 fprint (f,
'(invalid)')
◆ dump_TrigElectron()
| def python.Dumpers.dump_TrigElectron |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 3747 of file Dumpers.py.
3749 fprint (f, p.isValid(), p.roiId())
3750 fprint (f,
'\n ', p.trackAlgo(), p.trackIndx(), p.charge(),
3752 fprint (f,
'\n ', p.err_Pt(), p.err_eta(), p.err_phi(), p.err_Zvtx())
3753 fprint (f,
'\n ', p.trkClusDeta(), p.trkClusDphi(), p.EtOverPt())
◆ dump_TrigEMCluster()
| def python.Dumpers.dump_TrigEMCluster |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 3734 of file Dumpers.py.
3735 dump_TrigCaloCluster (c, f)
3736 fprint (f,
'\n ', c.energy(), c.et(), c.eta(), c.phi(),
3737 c.e237(), c.e277(), c.fracs1(), c.weta2(),
3738 c.ehad1(), c.Eta1(), c.emaxs1(), c.e2tsts1())
3739 fprint (f,
'\n ', [c.energyInSample(i)
for i
in range(25)])
◆ dump_TrigEMCluster_nolist()
| def python.Dumpers.dump_TrigEMCluster_nolist |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 3742 of file Dumpers.py.
3743 dump_TrigEMCluster (c, f)
◆ dump_TriggerInfo()
| def python.Dumpers.dump_TriggerInfo |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 2705 of file Dumpers.py.
2706 fprint (f, e.statusElement(), e.extendedLevel1ID(), e.level1TriggerType())
2707 fprint (f,
'\n l2:', formatItemUsingLong ([x
for x
in e.level2TriggerInfo()]))
2708 fprint (f,
'\n ef:', formatItemUsingLong ([x
for x
in e.eventFilterInfo()]))
2709 fprint (f,
'\n st:', [(x.name(), x.type(), x.obeysLumiblock())
for x
in e.streamTags()])
◆ dump_TriggerTower()
| def python.Dumpers.dump_TriggerTower |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5160 of file Dumpers.py.
5161 fprint (f, p.eta(), p.phi(), p.key(), p.emError(), p.hadError(),
5162 p.emPeak(), p.emADCPeak(), p.hadPeak(), p.hadADCPeak(),
5165 list(p.emBCIDvec()),
list(p.hadBCIDvec()),
5166 list(p.emBCIDext()),
list(p.hadBCIDext()))
◆ dump_TrigHisto()
| def python.Dumpers.dump_TrigHisto |
( |
|
h, |
|
|
|
f |
|
) |
| |
Definition at line 3924 of file Dumpers.py.
3925 fprint (f,
"x:", h.nbins_x(), h.min_x(), h.max_x(),
'[')
3926 for x
in h.contents():
◆ dump_TrigHisto1D()
| def python.Dumpers.dump_TrigHisto1D |
( |
|
h, |
|
|
|
f |
|
) |
| |
Definition at line 3930 of file Dumpers.py.
3931 dump_TrigHisto (h, f)
◆ dump_TrigHisto2D()
| def python.Dumpers.dump_TrigHisto2D |
( |
|
h, |
|
|
|
f |
|
) |
| |
Definition at line 3933 of file Dumpers.py.
3934 fprint (f,
"y:", h.nbins_y(), h.min_y(), h.max_y())
3935 dump_TrigHisto (h, f)
◆ dump_TrigInDetTrack()
| def python.Dumpers.dump_TrigInDetTrack |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3288 of file Dumpers.py.
3289 fprint (f,
"%d %f %d %d %d %d" %
3296 fprint (f,
tonone(t.siSpacePoints),
tonone(t.trtDriftCircles))
3297 fprint (f,
'\n par')
3299 dump_TrigInDetTrackFitPar (t.param, f)
3302 fprint (f,
'\n end')
3304 dump_TrigInDetTrackFitPar (t.endParam, f)
◆ dump_TrigInDetTrackCollection()
| def python.Dumpers.dump_TrigInDetTrackCollection |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3769 of file Dumpers.py.
3770 fprintln (f,
' ROI ', t.RoI_ID())
3771 t2 = [PyTrigInDetTrack(tt)
for tt
in t]
3772 dump_list (t2, f, dump_TrigInDetTrack)
◆ dump_TrigInDetTrackFitPar()
| def python.Dumpers.dump_TrigInDetTrackFitPar |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 3269 of file Dumpers.py.
3270 fprint (f,
"%f %f %f %f %f %f %f %f %f %f %f %d" %
3281 p.surfaceCoordinate,
3284 fprint (f, [x
for x
in p.cov])
◆ dump_TrigInDetTrackTruth()
| def python.Dumpers.dump_TrigInDetTrackTruth |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3251 of file Dumpers.py.
3252 fprint (f, t.nrMatches())
3253 if t.nrMatches() == 0:
return
3254 fprint (f, t.bestMatch().
barcode(),
3258 t.nrCommonHitsBestSi(),
3259 t.nrCommonHitsBestTRT())
3262 t.nrCommonSiHits(i),
3263 t.nrCommonTRTHits(i))
3264 for i
in range(t.nrMatches())]))
3265 fprint (f, formatItemUsingLong ([(p.first, p.second)
for p
in t.getFamilyTree()]))
◆ dump_TrigInDetTrackTruthMap()
| def python.Dumpers.dump_TrigInDetTrackTruthMap |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 3367 of file Dumpers.py.
3370 tm = [(m.truthi(i), PyTrigInDetTrack(m.tracki(i)))
3372 tm.sort (key = cmp_to_key (_tmcmp))
3373 for (i, (truth, track))
in enumerate(tm):
3374 fprint (f,
'\n ', i)
3375 dump_TrigInDetTrackTruth (truth, f)
3377 dump_TrigInDetTrack (track, f)
◆ dump_TrigL2Bjet()
| def python.Dumpers.dump_TrigL2Bjet |
( |
|
j, |
|
|
|
f |
|
) |
| |
Definition at line 3805 of file Dumpers.py.
3807 fprint (f, j.isValid(), j.roiId())
3808 fprint (f,
'\n ', j.prmVtx(), j.xComb(), j.xIP1D(), j.xIP2D(),
3809 j.xIP3D(), j.xCHI2(), j.xSV(), j.xMVtx(), j.xEVtx(), j.xNVtx())
3811 tonone(j.TrackCollection()),
3812 tonone(j.PrmVertexCollection()),
3813 tonone(j.SecVertexCollection()))
◆ dump_TrigL2Bphys()
| def python.Dumpers.dump_TrigL2Bphys |
( |
|
j, |
|
|
|
f |
|
) |
| |
Definition at line 3817 of file Dumpers.py.
3818 fprint (f, j.roiId(), j.particleType(), j.eta(), j.phi(),
3819 j.mass(), j.fitmass(), j.fitchi2(), j.fitndof(),
3820 j.fitx(), j.fity(), j.fitz())
3821 if j.pSecondDecay():
3822 fprint (f,
'\n second:')
3823 dump_TrigL2Bphys (j.pSecondDecay(), f)
3827 tv = j.trackVector()
3828 for i
in range(tv.size()):
3830 fprint (f,
'\n tv:', t.dataID(), t.index())
◆ dump_TrigMissingET()
| def python.Dumpers.dump_TrigMissingET |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 3834 of file Dumpers.py.
3835 fprint (f,
' ', m.ex(), m.ey(), m.ez(), m.sumEt(), m.sumE(),
3836 m.RoIword(), m.getFlag(), m.getNumOfComponents())
3837 for ic
in range(m.getNumOfComponents()):
3838 fprint (f,
'\n ', m.getNameOfComponent(ic),
3839 m.getExComponent(ic), m.getEyComponent(ic),
3840 m.getEzComponent(ic), m.getSumEtComponent(ic),
3841 m.getSumEComponent(ic), m.getComponentCalib0(ic),
3842 m.getComponentCalib1(ic), m.getSumOfSigns(ic),
3843 m.getUsedChannels(ic), m.getStatus(ic))
◆ dump_TrigMissingET_nolist()
| def python.Dumpers.dump_TrigMissingET_nolist |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 3847 of file Dumpers.py.
3848 dump_TrigMissingET (m, f)
◆ dump_TrigMonAlg()
| def python.Dumpers.dump_TrigMonAlg |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1804 of file Dumpers.py.
1805 fprint (f, [ord(x)
for x
in p.getByte()],
list(p.getWord()))
◆ dump_TrigMonConfig()
| def python.Dumpers.dump_TrigMonConfig |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1888 of file Dumpers.py.
1889 fprint (f,
'r/e/lb', p.getRun(), p.getEvent(), p.getLumi(),
1890 'tm', p.getSec(), p.getNanoSec(),
1891 'keys', p.getMasterKey(), p.getHLTPrescaleKey(),
1892 p.getLVL1PrescaleKey())
1893 fprint (f,
'\n chains')
1894 for r
in p.getChainVec():
1896 dump_TrigConfChain (r, f)
1897 fprint (f,
'\n seqs')
1898 for r
in p.getSeqVec():
1900 dump_TrigMonSeq (r, f)
1901 fprint (f,
'\n key',
list(p.getVarKey()))
1902 fprint (f,
'\n val',
list(p.getVarVal()))
1903 fprint (f,
'\n pairkey',
list(p.getPairKey()))
1904 fprint (f,
'\n pairval',
list(p.getPairVal()))
◆ dump_TrigMonEvent()
| def python.Dumpers.dump_TrigMonEvent |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1825 of file Dumpers.py.
1826 fprint (f,
'r/e/lb/bc', p.getRun(), p.getEvent(), p.getLumi(), p.getBunchId(),
1827 'tm', p.getSec(), p.getNanoSec(),
'addl',
list(p.word()))
1828 fprint (f,
'\n robs')
1829 for r
in p.getROBVec():
1831 dump_TrigMonROB (r, f)
1832 fprint (f,
'\n rois')
1833 for r
in p.getRoiVec():
1835 dump_TrigMonRoi (r, f)
1836 fprint (f,
'\n seq2')
1837 for r
in p.getSeqVec():
1839 dump_TrigMonSeq (r, f)
1840 fprint (f,
'\n tes')
1841 for r
in p.getTEVec():
1843 dump_TrigMonTE (r, f)
1844 fprint (f,
'\n l1',
list(p.getL1Item()))
1845 fprint (f,
'\n hlt',
list(p.getChain()))
1846 fprint (f,
'\n key',
list(p.getVarKey()))
1847 fprint (f,
'\n val',
list(p.getVarVal()))
◆ dump_TrigMonROB()
| def python.Dumpers.dump_TrigMonROB |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1793 of file Dumpers.py.
1794 fprint (f, [(x.getROBId(), x.isStatusOk(), x.isStatusPrefetched(),
1795 x.getROBSize(), x.getEncodedState(), x.getHistory(),
1796 x.getStatus())
for x
in p.getData()],
◆ dump_TrigMonRoi()
| def python.Dumpers.dump_TrigMonRoi |
( |
|
p, |
|
|
|
f |
|
) |
| |
◆ dump_TrigMonSeq()
| def python.Dumpers.dump_TrigMonSeq |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1808 of file Dumpers.py.
1809 fprint (f, p.getEncoded(),
list(p.getVarKey()),
list(p.getVarVal()))
1810 for a
in p.getAlg():
1812 dump_TrigMonAlg (a, f)
◆ dump_TrigMonTE()
| def python.Dumpers.dump_TrigMonTE |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1815 of file Dumpers.py.
1816 fprint (f, p.getId(),
1817 p.getIndex(), p.getType(),
1818 p.getActiveState(), p.getErrorState(), p.isTerminalNode(),
1819 p.isOutputL2Node(), p.isOutputEFNode(), p.isTopologicalTE(),
1820 list(p.getChildIndex()), list (p.getParentIndex()),
1821 list(p.getRoiId()),
list(p.getClid()),
1822 list(p.getVarKey()),
list(p.getVarVal()))
◆ dump_TrigMuonClusterFeature()
| def python.Dumpers.dump_TrigMuonClusterFeature |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4435 of file Dumpers.py.
4437 fprint (f, m.getNRoi(), m.getNTRK(), m.getNJet())
◆ dump_TrigMuonEF()
| def python.Dumpers.dump_TrigMuonEF |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4154 of file Dumpers.py.
4156 fprint (f, m.MuonCode(), m.RoINum(), m.charge())
◆ dump_TrigMuonEFInfo()
| def python.Dumpers.dump_TrigMuonEFInfo |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4337 of file Dumpers.py.
4338 fprint (f, t.RoINum())
4339 for tt
in t.TrackContainer():
4340 dump_TrigMuonEFInfoTrack (tt, f)
◆ dump_TrigMuonEFInfoTrack()
| def python.Dumpers.dump_TrigMuonEFInfoTrack |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4326 of file Dumpers.py.
4327 fprint (f,
'\n ', t.MuonType())
4328 fprint (f,
'\n spectrometer: ')
4329 dump_TrigMuonEFTrack (t.SpectrometerTrack(), f)
4330 fprint (f,
'\n extrapolated: ')
4331 dump_TrigMuonEFTrack (t.ExtrapolatedTrack(), f)
4332 fprint (f,
'\n combined: ')
4333 dump_TrigMuonEFTrack (t.CombinedTrack(), f)
◆ dump_TrigMuonEFIsolation()
| def python.Dumpers.dump_TrigMuonEFIsolation |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4458 of file Dumpers.py.
4459 fprint (f, m.sumTrkPtCone02(), m.sumTrkPtCone03(), m.trackPosition())
◆ dump_TrigMuonEFTrack()
| def python.Dumpers.dump_TrigMuonEFTrack |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4317 of file Dumpers.py.
4322 fprint (f, t.charge())
◆ dump_TrigOperationalInfo()
| def python.Dumpers.dump_TrigOperationalInfo |
( |
|
b, |
|
|
|
f |
|
) |
| |
◆ dump_TrigPassBits()
| def python.Dumpers.dump_TrigPassBits |
( |
|
b, |
|
|
|
f |
|
) |
| |
Definition at line 4441 of file Dumpers.py.
4442 fprint (f, [b.isPassing(i)
for i
in range(b.size())])
◆ dump_TrigPassFlags()
| def python.Dumpers.dump_TrigPassFlags |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4463 of file Dumpers.py.
4465 if hasattr (m,
'getNumObjects'):
4466 for i
in range (m.getNumObjects()):
4468 fprint (f, i,
list(m.getFlag(i,j)
for j
in range(m.getNumFlags(i))))
4470 for i
in range (m.size()):
4472 fprint (f, i,
list(m.getFlagBit(i,j)
for j
in range(m.flagSize())))
◆ dump_TrigPhoton()
| def python.Dumpers.dump_TrigPhoton |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 3757 of file Dumpers.py.
3759 fprint (f, p.isValid(), p.roiId())
3760 fprint (f,
'\n ', p.Et(), p.HadEt(), p.energyRatio(), p.rCore(),
3764 dump_TrigEMCluster (p.cluster(), f)
◆ dump_TrigRNNOutput()
| def python.Dumpers.dump_TrigRNNOutput |
( |
|
p, |
|
|
|
f |
|
) |
| |
◆ dump_TrigRoiDescriptor()
| def python.Dumpers.dump_TrigRoiDescriptor |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 3863 of file Dumpers.py.
3864 fprint (f,
' ', d.roiId(), d.l1Id(), d.roiWord())
3865 dump_RoiDescriptor (d, f)
◆ dump_TrigRoiDescriptor_nolist()
| def python.Dumpers.dump_TrigRoiDescriptor_nolist |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 3867 of file Dumpers.py.
3868 dump_TrigRoiDescriptor (d, f)
◆ dump_TrigSpacePointCounts()
| def python.Dumpers.dump_TrigSpacePointCounts |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 3938 of file Dumpers.py.
3939 fprint (f, c.sctSpEndcapC(), c.sctSpBarrel(), c.sctSpEndcapA(),
'[')
3940 for id
in c.droppedSctModules():
3941 fprint (f, id.getString())
3943 fprint (f,
'\n clus endcap c: ')
3944 dump_TrigHisto2D (c.pixelClusEndcapC(), f)
3945 fprint (f,
'\n clus barrel: ')
3946 dump_TrigHisto2D (c.pixelClusBarrel(), f)
3947 fprint (f,
'\n clus endcap a: ')
3948 dump_TrigHisto2D (c.pixelClusEndcapA(), f)
◆ dump_TrigSpacePointCounts_nolist()
| def python.Dumpers.dump_TrigSpacePointCounts_nolist |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 3951 of file Dumpers.py.
3952 dump_TrigSpacePointCounts (c, f)
◆ dump_TrigT2Jet()
| def python.Dumpers.dump_TrigT2Jet |
( |
|
j, |
|
|
|
f |
|
) |
| |
Definition at line 3877 of file Dumpers.py.
3880 fprint (f,
' ', j.e(), j.ehad0(), j.eem0(), j.eta(), j.phi(), j.m(),
3885 dump_Trig3Momentum (m, f)
◆ dump_TrigT2Jet_nolist()
| def python.Dumpers.dump_TrigT2Jet_nolist |
( |
|
j, |
|
|
|
f |
|
) |
| |
Definition at line 3889 of file Dumpers.py.
3890 dump_TrigT2Jet (j, f)
◆ dump_TrigT2MbtsBits()
| def python.Dumpers.dump_TrigT2MbtsBits |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4269 of file Dumpers.py.
4270 if hasattr(t,
'triggerEnergies'):
4271 fprint (f,
list(t.triggerEnergies()),
list(t.triggerTimes()))
4273 fprint (f, t.mbtsWord(),
list(t.triggerTimes()))
◆ dump_TrigT2ZdcSignals()
| def python.Dumpers.dump_TrigT2ZdcSignals |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2012 of file Dumpers.py.
2013 fprint (f,
list(p.triggerEnergies()),
list(p.triggerTimes()))
◆ dump_TrigTau()
| def python.Dumpers.dump_TrigTau |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3713 of file Dumpers.py.
3715 fprint (f, t.roiId(), t.Zvtx(), t.err_Zvtx(), t.etCalibCluster(),
3716 t.simpleEtFlow(), t.nMatchedTracks())
3717 fprint (f,
'\n ',
tonone(t.tauCluster()),
3718 tonone(t.trackCollection()),
◆ dump_TrigTau_nolist()
| def python.Dumpers.dump_TrigTau_nolist |
( |
|
t, |
|
|
|
f |
|
) |
| |
◆ dump_TrigTauCluster()
| def python.Dumpers.dump_TrigTauCluster |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3906 of file Dumpers.py.
3908 dump_TrigCaloCluster (t, f)
3909 fprint (f,
'\n ', t.energy(), t.EMCalibEnergy(), t.EMenergy(),
3910 t.HADenergy(), t.eta(), t.phi(), t.IsoFrac(), t.numStripCells(),
3911 t.stripWidth(), t.eCalib(), t.eEMCalib(), t.EMRadius2())
3913 fprint (f,
'\n %2d: '% s)
3914 fprint (f, t.energy(s))
3915 dump_TrigTauClusterDetails (t.clusterDetails(), f)
◆ dump_TrigTauCluster_nolist()
| def python.Dumpers.dump_TrigTauCluster_nolist |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3919 of file Dumpers.py.
3920 dump_TrigTauCluster (t, f)
◆ dump_TrigTauClusterDetails()
| def python.Dumpers.dump_TrigTauClusterDetails |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3894 of file Dumpers.py.
3897 fprint (f,
'\n EM%d: '% s)
3898 fprint (f, t.EMRadius(s), t.EMenergyWidth(s), t.EMenergyMedium(s),
3899 t.EMenergyWide(s), t.EMenergyNarrow(s))
3901 fprint (f,
'\n HAD%d: '% s)
3902 fprint (f, t.HADRadius(s), t.HADenergyWidth(s), t.HADenergyMedium(s),
3903 t.HADenergyWide(s), t.HADenergyNarrow(s))
◆ dump_TrigTauTracksInfo()
| def python.Dumpers.dump_TrigTauTracksInfo |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3956 of file Dumpers.py.
3959 fprint (f,
' ', t.roiId(), t.nCoreTracks(), t.nSlowTracks(),
3961 t.charge(), t.leadingTrackPt(), t.scalarPtSumCore(),
3962 t.scalarPtSumIso(), t.ptBalance())
3963 dump_Fourvec (t.threeFastestTracks(), f)
3964 if t.trackCollection():
3966 dump_TrigInDetTrackCollection (t.trackCollection(), f)
◆ dump_TrigTauTracksInfo_nolist()
| def python.Dumpers.dump_TrigTauTracksInfo_nolist |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3970 of file Dumpers.py.
3971 dump_TrigTauTracksInfo (t, f)
◆ dump_TrigTrackCounts()
| def python.Dumpers.dump_TrigTrackCounts |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3701 of file Dumpers.py.
3702 fprint (f,
'z0_pt:')
3703 dump_TrigHisto2D (t.z0_pt(), f)
3704 fprint (f,
'\neta_phi:')
3705 dump_TrigHisto2D (t.eta_phi(), f)
◆ dump_TrigTrackCounts_nolist()
| def python.Dumpers.dump_TrigTrackCounts_nolist |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3708 of file Dumpers.py.
3709 dump_TrigTrackCounts (t, f)
◆ dump_TrigTrtHitCounts()
| def python.Dumpers.dump_TrigTrtHitCounts |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4349 of file Dumpers.py.
4350 fprint (f,
' barrel')
4351 dump_TrigHisto1D (p.barrel(), f)
4352 fprint (f,
'\n endcapA')
4353 dump_TrigHisto1D (p.endcapA(), f)
4354 fprint (f,
'\n endcapC')
4355 dump_TrigHisto1D (p.endcapC(), f)
◆ dump_TrigVertex()
| def python.Dumpers.dump_TrigVertex |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 3662 of file Dumpers.py.
3663 dump_Threevec (v, f)
3664 fprint (f, v.algorithmId(), v.chi2(), v.ndof(), v.mass(),
3665 v.massVariance(), v.energyFraction(), v.nTwoTracksSecVtx())
3666 fprint (f,
'\n cov: ', [v.cov()[i]
for i
in range(6)])
3667 if v.tracks()
and v.tracks().
size() > 0:
3668 for (i, t)
in enumerate (v.tracks()):
3669 fprint (f,
'\n t%d'%i)
3671 fprint (f, p.a0(), p.z0(), p.phi0(), p.eta(), p.pT())
3672 if v.getMotherTrack():
3673 fprint (f,
'\n mother: ')
3674 dump_TrigInDetTrackFitPar (v.getMotherTrack(), f)
◆ dump_TrigVertexCounts()
| def python.Dumpers.dump_TrigVertexCounts |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 4452 of file Dumpers.py.
4454 formatItemUsingLong (
list(v.vtxNtrks())),
4455 list(v.vtxTrkPtSqSum()))
◆ dump_TRT_BSErrContainer()
| def python.Dumpers.dump_TRT_BSErrContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1763 of file Dumpers.py.
1764 fprint (f,
' Missing errors:', list (p.getMissingErrorSet()))
1765 fprint (f,
'\n Error errors:', list (p.getErrorErrorSet()))
1766 fprint (f,
'\n Sid errors:', list (p.getSidErrorSet()))
1767 fprint (f,
'\n L1 errors:', [(x.first, x.second)
for x
in p.getL1ErrorSet()])
1768 fprint (f,
'\n BCID errors:', [(x.first, x.second)
for x
in p.getBCIDErrorSet()])
1769 fprint (f,
'\n ROB errors:', [(x.first, x.second)
for x
in p.getRobErrorSet()])
◆ dump_TRT_DriftCircle()
| def python.Dumpers.dump_TRT_DriftCircle |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4633 of file Dumpers.py.
4634 dump_PrepRawData (p, f)
4635 fprint (f, p.getWord())
4636 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_TRT_DriftCircleContainer()
| def python.Dumpers.dump_TRT_DriftCircleContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4747 of file Dumpers.py.
4748 dump_IDC (dump_TRT_DriftCircle, p, f)
◆ dump_TRT_DriftCircleOnTrack()
| def python.Dumpers.dump_TRT_DriftCircleOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1668 of file Dumpers.py.
1669 dump_RIO_OnTrack (p, f)
1670 dump_AmgVector (p.globalPosition(), f)
1671 fprint (f, p.idDE().
value())
1672 dump_EL (p.prepRawDataLink(), f)
1673 fprint (f, p.status(), p.localAngle(), p.positionAlongWire())
1674 fprint (f, p.highLevel(), p.timeOverThreshold())
1675 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_TRT_RawDataContainer()
| def python.Dumpers.dump_TRT_RawDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4759 of file Dumpers.py.
4760 dump_IDC (dump_TRT_RDORawData, p, f)
◆ dump_TRT_RDORawData()
| def python.Dumpers.dump_TRT_RDORawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4651 of file Dumpers.py.
4652 dump_InDetRawData (p, f)
4653 fprint (f, p.highLevel(), p.timeOverThreshold(), p.driftTimeBin())
◆ dump_TRTUncompressedHit()
| def python.Dumpers.dump_TRTUncompressedHit |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4260 of file Dumpers.py.
4261 fprint (f, t.GetHitID(), t.truthBarcode(), t.GetParticleEncoding(),
4262 t.GetKineticEnergy(), t.GetEnergyDeposit(),
4263 t.GetPreStepX(), t.GetPreStepY(), t.GetPreStepZ(),
4264 t.GetPostStepX(), t.GetPostStepY(), t.GetPostStepZ(),
◆ dump_TruthInfo()
| def python.Dumpers.dump_TruthInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1042 of file Dumpers.py.
1043 dump_BaseTagInfo (info, f)
1044 fprint (f,
' %s %f %d ' %
1045 (info.jetTruthLabel(),
1046 info.deltaRMinTo (
'b'),
1048 dump_Threevec (info.BDecayVertex(), f)
◆ dump_TruthParticle()
| def python.Dumpers.dump_TruthParticle |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1352 of file Dumpers.py.
1353 dump_ParticleImpl (p, f)
1354 poltheta = fix_neg0 (p.polarization().theta())
1355 fprint (f,
' %3d %3d %f %f %d %d' %
1359 p.polarization().phi(),
1362 fprint (f,
'\n ', p.hasEtIsol())
1363 dump_HLV (p.genParticle().
momentum(), f)
1365 fprint (f,
'\n p0:')
1369 for i
in range(p.nParents()):
1371 mother = p.genMother(i)
1373 dump_HLV (mother.momentum(), f)
1374 dump_Fourvec (p.mother(mni), f)
1376 fprint (f,
'\n c0:')
1378 for i
in range(p.nDecay()):
1380 child = p.genChild(i)
1382 dump_HLV (child.momentum(), f)
1383 dump_Fourvec (p.child(mni), f)
◆ dump_TruthTrajectory()
| def python.Dumpers.dump_TruthTrajectory |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 1416 of file Dumpers.py.
1417 fprint (f, [l.barcode()
for l
in t])
◆ dump_Twovec()
| def python.Dumpers.dump_Twovec |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 300 of file Dumpers.py.
301 fprint (f,
"(%f %f)" % (v.x(), v.y()))
◆ dump_V0Candidate()
| def python.Dumpers.dump_V0Candidate |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 3654 of file Dumpers.py.
3655 fprint (f,
"V0Candidate", len(v.v0Hypothesis()))
3656 for h
in v.v0Hypothesis():
3658 dump_V0Hypothesis (h, f)
◆ dump_V0Hypothesis()
| def python.Dumpers.dump_V0Hypothesis |
( |
|
h, |
|
|
|
f |
|
) |
| |
Definition at line 3643 of file Dumpers.py.
3647 fprint (f,
'V0Hypothesis', h.positiveTrackID(),
3648 h.negativeTrackID(), h.hypothesisID())
3650 dump_ExtendedVxCandidate (h, f)
◆ dump_vector()
| def python.Dumpers.dump_vector |
( |
|
p, |
|
|
|
f |
|
) |
| |
◆ dump_Vertex()
| def python.Dumpers.dump_Vertex |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 2566 of file Dumpers.py.
2567 dump_Threevec (v.position(), f)
◆ dump_vvdouble()
| def python.Dumpers.dump_vvdouble |
( |
|
c, |
|
|
|
f |
|
) |
| |
◆ dump_vvelccell()
| def python.Dumpers.dump_vvelccell |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 903 of file Dumpers.py.
909 fprint (f,
'(', el.dataID(), el.index(),
') ')
911 fprint (f,
'(invEL) ')
◆ dump_VxCandidate()
| def python.Dumpers.dump_VxCandidate |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 2674 of file Dumpers.py.
2676 if isinstance (v, PyAthena.Trk.MVFVxCandidate):
2677 dump_MVFVxCandidate (v, f)
2678 elif (v.__class__ == PyAthena.Trk.VxCandidate
or
2679 isinstance (v, PyAthena.Trk.V0Hypothesis)):
2680 dump_VxCandidate1 (v, f)
2681 elif isinstance (v, PyAthena.Trk.ExtendedVxCandidate):
2682 dump_ExtendedVxCandidate (v, f)
2685 dump_VxCandidate1 (v, f)
◆ dump_VxCandidate1()
| def python.Dumpers.dump_VxCandidate1 |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 2642 of file Dumpers.py.
2643 dump_RecVertex (v.recVertex(), f)
2647 tav = v.vxTrackAtVertex()
2648 for i
in range(tav.size()):
2650 fprint (f,
'\n ',
typename(t.__class__))
2651 if isinstance (t, PyAthena.Trk.MVFVxTrackAtVertex):
2652 dump_MVFVxTrackAtVertex (t, f)
2653 elif t.__class__ == PyAthena.Trk.VxTrackAtVertex:
2654 dump_VxTrackAtVertex (t, f)
◆ dump_VxTrackAtVertex()
| def python.Dumpers.dump_VxTrackAtVertex |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 2601 of file Dumpers.py.
2602 dump_FitQuality (t.trackQuality(), f)
2603 fprint (f,
'%f %f' %
2604 (t.vtxCompatibility(),
2606 fprint (f,
tonone(t.linState()),
tonone(t.ImpactPoint3dAtaPlane()))
2607 if t.perigeeAtVertex():
2609 dump_parameters (t.perigeeAtVertex(), f)
2616 tel = PyAthena.ElementLink (
'DataVector<Trk::Track>')
2617 if not isinstance (t.trackOrParticleLink(), tel):
2620 trk = t.trackOrParticleLink().cptr()
2622 pm = trk.trackParameters()
2623 if pm
and len(pm) > 0:
2625 dump_parameters (perigee, f)
2627 if isinstance (t.trackOrParticleLink(), PyAthena.Trk.LinkToTrack):
2628 dump_LinkToTrack (t.trackOrParticleLink(), f)
2629 elif isinstance (t.trackOrParticleLink(),PyAthena.Trk.LinkToTrackParticleBase):
2630 dump_LinkToTrackParticleBase (t.trackOrParticleLink(), f)
2632 fprint (f, t.trackOrParticleLink())
◆ dump_xAOD()
| def python.Dumpers.dump_xAOD |
( |
|
o, |
|
|
|
f |
|
) |
| |
Definition at line 5693 of file Dumpers.py.
5694 fprint (f,
typename(o.__class__),
'\n ')
5695 dump_auxdata (o, f=f)
◆ dump_xAODObject()
| def python.Dumpers.dump_xAODObject |
( |
|
o, |
|
|
|
f |
|
) |
| |
◆ dump_xAODObjectNL()
| def python.Dumpers.dump_xAODObjectNL |
( |
|
o, |
|
|
|
f |
|
) |
| |
◆ dump_xAODTruthParticleLink()
| def python.Dumpers.dump_xAODTruthParticleLink |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5492 of file Dumpers.py.
5493 dump_HepMcParticleLink (p.first, f)
5494 dump_EL (p.second, f)
◆ dump_ZdcDigits()
| def python.Dumpers.dump_ZdcDigits |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5235 of file Dumpers.py.
5236 dump_ZdcRawData (p, f)
5237 fprint (f,
list(p.get_digits_gain0_delay0()))
5238 fprint (f,
list(p.get_digits_gain0_delay1()))
5239 fprint (f,
list(p.get_digits_gain1_delay0()))
5240 fprint (f,
list(p.get_digits_gain1_delay1()))
◆ dump_ZdcLucrod_Data()
| def python.Dumpers.dump_ZdcLucrod_Data |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5480 of file Dumpers.py.
5481 fprint (f,
'ld', p.GetLucrodID(),
'bcid', p.GetBCID(),
5482 'run', p.GetRunNumber(),
'l1id', p.GetLevel1ID(),
5483 'nbc', p.GetNumBCs(),
'stat', p.GetStatus(),
5484 'avga/c', p.GetTrigAvgA(), p.GetTrigAvgC(),
5485 'data',
list(p.GetTrigData()))
5486 for i
in range (p.GetChanDataSize()):
5487 ch = p.GetChanData(i)
5488 fprint (f,
'\n chan ', ch.id,
list(ch.waveform))
◆ dump_ZdcRawData()
| def python.Dumpers.dump_ZdcRawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5230 of file Dumpers.py.
5231 fprint (f, p.identify().getString())
◆ fix_neg0()
| def python.Dumpers.fix_neg0 |
( |
|
x, |
|
|
|
thresh = 0 |
|
) |
| |
library methods ---------------------------------------------------------—
Definition at line 199 of file Dumpers.py.
200 return 0
if x == 0
or abs(x) < thresh
else x
◆ format_dl()
| def python.Dumpers.format_dl |
( |
|
x | ) |
|
Definition at line 5501 of file Dumpers.py.
5504 key =
'(%d)' % x.key()
5505 return f
'DataLink({key})'
◆ format_el()
| def python.Dumpers.format_el |
( |
|
x | ) |
|
Definition at line 5506 of file Dumpers.py.
5507 if x.isDefaultIndex():
5511 key =
'(%d)' % x.key()
5512 return '%s[%d]' % (key, x.index())
◆ format_float()
| def python.Dumpers.format_float |
( |
|
x | ) |
|
◆ format_float_vector()
| def python.Dumpers.format_float_vector |
( |
|
v | ) |
|
◆ format_int()
| def python.Dumpers.format_int |
( |
|
x | ) |
|
◆ format_obj()
| def python.Dumpers.format_obj |
( |
|
x, |
|
|
|
name = None |
|
) |
| |
Definition at line 5554 of file Dumpers.py.
5555 if isinstance(x, float):
5556 return format_float (x)
5557 if isinstance(x, int):
5558 return format_int (x)
5560 if tname.startswith (
'CxxUtils::range_with_conv<'):
5563 if tname.startswith (
'ROOT.'):
5565 if tname.startswith (
'ElementLink<'):
5566 return format_el (x)
5567 if tname.startswith (
'DataLink<'):
5568 return format_dl (x)
5569 if tname.startswith (
'std::vector<')
or tname.startswith (
'vector<'):
5570 ipos = tname.find(
'<')
5571 tname2 = tname[ipos+1:]
5572 if (tname2.startswith(
'char,')
or
5573 tname2.startswith(
'char>')
or
5574 tname2.startswith (
'unsigned char,')
or
5575 tname2.startswith (
'unsigned char>')):
5576 l =
', '.join ([
str(ord(x[i]))
for i
in range(len(x))])
5577 elif tname2.startswith(
'bool,')
or tname2 ==
'bool>':
5578 l =
', '.join ([
str(
bool(xx))
for xx
in x])
5581 return '[' + l +
']'
5582 if isinstance(x, PyAthena.xAOD.CaloClusterBadChannelData_v1):
5583 return '<BadChannel: %6.3f/%6.3f/%2d: %04x>' % \
5584 (x.eta(), x.phi(), x.layer(), x.badChannel())
5585 if tname ==
'set<unsigned int>':
5586 acls=getattr(PyAthena,
'PyDumper::PySTLAdaptor<std::set<unsigned int>')
5590 if tname.startswith (
'std::pair<')
or tname.startswith (
'pair<'):
5593 if tname ==
'Trk::VxTrackAtVertex':
5595 dump_VxTrackAtVertex (x, fout)
5596 out = fout.getvalue()
5597 return '{' + out.replace(
'\n',
'; ') +
'}'
◆ formatItemUsingLong()
| def python.Dumpers.formatItemUsingLong |
( |
|
x | ) |
|
Helper for doing formatting compatibly with py2.
Convert X to a string, but add a `L' to the ends of integers.
Can be used for formatting expressions that using longs in py2.
Definition at line 159 of file Dumpers.py.
160 """Helper for doing formatting compatibly with py2.
162 Convert X to a string, but add a `L' to the ends of integers.
163 Can be used for formatting expressions that using longs in py2.
165 if isinstance (x, list):
166 sl = [formatItemUsingLong (xx)
for xx
in x]
167 return '[' +
', '.join (sl) +
']'
168 if isinstance (x, tuple):
169 sl = [formatItemUsingLong (xx)
for xx
in x]
170 return '(' +
', '.join (sl) +
')'
171 if isinstance (x, int):
173 if isinstance (x, forceInt):
175 if isinstance(x, ROOT.std.string):
◆ generic_dump_auxitem()
| def python.Dumpers.generic_dump_auxitem |
( |
|
x, |
|
|
|
auxid, |
|
|
|
f |
|
) |
| |
Definition at line 5602 of file Dumpers.py.
5603 if hasattr (x,
'container'):
5605 x.container().getConstStore().
getData(auxid)[0]
5607 fprint (f,
'<unavailable 1>')
5610 reg=ROOT.SG.AuxTypeRegistry.instance()
5611 tname = reg.getTypeName (auxid)
5612 ac = ROOT.SG.ConstAuxElement.TypelessConstAccessor (reg.getName(auxid))
5616 fprint (f,
'<unavailable 2>')
5619 obj = ROOT.TPython.CPPInstance_FromVoidPtr (buf, tname)
5621 fprint (f,
'<unknown %s>'%tname)
5623 fprint (f,
format_obj(obj, reg.getName(auxid)))
◆ genvertex_in_barcodes()
| def python.Dumpers.genvertex_in_barcodes |
( |
|
v | ) |
|
Definition at line 2810 of file Dumpers.py.
2811 if hasattr(v,
'particles_in_const_begin'):
2812 parts =
barcodes(v.particles_in_const_begin(),
2813 v.particles_in_const_end(),
2814 v.particles_in_size())
◆ genvertex_out_barcodes()
| def python.Dumpers.genvertex_out_barcodes |
( |
|
v | ) |
|
Definition at line 2819 of file Dumpers.py.
2820 if hasattr(v,
'particles_out_const_begin'):
2821 parts =
barcodes(v.particles_out_const_begin(),
2822 v.particles_out_const_end(),
2823 v.particles_out_size())
◆ get_dumper_fct()
| def python.Dumpers.get_dumper_fct |
( |
|
klass, |
|
|
|
ofile = sys.stdout, |
|
|
|
nmax = None |
|
) |
| |
helper function to automatically retrieve the suitable dumper function
given the name of a class or the class-type
@param `klass' a string containing the name of a C++ type or a type
@param `ofile' a file-like instance where to dump the objects' content
@param `nmax` maximum number of container elements to dump
Definition at line 6138 of file Dumpers.py.
6139 """helper function to automatically retrieve the suitable dumper function
6140 given the name of a class or the class-type
6141 @param `klass' a string containing the name of a C++ type or a type
6142 @param `ofile' a file-like instance where to dump the objects' content
6143 @param `nmax` maximum number of container elements to dump
6145 if isinstance(klass, type):
6148 elif isinstance(klass, str):
6149 klass = getattr(PyAthena,klass)
6152 raise TypeError(
'expected a type or a string')
6156 dumpers = [ i
for i
in dumpspecs
if i[0] == klname ]
6157 if len(dumpers) != 1:
6158 raise RuntimeError(
'no suitable dumper function for class [%s]'%
6161 nolist = hasattr (fct,
'nolist')
and fct.nolist
6162 from functools
import partial
as _partial
6165 dumper = _partial(fct, f=ofile, nmax=nmax)
6167 dumper = _partial(fct, f=ofile)
6169 dumper = _partial(dump_list, f=ofile, dumper=fct, nmax=nmax)
◆ nolist()
| def python.Dumpers.nolist |
( |
|
f | ) |
|
◆ nolist_nmax()
| def python.Dumpers.nolist_nmax |
( |
|
f | ) |
|
◆ safe_assocs()
| def python.Dumpers.safe_assocs |
( |
|
a, |
|
|
|
obj, |
|
|
|
coll, |
|
|
|
f |
|
) |
| |
Definition at line 3384 of file Dumpers.py.
3385 bv = a.beginAssociation(obj)
3386 ev = a.endAssociation(obj)
3391 targ = bv.__deref__()
3393 except RuntimeError
as e:
3394 if e.args[0].find (
'dereferencing invalid ElementLink') >= 0:
3406 a.assocs (obj, coll)
◆ safe_float_vector()
| def python.Dumpers.safe_float_vector |
( |
|
v | ) |
|
Definition at line 129 of file Dumpers.py.
130 sa = ROOT.PyDumper.SafeFloatAccess(v)
131 return [sa[i]
for i
in range(len(v))]
◆ signalstate()
| def python.Dumpers.signalstate |
( |
|
o, |
|
|
|
state |
|
) |
| |
Definition at line 134 of file Dumpers.py.
135 if hasattr(o,
'setSignalState'):
136 old = o.signalState()
137 o.setSignalState (state)
139 o.setSignalState (old)
141 sh = PyAthena.SignalStateHelper (o)
142 sh.setSignalState (state)
◆ toiter()
| def python.Dumpers.toiter |
( |
|
beg, |
|
|
|
end |
|
) |
| |
◆ toiter1()
| def python.Dumpers.toiter1 |
( |
|
c | ) |
|
Definition at line 100 of file Dumpers.py.
101 return toiter (c.begin(), c.end())
◆ tonone()
| def python.Dumpers.tonone |
( |
|
x | ) |
|
Definition at line 113 of file Dumpers.py.
114 if not x:
return None
◆ typename()
| def python.Dumpers.typename |
( |
|
t | ) |
|
Definition at line 193 of file Dumpers.py.
194 return getattr (t,
'__cpp_name__', t.__name__)
◆ uf()
| def python.Dumpers.uf |
( |
|
x | ) |
|
Definition at line 438 of file Dumpers.py.
439 if abs(x) < 1e-38:
return 0
◆ __author__
| string python.Dumpers.__author__ = "Scott Snyder, Sebastien Binet" |
|
private |
◆ __doc__
| string python.Dumpers.__doc__ = """python library to dump various EDM classes""" |
|
private |
◆ __version__
| string python.Dumpers.__version__ = "$Revision: 1.32 $" |
|
private |
◆ accessors
| dictionary python.Dumpers.accessors |
Initial value:
2 'char' : char_accessor,
3 'unsigned char' : uchar_accessor,
Definition at line 5538 of file Dumpers.py.
◆ Analysis
| python.Dumpers.Analysis = getattr (cppyy.gbl, 'Analysis', None) |
◆ aname
◆ atomic_accessors
| dictionary python.Dumpers.atomic_accessors |
Initial value:
2 'unsigned int' : getattr (ROOT,
'SG::AtomicConstAccessor<unsigned int>'),
Definition at line 5549 of file Dumpers.py.
◆ char_accessor_
◆ dumpspecs
| list python.Dumpers.dumpspecs |
◆ etcone10
| int python.Dumpers.etcone10 = 0 |
◆ FitQuality
| python.Dumpers.FitQuality = getattr (Trk, 'FitQuality', None) |
◆ fitQualityNull
◆ InDet
| python.Dumpers.InDet = getattr (cppyy.gbl, 'InDet', None) |
◆ InDetLowBetaCandidate
| python.Dumpers.InDetLowBetaCandidate = getattr (InDet, 'InDetLowBetaCandidate', None) |
◆ InDetLowBetaCandidateNull
◆ JetAssociationBase
◆ jetAssocNull
◆ Muon
◆ muonNull
| python.Dumpers.muonNull = cppyy.bind_object(cppyy.nullptr, Muon) if Muon else None |
◆ nucone10
| int python.Dumpers.nucone10 = 8 |
◆ tlist
| list python.Dumpers.tlist |
◆ Trk
| python.Dumpers.Trk = getattr (cppyy.gbl, 'Trk', None) |
◆ uchar_accessor_
def dump_MultiSVInfoPlus(info, f)
def dump_TrigMuonEFInfoTrack(t, f)
def dump_CscRawData(p, f)
def dump_PixelClusterOnTrack(p, f)
def dump_TrigInDetTrackFitPar(p, f)
def dump_egDetailContainer(p, f)
def dump_TrigVertex(v, f)
def dump_ITrackLink(l, f)
def dump_HLTSignature(s, f)
def dump_TgcRawData(p, f)
def dump_EventBookkeeper(p, f, level=0)
def dump_LArRawChannel(p, f)
def dump_PileUpEventInfo(e, f)
def dump_TrigOperationalInfo(b, f)
def dump_RpcCoinMatrix(p, f)
def dump_RpcCoinDataContainer(p, f)
def dump_RpcFiredChannel(p, f)
def dump_LArFebErrorSummary(p, f)
def dump_Assocs(a, f, colltype)
const InDetSimData * getData(const InDetSimDataCollection &coll, const Identifier &id)
def dump_TrigMuonClusterFeature(m, f)
def dump_CMMJetHits(p, f)
def dump_TrigSpacePointCounts(c, f)
def dump_eflowObject(e, f)
def dump_TruthParticle(p, f)
def dump_parameters(p, f)
def dump_TauDetailsContainer(p, f)
def dump_RpcSLTriggerHit(p, f)
def dump_MuonMcData(p, f)
def dump_TRT_DriftCircleOnTrack(p, f)
def dump_IPInfoPlus(info, f)
def dump_TrigMissingET(m, f)
def dump_EMTrackMatch(d, f)
def dump_InDetLowBetaCandidate(p, f)
def dump_TrackParticleAssocs(a, f)
def dump_TrigPassFlags(m, f)
def dump_TgcRdo_RodStatus(p, f)
def dump_PRD_MultiTruthCollection(p, f)
def dump_VxCandidate1(v, f)
def dump_L1DataBaseclass(c, f)
def _gen_vecattr(e, a, typ)
def dump_ElectronConstituent(info, f)
def dump_JetConstituent(info, f)
def dump_TileMuFeature(m, f)
def dump_PrepRawData(p, f)
const TrigPassBits * getBits(size_t sz, const HLT::TriggerElement *te, const std::string &, const HLT::NavigationCore *navigation)
def dump_EMTrackFit(d, f)
def dump_JetElement(p, f)
def dump_xAODObject(o, f)
def dump_eflowObjectContainer(c, f)
def dump_DetailedTrackTruthCollection(c, f)
def get_dumper_fct(klass, ofile=sys.stdout, nmax=None)
def dump_TauPi0Details(t, f)
def _genevent_particles_size(e)
def dump_TrigT2ZdcSignals(p, f)
def dump_L1TopoResult(p, f)
def dump_Lvl1AODConfigData(d, f)
def dump_ElectronAssociation(a, f)
def dump_AFP_RawCollectionHead(p, f)
def dump_MaterialEffectsOnTrack(p, f)
def dump_TrigL2Bjet(j, f)
def dump_TrackParticleTruthCollection(c, f)
def dump_TrigEFBphys(j, f)
def dump_TgcRdo_LocalStatus(p, f)
def dump_IPInfoBase(info, f)
def dump_LArFebHeader(p, f)
def dump_CaloShower(s, f)
def dump_ParametersBase(info, f)
def dump_TrigConfChain(p, f)
def dump_list(l, f, dumper, nmax=None)
def dump_SVTrackInfo(info, f)
def dump_CaloCellLink(l, f)
def dump_ZdcRawData(p, f)
def dump_TrigRoiDescriptor_nolist(d, f)
def dump_CscPrepDataContainer(p, f)
def dump_AttributeList(p, f)
def dump_PerigeeSurface(info, f)
def generic_dump_auxitem(x, auxid, f)
def dump_TrigTauClusterDetails(t, f)
def _genevent_vertices_size(e)
def dump_CosmicMuon(m, f)
def dump_HLTStreamTag(s, f)
def dump_ZdcLucrod_Data(p, f)
def dump_TrigMonROB(p, f)
def dump_TruthInfo(info, f)
def dump_CompetingMuonClustersOnTrack(p, f)
def dump_TrigT2Jet_nolist(j, f)
def dump_SoftElectronInfo(info, f)
def dump_Tau1P3PExtraDetails(t, f)
def dump_RpcPrepDataContainer(p, f)
def _genvertex_particles_out_size(e)
def dump_StraightLineSurface(info, f)
def dump_MMClusterOnTrack(p, f)
def dump_TrigInDetTrackTruth(t, f)
def dump_HLTSequence(s, f)
def dump_LocalParameters(p, f)
def dump_SoftMuonInfo(info, f)
def dump_CombinedMuonFeature_nolist(m, f)
def dump_EMTauResult(p, f)
def dump_SLTrueInfo(info, f)
def dump_SiClusterOnTrack(p, f)
def dump_MuCTPIResult(p, f)
def dump_IsoMuonFeature(m, f)
def dump_SaggedLineSurface(info, f)
bool isValid(const T &p)
Av: we implement here an ATLAS-sepcific convention: all particles which are 99xxxxx are fine.
def dump_CaloClusterCellLink(l, f)
def dump_CTP_Decision(t, f)
def dump_MuonFeatureDetails(m, f)
def dump_TgcRdo_Errors(p, f)
def dump_JetEnergyRoI(p, f)
def dump_MdtTrackSegment(t, f)
def dump_MVFVxTrackAtVertex(t, f)
def dump_AFP_SiRawData(p, f)
def dump_TriggerInfo(e, f)
def dump_xAODTruthParticleLink(p, f)
def dump_Fourvec(v, f, parens=1)
def dump_SMTrackInfo(info, f)
def dump_TruthTrajectory(t, f)
def dump_RoIBResult(p, f)
def dump_RpcPrepData(p, f)
def dump_TrigMuonEFInfo(t, f)
def dump_PixelClusterContainer(p, f)
def dump_MuonSimDataCollection(p, f)
def dump_TgcClusterOnTrack(p, f)
def dump_AFP_RawDataCommonHead(p, f)
def dump_EventStreamInfo(e, f)
def dump_CaloClusterMomentStore(m, f)
def dump_JetKeyDescriptorCollection(p, f)
def dump_ISvxAssociation(a, f)
def dump_RpcPadContainer(p, f)
def dump_PixelGangedClusterAmbiguities(p, f)
def dump_STGC_RawDataContainer(p, f)
def dump_auxitem(x, auxid, f=sys.stdout)
def dump_TrigTrtHitCounts(p, f)
def dump_TrigCaloCluster(c, f)
def dump_InDetRawData(p, f)
def dump_MaterialEffectsBase(p, f)
def format_obj(x, name=None)
def dump_TileBeamElemContainer(data, f)
def dump_PixelRawDataContainer(p, f)
def dump_SoftLeptonTruthInfo(info, f)
def dump_AmgMatrix(m, f, thresh=1e-38)
def dump_AlignmentEffectsOnTrack(p, f)
def dump_SETrackInfo(info, f)
def dump_TileRawDataCollection(data, f)
def safe_assocs(a, obj, coll, f)
def dump_AtlfInfo(info, f)
def dump_associatedSurface(p, f)
def dump_TrigMissingET_nolist(m, f)
def dump_InDetSimDataCollection(p, f)
def dump_MM_RawData(p, f)
def dump_PhotonAssociation(a, f)
def dump_TrigPhoton(p, f)
def _genvertex_particles_in_size(e)
def dump_PlaneSurface(info, f)
def dump_auxdata(x, exclude=None, f=sys.stdout)
def dump_TrackStateOnSurface(p, f)
def dump_NSW_PadTriggerDataContainer(p, f)
def dump_TRT_DriftCircleContainer(p, f)
def dump_CscSimDataCollection(p, f)
def dump_xAODObjectNL(o, f)
def dump_STGC_RawData(p, f)
def dump_TgcPrepData(p, f)
def dump_ChamberT0s(m, f)
def dump_MdtDriftCircleOnTrack(p, f)
def dump_TrigSpacePointCounts_nolist(c, f)
def dump_TauCommonExtraDetails(t, f)
def dump_RpcSectorLogic(p, f)
def dump_TrigConfSeq(p, f)
def dump_TileRawChannel(data, f)
def dump_TrigMuonEF(m, f)
def dump_TriggerTower(p, f)
def dump_MuonClusterOnTrack(p, f)
def dump_TrigInDetTrackTruthMap(m, f)
def dump_IdentContIndex(p, f)
def dump_AFP_RawContainer(p, f)
def dump_EnergySum_ROI(m, f)
def dump_TrigTauCluster_nolist(t, f)
def dump_measurement(p, f)
def barcodes(beg, end, sz)
def dump_CscPrepData(p, f)
def dump_PixelCluster(p, f)
def dump_TrackParticleTruth(p, f)
def dump_ALFA_RawDataContainer(p, f)
def dump_LinkToTrack(l, f)
def dump_MdtPrepData(p, f)
def dump_JetFitterTagInfo(info, f)
def dump_MuonAssociation(a, f)
def dump_JetAssociationBase(a, f)
def _genevent_vertices(e)
def dump_CaloClusters_sorted(l, f, nmax=None)
setTeId setLumiBlock roiId
def dump_TRT_RDORawData(p, f)
def dump_MuonFeature(m, f)
def dump_MissingEtTruth(m, f)
def dump_TrigMonAlg(p, f)
def dump_RpcCoinData(p, f)
def dump_sTgcClusterOnTrack(p, f)
def dump_SecVtxInfo(info, f)
def dump_TrackParticle(p, f)
def dump_AFP_ToFRawCollection(p, f)
def dump_RIO_OnTrack(p, f)
def dump_TauRecExtraDetails(t, f)
def dump_ROIBHeader(p, f)
def dump_ALFA_RawDataCollection(p, f)
std::string repr(PyObject *o)
returns the string representation of a python object equivalent of calling repr(o) in python
def dump_LUCID_RawData(p, f)
def dump_MissingETSig(m, f)
def dump_CompetingRIOsOnTrack(p, f)
def asinh(x)
helper methods ---------------------------------------------------------—
def dump_MissingETSigHypo(h, f)
def dump_RoiDescriptor(d, f)
def dump_GenParticle(p, f)
def dump_ExtendedVxCandidate(c, f)
def dump_TgcPrepDataContainer(p, f)
def dump_MuonSpShower(m, f)
def dump_TrigElectron(p, f)
def dump_ROIBTrailer(p, f)
def dump_SCT_ClusterOnTrack(p, f)
def genvertex_out_barcodes(v)
def dump_TgcCoinDataContainer(p, f)
def dump_Surface(info, f)
def dump_IDC(payload_dumper, p, f, extra_idc_dumper=None)
def dump_TgcCoinData(p, f)
def dump_CscStripPrepData(p, f)
def dump_TrigTauTracksInfo_nolist(t, f)
def dump_SCT_RawDataContainer(p, f)
def dump_HLTResultMT(p, f)
def dump_ScatteringAngles(p, f)
def dump_HLTAODConfigData(d, f)
def formatItemUsingLong(x)
def dump_TrigMuonEFIsolation(m, f)
def dump_Lvl1Result(t, f)
def dump_TrigTauTracksInfo(t, f)
def dump_CaloSamplingData(s, f)
def dump_JetMomentMapCollection(p, f)
def dump_TrackAssociation(a, f)
def _genevent_particles(e)
def dump_MvfFitInfo(v, f)
def dump_LinkToTrackParticleBase(l, f)
def dump_TileRawChannelCollection(data, f)
def dump_LineSaggingDescriptor(info, f)
def dump_TrigMuonEFTrack(t, f)
def dump_V0Candidate(v, f)
def dump_AmgVector(m, f, thresh=1e-38, prec=3)
def dump_TileMuonReceiverObj(p, f)
def dump_INav4MomAssocs(a, f)
def dump_CaloCluster(c, f)
std::string join(const std::vector< std::string > &v, const char c=',')
def dump_CscSimData(p, f)
def dump_TRT_DriftCircle(p, f)
def dump_NSW_PadTriggerData(p, f)
def dump_MissingEtCalo(m, f)
def dump_TrigDecision(t, f)
def dump_MdtPrepDataContainer(p, f)
def dump_DiscSurface(info, f)
def dump_TrigT2MbtsBits(t, f)
def dump_TrigInDetTrackCollection(t, f)
def dump_TrackConstituents(info, f)
def dump_TRT_RawDataContainer(p, f)
def dump_SCT_Cluster(p, f)
def dump_CscClusterOnTrack(p, f)
def dump_MM_RawDataContainer(p, f)
def dump_TrigEFBjet(j, f)
def dump_TrigMonConfig(p, f)
def dump_ParticleJet(j, f)
std::string to_string(const DetectorType &type)
def dump_SCT_ClusterContainer(p, f)
def dump_TrigRoiDescriptor(d, f)
def signalstate(o, state)
def _genevent_signal_process_vertex(e)
def dump_ElectronMuonTopoInfo(a, f)
def dump_TRT_BSErrContainer(p, f)
def dump_CaloTopoTowerContainer(t, f)
def dump_EnergyLoss(p, f)
def dump_SVInfoPlus(info, f)
def fix_neg0(x, thresh=0)
library methods ---------------------------------------------------------—
def dump_ALFA_RawData(p, f)
def dump_MissingETComposition(m, f)
def dump_AFP_ToFRawData(p, f)
def dump_TgcRdoContainer(p, f)
def dump_IPTrackInfo(info, f)
def dump_CaloTowerContainer(t, f)
def dump_TauRecDetails(t, f)
def dump_Tau1P3PDetails(t, f)
def dump_BunchConfKey(p, f)
def dump_PseudoMeasurementOnTrack(p, f)
def dump_MuonCluster(p, f)
def dump_InDetSimData(p, f)
def dump_AFP_SiRawCollection(p, f)
def dump_materialeffects(p, f)
def dump_TrigEMCluster(c, f)
def dump_TrigEMCluster_nolist(c, f)
def dump_TrigHisto1D(h, f)
def dump_DetStatusMap(m, f)
def dump_TauPi0Cluster(t, f)
def dump_VxTrackAtVertex(t, f)
def dump_SCT_RDORawData(p, f)
def dump_MuonSimData(p, f)
def dump_CaloCalibrationHit(t, f)
def dump_FitQuality(info, f)
def dump_TgcBitmask(p, f, lab, fields)
def dump_TileTrackMuFeature(m, f)
def dump_IDCInDetBSErrContainer(p, f)
def dump_MissingETSigObject(m, f)
def dump_Trig3Momentum(m, f)
def dump_CurvilinearParameters(info, f)
def dump_MeasurementBase(p, f)
def dump_ClusterSplitProbabilityContainer(p, f)
def dump_TrigVertexCounts(v, f)
def dump_TrigMonEvent(p, f)
def dump_TauCommonDetails(t, f)
def dump_EMErrorDetail(d, f)
def dump_CscStripPrepDataContainer(p, f)
def dump_TrigTau_nolist(t, f)
def genvertex_in_barcodes(v)
def dump_RingerRings(r, f)
def dump_MdtCsmContainer(p, f)
def dump_TrackTruthCollection(p, f)
def dump_BaseTagInfo(info, f)
def dump_TrigMonSeq(p, f)
def dump_TileDigitsContainer(p, f)
def dump_TrigRNNOutput(p, f)
def dump_JetEnergyResult(p, f)
def format_float_vector(v)
def dump_TrigPassBits(b, f)
def dump_RawInfoSummaryForTag(p, f)
def dump_TrigConfSig(p, f)
def dump_CscRawDataContainer(p, f)
def dump_MuCTPI_RDO(p, f)
def dump_TileRawChannelContainer(data, f)
def dump_PixelRDORawData(p, f)
def dump_TRTUncompressedHit(t, f)
def dump_ParticleImpl(p, f)
def dump_MVFVxCandidate(v, f)
def dump_CombinedMuonFeature(m, f)
def dump_TrigConfKeys(p, f)
def dump_TrigTrackCounts(t, f)
def dump_TileDigits(p, f)
def dump_RpcClusterOnTrack(p, f)
def dump_CaloEnergy(p, f)
def dump_SVInfoBase(info, f)
def dump_TrigHisto2D(h, f)
def dump_HLTTriggerElement(e, f)
def dump_JetProbInfoBase(info, f)
def dump_TileRawData(p, f)
def dump_GenericResult(t, f)
def dump_TrigConfAlg(p, f)
def dump_TrigTauCluster(t, f)
def dump_VxCandidate(v, f)
setBGCode setTAP setLVL2ErrorBits bool
def dump_TrigInDetTrack(t, f)
def dump_V0Hypothesis(h, f)
def dump_LArNoisyROSummary(p, f)
def dump_MuonConstituent(info, f)
def dump_TrigMonRoi(p, f)
def dump_TrackSummary(info, f)
def dump_Lvl1AODPrescaleConfigData(d, f)
def dump_TrackCountingInfo(info, f)
def dump_BCM_RDO_Collection(p, f)
def dump_RecoTimingObj(c, f)
def dump_MuonFeature_nolist(m, f)
def dump_SubDetHitStatistics(s, f)
def dump_TrigTrackCounts_nolist(t, f)
def dump_ParticleBase(e, f)
def dump_SkimDecision(p, f)
def dump_HepMcParticleLink(p, f)
def dump_TauPi0Candidate(t, f)
def dump_TrigL2Bphys(j, f)
def dump_GbbNNTagInfo(info, f)
def dump_CylinderSurface(info, f)
def dump_TrackRecord(t, f)
1.8.18