 |
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 2753 of file Dumpers.py.
2754 fn = getattr(e, a,
None)
2757 v = e.attribute_as_string(a)
2758 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 2760 of file Dumpers.py.
2761 fn = getattr(e, a,
None)
2764 return [typ(x)
for x
in e.attribute_as_string(a).
split()]
◆ _genevent_particles()
| def python.Dumpers._genevent_particles |
( |
|
e | ) |
|
|
private |
Definition at line 2775 of file Dumpers.py.
2776 if hasattr(e,
'particles_begin'):
2777 return toiter (e.particles_begin(), e.particles_end())
2778 return e.particles()
◆ _genevent_particles_size()
| def python.Dumpers._genevent_particles_size |
( |
|
e | ) |
|
|
private |
Definition at line 2767 of file Dumpers.py.
2768 if hasattr(e,
'particles_size'):
2769 return e.particles_size()
2770 return e.particles().
size()
◆ _genevent_signal_process_vertex()
| def python.Dumpers._genevent_signal_process_vertex |
( |
|
e | ) |
|
|
private |
Definition at line 2783 of file Dumpers.py.
2784 if hasattr(e,
'signal_process_vertex'):
2785 return e.signal_process_vertex()
2786 for v
in e.vertices():
2787 if v.attribute_as_string(
'signal_process_vertex') ==
'1':
◆ _genevent_vertices()
| def python.Dumpers._genevent_vertices |
( |
|
e | ) |
|
|
private |
Definition at line 2779 of file Dumpers.py.
2780 if hasattr(e,
'vertices_begin'):
2781 return toiter (e.vertices_begin(), e.vertices_end())
◆ _genevent_vertices_size()
| def python.Dumpers._genevent_vertices_size |
( |
|
e | ) |
|
|
private |
Definition at line 2771 of file Dumpers.py.
2772 if hasattr(e,
'vertices_size'):
2773 return e.vertices_size()
2774 return e.vertices().
size()
◆ _genvertex_particles_in_size()
| def python.Dumpers._genvertex_particles_in_size |
( |
|
e | ) |
|
|
private |
Definition at line 2790 of file Dumpers.py.
2791 if hasattr(e,
'particles_in_size'):
2792 return e.particles_in_size()
2793 return e.particles_in().
size()
◆ _genvertex_particles_out_size()
| def python.Dumpers._genvertex_particles_out_size |
( |
|
e | ) |
|
|
private |
Definition at line 2794 of file Dumpers.py.
2795 if hasattr(e,
'particles_out_size'):
2796 return e.particles_out_size()
2797 return e.particles_out().
size()
◆ _infoType()
| def python.Dumpers._infoType |
( |
|
i | ) |
|
|
private |
◆ _tmcmp()
| def python.Dumpers._tmcmp |
( |
|
x, |
|
|
|
y |
|
) |
| |
|
private |
Definition at line 3354 of file Dumpers.py.
3356 if x[0].nrMatches() > 0:
3357 xbc = x[0].bestSiMatch().
barcode()
3359 if y[0].nrMatches() > 0:
3360 ybc = y[0].bestSiMatch().
barcode()
3366 return cmp (x[1].chi2, y[1].chi2)
◆ asinh()
| def python.Dumpers.asinh |
( |
|
x | ) |
|
helper methods ---------------------------------------------------------—
Definition at line 89 of file Dumpers.py.
90 arg = math_sqrt (x*x+1) - x
93 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 2800 of file Dumpers.py.
2805 while beg != end
and sz > 0:
2809 out.append (x.barcode())
◆ boolvec()
| def python.Dumpers.boolvec |
( |
|
v | ) |
|
◆ cmp()
| def python.Dumpers.cmp |
( |
|
x, |
|
|
|
y |
|
) |
| |
Definition at line 37 of file Dumpers.py.
38 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 1917 of file Dumpers.py.
1918 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 1954 of file Dumpers.py.
1955 fprint (f, p.lvl1Id(), p.bcId(), p.lumiBlock(),
1956 p.timeStamp(), p.timeStampNS())
1957 fprint (f,
'\n si collections')
1958 for c
in p.collectionsSi():
1960 dump_AFP_SiRawCollection (c, f)
1961 fprint (f,
'\n tof collections')
1962 for c
in p.collectionsToF():
1964 dump_AFP_ToFRawCollection (c, f)
◆ dump_AFP_RawDataCommonHead()
| def python.Dumpers.dump_AFP_RawDataCommonHead |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1921 of file Dumpers.py.
1922 fprint (f, p.hitDiscConfig(), p.link())
◆ dump_AFP_SiRawCollection()
| def python.Dumpers.dump_AFP_SiRawCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1930 of file Dumpers.py.
1931 dump_AFP_RawCollectionHead (p, f)
1932 for r
in p.dataRecords():
1934 dump_AFP_SiRawData (r, f)
◆ dump_AFP_SiRawData()
| def python.Dumpers.dump_AFP_SiRawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1925 of file Dumpers.py.
1926 dump_AFP_RawDataCommonHead (p, f)
1927 fprint (f, p.column(), p.row(), p.timeOverThreshold())
◆ dump_AFP_ToFRawCollection()
| def python.Dumpers.dump_AFP_ToFRawCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1946 of file Dumpers.py.
1947 dump_AFP_RawCollectionHead (p, f)
1948 for r
in p.dataRecords():
1950 dump_AFP_ToFRawData (r, f)
◆ dump_AFP_ToFRawData()
| def python.Dumpers.dump_AFP_ToFRawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1937 of file Dumpers.py.
1938 dump_AFP_RawDataCommonHead (p, f)
1939 fprint (f, p.header(), p.edge(), p.channel())
1941 fprint (f, p.delayedTrigger(), p.triggerPattern())
1943 fprint (f, p.time(), p.pulseLength())
◆ dump_ALFA_RawData()
| def python.Dumpers.dump_ALFA_RawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1968 of file Dumpers.py.
1969 fprint (f, p.GetWordId_PMF(), p.GetPMFId_PMF(), p.GetMBId_PMF(),
1970 p.GetEventCount_PMF(), p.Get_bit16(), p.Get_bit18(),
1971 p.Get_bit26_27(), p.Get_bit24_27(), p.Get_error_bit17(),
1972 list(p.HitChan()), list (p.dataWords()))
◆ dump_ALFA_RawDataCollection()
| def python.Dumpers.dump_ALFA_RawDataCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1976 of file Dumpers.py.
1977 fprint (f,
'collection')
1978 fprint (f,
'mb', p.GetMBId_POT(),
'mrod', p.GetMrodId_POT(),
1979 'ec', p.GetEventCount_POT(),
1980 'scid', p.Get_scaler_POT(),
1981 'adc', p.Get_ADC1_POT(), p.Get_ADC2_POT(),
1982 'err', p.GetTrigSyncErr(),
1983 'pat', boolvec (p.Get_pattern_POT()))
1984 fprint (f,
'\n data')
1985 for r
in p.Get_POT_DATA():
1987 dump_ALFA_RawData (r, f)
1988 fprint (f,
'\n contents')
1991 dump_ALFA_RawData (r, f)
◆ dump_ALFA_RawDataContainer()
| def python.Dumpers.dump_ALFA_RawDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1996 of file Dumpers.py.
1997 if p.is_FullEVmarker(): fprint (f,
'fullev')
1998 if p.is_ROBmarker(): fprint (f,
'rob')
1999 if p.is_RODmarker(): fprint (f,
'rod')
2000 fprint (f,
'sd/mrod/l1/ecr/bc', p.subdetId(), p.mrodId(), p.lvl1Id(),
2001 p.ecrId(), p.bcId())
2002 fprint (f,
'\n run/typ/tt/evtyp', p.runNum(), p.runType(),
2003 p.trigtypeId(), p.DetEventType(),
2004 'ts', p.GetTimeStamp(), p.GetTimeStampns(),
2005 p.GetLumiBlock(), p.GetBCId())
2006 fprint (f,
'\n lvl1',
boolvec(p.GetLvl1Pattern_POT()))
2007 fprint (f,
'\n lvl2',
boolvec(p.GetLvl2Pattern_POT()))
2008 fprint (f,
'\n ef',
boolvec(p.GetEFPattern_POT()))
2011 dump_ALFA_RawDataCollection (c, f)
◆ dump_AlignmentEffectsOnTrack()
| def python.Dumpers.dump_AlignmentEffectsOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2229 of file Dumpers.py.
2231 fprint (f,
'(null)')
2233 fprint (f, p.deltaTranslation(), p.sigmaDeltaTrranslation(), p.deltaAngle(), p.sigmaDeltaAngle())
2234 for t
in p.vectorOfAffectedTSOS():
2235 fprint (f,
'\n ts ')
2236 dump_parameters (t.trackparameters(), f)
2237 fprint (f,
'\n sf ')
2238 dump_Surface (p.associatedSurface(), f)
◆ dump_AmgMatrix()
| def python.Dumpers.dump_AmgMatrix |
( |
|
m, |
|
|
|
f, |
|
|
|
thresh = 1e-38 |
|
) |
| |
Definition at line 307 of file Dumpers.py.
309 for r
in range(m.rows()):
311 for c
in range(m.cols()):
313 if abs(v) < thresh: v = 0
314 fprint (f,
'%#6.3g' % v)
◆ dump_AmgVector()
| def python.Dumpers.dump_AmgVector |
( |
|
m, |
|
|
|
f, |
|
|
|
thresh = 1e-38, |
|
|
|
prec = 3 |
|
) |
| |
Definition at line 319 of file Dumpers.py.
321 fprint (f,
'(null vector)')
324 for r
in range(m.rows()):
326 if abs(v) < thresh: v = 0
327 fprint (f,
'%#6.*g' % (prec, v))
◆ dump_associatedSurface()
| def python.Dumpers.dump_associatedSurface |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1545 of file Dumpers.py.
1546 if hasattr(p,
'hasSurface')
and not p.hasSurface():
1549 dump_surface (p.associatedSurface(), f)
◆ dump_Assocs()
| def python.Dumpers.dump_Assocs |
( |
|
a, |
|
|
|
f, |
|
|
|
colltype |
|
) |
| |
Definition at line 3414 of file Dumpers.py.
3415 bo = a.beginObject()
3419 obj = a.getObject(bo)
3421 errflag = safe_assocs (a, obj, coll, f)
3422 l.append ((obj, coll, errflag))
3425 l.sort (key=
lambda a: a[0].
pt(), reverse=
True)
3427 for obj, coll, errflag
in l:
3428 fprint (f,
'\n',
typename(obj.__class__))
3429 dump_Fourvec (obj, f)
3435 fprint (f,
' [Got invalid EL error]')
◆ dump_AtlfInfo()
| def python.Dumpers.dump_AtlfInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1233 of file Dumpers.py.
1234 dump_BaseTagInfo (info, f)
1235 fprint (f, info.isBTagged(), info.isTauTagged(), info.isTau1PTagged(),
1236 info.isTau3PTagged(), info.LightHypoCalFactor(),
1237 info.TauHypoCalFactor(), info.Tau1P3PHypoCalFactor(),
1238 info.BHypoCalFactor(),
1239 info.deltaRMinTo(
"b"),
1240 info.deltaRMinTo(
"c"),
1241 info.deltaRMinTo(
"t"))
◆ dump_Attribute()
| def python.Dumpers.dump_Attribute |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1727 of file Dumpers.py.
1728 if isinstance (p, str):
1731 ss = ROOT.std.ostringstream()
1732 p.toOutputStream (ss)
1733 fprint (f, ss.str())
◆ dump_AttributeList()
| def python.Dumpers.dump_AttributeList |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1736 of file Dumpers.py.
1740 ss = ROOT.std.ostringstream()
1746 if s[0] ==
'{': s = s[1:]
1747 if s[-1] ==
'}': s = s[:-1]
1748 for a
in s.split(
','):
1749 fprint (f,
' ', a,
'\n')
◆ dump_auxdata()
| def python.Dumpers.dump_auxdata |
( |
|
x, |
|
|
|
exclude = None, |
|
|
|
f = sys.stdout |
|
) |
| |
Definition at line 5675 of file Dumpers.py.
5676 reg=ROOT.SG.AuxTypeRegistry.instance()
5677 if cppyy.addressof (x) == 0:
5678 fprint (f,
'<null pointer>', x,
type(x))
5681 auxids = ROOT.PyDumper.Utils.getAuxIDVector (x)
5685 auxids = [(reg.getName(id), id)
for id
in auxids]
5687 for name, auxid
in auxids:
5688 if exclude
and name
in exclude:
continue
5689 if name.endswith (
'_linked'):
continue
5690 fprint (f, name +
': ')
5691 dump_auxitem (x, auxid, f)
◆ dump_auxitem()
| def python.Dumpers.dump_auxitem |
( |
|
x, |
|
|
|
auxid, |
|
|
|
f = sys.stdout |
|
) |
| |
Definition at line 5630 of file Dumpers.py.
5631 if hasattr (x,
'container'):
5632 auxdata = x.container().getConstStore().
getData(auxid)
5635 fprint (f,
'<unavailable>')
5640 fprint (f,
'<unavailable 4>')
5643 reg=ROOT.SG.AuxTypeRegistry.instance()
5644 tname = reg.getTypeName (auxid)
5645 atomic = reg.getFlags (auxid) & ROOT.SG.AuxVarFlags.Atomic
5647 ac_cl = atomic_accessors.get (tname)
5649 ac_cl = accessors.get (tname)
5651 if not ac_cl
and tname.startswith (
'SG::JaggedVecElt<'):
5652 ac_cl = getattr (ROOT,
'SG::ConstAccessor<' + tname +
' >')
5654 accessors[tname] = ac_cl
5656 if not ac_cl
and tname.startswith (
'SG::PackedLink<')
or tname.startswith (
'std::vector<SG::PackedLink<'):
5657 ac_cl = getattr (ROOT,
'SG::ConstAccessor<' + tname +
' >')
5659 accessors[tname] = ac_cl
5663 ac = ac_cl(reg.getName(auxid))
5668 val =
'<unavailable 5>'
5671 generic_dump_auxitem (x, auxid, f)
◆ dump_BaseTagInfo()
| def python.Dumpers.dump_BaseTagInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1039 of file Dumpers.py.
1040 fprint (f,
' '.join ([
'%f'%x
for x
in info.tagLikelihood()]),
1041 info.weight(), info.isValid())
◆ dump_BCM_RDO()
| def python.Dumpers.dump_BCM_RDO |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5181 of file Dumpers.py.
5182 fprint (f,
'[', p.getWord1(), p.getWord2(),
']')
◆ dump_BCM_RDO_Collection()
| def python.Dumpers.dump_BCM_RDO_Collection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5186 of file Dumpers.py.
5187 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 4231 of file Dumpers.py.
4232 fprint (f, t.cellID().getString(), t.particleID(),
4233 [t.energy(i)
for i
in range(4)])
◆ dump_CaloCell()
| def python.Dumpers.dump_CaloCell |
( |
|
l, |
|
|
|
f |
|
) |
| |
Definition at line 2559 of file Dumpers.py.
2560 fprint (f, l.ID().getString())
2561 if l.__class__ == PyAthena.TileCell:
2562 fprint (f,
'%.2f %.2f %d %d %d ' % (l.ene1(), l.time1(), l.qual1(), l.qbit1(), l.gain1()))
2563 fprint (f,
'%.2f %.2f %d %d %d ' % (l.ene2(), l.time2(), l.qual2(), l.qbit2(), l.gain2()))
2565 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 2536 of file Dumpers.py.
2541 el = beg.getElement()
2542 if last != el.dataID():
2545 fprint (f, el.index())
◆ dump_CaloCluster()
| def python.Dumpers.dump_CaloCluster |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 2487 of file Dumpers.py.
2490 fprint (f,
"%3d %f %f %f %f %f %d %d %d" %
2491 (c.getClusterSize(),
2500 fprint (f, c.getRecoStatus().getStatusWord())
2501 beg = c.beginMoment()
2504 fprint (f,
'\n mom %d %f' % (c.getMomentType(beg),
2505 c.getMomentValue(beg)))
2508 for i
in range (c.nSamples()):
2509 fprint (f,
'\n %2d %d %d %d %f %f %f %f %f %f %f %f %f %f %f' %
2511 c.is_valid_sampling(i),
◆ dump_CaloClusterCellLink()
| def python.Dumpers.dump_CaloClusterCellLink |
( |
|
l, |
|
|
|
f |
|
) |
| |
Definition at line 2550 of file Dumpers.py.
2554 fprint (f,
'%d/%f' % (beg.index(), beg.weight()))
◆ dump_CaloClusterMomentStore()
| def python.Dumpers.dump_CaloClusterMomentStore |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4168 of file Dumpers.py.
4172 fprint (f,
'\n ', beg.getMomentType(), beg.getMoment().getValue())
◆ dump_CaloClusters_sorted()
| def python.Dumpers.dump_CaloClusters_sorted |
( |
|
l, |
|
|
|
f, |
|
|
|
nmax = None |
|
) |
| |
Definition at line 2529 of file Dumpers.py.
2531 ll.sort (key=
lambda a: a.pt(), reverse=
True)
2532 dump_list (ll, f, dump_CaloCluster, nmax=nmax)
◆ dump_CaloEnergy()
| def python.Dumpers.dump_CaloEnergy |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 616 of file Dumpers.py.
617 dump_EnergyLoss (p, f)
618 fprint (f,
'%d %f %f %f %f' %
621 p.caloLRLikelihood(),
622 p.fsrCandidateEnergy(),
624 fprint (f, p.deltaEParam(), p.sigmaMinusDeltaEParam(), p.sigmaPlusDeltaEParam(), p.deltaEMeas(), p.sigmaDeltaEMeas())
625 fprint (f,
'\n deposits:')
626 for d
in p.depositInCalo():
627 fprint (f,
" (%d %f %f)" %
628 (d.subCaloId(), d.energyDeposited(), d.muonEnergyLoss()))
◆ dump_CaloSamplingData()
| def python.Dumpers.dump_CaloSamplingData |
( |
|
s, |
|
|
|
f |
|
) |
| |
Definition at line 4177 of file Dumpers.py.
4178 nsamp = s.getNumberOfSamplings()
4179 for i
in range(
min(10, s.getNumberOfVariableTypes())):
4181 slist = [s.retrieveData(i, samp)
for samp
in range(nsamp)]
4182 fprint (f,
'\n ', i, slist)
◆ dump_CaloShower()
| def python.Dumpers.dump_CaloShower |
( |
|
s, |
|
|
|
f |
|
) |
| |
Definition at line 4186 of file Dumpers.py.
4187 fprint (f,
' moments:')
4188 dump_CaloClusterMomentStore (s.getMomentStore(), f)
4189 fprint (f,
'\n sampling data:')
4190 dump_CaloSamplingData (s.getSamplingStore(), f)
◆ dump_CaloTopoTowerContainer()
| def python.Dumpers.dump_CaloTopoTowerContainer |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4203 of file Dumpers.py.
4205 dump_CaloTowerContainer (t, f)
4206 fprint (f,
' ', t.GetMinimumCellEnergy(),
4207 t.GetMinimumClusterEnergy(),
4208 t.GetUseCellWeights(),
4212 t.GetCellESignificanceThreshold(),
4213 t.GetCaloSelection())
4214 ci = t.GetCaloIndices()
4216 fprint (f, [ci[i]
for i
in range(ci.size())])
4219 if l.isValid(): fprintln (f, l.dataID())
4220 else: fprintln (f,
'(null)')
4224 if t.GetCellToClusterMap():
4225 fprintln (f,
' ', t.GetCellToClusterMap().
size())
4227 fprintln (f,
' (null)')
◆ dump_CaloTowerContainer()
| def python.Dumpers.dump_CaloTowerContainer |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4195 of file Dumpers.py.
4197 fprintln (f, t.neta(), t.etamin(), t.deta(),
4198 t.nphi(), t.phimin(), t.dphi())
◆ dump_ChamberT0s()
| def python.Dumpers.dump_ChamberT0s |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4432 of file Dumpers.py.
4433 for p
in m.getAllT0s():
4434 fprintln (f,
' ', p.first.getString(), p.second)
◆ dump_clist()
| def python.Dumpers.dump_clist |
( |
|
l, |
|
|
|
f |
|
) |
| |
Definition at line 3681 of file Dumpers.py.
3689 fprint (f,
'%f, ' % last)
3691 fprint (f,
'%d*%f, ' % (n, last))
3698 fprint (f,
'%f, ' % last)
3700 fprint (f,
'%d*%f, ' % (n, last))
◆ dump_ClusterSplitProbabilityContainer()
| def python.Dumpers.dump_ClusterSplitProbabilityContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2052 of file Dumpers.py.
2053 for x
in p.splitProbMap():
2054 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 4962 of file Dumpers.py.
4963 fprint (f, p.crate(), p.dataID(), p.peak(),
4964 formatItemUsingLong (
list(p.HitsVec0())),
4965 formatItemUsingLong (
list(p.HitsVec1())),
4966 list(p.ErrorVec0()),
4967 list(p.ErrorVec1()))
◆ dump_CMMEtSums()
| def python.Dumpers.dump_CMMEtSums |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4971 of file Dumpers.py.
4972 fprint (f, p.crate(), p.dataID(), p.peak(),
4973 formatItemUsingLong (
list(p.EtVec())),
4974 formatItemUsingLong (
list(p.ExVec())),
4975 formatItemUsingLong (
list(p.EyVec())),
4976 list(p.EtErrorVec()),
4977 list(p.ExErrorVec()),
4978 list(p.EyErrorVec()))
◆ dump_CMMJetHits()
| def python.Dumpers.dump_CMMJetHits |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4982 of file Dumpers.py.
4983 fprint (f, p.crate(), p.dataID(), p.peak(),
4984 formatItemUsingLong (
list(p.HitsVec())),
◆ dump_CMMRoI()
| def python.Dumpers.dump_CMMRoI |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4990 of file Dumpers.py.
4991 fprint (f, p.jetEtRoiWord(),
◆ dump_CombinedMuonFeature()
| def python.Dumpers.dump_CombinedMuonFeature |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4138 of file Dumpers.py.
4141 fprint (f, m.pt(), m.eta(), m.phi(), m.m(), m.sigma_pt())
4142 if m.IDTrackLink().
isValid()
and m.IDTrack():
4144 dump_TrigInDetTrack (PyTrigInDetTrack(m.IDTrack()), f)
4145 if m.muFastTrackLink().
isValid()
and m.muFastTrack():
4146 fprint (f,
'\n fast')
4147 dump_MuonFeature (m.muFastTrack(), f)
◆ dump_CombinedMuonFeature_nolist()
| def python.Dumpers.dump_CombinedMuonFeature_nolist |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4152 of file Dumpers.py.
4153 dump_CombinedMuonFeature (m, f)
◆ dump_CompetingMuonClustersOnTrack()
| def python.Dumpers.dump_CompetingMuonClustersOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1709 of file Dumpers.py.
1710 dump_CompetingRIOsOnTrack (p, f)
1711 dump_AmgVector (p.globalPosition(), f)
1712 dump_associatedSurface (p, f)
1713 for r
in p.containedROTs():
1714 fprint (f,
'\n mc ')
1715 dump_MuonClusterOnTrack (r, f)
◆ dump_CompetingRIOsOnTrack()
| def python.Dumpers.dump_CompetingRIOsOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1693 of file Dumpers.py.
1694 dump_MeasurementBase (p, f)
1695 fprint (f, p.indexOfMaxAssignProb())
1696 sz = p.numberOfContainedROTs()
1697 fprint (f, [p.assignmentProbability(i)
for i
in range(sz)])
◆ dump_ComTime()
| def python.Dumpers.dump_ComTime |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2103 of file Dumpers.py.
2104 fprint (f, p.getTTCTime(), p.getTime())
2105 dump_H3V (p.GetCounterPosition(), f)
2106 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 4998 of file Dumpers.py.
4999 fprint (f, p.crate(), p.module(), p.peak(),
5000 formatItemUsingLong (
list(p.HitsVec0())),
5001 formatItemUsingLong (
list(p.HitsVec1())))
◆ dump_CPMRoI()
| def python.Dumpers.dump_CPMRoI |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5005 of file Dumpers.py.
5006 fprint (f, p.roiWord())
◆ dump_CPMTower()
| def python.Dumpers.dump_CPMTower |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5010 of file Dumpers.py.
5011 fprint (f, p.eta(), p.phi(), p.peak(),
5012 list(p.emEnergyVec()),
5013 list(p.hadEnergyVec()),
5014 list(p.emErrorVec()),
5015 list(p.hadErrorVec()))
◆ dump_CscClusterOnTrack()
| def python.Dumpers.dump_CscClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2143 of file Dumpers.py.
2144 dump_MuonClusterOnTrack (p, f)
2145 dump_EL (p.prepRawDataLink(), f)
2146 fprint (f, p.status(), p.timeStatus(), p.time())
2147 if p.detectorElement():
2148 fprint (f, p.detectorElement().identifyHash().
value())
2150 fprint (f,
'(null detEl)')
◆ dump_CscMcData()
| def python.Dumpers.dump_CscMcData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4773 of file Dumpers.py.
4774 fprint (f, p.energy(), p.ypos(), p.zpos(), p.charge())
◆ dump_CscPrepData()
| def python.Dumpers.dump_CscPrepData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4541 of file Dumpers.py.
4542 dump_MuonCluster (p, f)
4543 fprint (f, p.charge(), p.time(), p.status(), p.timeStatus())
4544 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_CscPrepDataContainer()
| def python.Dumpers.dump_CscPrepDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4696 of file Dumpers.py.
4697 dump_IDC (dump_CscPrepData, p, f)
◆ dump_CscRawData()
| def python.Dumpers.dump_CscRawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5294 of file Dumpers.py.
5295 fprint (f, p.address(), p.hashId(), p.identify(), p.rpuID(),
5296 p.time(), p.width(), p.isTimeComputed(),
list(p.samples()))
◆ dump_CscRawDataContainer()
| def python.Dumpers.dump_CscRawDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5300 of file Dumpers.py.
5301 dump_IDC (dump_CscRawData, p, f,
5302 extra_idc_dumper =
lambda p, f: \
5303 fprint (f, p.identify(), p.rodId(), p.subDetectorId(),
5304 p.samplingPhase(), p.triggerType(), p.firstBitSummary(),
5305 p.eventType(), p.scaAddress(),
5306 list(p.rpuID()), [ord(c)
for c
in p.dataType()]))
◆ dump_CscSimData()
| def python.Dumpers.dump_CscSimData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4778 of file Dumpers.py.
4779 fprint (f, p.word())
4780 for d
in p.getdeposits():
4781 dump_HepMcParticleLink (d.first, f)
4782 dump_CscMcData (d.second, f)
◆ dump_CscSimDataCollection()
| def python.Dumpers.dump_CscSimDataCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4787 of file Dumpers.py.
4789 fprint (f, elt.first.getString())
4790 dump_CscSimData (elt.second, f)
◆ dump_CSCSimHit()
| def python.Dumpers.dump_CSCSimHit |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5193 of file Dumpers.py.
5194 fprint (f, p.CSCid(), p.globalTime(), p.energyDeposit())
5195 dump_Threevec (p.getHitStart(), f)
5196 dump_Threevec (p.getHitEnd(), f)
5197 fprint (f, p.particleID(), p.kineticEnergy())
5198 dump_HepMcParticleLink (p.particleLink(), f)
◆ dump_CscStripPrepData()
| def python.Dumpers.dump_CscStripPrepData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4548 of file Dumpers.py.
4549 dump_MuonCluster (p, f)
4550 fprint (f, p.timeOfFirstSample(), p.samplingPhase(), p.samplingTime())
4551 fprint (f,
list(p.sampleCharges()))
4552 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_CscStripPrepDataContainer()
| def python.Dumpers.dump_CscStripPrepDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4702 of file Dumpers.py.
4703 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 5020 of file Dumpers.py.
5021 fprint (f, p.getCTPVersionNumber(),
5022 p.getCTPVersion().getVersionNumber(),
5023 formatItemUsingLong (
list(p.getDataWords())),
5024 p.getL1AcceptBunchPosition(),
5026 p.getNumberOfBunches(),
5027 p.getNumberOfAdditionalWords())
◆ dump_CTPConfig()
| def python.Dumpers.dump_CTPConfig |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 3172 of file Dumpers.py.
3173 dump_L1DataBaseclass (c, f)
◆ dump_CTPResult()
| def python.Dumpers.dump_CTPResult |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5096 of file Dumpers.py.
5097 dump_ROIBHeader (p.header(), f)
5098 for r
in p.roIVec():
5100 dump_ROIBTrailer (p.trailer(), f)
◆ dump_CTPRoI()
| def python.Dumpers.dump_CTPRoI |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5091 of file Dumpers.py.
5092 fprint (f, p.roIWord())
◆ dump_CurvilinearParameters()
| def python.Dumpers.dump_CurvilinearParameters |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1567 of file Dumpers.py.
1568 dump_ParametersBase (info, f)
1569 fprint (f,
'\n curvilinear')
1570 fprint (f, info.cIdentifier())
1571 mat = info.measurementFrame()
1572 dump_AmgVector (mat.col(0), f)
1573 dump_AmgVector (mat.col(1), f)
1574 dump_AmgVector (mat.col(2), f)
◆ dump_CylinderSurface()
| def python.Dumpers.dump_CylinderSurface |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1500 of file Dumpers.py.
1501 dump_Surface (info, f)
◆ dump_DetailedTrackTruthCollection()
| def python.Dumpers.dump_DetailedTrackTruthCollection |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 1425 of file Dumpers.py.
1426 fprint (f,
' ', c.trackCollectionLink().
key(), c.size())
1428 fprint (f,
'\n %3d' % p.first.index(),
' common ')
1429 dump_SubDetHitStatistics (p.second.statsCommon(), f)
1430 fprint (f,
'\n ',
' track ')
1431 dump_SubDetHitStatistics (p.second.statsTrack(), f)
1432 fprint (f,
'\n ',
' truth ')
1433 dump_SubDetHitStatistics (p.second.statsTruth(), f)
1434 fprint (f,
'\n ',
' trajectory ')
1435 dump_TruthTrajectory (p.second.trajectory(), f)
◆ dump_DetStatus()
| def python.Dumpers.dump_DetStatus |
( |
|
s, |
|
|
|
f |
|
) |
| |
Definition at line 3237 of file Dumpers.py.
3238 fprintln (f, s.code(),
◆ dump_DetStatusMap()
| def python.Dumpers.dump_DetStatusMap |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 3247 of file Dumpers.py.
3250 dump_DetStatus (e.second, f)
◆ dump_DiscSurface()
| def python.Dumpers.dump_DiscSurface |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1505 of file Dumpers.py.
1506 dump_Surface (info, f)
◆ dump_eflowObject()
| def python.Dumpers.dump_eflowObject |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 4479 of file Dumpers.py.
4481 fprint (f, e.eflowType(), e.isValid(), e.d0(), e.z0(),
4482 e.getPassEOverPCheck(), e.getIsSubtracted(),
4483 e.getIsDuplicated(), e.getCaloRecoStatus().getStatusWord())
4484 for i
in range(e.numTrack()):
4485 fprint (f,
'\n tk: ')
4486 dump_EL (e.trackLink(i), f)
4487 for i
in range(e.numClus()):
4488 fprint (f,
'\n cl: ')
4489 dump_EL (e.clusLink(i), f)
4490 fprint (f,
'\n mu: ')
4491 dump_EL (e.muonLink(), f)
4492 fprint (f,
'\n cv: ')
4493 dump_EL (e.conversionLink(), f)
◆ dump_eflowObjectContainer()
| def python.Dumpers.dump_eflowObjectContainer |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 4498 of file Dumpers.py.
4499 print (c.missET(), c.sumET(), c.pTx(), c.pTy(), c.numEf(),
4500 c.numPhot(), c.numEle(), c.numMuo(), c.isValid(),
4501 c.circularity(), c.thrust(), c.oblateness(),
4503 dump_list (c, f, dump_eflowObject)
◆ dump_egamma()
| def python.Dumpers.dump_egamma |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 550 of file Dumpers.py.
552 dump_ParticleImpl (e, f)
553 fprint (f,
"\n %d %d %d" % (e.author(), e.isem(), e.isemse()))
554 if e.clusterElementLink().
isValid():
555 fprint (f,
'\n cl: %2d:' % e.clusterElementLink().
index())
556 dump_Fourvec (e.cluster(), f)
557 for i
in range(e.nTrackParticles()):
558 tp = e.trackParticleElementLink(i)
560 fprint (f,
'\n tp: %2d:' %tp.index())
561 dump_Fourvec (e.trackParticle(i), f)
562 for i
in range(e.nConversions()):
563 cv = e.conversionElementLink(i)
565 fprint (f,
'\n cv: %2d:' % cv.index())
566 dump_Threevec (e.conversion(i).recVertex().position(), f)
567 for i
in range (e.nDetails()):
568 if e.detailElementLink(i).
isValid():
570 fprint (f,
'\n %s: ' % d.className())
571 if isinstance (d, PyAthena.EMConvert):
572 dump_EMConvert (d, f)
573 elif isinstance (d, PyAthena.EMBremFit):
574 dump_EMBremFit (d, f)
575 elif isinstance (d, PyAthena.EMTrackMatch):
576 dump_EMTrackMatch (d, f)
577 elif isinstance (d, PyAthena.EMShower):
579 elif isinstance (d, PyAthena.EMErrorDetail):
580 dump_EMErrorDetail (d, f)
581 elif isinstance (d, PyAthena.EMTrackFit):
582 dump_EMTrackFit (d, f)
586 fprint (f,
'\n Detail link %d not valid; skipped.' % i)
588 pid = PyAthena.egammaPIDObs
590 pid = PyAthena.egammaPID
591 fprint (f,
'\n pid: %g %g %f %g %f %f' %
592 (e.egammaID(pid.ElectronWeight), e.egammaID(pid.BgWeight),
593 e.egammaID(pid.NeuralNet), e.egammaID(pid.Hmatrix),
594 e.egammaID(pid.IsolationLikelihood_jets),
595 e.egammaID(pid.IsolationLikelihood_HQDelectrons)))
◆ dump_egDetailContainer()
| def python.Dumpers.dump_egDetailContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2027 of file Dumpers.py.
2028 fprint (f,
'(Dumped as a part of egamma)')
◆ dump_EL()
| def python.Dumpers.dump_EL |
( |
|
l, |
|
|
|
f |
|
) |
| |
Definition at line 332 of file Dumpers.py.
335 pos2 = nm.rfind (
'>')
336 nm = nm[pos1+1:pos2].strip()
340 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 3474 of file Dumpers.py.
3475 dump_JetAssociationBase (a, f)
3478 fprint (f, a.getElectronWeight (ele))
3479 dump_Fourvec (ele, f)
◆ dump_ElectronConstituent()
| def python.Dumpers.dump_ElectronConstituent |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1289 of file Dumpers.py.
1291 dump_Fourvec (info.electron(), f)
1292 fprint (f, info.getElectronWeight (info.electron()))
◆ dump_ElectronMuonTopoInfo()
| def python.Dumpers.dump_ElectronMuonTopoInfo |
( |
|
a, |
|
|
|
f |
|
) |
| |
Definition at line 3449 of file Dumpers.py.
3450 fprint (f, a.RoiWord(), a.DeltaPhi(), a.DeltaR(), a.InvMass(),
3451 a.ElecValid(), a.OppositeCharge(), a.VertexState())
◆ dump_EMBremFit()
| def python.Dumpers.dump_EMBremFit |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 382 of file Dumpers.py.
384 iperr = d.bremInvpTerr()
386 if iperr==-999: iperr = 0
389 if br == -999: br = 0
390 if bx == -999: bx = 0
393 if nt == -999: nt = 0
394 if nr == -999: nr = 0
397 if d0 == -999: d0 = 0
398 if phi0 == -999: phi0 = 0
399 fprint (f,
"%f %f %f %f %f %2d %2d %2d %2d %f %f" %
400 (ip*1e6, br, bx, iperr*1e6,
401 d.bremClusterRadius(), d.bremFitStatus(), d.bremErrorFlag(),
403 fprint (f, d.bremZ0(), d.bremDzDr(), d.bremNZ(), d.bremFitChi2())
◆ dump_EMConvert()
| def python.Dumpers.dump_EMConvert |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 378 of file Dumpers.py.
379 fprint (f, d.convTrackMatch(), d.convAngleMatch())
◆ dump_EMErrorDetail()
| def python.Dumpers.dump_EMErrorDetail |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 445 of file Dumpers.py.
446 fprint (f, d.linkIndex())
448 uf(d.EMconvertedphoton_perigee_d0()),
449 uf(d.EMconvertedphoton_perigee_z0()),
450 uf(d.EMconvertedphoton_perigee_phi0()),
451 uf(d.EMconvertedphoton_perigee_theta()),
452 uf(d.EMconvertedphoton_perigee_eta()),
453 uf(d.EMconvertedphoton_perigee_momentum()),
454 uf(d.EMconvertedphoton_perigee_Covd0d0 ()),
455 uf(d.EMconvertedphoton_perigee_Covd0z0 ()),
456 uf(d.EMconvertedphoton_perigee_Covd0phi ()),
457 uf(d.EMconvertedphoton_perigee_Covd0theta ()),
458 uf(d.EMconvertedphoton_perigee_Covz0z0 ()),
459 uf(d.EMconvertedphoton_perigee_Covz0phi ()),
460 uf(d.EMconvertedphoton_perigee_Covz0theta ()),
461 uf(d.EMconvertedphoton_perigee_Covphiphi ()),
462 uf(d.EMconvertedphoton_perigee_Covphitheta ()),
463 uf(d.EMconvertedphoton_perigee_Covthetatheta ()))
465 uf(d.EMtrack_perigee_d0 ()),
466 uf(d.EMtrack_perigee_phi0 ()),
467 uf(d.EMtrack_perigee_z0 ()),
468 uf(d.EMtrack_perigee_theta ()),
469 uf(d.EMtrack_perigee_eta ()),
470 uf(d.EMtrack_perigee_momentum ()),
471 uf(d.EMtrack_perigee_Covd0d0 ()),
472 uf(d.EMtrack_perigee_Covd0z0 ()),
473 uf(d.EMtrack_perigee_Covd0phi ()),
474 uf(d.EMtrack_perigee_Covd0theta ()),
475 uf(d.EMtrack_perigee_Covz0z0 ()),
476 uf(d.EMtrack_perigee_Covz0phi ()),
477 uf(d.EMtrack_perigee_Covz0theta ()),
478 uf(d.EMtrack_perigee_Covphiphi ()),
479 uf(d.EMtrack_perigee_Covphitheta ()),
480 uf(d.EMtrack_perigee_Covthetatheta ()))
482 uf(d.EMphoton_eta ()),
483 uf(d.EMphoton_phi0 ()),
484 uf(d.EMphoton_Eclus ()),
485 uf(d.EMphoton_Covetaeta ()),
486 uf(d.EMphoton_Covetaphi ()),
487 uf(d.EMphoton_CovetaEclus ()),
488 uf(d.EMphoton_Covphiphi ()),
489 uf(d.EMphoton_CovphiEclus ()),
490 uf(d.EMphoton_CovEclusEclus ()))
492 uf(d.EMtrack_comb_Covd0d0 ()),
493 uf(d.EMtrack_comb_Covd0z0 ()),
494 uf(d.EMtrack_comb_Covd0phi ()),
495 uf(d.EMtrack_comb_Covd0eta ()),
496 uf(d.EMtrack_comb_Covd0P ()),
497 uf(d.EMtrack_comb_Covz0z0 ()),
498 uf(d.EMtrack_comb_Covz0phi ()),
499 uf(d.EMtrack_comb_Covz0eta ()),
500 uf(d.EMtrack_comb_Covz0P ()),
501 uf(d.EMtrack_comb_Covphiphi ()),
502 uf(d.EMtrack_comb_Covphieta ()),
503 uf(d.EMtrack_comb_CovphiP ()),
504 uf(d.EMtrack_comb_Covetaeta ()),
505 uf(d.EMtrack_comb_CovetaP ()),
506 uf(d.EMtrack_comb_CovPP ()))
◆ dump_EMShower()
| def python.Dumpers.dump_EMShower |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 413 of file Dumpers.py.
415 if weta1 < -10: weta1 = 0
417 if pos7 < -10: pos7 = 0
419 if not hasattr(d,
'etconoisedR04Sig2'):
420 d.etconoisedR04Sig2 = d.etconoise20
421 d.etconoisedR04Sig3 = d.etconoise30
422 fprint (f, d.e011(), d.e033(), d.ethad1(),
423 d.ethad(), d.ehad1(), d.f1(), d.f3(), d.f1core(), d.f3core(),
424 d.e233(), d.e235(), d.e255(), d.e237(), d.e277(), d.e333(),
425 d.e335(), d.e337(), d.e377(), weta1, d.weta2(), d.e2ts1(),
426 d.e2tsts1(), d.fracs1(), d.widths1(), d.widths2(),
427 d.poscs1(), d.poscs2(), d.asy1(), d.pos(), pos7, d.barys1(),
428 d.wtots1(), d.emins1(), d.emaxs1(), d.etcone(), d.etcone20(),
429 d.etcone30(), d.etcone40(),
430 d.etconoisedR04Sig2(), d.etconoisedR04Sig3(),
432 if hasattr (d,
'e131'):
433 fprint (f, d.e131(), d.e1153(), d.iso())
435 fprint (f, d.e132(), d.e1152(), d.r33over37allcalo())
◆ dump_EmTau_ROI()
| def python.Dumpers.dump_EmTau_ROI |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2952 of file Dumpers.py.
2954 fprint (f,
"%d %f %f %f %f %f %f %d" %
2963 for (n,v)
in zip (m.getThresholdNames(), m.getThresholdValues()):
◆ dump_EMTauResult()
| def python.Dumpers.dump_EMTauResult |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5122 of file Dumpers.py.
5123 dump_ROIBHeader (p.header(), f)
5124 for r
in p.roIVec():
5125 dump_EMTauRoI (r, f)
5126 dump_ROIBTrailer (p.trailer(), f)
◆ dump_EMTauRoI()
| def python.Dumpers.dump_EMTauRoI |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5117 of file Dumpers.py.
5118 fprint (f, p.roIWord())
◆ dump_EMTrackFit()
| def python.Dumpers.dump_EMTrackFit |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 510 of file Dumpers.py.
512 d.track_perigee_d0 (),
513 d.track_perigee_phi0 (),
514 d.track_perigee_qOverP(),
515 d.track_perigee_z0 (),
516 d.track_perigee_theta (),
517 d.track_perigee_Covd0d0 (),
518 d.track_perigee_Covd0z0 (),
519 d.track_perigee_Covd0phi (),
520 d.track_perigee_Covd0theta (),
521 d.track_perigee_Covd0qOverP (),
522 d.track_perigee_Covz0z0 (),
523 d.track_perigee_Covz0phi (),
524 d.track_perigee_Covz0theta (),
525 d.track_perigee_Covz0qOverP (),
526 d.track_perigee_Covphiphi (),
527 d.track_perigee_Covphitheta (),
528 d.track_perigee_CovphiqOverP (),
529 d.track_perigee_Covthetatheta (),
530 d.track_perigee_CovthetaqOverP (),
531 d.track_perigee_CovqOverPqOverP ())
533 d.track_LastM_loc1 (),
534 d.track_LastM_loc2 (),
535 d.track_LastM_phi (),
536 d.track_LastM_theta (),
537 d.track_LastM_qOverP (),
538 d.bremTrackAuthor (),
544 d.bremMaterialTraversed (),
◆ dump_EMTrackMatch()
| def python.Dumpers.dump_EMTrackMatch |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 406 of file Dumpers.py.
407 fprint (f,
"%f %f %4d %4d" %
408 (d.deltaEta(2), d.deltaPhi(2),
409 d.trackNumber(), d.tracksInBroadWindow()))
410 fprint (f, d.trackRefit(), d.isPrimary())
◆ dump_EnergyLoss()
| def python.Dumpers.dump_EnergyLoss |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 607 of file Dumpers.py.
611 fprint (f, p.deltaE(), p.sigmaDeltaE(), p.sigmaMinusDeltaE(), p.sigmaPlusDeltaE())
612 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 2989 of file Dumpers.py.
2990 fprint (f,
"%d %d %d %f %f %f %f %f %d %d %d %d %d %d" %
3003 m.getThrPatSummET(),
3004 m.getThrPatMissET()))
3005 fprint (f, [t
for t
in m.getThresholds()])
◆ dump_EventBookkeeper()
| def python.Dumpers.dump_EventBookkeeper |
( |
|
p, |
|
|
|
f, |
|
|
|
level = 0 |
|
) |
| |
Definition at line 5247 of file Dumpers.py.
5248 fprint (f, p.getName(), p.getDescription(), p.getInputStream(), p.getOutputStream(), p.getLogic(), p.getNAcceptedEvents(), p.getNWeightedAcceptedEvents(), p.getCycle())
5249 for c
in list(p.getChildrenEventBookkeepers()):
5250 fprint (f,
'\n ' + (
' '*level))
5251 dump_EventBookkeeper (c, f, level+1)
◆ dump_EventID()
| def python.Dumpers.dump_EventID |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 2692 of file Dumpers.py.
2693 fprint (f,
'%9d %9d %9d %9d %9d %9d' %
2697 e.time_stamp_ns_offset(),
2699 e.bunch_crossing_id()))
◆ dump_EventInfo()
| def python.Dumpers.dump_EventInfo |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 2717 of file Dumpers.py.
2718 fprint (f, e.clID())
2719 dump_EventID (e.event_ID(), f)
2721 fprint (f, e.actualInteractionsPerCrossing(), e.averageInteractionsPerCrossing())
2722 for i
in range(ROOT.EventInfo.nDets):
2723 fprint (f,
'\n det', i, e.eventFlags(i), e.errorState(i))
2725 dump_EventType (e.event_type(), f)
2727 dump_TriggerInfo (e.trigger_info(), f)
◆ dump_EventStreamInfo()
| def python.Dumpers.dump_EventStreamInfo |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 2740 of file Dumpers.py.
2741 fprint (f,
'nevents: ', e.getNumberOfEvents())
2744 fprint (f,
'\nproc tags: ',
list(e.getProcessingTags()))
2745 fprint (f,
'\nitem list: ',
formatItemUsingLong([(p.first, p.second)
for p
in e.getItemList()]))
2746 for typ
in list(e.getEventTypes()):
2748 dump_EventType (typ, f)
◆ dump_EventType()
| def python.Dumpers.dump_EventType |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 2703 of file Dumpers.py.
2704 fprint (f, e.typeToString(), e.user_type(), e.mc_event_weight())
◆ dump_ExtendedVxCandidate()
| def python.Dumpers.dump_ExtendedVxCandidate |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 3636 of file Dumpers.py.
3637 dump_VxCandidate1 (c, f)
3639 if c.fullCovariance():
3640 dump_AmgMatrix (c.fullCovariance(), f)
◆ dump_FitQuality()
| def python.Dumpers.dump_FitQuality |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1439 of file Dumpers.py.
1441 fprint (f,
'(null)')
1443 fprint (f,
'%f %f' % (info.chiSquared(), info.doubleNumberDoF()))
◆ dump_Fourvec()
| def python.Dumpers.dump_Fourvec |
( |
|
v, |
|
|
|
f, |
|
|
|
parens = 1 |
|
) |
| |
Definition at line 234 of file Dumpers.py.
235 ParticleImpl_EEtaPhiM = getattr(PyAthena,
'ParticleImpl<NavigableTerminalNode,P4ImplEEtaPhiM,ParticleEvent::Base>')
239 if isinstance (v, PyAthena.P4EEtaPhiMBase)
or \
240 isinstance (v, ParticleImpl_EEtaPhiM)
or \
241 isinstance (vmom, PyAthena.P4BaseEEtaPhiM)
or \
242 isinstance (v, PyAthena.xAOD.IParticle):
249 elif isinstance (v, PyAthena.P4PtEtaPhiMBase)
or \
250 isinstance (vmom, PyAthena.P4BasePtEtaPhiM):
254 elif isinstance (v, PyAthena.P4IPtCotThPhiMBase)
or \
255 isinstance (vmom, PyAthena.P4BaseIPtCotThPhiM):
261 if ipt == 0
and m == 0
and cotth == 0
and v.phi() == 0:
265 aux = math_hypot(1, cotth)
266 eta = math_log ((aux-cotth) / (aux+cotth))
275 m2 = v.e()**2 - v.px()**2 - v.py()**2 - v.pz()**2
277 m = - math_sqrt (-m2)
282 pt = math_hypot (v.px(), v.py())
289 eta = asinh (v.pz() / pt)
292 if parens: fprint (f,
'(')
293 fprint (f,
"%f %f %f %f" % (pt, eta, v.phi(), m))
294 if parens: fprint (f,
')')
◆ dump_GbbNNTagInfo()
| def python.Dumpers.dump_GbbNNTagInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1259 of file Dumpers.py.
1260 dump_BaseTagInfo (info, f)
1261 fprint (f, info.nMatchingTracks(), info.trkJetWidth(),
1262 info.trkJetMaxDeltaR())
◆ dump_GenericResult()
| def python.Dumpers.dump_GenericResult |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3029 of file Dumpers.py.
3030 fprint (f,
"%d %d %d" %
◆ dump_GenEvent()
| def python.Dumpers.dump_GenEvent |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 2897 of file Dumpers.py.
2898 fprint (f,
'%d %d %f %f %f %d %d' %
2906 fprint (f,
'\n wt', [w
for w
in e.weights()], \
2911 dump_GenVertex (sv, f)
2916 dump_GenVertex (v, f)
2923 dump_GenParticle (p, f)
◆ dump_GenParticle()
| def python.Dumpers.dump_GenParticle |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2858 of file Dumpers.py.
2859 fprint (f,
"%d %5s %d %d" %
2861 PDG.pdgid_to_name(p.pdg_id()),
2862 p.parent_event().event_number(),
2864 if p.production_vertex():
2865 s =
str(_gen_barcode (p.production_vertex())) +
'('
2866 parts = genvertex_in_barcodes (p.production_vertex())
2867 for bc
in parts: s +=
'%d ' % bc
2868 if len(parts) > 3: s +=
'...'
2874 s = str (_gen_barcode (p.end_vertex())) +
'(->'
2875 parts = genvertex_out_barcodes (p.end_vertex())
2876 for bc
in parts: s +=
'%d ' % bc
2877 if len(parts) > 3: s +=
'...'
2882 dump_HLV (p.momentum(), f)
2883 if hasattr (p,
'polarization'):
2884 pol = p.polarization()
2885 poltheta = fix_neg0 (pol.theta())
2886 fprint (f,
"%f %f" % (poltheta, pol.phi()))
2887 if pol.normal3d().theta() != 0
or pol.normal3d().phi() != 0:
2888 fprint (f,
"%f %f" %
2889 (pol.normal3d().theta(), pol.normal3d().phi()))
2891 poltheta = fix_neg0 (
_gen_attr(p,
'theta', float))
2893 fprint (f,
"%f %f" % (poltheta, polphi))
◆ dump_GenVertex()
| def python.Dumpers.dump_GenVertex |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 2831 of file Dumpers.py.
2832 fprint (f,
"%d %d %d %d %d" %
2833 (v.status()
if hasattr(v,
'status')
else v.id(),
2835 v.parent_event().event_number(),
2838 dump_Threevec (v.position(), f)
2839 fprint (f,
'%f ' % v.position().
t())
2840 if not hasattr(v,
'weights'):
2842 elif v.weights().
size() == 0:
2845 ww =
list(v.weights())
2846 fprintln (f, [w
for w
in ww])
◆ dump_H3V()
| def python.Dumpers.dump_H3V |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 204 of file Dumpers.py.
205 fprint (f,
"(%f %f %f)" %
206 (v.perp(),v.eta(),v.phi()))
◆ dump_HepMcParticleLink()
| def python.Dumpers.dump_HepMcParticleLink |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4249 of file Dumpers.py.
4250 fprint (f, p.barcode(), p.eventIndex())
◆ dump_HLTAODConfigData()
| def python.Dumpers.dump_HLTAODConfigData |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 3155 of file Dumpers.py.
3158 for c
in d.getChainList().
chains():
3160 dump_HLTChain (c, f)
3161 for c
in d.getSequenceList().sequences():
3163 dump_HLTSequence (c, f)
◆ dump_HLTChain()
| def python.Dumpers.dump_HLTChain |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 3124 of file Dumpers.py.
3125 fprint (f, c.chain_name(),
3129 c.lower_chain_name(),
3130 c.lower_chain_counter(),
3134 c.lower_chain_hash_id())
3135 for s
in c.signatureList():
3136 dump_HLTSignature (s, f)
3137 fprint (f, [t.bit()
for t
in c.triggerTypeList()])
3138 for s
in c.streamTagList():
3139 dump_HLTStreamTag (s, f)
3140 fprint (f, [s
for s
in c.groupList()])
◆ dump_HLTResult()
| def python.Dumpers.dump_HLTResult |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3038 of file Dumpers.py.
3039 dump_GenericResult (t, f)
3040 fprint (f,
"%d %d %d %d %d %d %d %d %d %d %d %d" %
3041 (t.getHLTResultClassVersion(),
3044 t.getHLTStatus().code,
3045 t.getLvlConverterStatus().code,
3048 t.getNumOfSatisfiedSigs(),
3049 t.isCreatedOutsideHLT(),
3050 t.isHLTResultTruncated(),
3054 fprint (f, [i
for i
in t.partSizes()])
3055 fprint (f, [i
for i
in t.getNavigationResult()])
3056 fprint (f, [i
for i
in t.getChainResult()])
3057 fprint (f, [i
for i
in t.getNavigationResultCuts()])
◆ dump_HLTResultMT()
| def python.Dumpers.dump_HLTResultMT |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 3062 of file Dumpers.py.
3063 fprint (f,
'version', p.getVersion())
3064 fprint (f,
'\n streamtags',
list(p.getStreamTags()))
3067 fprint (f,
'\n hltbits',
list(p.getHltBitsAsWords()))
3068 fprint (f,
'\n data size', p.getSerialisedData().
size())
3070 fprint (f,
'\n status',
list(p.getStatus()))
3071 fprint (f,
'\n trunc', p.severeTruncation(),
list(p.getTruncatedModuleIds()))
◆ dump_HLTSequence()
| def python.Dumpers.dump_HLTSequence |
( |
|
s, |
|
|
|
f |
|
) |
| |
Definition at line 3144 of file Dumpers.py.
3146 dump_HLTTriggerElement (s.outputTE(), f)
3147 dump_HLTTriggerElement (s.topoStartTE(), f)
3148 for t
in s.inputTEs():
3149 dump_HLTTriggerElement (t, f)
3150 fprint (f, [a
for a
in s.algorithms()],
')')
◆ dump_HLTSignature()
| def python.Dumpers.dump_HLTSignature |
( |
|
s, |
|
|
|
f |
|
) |
| |
Definition at line 3105 of file Dumpers.py.
3106 fprint (f,
'(', s.signature_counter(),
3109 for e
in s.outputTEs():
3110 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 3100 of file Dumpers.py.
3101 fprint (f, e.id(), e.name())
◆ dump_HLV()
| def python.Dumpers.dump_HLV |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 209 of file Dumpers.py.
210 m2 = v.e()**2 - v.px()**2 - v.py()**2 - v.pz()**2
212 m2 = fix_neg0 (m2, 1e-3)
214 m = - math_sqrt (-m2)
220 pt = math_hypot (v.px(), v.py())
227 eta = asinh (v.pz() / pt)
229 fprint (f,
"(%f %f %f %f)" %
230 (v.perp(),eta,v.phi(), m))
◆ dump_IDC()
| def python.Dumpers.dump_IDC |
( |
|
payload_dumper, |
|
|
|
p, |
|
|
|
f, |
|
|
|
extra_idc_dumper = None |
|
) |
| |
Definition at line 4666 of file Dumpers.py.
4666 def dump_IDC (payload_dumper, p, f, extra_idc_dumper = None):
4669 if hasattr(beg.__class__,
'__preinc__'):
4670 nextfunc = beg.__preinc__
4671 elif hasattr(beg.__class__,
'__next__'):
4672 nextfunc = beg.__next__
4677 if hasattr (coll,
'identifyHash'):
4678 hash = coll.identifyHash().
value()
4680 hash = coll.identifierHash().
value()
4681 fprint (f,
'IDC', beg.hashId().
value(), hash, coll.size())
4682 if hasattr (coll,
'type'):
4683 fprint (f, coll.type())
4684 if extra_idc_dumper:
4685 extra_idc_dumper (coll, f)
4688 payload_dumper (x, f)
◆ dump_IDCInDetBSErrContainer()
| def python.Dumpers.dump_IDCInDetBSErrContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1759 of file Dumpers.py.
1760 for x
in p.getAll():
1761 fprint (f,
'\n ', x.first, x.second)
◆ dump_IdentContIndex()
| def python.Dumpers.dump_IdentContIndex |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4518 of file Dumpers.py.
4519 fprint (f, p.collHash(), p.objIndex())
◆ dump_INav4MomAssocs()
| def python.Dumpers.dump_INav4MomAssocs |
( |
|
a, |
|
|
|
f |
|
) |
| |
Definition at line 3440 of file Dumpers.py.
3441 return dump_Assocs (a, f, PyAthena.DataVector(PyAthena.INavigable4Momentum))
◆ dump_InDetLowBetaCandidate()
| def python.Dumpers.dump_InDetLowBetaCandidate |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4370 of file Dumpers.py.
4371 if p == InDetLowBetaCandidateNull:
4372 fprint (f,
'(null)')
4374 if hasattr (p,
'getTRTInverseBeta'):
4375 fprint (f, p.getTRTCorrBitsOverThreshold(),
4376 p.getTRTInverseBeta(),
4377 p.getTRTInverseBetaError(),
4378 p.getTRTNLastBits())
4380 fprint (f, p.getTRTCorrBitsOverThreshold(),
4381 p.getTRTTrailingEdge(),
4382 p.getTRTTrailingEdgeError(),
4383 p.getTRTNLastBits())
4384 others = (p.getTRTdEdx(),
4385 p.getTRTLikelihoodBeta(),
4386 p.getTRTLikelihoodError(),
4387 p.getTRTHighTbits(),)
4388 if max(others)!=0
or min(others) != 0:
4389 for o
in others: fprint (f, o)
◆ dump_InDetRawData()
| def python.Dumpers.dump_InDetRawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4643 of file Dumpers.py.
4644 fprint (f, p.identify().getString(), p.getWord())
◆ dump_InDetSimData()
| def python.Dumpers.dump_InDetSimData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2058 of file Dumpers.py.
2060 fprint (f,
'(null)')
2062 fprint (f, p.word())
2063 for d
in p.getdeposits():
2065 dump_HepMcParticleLink (d.first, f)
2066 fprint (f, d.second)
◆ dump_InDetSimDataCollection()
| def python.Dumpers.dump_InDetSimDataCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2071 of file Dumpers.py.
2072 getData = ROOT.InDetSimDataHelpers.getData
2073 for id
in ROOT.InDetSimDataHelpers.identifiers(p):
2074 fprint (f,
'\n ', id.getString())
2075 dump_InDetSimData (getData (p, id), f)
◆ dump_InDetTime()
| def python.Dumpers.dump_InDetTime |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1753 of file Dumpers.py.
1754 fprint (f, p.first, p.second)
◆ dump_IPInfoBase()
| def python.Dumpers.dump_IPInfoBase |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1115 of file Dumpers.py.
1116 dump_BaseTagInfo (info, f)
1117 fprint (f, info.nbTracks())
◆ dump_IPInfoPlus()
| def python.Dumpers.dump_IPInfoPlus |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1106 of file Dumpers.py.
1107 dump_BaseTagInfo (info, f)
1108 fprint (f,
' %d' % info.numTrackInfo())
1109 for i
in range(info.numTrackInfo()):
1111 dump_IPTrackInfo (info.getTrackInfo(i), f)
◆ dump_IPTrackInfo()
| def python.Dumpers.dump_IPTrackInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1091 of file Dumpers.py.
1092 dump_Fourvec (info.track(), f)
1093 fprint (f,
' %d %s %d %f %f %f %f %f %f %f' %
1094 (info.trackGrade().gradeNumber(),
1095 info.trackGrade().gradeString(),
1098 info.d0Significance(),
1100 info.z0Significance(),
1101 info.trackWeight2D(),
1102 info.trackWeight3D(),
1103 info.trackProbJP()))
◆ dump_IsoMuonFeature()
| def python.Dumpers.dump_IsoMuonFeature |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4309 of file Dumpers.py.
4311 fprint (f,
'\n ', m.getEtInnerConeEC(), m.getEtOuterConeEC(),
4312 m.getEtInnerConeHC(), m.getEtOuterConeHC())
4313 fprint (f,
'\n ', m.getNTracksCone(), m.getSumPtTracksCone(),
4314 m.getPtMuTracksCone())
4315 fprint (f,
'\n ', m.getRoiIdMu(), m.getPtMu(), m.getEtaMu(),
4316 m.getPhiMu(), m.getLArWeight(), m.getTileWeight())
◆ dump_ISvxAssociation()
| def python.Dumpers.dump_ISvxAssociation |
( |
|
a, |
|
|
|
f |
|
) |
| |
Definition at line 3512 of file Dumpers.py.
3513 dump_JetAssociationBase (a, f)
3516 for v
in vi.vertices():
3517 dump_Threevec (v.position(), f)
◆ dump_ITrackLink()
| def python.Dumpers.dump_ITrackLink |
( |
|
l, |
|
|
|
f |
|
) |
| |
Definition at line 2581 of file Dumpers.py.
2585 pm = trk.trackParameters()
2586 if pm
and len(pm) > 0:
2588 dump_parameters (perigee, f)
◆ dump_JEMEtSums()
| def python.Dumpers.dump_JEMEtSums |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5039 of file Dumpers.py.
5040 fprint (f, p.crate(), p.module(), p.peak(),
5041 formatItemUsingLong (
list(p.EtVec())),
5042 formatItemUsingLong (
list(p.ExVec())),
5043 formatItemUsingLong (
list(p.EyVec())))
◆ dump_JEMHits()
| def python.Dumpers.dump_JEMHits |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5047 of file Dumpers.py.
5048 fprint (f, p.crate(), p.module(), p.peak(),
5049 formatItemUsingLong (
list(p.JetHitsVec())))
◆ dump_JEMRoI()
| def python.Dumpers.dump_JEMRoI |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5053 of file Dumpers.py.
5054 fprint (f, p.roiWord())
◆ dump_Jet()
| def python.Dumpers.dump_Jet |
( |
|
j, |
|
|
|
f |
|
) |
| |
Definition at line 3524 of file Dumpers.py.
3525 if j.e() == 0
and j.phi() == 0
and j.eta() == 0:
3526 with signalstate (j, PyAthena.P4SignalState.JETEMSCALE):
3527 dump_ParticleImpl (j, f)
3529 dump_ParticleImpl (j, f)
3530 fprint (f,
'\n %s %f' %
3532 j.getFlavourTagWeight(),))
3534 tower_constituents_p =
False
3535 if j.firstConstituent() != j.lastConstituent():
3536 if isinstance (j.getContainer(j.firstConstituent()),
3537 PyAthena.CaloTowerContainer):
3538 tower_constituents_p =
True
3539 elif j.firstConstituent().__deref__():
3540 ss =
asint(j.constituentSignalState())
3541 j.setConstituentSignalState (PyAthena.P4SignalState.CALIBRATED)
3542 dump_HLV (j.constituent_sum4Mom(), f)
3543 j.setConstituentSignalState (ss)
3544 fprint (f, [x
for x
in j.combinedLikelihood()])
3545 fprint (f,
'\n moms ')
3546 for mk
in j.getMomentKeys():
3547 if mk
in [
'Timing',
'LArQuality']:
continue
3548 mom = j.getMoment (mk,
False)
3550 fprint (f, mk, j.getMoment (mk,
True))
3551 if hasattr(j,
'getJetTime'):
3552 fprint (f,
'\n timing ', j.getJetTime(),
3553 ' qual ', j.getJetQuality())
3555 fprint (f,
'\n timing ', j.getMoment(
'Timing',
True),
3556 ' qual ', j.getMoment(
'LArQuality',
True))
3557 fprint (f,
'\n assoc ')
3558 for ak
in j.getAssociationKeys():
3559 ass = j.getAssociationBase(ak)
3560 if ass == jetAssocNull :
continue
3561 fprint (f,
'\n ', ak)
3562 if isinstance (ass, PyAthena.Analysis.ElectronAssociation):
3563 dump_ElectronAssociation (ass, f)
3564 elif isinstance (ass, PyAthena.Analysis.PhotonAssociation):
3565 dump_PhotonAssociation (ass, f)
3566 elif isinstance (ass, PyAthena.Analysis.MuonAssociation):
3567 dump_MuonAssociation (ass, f)
3568 elif isinstance (ass, PyAthena.Analysis.TrackAssociation):
3569 dump_TrackAssociation (ass, f)
3570 elif isinstance (ass, PyAthena.Analysis.ISvxAssociation):
3571 dump_ISvxAssociation (ass, f)
3574 ti = j.jetTagInfoVector()
3575 fprint (f,
'\n tag info:')
3579 ti.sort (key=_infoType)
3582 fprint (f,
'\n (null)')
3584 fprint (f,
'\n %s %s: %f: '
3585 % (info.infoType(),
typename(info.__class__), j.getFlavourTagWeight (info.infoType())))
3586 if isinstance (info, PyAthena.Analysis.TruthInfo):
3587 dump_TruthInfo (info, f)
3588 elif isinstance (info, PyAthena.Analysis.SoftLeptonTruthInfo):
3589 dump_SoftLeptonTruthInfo (info, f)
3590 elif isinstance (info, PyAthena.Analysis.SecVtxInfo):
3591 dump_SecVtxInfo (info, f)
3592 elif isinstance (info, PyAthena.Analysis.IPInfoPlus):
3593 dump_IPInfoPlus (info, f)
3594 elif isinstance (info, PyAthena.Analysis.IPInfoBase):
3595 dump_IPInfoBase (info, f)
3596 elif isinstance (info, PyAthena.Analysis.SVInfoBase):
3597 dump_SVInfoBase (info, f)
3598 elif isinstance (info, PyAthena.Analysis.SVInfoPlus):
3599 dump_SVInfoPlus (info, f)
3600 elif isinstance (info, PyAthena.Analysis.MultiSVInfoPlus):
3601 dump_MultiSVInfoPlus (info, f)
3602 elif isinstance (info, PyAthena.Analysis.JetProbInfoBase):
3603 dump_JetProbInfoBase (info, f)
3604 elif isinstance (info, PyAthena.Analysis.SoftElectronInfo):
3605 dump_SoftElectronInfo (info, f)
3606 elif isinstance (info, PyAthena.Analysis.JetFitterTagInfo):
3607 dump_JetFitterTagInfo (info, f)
3608 elif (hasattr (PyAthena.Analysis,
'TrackCountingInfo')
and
3609 isinstance (info, PyAthena.Analysis.TrackCountingInfo)):
3610 dump_TrackCountingInfo (info, f)
3611 elif isinstance (info, PyAthena.Analysis.AtlfInfo):
3612 dump_AtlfInfo (info, f)
3613 elif isinstance (info, PyAthena.Analysis.SoftMuonInfo):
3614 dump_SoftMuonInfo (info, f)
3615 elif info.__class__
is PyAthena.Analysis.BaseTagInfo:
3616 dump_BaseTagInfo (info, f)
3617 elif info.__class__
is PyAthena.Analysis.GbbNNTagInfo:
3618 dump_GbbNNTagInfo (info, f)
3621 if tower_constituents_p:
3622 fprint (f,
'\n (not dumping tower constituents)')
3624 fprint (f,
'\n constituents:')
3625 for c
in toiter (j.firstConstituent(), j.lastConstituent()):
3631 fprint (f, j.getWeight (c))
◆ dump_Jet_ROI()
| def python.Dumpers.dump_Jet_ROI |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2968 of file Dumpers.py.
2970 fprint (f,
"%d %d %f %f %f" %
2976 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 1266 of file Dumpers.py.
1267 fprint (f, [info.energyInSample(i)
for i
in range(8)],
1268 info.energyInCryostat(), info.wtCryo(), info.jet())
◆ dump_JetElement()
| def python.Dumpers.dump_JetElement |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5058 of file Dumpers.py.
5059 fprint (f, p.eta(), p.phi(), p.key(), p.peak(),
5060 list(p.emEnergyVec()),
5061 list(p.hadEnergyVec()),
5062 list(p.emErrorVec()),
5063 list(p.hadErrorVec()),
5064 list(p.linkErrorVec()))
◆ dump_JetEnergyResult()
| def python.Dumpers.dump_JetEnergyResult |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5109 of file Dumpers.py.
5110 dump_ROIBHeader (p.header(), f)
5111 for r
in p.roIVec():
5112 dump_JetEnergyRoI (r, f)
5113 dump_ROIBTrailer (p.trailer(), f)
◆ dump_JetEnergyRoI()
| def python.Dumpers.dump_JetEnergyRoI |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5104 of file Dumpers.py.
5105 fprint (f, p.roIWord())
◆ dump_JetET_ROI()
| def python.Dumpers.dump_JetET_ROI |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2981 of file Dumpers.py.
2982 fprint (f,
"%d %d" %
2984 m.getThrPattern(),))
2985 fprint (f, [t
for t
in m.getThresholds()])
◆ dump_JetFitterTagInfo()
| def python.Dumpers.dump_JetFitterTagInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1208 of file Dumpers.py.
1209 dump_BaseTagInfo (info, f)
1210 fprint (f,
'%d %d %d %f %f %f %f %f' %
1212 info.nSingleTracks(),
1213 info.nTracksAtVtx(),
1214 info.energyFraction(),
1216 info.significance3d(),
◆ dump_JetKeyDescriptorCollection()
| def python.Dumpers.dump_JetKeyDescriptorCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2039 of file Dumpers.py.
2040 fprint (f,
'(Dumped as a part of jets)')
◆ dump_JetMomentMapCollection()
| def python.Dumpers.dump_JetMomentMapCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2033 of file Dumpers.py.
2034 fprint (f,
'(Dumped as a part of jets)')
◆ dump_JetProbInfoBase()
| def python.Dumpers.dump_JetProbInfoBase |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1185 of file Dumpers.py.
1186 dump_BaseTagInfo (info, f)
1187 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 5130 of file Dumpers.py.
5131 fprint (f, p.getSourceID(),
5132 list(p.getErrors()),
5133 list(p.getDataWords()),
5134 list(p.getStatusWords()))
◆ dump_L1TopoResult()
| def python.Dumpers.dump_L1TopoResult |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5138 of file Dumpers.py.
5139 dump_ROIBHeader (p.header(), f)
5140 dump_L1TopoRDO (p.rdo(), f)
5141 dump_ROIBTrailer (p.trailer(), f)
◆ dump_LArDigit()
| def python.Dumpers.dump_LArDigit |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5228 of file Dumpers.py.
5229 fprint (f, p.channelID().getString(), p.gain(),
list(p.samples()))
◆ dump_LArFebErrorSummary()
| def python.Dumpers.dump_LArFebErrorSummary |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2045 of file Dumpers.py.
2046 for x
in p.get_all_febs():
2047 fprint (f,
'\n ', x.first, x.second)
◆ dump_LArFebHeader()
| def python.Dumpers.dump_LArFebHeader |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1776 of file Dumpers.py.
1777 fprint (f,
'feb', p.FEBId().getString(), p.FebELVL1Id(), p.FebBCId(),
1778 'febh', p.FormatVersion(), p.SourceId(),
1779 p.RunNumber(), p.ELVL1Id(), p.BCId(), p.LVL1TigType(),
1781 'dsp', p.DspCodeVersion(), p.DspEventCounter(),
1782 'res', p.RodResults1Size(), p.RodResults2Size(), p.RodRawDataSize(),
1783 p.NbSamples(), p.NbSweetCells1(), p.NbSweetCells2(),
1784 p.OnlineChecksum(), p.OfflineChecksum(), p.RodStatus(),
1786 list(p.FebCtrl1()),
list(p.FebCtrl2()),
list(p.FebCtrl3()))
◆ dump_LArHit()
| def python.Dumpers.dump_LArHit |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4237 of file Dumpers.py.
4238 fprint (f, t.cellID().getString(), t.energy(), t.time())
◆ dump_LArNoisyROSummary()
| def python.Dumpers.dump_LArNoisyROSummary |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4394 of file Dumpers.py.
4395 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 1790 of file Dumpers.py.
1791 fprint (f, p.identify().getString(), p.energy(), p.time(),
1792 p.quality(), p.provenance(), p.gain())
◆ dump_LArTTL1()
| def python.Dumpers.dump_LArTTL1 |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2096 of file Dumpers.py.
2097 fprint (f, p.ttOnlineID().getString(), p.ttOfflineID().getString(),
◆ dump_LineSaggingDescriptor()
| def python.Dumpers.dump_LineSaggingDescriptor |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1510 of file Dumpers.py.
1511 os = ROOT.ostringstream()
1513 s = os.str().replace (
'\n',
';')
◆ dump_LinkToTrack()
| def python.Dumpers.dump_LinkToTrack |
( |
|
l, |
|
|
|
f |
|
) |
| |
Definition at line 2592 of file Dumpers.py.
2593 dump_ITrackLink (l, f)
2594 fprint (f,
'\n ', l.isValid(), l.index(), l.dataID())
◆ dump_LinkToTrackParticleBase()
| def python.Dumpers.dump_LinkToTrackParticleBase |
( |
|
l, |
|
|
|
f |
|
) |
| |
Definition at line 2598 of file Dumpers.py.
2599 dump_ITrackLink (l, f)
2600 fprint (f, l.isValid(), l.index(), l.dataID())
◆ dump_list()
| def python.Dumpers.dump_list |
( |
|
l, |
|
|
|
f, |
|
|
|
dumper, |
|
|
|
nmax = None |
|
) |
| |
Definition at line 5715 of file Dumpers.py.
5715 def dump_list (l, f, dumper, nmax = None):
5718 if nmax
is not None and i >= nmax:
break
◆ dump_LocalParameters()
| def python.Dumpers.dump_LocalParameters |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1630 of file Dumpers.py.
1631 dump_AmgVector (p, f)
1632 fprint (f, p.parameterKey())
◆ dump_LUCID_RawData()
| def python.Dumpers.dump_LUCID_RawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5173 of file Dumpers.py.
5174 fprint (f, p.getStatus(),
5175 p.getWord0(), p.getWord1(), p.getWord2() , p.getWord3(),
5176 p.getWord0p(), p.getWord1p(), p.getWord2p(), p.getWord3p(),
5177 p.getWord0n(), p.getWord1n(), p.getWord2n(), p.getWord3n())
◆ dump_LVL1_ROI()
| def python.Dumpers.dump_LVL1_ROI |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3010 of file Dumpers.py.
3011 for m
in t.getMuonROIs():
3013 dump_Muon_ROI (m, f)
3014 for m
in t.getEmTauROIs():
3016 dump_EmTau_ROI (m, f)
3017 for m
in t.getJetROIs():
3020 for m
in t.getJetEtROIs():
3022 dump_JetET_ROI (m, f)
3023 for m
in t.getEnergySumROIs():
3025 dump_EnergySum_ROI (m, f)
◆ dump_Lvl1AODConfigData()
| def python.Dumpers.dump_Lvl1AODConfigData |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 3196 of file Dumpers.py.
3197 fprint (f, d.masterKey())
3198 fprint (f,
'\nit', [s
for s
in d.getItems()])
3199 fprint (f,
'\nmu', [s
for s
in d.getMuonThresholds()])
3200 fprint (f,
'\nem', [s
for s
in d.getEMTauThresholds()])
3201 fprint (f,
'\njt', [s
for s
in d.getJetThresholds()])
3202 fprint (f,
'\nfj', [s
for s
in d.getForwardJetThresholds()])
3203 fprint (f,
'\net', [s
for s
in d.getTotalEtThresholds()])
3204 fprint (f,
'\nje', [s
for s
in d.getJetEtThresholds()])
3205 fprint (f,
'\nms', [s
for s
in d.getMissingEtThresholds()])
3208 dump_CTPConfig (d.ctpConfig(), f)
3212 if d.thresholdConfig():
3213 fprint (f, d.thresholdConfig())
◆ dump_Lvl1AODPrescaleConfigData()
| def python.Dumpers.dump_Lvl1AODPrescaleConfigData |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 3220 of file Dumpers.py.
3221 fprint (f, d.masterKey())
3222 fprint (f, [i
for i
in d.getPrescales()])
◆ dump_Lvl1Result()
| def python.Dumpers.dump_Lvl1Result |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3076 of file Dumpers.py.
3077 fprint (f, t.isConfigured(),
3079 t.anyActiveL1ItemAfterVeto(),
3081 fprint (f,
'\n ', [i
for i
in t.itemsPassed()])
3082 fprint (f,
'\n ', [i
for i
in t.itemsBeforePrescale()])
3083 fprint (f,
'\n ', [i
for i
in t.itemsAfterPrescale()])
3084 fprint (f,
'\n ', [i
for i
in t.itemsAfterVeto()])
◆ dump_materialeffects()
| def python.Dumpers.dump_materialeffects |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2218 of file Dumpers.py.
2220 fprint (f,
'(null)')
2223 fprint (f, nm +
': ')
2224 if nm ==
'Trk::MaterialEffectsOnTrack':
2225 dump_MaterialEffectsOnTrack (p, f)
◆ dump_MaterialEffectsBase()
| def python.Dumpers.dump_MaterialEffectsBase |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2196 of file Dumpers.py.
2197 fprint (f, p.dumpType(), p.thicknessInX0())
2198 dump_associatedSurface (p, f)
◆ dump_MaterialEffectsOnTrack()
| def python.Dumpers.dump_MaterialEffectsOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2211 of file Dumpers.py.
2212 dump_MaterialEffectsBase (p, f)
2213 dump_ScatteringAngles (p.scatteringAngles(), f)
2214 dump_EnergyLoss (p.energyLoss(), f)
◆ dump_MdtAmtHit()
| def python.Dumpers.dump_MdtAmtHit |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5410 of file Dumpers.py.
5411 fprint (f, p.tdcId(), p.channelId(), p.leading(), p.coarse(), p.fine(),
5412 p.width(), p.isMasked(),
list(p.dataWords()))
◆ dump_MdtCsmContainer()
| def python.Dumpers.dump_MdtCsmContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5416 of file Dumpers.py.
5417 dump_IDC (dump_MdtAmtHit, p, f,
5418 extra_idc_dumper =
lambda p, f: \
5419 fprint (f, p.identify().getString(),
5420 p.SubDetId(), p.MrodId(), p.CsmId()))
◆ dump_MdtDriftCircleOnTrack()
| def python.Dumpers.dump_MdtDriftCircleOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1682 of file Dumpers.py.
1683 dump_RIO_OnTrack (p, f)
1684 dump_AmgVector (p.globalPosition(), f, thresh=1e-8)
1685 dump_EL (p.prepRawDataLink(), f)
1686 fprint (f, p.status(), p.localAngle(), p.positionAlongWire())
1688 fprint (f, p.detectorElement().identifyHash().
value())
1689 dump_StraightLineSurface (p.associatedSurface(), f)
◆ dump_MdtPrepData()
| def python.Dumpers.dump_MdtPrepData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4588 of file Dumpers.py.
4589 dump_MuonCluster (p, f)
4590 fprint (f, p.tdc(), p.adc(), p.status())
4591 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_MdtPrepDataContainer()
| def python.Dumpers.dump_MdtPrepDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4732 of file Dumpers.py.
4733 dump_IDC (dump_MdtPrepData, p, f)
◆ dump_MDTSimHit()
| def python.Dumpers.dump_MDTSimHit |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5202 of file Dumpers.py.
5203 fprint (f, p.MDTid(), p.globalTime(), p.driftRadius())
5204 dump_Threevec (p.localPosition(), f)
5205 fprint (f, p.stepLength(), p.energyDeposit(), p.particleEncoding(), p.kineticEnergy())
5206 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 2161 of file Dumpers.py.
2163 fprint (f,
'(null)')
2166 fprint (f, nm +
': ')
2167 if nm ==
'InDet::PixelClusterOnTrack':
2168 dump_PixelClusterOnTrack (p, f)
2169 elif nm ==
'InDet::SCT_ClusterOnTrack':
2170 dump_SCT_ClusterOnTrack (p, f)
2171 elif nm ==
'InDet::TRT_DriftCircleOnTrack':
2172 dump_TRT_DriftCircleOnTrack (p, f)
2173 elif nm ==
'Muon::MdtDriftCircleOnTrack':
2174 dump_MdtDriftCircleOnTrack (p, f)
2175 elif nm ==
'Muon::MdtDriftCircleOnTrack':
2176 dump_MdtDriftCircleOnTrack (p, f)
2177 elif nm ==
'Muon::CompetingMuonClustersOnTrack':
2178 dump_CompetingMuonClustersOnTrack (p, f)
2179 elif nm ==
'Muon::RpcClusterOnTrack':
2180 dump_RpcClusterOnTrack (p, f)
2181 elif nm ==
'Muon::TgcClusterOnTrack':
2182 dump_TgcClusterOnTrack (p, f)
2183 elif nm ==
'Muon::sTgcClusterOnTrack':
2184 dump_sTgcClusterOnTrack (p, f)
2185 elif nm ==
'Muon::MMClusterOnTrack':
2186 dump_MMClusterOnTrack (p, f)
2187 elif nm ==
'Muon::CscClusterOnTrack':
2188 dump_CscClusterOnTrack (p, f)
2189 elif nm ==
'Trk::PseudoMeasurementOnTrack':
2190 dump_PseudoMeasurementOnTrack (p, f)
◆ dump_MeasurementBase()
| def python.Dumpers.dump_MeasurementBase |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1636 of file Dumpers.py.
1637 dump_LocalParameters (p.localParameters(), f)
1638 dump_AmgMatrix (p.localCovariance(), f)
◆ dump_MissingET()
| def python.Dumpers.dump_MissingET |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2301 of file Dumpers.py.
2302 fprint (f,
'%d %f %f %f %f %f' %
2312 fprint (f,
'\n %d %f %f %f' %
◆ dump_MissingEtCalo()
| def python.Dumpers.dump_MissingEtCalo |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2462 of file Dumpers.py.
2463 dump_MissingET (m, f)
2464 fprintln (f,
' ', m.calibType())
2466 fprintln (f,
' %d %d %f %f %f' %
◆ dump_MissingETComposition()
| def python.Dumpers.dump_MissingETComposition |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4416 of file Dumpers.py.
4417 for p
in toiter1 (m):
4418 fprint (f,
' ',
typename(p.__class__))
4420 fprint (f,
'(null)')
4425 fprint (f,
' [', w.wet(), w.wpx(), w.wpy(), w.statusWord(),
']')
4426 except RuntimeError:
◆ dump_MissingETSig()
| def python.Dumpers.dump_MissingETSig |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2322 of file Dumpers.py.
2323 fprint (f,
"%f %f" %
2326 fprint (f,
"\n %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f" %
2343 fprint (f,
"\n %f %f %f %f %f %f %f %f" %
2352 fprint (f,
"\n %f %f %f %f" %
◆ dump_MissingETSigHypo()
| def python.Dumpers.dump_MissingETSigHypo |
( |
|
h, |
|
|
|
f |
|
) |
| |
Definition at line 2360 of file Dumpers.py.
2366 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" %
2395 dump_Fourvec (h.getObject(), f)
2397 fprint (f,
'\n %d %f %f %f %f %f' %
2404 fprint (f,
'\n ', [x
for x
in toiter1(h)])
◆ dump_MissingETSigObject()
| def python.Dumpers.dump_MissingETSigObject |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2408 of file Dumpers.py.
2410 fprint (f,
" %d %d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f %f " %
2411 (m.isValidDefault(),
2416 m.getDefaultType().
type(),
2419 m.getType(0).
type(),
2431 fprint (f,
'\n %f %f %f %f %f %f %f %d %d %d' %
2443 fprint (f,
'\n ', [i
for i
in m.types()])
2445 fprint (f,
'\n %d %f %f %f %f %f' %
2453 [x
for x
in toiter1 (m.getExcess())],
2454 [x
for x
in toiter1 (m.getDeficit())])
2455 dump_MissingETSigHypo (m.getHypo(), f)
2456 dump_MissingETSigHypo (m.getDefaultHypo(), f)
2457 dump_MissingETSigHypo (m.getHypo(0), f)
◆ dump_MissingEtTruth()
| def python.Dumpers.dump_MissingEtTruth |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2476 of file Dumpers.py.
2477 dump_MissingET (m, f)
2479 fprintln (f,
' %d %f %f %f' %
◆ dump_MM_RawData()
| def python.Dumpers.dump_MM_RawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5435 of file Dumpers.py.
5436 fprint (f, p.identify().getString(), p.channel(), p.relBcid(),
5437 p.time(), p.charge(),
5438 p.timeAndChargeInCounts())
◆ dump_MM_RawDataContainer()
| def python.Dumpers.dump_MM_RawDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5442 of file Dumpers.py.
5443 dump_IDC (dump_MM_RawData, p, f)
◆ dump_MMClusterOnTrack()
| def python.Dumpers.dump_MMClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2131 of file Dumpers.py.
2132 dump_MuonClusterOnTrack (p, f)
2133 dump_EL (p.prepRawDataLink(), f)
2134 fprint (f, p.detectorElement().identifyHash().
value())
2135 fprint (f,
'\n stripDriftDists: ',
list(p.stripDriftDists()))
2136 fprint (f,
'\n stripDriftDistErrors:')
2137 for m
in p.stripDriftDistErrors():
2139 dump_AmgMatrix (m, f)
◆ dump_MuCTPI_RDO()
| def python.Dumpers.dump_MuCTPI_RDO |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5032 of file Dumpers.py.
5034 formatItemUsingLong (
list(p.getAllCandidateMultiplicities())),
5035 formatItemUsingLong (
list(p.dataWord())))
◆ dump_MuCTPIResult()
| def python.Dumpers.dump_MuCTPIResult |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5083 of file Dumpers.py.
5084 dump_ROIBHeader (p.header(), f)
5085 for r
in p.roIVec():
5086 dump_MuCTPIRoI (r, f)
5087 dump_ROIBTrailer (p.trailer(), f)
◆ dump_MuCTPIRoI()
| def python.Dumpers.dump_MuCTPIRoI |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5078 of file Dumpers.py.
5079 fprint (f, p.roIWord())
◆ dump_MultiSVInfoPlus()
| def python.Dumpers.dump_MultiSVInfoPlus |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1158 of file Dumpers.py.
1159 dump_BaseTagInfo (info, f)
1160 fprint (f, info.getNGTrackInJet(),
1161 info.getNGTrackInSvx(),
1165 fprint (f,
'\n verts: ')
1166 for i
in range (info.numVtxInfo()):
1167 fprint (f,
'\n %d: ' % i)
1168 vx = info.getVtxInfo(i)
1169 fprint (f, vx.getMass(), vx.getPt(), vx.getEta(), vx.getPhi(),
1170 vx.getEnergyFraction(), vx.getNormDist(), vx.numTrackInfo())
1171 fprint (f,
'\n vert: ')
1172 dump_RecVertex (vx.getRecSvx(), f)
1173 fprint (f,
'\n tracks: ')
1176 ti = [vx.getTrackInfo(i)
for i
in range(vx.numTrackInfo())]
1177 ti.sort (key=
lambda a: a.track().
pt(), reverse=
True)
1178 i = vx.numTrackInfo()-1
1180 fprint (f,
'\n %d: ' % i)
1181 dump_SVTrackInfo (tt, f)
◆ dump_Muon()
| def python.Dumpers.dump_Muon |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 632 of file Dumpers.py.
633 dump_ParticleImpl (m, f)
634 fprint (f,
' %1d' % m.author())
635 if m.inDetTrackLink().
isValid():
636 fprint (f,
'\n idtp: %2d:' % m.inDetTrackLink().
index())
637 dump_Fourvec (m.inDetTrackParticle(), f)
639 if hasattr(m,
'muonSpTrackLink')
and m.muonSpTrackLink().
isValid():
640 fprint (f,
'\n sptp: %2d:' % m.muonSpTrackLink().
index())
641 dump_Fourvec (m.muonSpectrometerTrackParticle(), f)
642 if m.muonExtrapTrackLink().
isValid():
643 fprint (f,
'\n mxtp: %2d:' % m.muonExtrapTrackLink().
index())
644 dump_Fourvec (m.muonExtrapolatedTrackParticle(), f)
645 if m.innerExtrapTrackLink().
isValid():
646 fprint (f,
'\n ixtp: %2d:' % m.innerExtrapTrackLink().
index())
647 dump_Fourvec (m.innerExtrapolatedTrackParticle(), f)
648 if m.combinedTrackLink().
isValid():
649 fprint (f,
'\n cmtp: %2d:' % m.combinedTrackLink().
index())
650 dump_Fourvec (m.combinedMuonTrackParticle(), f)
652 fprint (f,
'\n cl: %2d:' % m.clusterLink().
index())
653 dump_Fourvec (m.cluster(), f)
654 fprint (f,
'\n a: %f %f %d %f %d %f %d' %
655 (m.matchChi2(), m.matchChi2OverDoF(), m.matchNumberDoF(),
656 m.fitChi2(), m.fitNumberDoF(), m.fitChi2OverDoF(),
658 fprint (f,
'\n b: %d %d %d %d %d %d %d %d %d %d %d %d' %
659 (m.numberOfInnermostPixelLayerHits(),
660 m.numberOfPixelHits(),
663 m.numberOfTRTHighThresholdHits(),
664 m.numberOfInnermostPixelLayerSharedHits(),
665 m.numberOfPixelSharedHits(),
666 m.numberOfPixelHoles(),
667 m.numberOfSCTSharedHits(),
668 m.numberOfSCTHoles(),
669 m.numberOfTRTOutliers(),
670 m.numberOfTRTHighThresholdOutliers()))
671 fprint (f,
'\n c: %d %d %d %d %d %d %d %d %d %d %d %d %d %d' %
672 (m.numberOfMDTHits(),
673 m.numberOfMDTHoles(),
674 m.numberOfCSCEtaHits(),
675 m.numberOfCSCEtaHoles(),
676 m.numberOfCSCPhiHits(),
677 m.numberOfCSCPhiHoles(),
678 m.numberOfRPCEtaHits(),
679 m.numberOfRPCEtaHoles(),
680 m.numberOfRPCPhiHits(),
681 m.numberOfRPCPhiHoles(),
682 m.numberOfTGCEtaHits(),
683 m.numberOfTGCEtaHoles(),
684 m.numberOfTGCPhiHits(),
685 m.numberOfTGCPhiHoles()))
686 fprint (f,
'\n d: %d %d %f %f %f %f %f %f' %
687 (m.numberOfGangedPixels(),
688 m.numberOfOutliersOnTrack(),
690 m.segmentChi2OverDoF(),
695 fprint (f,
'\n e: %f %f %d %d' %
696 (m.parameter(etcone10),
697 m.parameter(nucone10),
698 m.alsoFoundByLowPt(),
699 m.alsoFoundByCaloMuonId()))
700 fprint (f,
'\n f:', [i
for i
in m.associatedEtaDigits()])
701 fprint (f,
'\n h:', [i
for i
in m.associatedPhiDigits()])
702 fprint (f,
'\n i:', [i
for i
in m.segmentEtaDigits()])
703 fprint (f,
'\n j:', [i
for i
in m.segmentPhiDigits()])
704 caloe = m.caloEnergyLoss()
707 dump_CaloEnergy (caloe, f)
◆ dump_Muon_ROI()
| def python.Dumpers.dump_Muon_ROI |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2935 of file Dumpers.py.
2937 fprint (f,
"%d %s %f %d %d %d %d %d %d %d %d" %
2943 m.getSectorAddress(),
2944 m.isFirstCandidate(),
2945 m.isMoreCandInRoI(),
2946 m.isMoreCandInSector(),
◆ dump_MuonAssociation()
| def python.Dumpers.dump_MuonAssociation |
( |
|
a, |
|
|
|
f |
|
) |
| |
Definition at line 3492 of file Dumpers.py.
3493 dump_JetAssociationBase (a, f)
3496 fprint (f, a.getMuonWeight (muo))
3497 dump_Fourvec (muo, f)
◆ dump_MuonCluster()
| def python.Dumpers.dump_MuonCluster |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4535 of file Dumpers.py.
4536 dump_PrepRawData (p, f)
4537 dump_AmgVector (p.globalPosition(), f, thresh=1e-8, prec=4)
◆ dump_MuonClusterOnTrack()
| def python.Dumpers.dump_MuonClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1701 of file Dumpers.py.
1702 dump_RIO_OnTrack (p, f)
1703 dump_AmgVector (p.globalPosition(), f, 1e-12, 4)
1704 fprint (f, p.positionAlongStrip())
◆ dump_MuonConstituent()
| def python.Dumpers.dump_MuonConstituent |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1298 of file Dumpers.py.
1300 dump_Fourvec (info.muon(), f)
1301 fprint (f, info.getMuonWeight (info.muon()))
◆ dump_MuonFeature()
| def python.Dumpers.dump_MuonFeature |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 3978 of file Dumpers.py.
3979 fprint (f,
' ', m.roiId(), m.saddress(), m.pt(), m.radius(),
3980 m.eta(), m.phi(), m.dir_phi(), m.zeta(), m.dir_zeta(), m.beta(),
3981 m.sp1_r(), m.sp1_z(), m.sp1_slope(),
3982 m.sp2_r(), m.sp2_z(), m.sp2_slope(),
3983 m.sp3_r(), m.sp3_z(), m.sp3_slope(),
3984 m.br_radius(), m.br_sagitta(), m.ec_alpha(), m.ec_beta(),
3985 m.dq_var1(), m.dq_var2(), m.algoId())
◆ dump_MuonFeature_nolist()
| def python.Dumpers.dump_MuonFeature_nolist |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 3988 of file Dumpers.py.
3989 dump_MuonFeature (m, f)
◆ dump_MuonFeatureDetails()
| def python.Dumpers.dump_MuonFeatureDetails |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 3993 of file Dumpers.py.
3994 fprint (f, m.extension_capacity(),
3995 m.max_rob_capacity(),
3996 m.max_csm_capacity(),
3997 m.max_lvl1_emu_capacity(),
3998 m.max_rpc_hits_capacity(),
3999 m.max_tgc_hits_capacity(),
4000 m.max_mdt_hits_capacity(),
4001 m.id(), m.te_id(), m.error())
4003 m.lvl1_id(), m.lumi_block(), m.muondetmask(),
4004 m.roi_id(), m.roi_system(), m.roi_subsystem(),
4005 m.roi_sector(), m.roi_number(), m.roi_threshold(),
4006 daz(m.roi_eta()),
daz(m.roi_phi()),
4007 m.rpc_pad_error(), m.tgc_rdo_error())
4009 m.rpc1_x(), m.rpc1_y(), m.rpc1_z(),
4010 m.rpc2_x(), m.rpc2_y(), m.rpc2_z(),
4011 m.rpc3_x(), m.rpc3_y(), m.rpc3_z())
4013 m.tgc_Mid1_eta(), m.tgc_Mid1_phi(), m.tgc_Mid1_r(), m.tgc_Mid1_z(),
4014 m.tgc_Mid2_eta(), m.tgc_Mid2_phi(), m.tgc_Mid2_r(), m.tgc_Mid2_z(),
4015 m.tgc_Mid_rho_chi2(), m.tgc_Mid_rho_N(),
4016 m.tgc_Mid_phi_chi2(), m.tgc_Mid_phi_N())
4018 m.tgc_Inn_eta(), m.tgc_Inn_phi(),
4019 m.tgc_Inn_r(), m.tgc_Inn_z(),
4020 m.tgc_Inn_rho_std(), m.tgc_Inn_rho_N(),
4021 m.tgc_Inn_phi_std(), m.tgc_Inn_phi_N(),
4024 m.mdt_Inner_slope(),
4025 m.mdt_Inner_intercept(),
4028 m.mdt_Inner_fit_chi(),
4029 m.mdt_Middle_slope(),
4030 m.mdt_Middle_intercept(),
4033 m.mdt_Middle_fit_chi(),
4034 m.mdt_Outer_slope(),
4035 m.mdt_Outer_intercept(),
4038 m.mdt_Outer_fit_chi())
4040 m.Address(), m.Sagitta(), m.Radius(), m.Slope(), m.Intercept(),
4041 m.Alpha(), m.Beta(), m.DeltaR(), m.Speed_over_c(),
4042 m.PhiMap(), m.Phi(), m.PhiDir(), m.Pt(), m.Charge())
4050 m.eta_high_0_lay0(),
4051 m.eta_high_1_lay0(),
4052 m.eta_high_0_lay1(),
4053 m.eta_high_1_lay1(),
4060 m.phi_high_0_lay0(),
4061 m.phi_high_1_lay0(),
4062 m.phi_high_0_lay1(),
4063 m.phi_high_1_lay1())
4065 fprint (f,
'\n ', formatItemUsingLong (
list(m.rob_id())))
4066 fprint (f,
'\n ', formatItemUsingLong (
list(m.csm_id())))
4067 fprint (f,
'\n ', formatItemUsingLong (
list(m.csm_size())))
4068 fprint (f,
'\n ', formatItemUsingLong (
list(m.csm_error())))
4069 fprint (f,
'\n ', formatItemUsingLong (
list(m.removed_rob_id())))
4070 fprint (f,
'\n ', formatItemUsingLong (
list(m.removed_csm_id())))
4071 fprint (f,
'\n ', formatItemUsingLong (
list(m.lvl1_emulation())))
4072 fprint (f,
'\n ', formatItemUsingLong (
list(m.pad_hit_onlineId())))
4073 fprint (f,
'\n ', formatItemUsingLong (
list(m.pad_hit_code())))
4083 fprint (f,
'\n ', formatItemUsingLong (
list(m.tgc_Inn_rho_hit_in_seg())))
4088 fprint (f,
'\n ', formatItemUsingLong (
list(m.tgc_Inn_phi_hit_in_seg())))
4093 fprint (f,
'\n ', formatItemUsingLong (
list(m.tgc_Mid_rho_hit_in_seg())))
4098 fprint (f,
'\n ', formatItemUsingLong (
list(m.tgc_Mid_phi_hit_in_seg())))
4099 fprint (f,
'\n ', formatItemUsingLong (
list(m.mdt_onlineId())))
4100 fprint (f,
'\n ', formatItemUsingLong (
list(m.mdt_offlineId())))
4107 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension0())))
4108 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension1())))
4109 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension2())))
4110 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension3())))
4111 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension4())))
4112 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension5())))
4113 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension6())))
4114 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension7())))
4115 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension8())))
4116 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension9())))
◆ dump_MuonMcData()
| def python.Dumpers.dump_MuonMcData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4795 of file Dumpers.py.
4796 fprint (f, p.firstEntry(), p.secondEntry())
◆ dump_MuonSimData()
| def python.Dumpers.dump_MuonSimData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4800 of file Dumpers.py.
4801 fprint (f, p.word())
4802 dump_AmgVector (p.globalPosition(), f)
4803 for d
in p.getdeposits():
4804 dump_HepMcParticleLink (d.first, f)
4805 dump_MuonMcData (d.second, f)
◆ dump_MuonSimDataCollection()
| def python.Dumpers.dump_MuonSimDataCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4810 of file Dumpers.py.
4812 fprint (f, elt.first.getString())
4813 dump_MuonSimData (elt.second, f)
◆ dump_MuonSpShower()
| def python.Dumpers.dump_MuonSpShower |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 3455 of file Dumpers.py.
3456 fprint (f,
"%f %f %d %d %d %d %d %d %d" %
3459 m.numberOfTriggerHits(),
3460 m.numberOfInnerHits(),
3461 m.numberOfMiddleHits(),
3462 m.numberOfOuterHits(),
3463 m.numberOfInnerSegments(),
3464 m.numberOfMiddleSegments(),
3465 m.numberOfOuterSegments()))
◆ dump_MvfFitInfo()
| def python.Dumpers.dump_MvfFitInfo |
( |
|
v, |
|
|
|
f |
|
) |
| |
◆ dump_MVFVxCandidate()
| def python.Dumpers.dump_MVFVxCandidate |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 2670 of file Dumpers.py.
2671 dump_VxCandidate1 (v, f)
2672 fprint (f,
'\n ', v.isInitialized(),
'fi')
2673 dump_MvfFitInfo (v.vertexFitInfo(), f)
◆ dump_MVFVxTrackAtVertex()
| def python.Dumpers.dump_MVFVxTrackAtVertex |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 2639 of file Dumpers.py.
2640 dump_VxTrackAtVertex (t, f)
2641 fprint (f,
'\n ',
tonone(t.linkToVertices()))
◆ dump_NSW_PadTriggerData()
| def python.Dumpers.dump_NSW_PadTriggerData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5447 of file Dumpers.py.
5448 fprint (f, p.getSourceid(), p.getFlags(), p.getEc(), p.getFragid(),
5449 p.getSecid(), p.getSpare(), p.getOrbit(), p.getBcid(), p.getL1id(),
5450 p.getOrbitid(), p.getOrbit1(), p.getStatus(),
5451 p.getNumberOfHits(), p.getNumberOfPfebs(), p.getNumberOfTriggers(),
5452 p.getNumberOfBcids(),
5453 list(p.getHitRelBcids()),
5454 list(p.getHitPfebs()),
5455 list(p.getHitTdsChannels()),
5456 list(p.getHitVmmChannels()),
5457 list(p.getHitVmms()),
5458 list(p.getHitPadChannels()),
5459 list(p.getPfebAddrs()),
5460 list(p.getPfebNChannels()),
5461 list(p.getPfebDisconnecteds()),
5462 list(p.getTriggerBandIds()),
5463 list(p.getTriggerPhiIds()),
5464 list(p.getTriggerRelBcids()),
5465 list(p.getBcidRels()),
5466 list(p.getBcidStatuses()),
5467 list(p.getBcidMultZeros()),
5468 list(p.getBcidMultiplicities()))
◆ dump_NSW_PadTriggerDataContainer()
| def python.Dumpers.dump_NSW_PadTriggerDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5472 of file Dumpers.py.
5476 dump_NSW_PadTriggerData (beg.cptr(), f)
◆ dump_parameters()
| def python.Dumpers.dump_parameters |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1578 of file Dumpers.py.
1582 if typename(p.__class__).startswith (
'DataModel_detail::ElementProxy<'):
1586 elif (
typename(p.__class__).startswith (
'Trk::ParametersT<')
or
1587 typename(p.__class__).startswith (
'Trk::ParametersBase<')):
1588 dump_ParametersBase (p, f)
1589 elif typename(p.__class__).startswith (
'Trk::CurvilinearParametersT<'):
1590 dump_CurvilinearParameters (p, f)
◆ dump_ParametersBase()
| def python.Dumpers.dump_ParametersBase |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1553 of file Dumpers.py.
1554 dump_AmgVector (info.parameters(), f)
1555 dump_Threevec (info.momentum(), f)
1556 dump_Threevec (info.position(), f)
1557 dump_Twovec (info.localPosition(), f)
1558 fprint (f,
"%f" % (info.charge(),))
1559 if info.covariance():
1560 fprint (f,
'\n cov')
1561 dump_AmgMatrix (info.covariance(), f)
1563 dump_associatedSurface (info, f)
◆ dump_ParticleBase()
| def python.Dumpers.dump_ParticleBase |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 345 of file Dumpers.py.
346 dump_Fourvec (e, f, 0)
347 orig = e.originLink()
349 charge =
"%f" % e.charge()
352 fprint (f,
" %1d %1d %4d %s" %
353 (e.dataType(), e.hasPdgId(),
asint32(e.pdgId()), charge))
355 fprint (f,
"%1d"%orig.index())
356 dump_Threevec (e.origin().position(), f)
358 fprint (f,
"(no orig)")
◆ dump_ParticleImpl()
| def python.Dumpers.dump_ParticleImpl |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 362 of file Dumpers.py.
363 dump_Fourvec (p, f, 0)
369 fprint (f,
' %d %s %5d ' %
370 (p.dataType(), c,
asint32(p.pdgId())))
372 dump_Threevec (p.origin().position(), f)
374 fprint (f,
"(no orig)")
◆ dump_ParticleJet()
| def python.Dumpers.dump_ParticleJet |
( |
|
j, |
|
|
|
f |
|
) |
| |
Definition at line 1306 of file Dumpers.py.
1307 dump_ParticleBase (j, f)
1308 fprint (f,
'\n %s %f %f' %
1312 fprint (f, [x
for x
in j.combinedLikelihood()])
1313 ti = j.jetTagInfoVector()
1315 fprint (f,
'\n %s: ' % info.infoType())
1316 if isinstance (info, PyAthena.Analysis.TruthInfo):
1317 dump_TruthInfo (info, f)
1318 elif isinstance (info, PyAthena.Analysis.SoftLeptonTruthInfo):
1319 dump_SoftLeptonTruthInfo (info, f)
1320 elif isinstance (info, PyAthena.Analysis.SecVtxInfo):
1321 dump_SecVtxInfo (info, f)
1322 elif isinstance (info, PyAthena.Analysis.IPInfoPlus):
1323 dump_IPInfoPlus (info, f)
1324 elif isinstance (info, PyAthena.Analysis.IPInfoBase):
1325 dump_IPInfoBase (info, f)
1326 elif isinstance (info, PyAthena.Analysis.SVInfoBase):
1327 dump_SVInfoBase (info, f)
1328 elif isinstance (info, PyAthena.Analysis.JetProbInfoBase):
1329 dump_JetProbInfoBase (info, f)
1330 elif isinstance (info, PyAthena.Analysis.SoftElectronInfo):
1331 dump_SoftElectronInfo (info, f)
1332 elif isinstance (info, PyAthena.Analysis.JetFitterTagInfo):
1333 dump_JetFitterTagInfo (info, f)
1334 elif isinstance (info, PyAthena.Analysis.BaseTagInfo):
1335 dump_BaseTagInfo (info, f)
1339 for c
in j.constituentKeys():
1340 fprint (f,
'\n %s: ' % c)
1341 info = j.constituent (c)
1342 if isinstance (info, PyAthena.Analysis.JetConstituent):
1343 dump_JetConstituent (info, f)
1344 elif isinstance (info, PyAthena.Analysis.TrackConstituents):
1345 dump_TrackConstituents (info, f)
1346 elif isinstance (info, PyAthena.Analysis.ElectronConstituent):
1347 dump_ElectronConstituent (info, f)
1348 elif isinstance (info, PyAthena.Analysis.MuonConstituent):
1349 dump_MuonConstituent (info, f)
◆ dump_PerigeeSurface()
| def python.Dumpers.dump_PerigeeSurface |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1485 of file Dumpers.py.
1486 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 3483 of file Dumpers.py.
3484 dump_JetAssociationBase (a, f)
3487 fprint (f, a.getPhotonWeight (gam))
3488 dump_Fourvec (gam, f)
◆ dump_PileUpEventInfo()
| def python.Dumpers.dump_PileUpEventInfo |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 2732 of file Dumpers.py.
2733 dump_EventInfo (e, f)
2734 for (i,s)
in enumerate (toiter (e.beginSubEvt(), e.endSubEvt())):
2735 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 4622 of file Dumpers.py.
4623 dump_SiCluster (p, f)
4624 fprint (f, p.omegax(), p.omegay(), list (p.totList()))
4625 fprint (f, p.totalToT(),
list(p.chargeList()), p.totalCharge())
4626 fprint (f, p.isFake(), p.isAmbiguous(), p.LVL1A(), p.splitInfoRaw(), p.tooBigToBeSplit())
◆ dump_PixelClusterContainer()
| def python.Dumpers.dump_PixelClusterContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4738 of file Dumpers.py.
4739 dump_IDC (dump_PixelCluster, p, f)
◆ dump_PixelClusterOnTrack()
| def python.Dumpers.dump_PixelClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1655 of file Dumpers.py.
1656 dump_SiClusterOnTrack (p, f)
1657 dump_EL (p.prepRawDataLink(), f)
1658 fprint (f, p.hasClusterAmbiguity(), p.isFake(), p.energyLoss())
1659 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_PixelGangedClusterAmbiguities()
| def python.Dumpers.dump_PixelGangedClusterAmbiguities |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4819 of file Dumpers.py.
4821 dump_SiCluster (elt.first, f)
4822 dump_SiCluster (elt.second, f)
◆ dump_PixelRawDataContainer()
| def python.Dumpers.dump_PixelRawDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4756 of file Dumpers.py.
4757 dump_IDC (dump_PixelRDORawData, p, f)
◆ dump_PixelRDORawData()
| def python.Dumpers.dump_PixelRDORawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4648 of file Dumpers.py.
4649 dump_InDetRawData (p, f)
4650 fprint (f, p.getToT(), p.getBCID(), p.getLVL1A(), p.getLVL1ID())
◆ dump_PlaneSurface()
| def python.Dumpers.dump_PlaneSurface |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1490 of file Dumpers.py.
1491 dump_Surface (info, f)
◆ dump_PRD_MultiTruthCollection()
| def python.Dumpers.dump_PRD_MultiTruthCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2080 of file Dumpers.py.
2081 for x
in ROOT.TrkTruthDataHelpers.getData (p):
2082 fprint (f,
'\n ', x.first.getString())
2083 dump_HepMcParticleLink (x.second, f)
◆ dump_PrepRawData()
| def python.Dumpers.dump_PrepRawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4523 of file Dumpers.py.
4524 fprint (f, p.identify().getString())
4525 dump_IdentContIndex (p.getHashAndIndex(), f)
4526 dump_AmgVector (p.localPosition(), f)
4527 dump_AmgMatrix (p.localCovariance(), f)
4529 for i
in p.rdoList():
4530 fprint (f, i.getString())
◆ dump_PseudoMeasurementOnTrack()
| def python.Dumpers.dump_PseudoMeasurementOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2154 of file Dumpers.py.
2155 dump_MeasurementBase (p, f)
2156 dump_AmgVector (p.globalPosition(), f)
2157 dump_associatedSurface (p, f)
◆ dump_RawInfoSummaryForTag()
| def python.Dumpers.dump_RawInfoSummaryForTag |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4408 of file Dumpers.py.
4410 if a.startswith (
'get'):
4411 fprintln (f, a[3:]+
':', getattr(p, a)())
◆ dump_RecoTimingObj()
| def python.Dumpers.dump_RecoTimingObj |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 4507 of file Dumpers.py.
4508 fprintln (f, list (c))
◆ dump_RecVertex()
| def python.Dumpers.dump_RecVertex |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 2574 of file Dumpers.py.
2576 dump_FitQuality (v.fitQuality(), f)
2577 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 1642 of file Dumpers.py.
1643 dump_MeasurementBase (p, f)
1644 fprint (f, p.identify().getString())
◆ dump_ROIBHeader()
| def python.Dumpers.dump_ROIBHeader |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5068 of file Dumpers.py.
5069 fprint (f, formatItemUsingLong (
list(p.header())))
◆ dump_RoIBResult()
| def python.Dumpers.dump_RoIBResult |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5146 of file Dumpers.py.
5147 fprint (f,
'MuCTPI:')
5148 dump_MuCTPIResult (p.muCTPIResult(), f)
5149 fprint (f,
'\nCTP:')
5150 dump_CTPResult (p.cTPResult(), f)
5151 for r
in p.jetEnergyResult():
5152 fprint (f,
'\nJetEnergy:')
5154 for r
in p.eMTauResult():
5155 fprint (f,
'\nEMTau:')
5157 for r
in p.l1TopoResult():
5158 fprint (f,
'\nL1Topo:')
◆ dump_ROIBTrailer()
| def python.Dumpers.dump_ROIBTrailer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5073 of file Dumpers.py.
5074 fprint (f, formatItemUsingLong (
list(p.trailer())))
◆ dump_RoiDescriptor()
| def python.Dumpers.dump_RoiDescriptor |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 3855 of file Dumpers.py.
3857 d.version(), d.isFullscan(),
3858 d.eta(), d.etaPlus(), d.etaMinus(),
3859 d.phi(), d.phiPlus(), d.phiMinus(),
3860 d.zed(), d.zedPlus(), d.zedMinus(),
3861 d.composite(), d.manageConstituents(), d.size(),
3862 formatItemUsingLong ([d.at(i).
roiId()
for i
in range(d.size())]))
◆ dump_RpcClusterOnTrack()
| def python.Dumpers.dump_RpcClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1719 of file Dumpers.py.
1720 dump_MuonClusterOnTrack (p, f)
1721 dump_EL (p.prepRawDataLink(), f)
1722 fprint (f, p.time())
1723 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_RpcCoinData()
| def python.Dumpers.dump_RpcCoinData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4601 of file Dumpers.py.
4602 dump_RpcPrepData (p, f)
4603 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 4708 of file Dumpers.py.
4709 dump_IDC (dump_RpcCoinData, p, f)
◆ dump_RpcCoinMatrix()
| def python.Dumpers.dump_RpcCoinMatrix |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5260 of file Dumpers.py.
5261 fprint (f, p.identify().getString(), p.onlineId(), p.crc(), p.fel1Id(), p.febcId())
5264 dump_RpcFiredChannel (chan, f)
◆ dump_RpcFiredChannel()
| def python.Dumpers.dump_RpcFiredChannel |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5255 of file Dumpers.py.
5256 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 5269 of file Dumpers.py.
5270 dump_IDC (dump_RpcCoinMatrix, p, f,
5271 extra_idc_dumper =
lambda p, f: \
5272 fprint (f, p.identify().getString(), p.onlineId(), p.lvl1Id(), p.bcId(),
5273 p.sector(), p.status(), p.errorCode()))
◆ dump_RpcPrepData()
| def python.Dumpers.dump_RpcPrepData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4595 of file Dumpers.py.
4596 fprint (f, p.time(), p.ambiguityFlag())
4597 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_RpcPrepDataContainer()
| def python.Dumpers.dump_RpcPrepDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4714 of file Dumpers.py.
4715 dump_IDC (dump_RpcPrepData, p, f)
◆ dump_RpcSectorLogic()
| def python.Dumpers.dump_RpcSectorLogic |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5283 of file Dumpers.py.
5284 fprint (f, p.sectorId(), p.fel1Id(), p.bcid(), p.errorCode(), p.crc(),
5285 p.hasMoreThan2TriggerCand(),
5286 list (p.counters()),
5287 list (p.triggerRates()))
5290 dump_RpcSLTriggerHit (hit, f)
◆ dump_RPCSimHit()
| def python.Dumpers.dump_RPCSimHit |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5210 of file Dumpers.py.
5211 fprint (f, p.RPCid(), p.globalTime())
5212 dump_Threevec (p.localPosition(), f)
5213 dump_Threevec (p.postLocalPosition(), f)
5214 fprint (f, p.stepLength(), p.energyDeposit(), p.particleEncoding(), p.kineticEnergy())
5215 dump_HepMcParticleLink (p.particleLink(), f)
◆ dump_RpcSLTriggerHit()
| def python.Dumpers.dump_RpcSLTriggerHit |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5277 of file Dumpers.py.
5278 fprint (f,
'hit', p.rowinBcid(), p.padId(), p.ptId(), p.roi(),
5279 p.outerPlane(), p.overlapPhi(), p.overlapEta(),
5280 p.triggerBcid(), p.isInput())
◆ dump_SaggedLineSurface()
| def python.Dumpers.dump_SaggedLineSurface |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1518 of file Dumpers.py.
1519 dump_StraightLineSurface (info, f)
1521 dump_LineSaggingDescriptor (info.distortionDescriptor())
◆ dump_ScatteringAngles()
| def python.Dumpers.dump_ScatteringAngles |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2202 of file Dumpers.py.
2206 fprint (f,
daz(p.deltaPhi()),
daz(p.deltaTheta()))
2207 fprint (f, p.sigmaDeltaPhi(), p.sigmaDeltaTheta())
◆ dump_SCT_Cluster()
| def python.Dumpers.dump_SCT_Cluster |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4630 of file Dumpers.py.
4631 dump_SiCluster (p, f)
4632 fprint (f, p.hitsInThirdTimeBin())
◆ dump_SCT_ClusterContainer()
| def python.Dumpers.dump_SCT_ClusterContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4744 of file Dumpers.py.
4745 dump_IDC (dump_SCT_Cluster, p, f)
◆ dump_SCT_ClusterOnTrack()
| def python.Dumpers.dump_SCT_ClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1663 of file Dumpers.py.
1664 dump_SiClusterOnTrack (p, f)
1665 dump_EL (p.prepRawDataLink(), f)
1666 fprint (f, p.positionAlongStrip())
1667 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_SCT_RawDataContainer()
| def python.Dumpers.dump_SCT_RawDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4768 of file Dumpers.py.
4769 dump_IDC (dump_SCT_RDORawData, p, f)
◆ dump_SCT_RDORawData()
| def python.Dumpers.dump_SCT_RDORawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4660 of file Dumpers.py.
4661 dump_InDetRawData (p, f)
4662 fprint (f, p.getGroupSize())
◆ dump_SecVtxInfo()
| def python.Dumpers.dump_SecVtxInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1076 of file Dumpers.py.
1077 dump_BaseTagInfo (info, f)
1078 fprint (f,
'\n %d %d %d %d %f %f %f %f %f' %
1080 info.numSelTracksForFit(),
1082 info.NumberOfG2TrackVertices(),
1084 info.rphidistance(),
1087 info.energyFraction()))
1088 return dump_Threevec (info.secVertexPos().position(), f)
◆ dump_Segment()
| def python.Dumpers.dump_Segment |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2291 of file Dumpers.py.
2292 dump_MeasurementBase (p, f)
2293 fprint (f, p.author())
2294 dump_FitQuality (p.fitQuality(), f)
2295 for x
in p.containedMeasurements():
2296 dump_measurement (x, f)
◆ dump_SETrackInfo()
| def python.Dumpers.dump_SETrackInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1191 of file Dumpers.py.
1192 dump_Fourvec (info.electron(), f)
1193 fprint (f,
'%f %f' % (info.d0Value(), info.pTrel()),
1194 [x
for x
in info.tagLikelihood()])
◆ dump_SiCluster()
| def python.Dumpers.dump_SiCluster |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4613 of file Dumpers.py.
4614 dump_PrepRawData (p, f)
4615 fprint (f, p.gangedPixel())
4616 dump_AmgVector (p.globalPosition(), f)
4617 dump_SiWidth (p.width(), f)
4618 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_SiClusterOnTrack()
| def python.Dumpers.dump_SiClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1648 of file Dumpers.py.
1649 dump_RIO_OnTrack (p, f)
1650 fprint (f, p.idDE().
value(), p.isBroadCluster())
1651 dump_AmgVector (p.globalPosition(), f)
◆ dump_SiHit()
| def python.Dumpers.dump_SiHit |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4254 of file Dumpers.py.
4255 fprint (f, t.identify())
4256 dump_Threevec (t.localStartPosition(), f)
4257 dump_Threevec (t.localEndPosition(), f)
4258 fprint (f, t.energyLoss(), t.meanTime(), t.truthBarcode())
4259 dump_HepMcParticleLink (t.particleLink(), f)
◆ dump_SiWidth()
| def python.Dumpers.dump_SiWidth |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4607 of file Dumpers.py.
4608 dump_AmgVector (p.colRow(), f)
4609 dump_AmgVector (p.widthPhiRZ(), f)
◆ dump_SkimDecision()
| def python.Dumpers.dump_SkimDecision |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4402 of file Dumpers.py.
4403 fprint (f, p.getName(), p.isAccepted())
◆ dump_SLTrueInfo()
| def python.Dumpers.dump_SLTrueInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1055 of file Dumpers.py.
1056 fprint (f,
'%d %d %d %d %d %d ' %
1063 dump_H3V (info.momentum(), f)
1065 dump_H3V (info.prodvtx(), f)
◆ dump_SMTrackInfo()
| def python.Dumpers.dump_SMTrackInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1245 of file Dumpers.py.
1246 dump_ParticleImpl (info.muon(), f)
1247 fprint (f, info.d0Value(), info.pTrel(),
list(info.tagLikelihood()))
◆ dump_SoftElectronInfo()
| def python.Dumpers.dump_SoftElectronInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1198 of file Dumpers.py.
1199 dump_BaseTagInfo (info, f)
1200 fprint (f,
' '.
join([
'%f'%x
for x
in info.vectorTrackProb()]),
1201 info.nTrackProb(), info.numTrackInfo())
1202 for i
in range(info.numTrackInfo()):
1204 dump_SETrackInfo (info.getTrackInfo(i), f)
◆ dump_SoftLeptonTruthInfo()
| def python.Dumpers.dump_SoftLeptonTruthInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1068 of file Dumpers.py.
1069 dump_BaseTagInfo (info, f)
1070 for i
in range (info.numSLTrueInfo()):
1072 dump_SLTrueInfo (info.getSLTrueInfo(i), f)
◆ dump_SoftMuonInfo()
| def python.Dumpers.dump_SoftMuonInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1251 of file Dumpers.py.
1252 dump_BaseTagInfo (info, f)
1253 for i
in range (info.numTrackInfo()):
1255 dump_SMTrackInfo (info.getTrackInfo(i), f)
◆ dump_STGC_RawData()
| def python.Dumpers.dump_STGC_RawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5424 of file Dumpers.py.
5425 fprint (f, p.identify().getString(), p.bcTag(), p.time(), p.tdo(), p.charge(),
5426 p.isDead(), p.timeAndChargeInCounts())
◆ dump_STGC_RawDataContainer()
| def python.Dumpers.dump_STGC_RawDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5430 of file Dumpers.py.
5431 dump_IDC (dump_STGC_RawData, p, f)
◆ dump_sTgcClusterOnTrack()
| def python.Dumpers.dump_sTgcClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2124 of file Dumpers.py.
2125 dump_MuonClusterOnTrack (p, f)
2126 dump_EL (p.prepRawDataLink(), f)
2127 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_StraightLineSurface()
| def python.Dumpers.dump_StraightLineSurface |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1495 of file Dumpers.py.
1496 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 1456 of file Dumpers.py.
1457 fprint (f,
typename(info.__class__) +
':')
1458 dump_Threevec (info.center(), f)
1459 dump_Threevec (PyAthena.Trk.Surface.normal (info), f)
1460 if (isinstance (info, PyAthena.Trk.DiscSurface)
and
1461 typename(info.bounds().__class__).find (
'NoBounds') >= 0):
1462 bd_class = info.bounds().__class__
1463 fprint (f,
'(no bounds)')
1464 elif (isinstance (info, PyAthena.Trk.CylinderSurface)
and
1465 (
not info.hasBounds()
or not info.bounds())):
1466 fprint (f,
'(no bounds)')
1467 bd_class = PyAthena.Trk.CylinderBounds
1469 dump_Threevec (info.globalReferencePoint(), f)
1470 bd_class = info.bounds().__class__
1471 if isinstance (info, PyAthena.Trk.CylinderSurface):
1472 dump_AmgVector (info.rotSymmetryAxis(), f)
1474 dump_AmgMatrix (info.transform().
matrix(), f, thresh=1e-8)
1476 layer = tonone (info.associatedLayer())
1478 layer = typename (info.associatedLayer().__class__)
1479 fprint (f,
'\n ly', layer)
1480 fprint (f,
'\n bd',
typename(bd_class))
1482 info.associatedDetectorElementIdentifier().getString())
◆ dump_surface()
| def python.Dumpers.dump_surface |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1525 of file Dumpers.py.
1528 elif isinstance (p, PyAthena.Trk.PerigeeSurface):
1529 dump_PerigeeSurface (p, f)
1530 elif isinstance (p, PyAthena.Trk.PlaneSurface):
1531 dump_PlaneSurface (p, f)
1532 elif isinstance (p, PyAthena.Trk.StraightLineSurface):
1533 dump_StraightLineSurface (p, f)
1534 elif isinstance (p, PyAthena.Trk.CylinderSurface):
1535 dump_CylinderSurface (p, f)
1536 elif isinstance (p, PyAthena.Trk.DiscSurface):
1537 dump_DiscSurface (p, f)
1538 elif isinstance (p, PyAthena.Trk.SaggedLineSurface):
1539 dump_SaggedLineSurface (p, f)
◆ dump_SVInfoBase()
| def python.Dumpers.dump_SVInfoBase |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1121 of file Dumpers.py.
1122 dump_BaseTagInfo (info, f)
◆ dump_SVInfoPlus()
| def python.Dumpers.dump_SVInfoPlus |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1135 of file Dumpers.py.
1136 dump_BaseTagInfo (info, f)
1137 fprint (f, info.getNGTrackInJet(),
1138 info.getNGTrackInSvx(),
1141 info.getEnergyFraction(),
1143 info.numTrackInfo())
1144 fprint (f,
'\n vert: ')
1145 dump_RecVertex (info.getRecSvx(), f)
1146 fprint (f,
'\n tracks: ')
1149 ti = [info.getTrackInfo(i)
for i
in range(info.numTrackInfo())]
1150 ti.sort (key=
lambda a: a.track().
pt(), reverse=
True)
1151 i = info.numTrackInfo()-1
1153 fprint (f,
'\n %d: ' % i)
1154 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 718 of file Dumpers.py.
719 dump_TauDetail (t, f)
720 fprint (f,
' %f %1d %f %f %1d %1d %f %f %f %f' %
725 t.nAssocTracksCore(),
726 t.nAssocTracksIsol(),
732 fprint (f,
' %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f' %
733 (t.isolationFraction(),
740 t.etChrgHADoverPttot(),
747 t.etResChrgEMTrk(0)))
749 dump_HLV (t.sumEM(), f)
751 dump_Threevec (t.secVertex().position(), f)
752 if t.cellEM012Cluster():
753 dump_Fourvec (t.cellEM012Cluster(), f)
754 for i
in range(t.numPi0()):
755 fprint (f,
'\n pi: ')
756 dump_Fourvec (t.pi0 (i), f)
◆ dump_Tau1P3PExtraDetails()
| def python.Dumpers.dump_Tau1P3PExtraDetails |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 782 of file Dumpers.py.
783 dump_TauDetail (t, f)
784 fprint (f, t.sumPTTracks())
789 for tr
in range(t.ntrack()):
790 for s
in range(t.nsamp()):
791 fprint (f,
'\n ', tr, s,
792 t.etaTrackCaloSamp(tr,s), t.phiTrackCaloSamp(tr,s))
◆ dump_TauCommonDetails()
| def python.Dumpers.dump_TauCommonDetails |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 852 of file Dumpers.py.
853 dump_TauDetail (t, f)
854 fprint (f, t.ipZ0SinThetaSigLeadTrk(), t.etOverPtLeadTrk(),
855 t.leadTrkPt(), t.ipSigLeadTrk(), t.ipSigLeadLooseTrk(),
856 t.etOverPtLeadLooseTrk(), t.leadLooseTrkPt(), t.chrgLooseTrk(),
857 t.massTrkSys(), t.trkWidth2())
859 fprint (f, t.trFlightPathSig(), t.etEflow(), t.seedCalo_EMRadius(),
860 t.seedCalo_hadRadius(), t.seedCalo_etEMAtEMScale(),
861 t.seedCalo_etHadAtEMScale(), t.seedCalo_isolFrac(),
862 t.seedCalo_centFrac(), t.seedCalo_stripWidth2(), t.seedCalo_nStrip())
864 fprint (f, t.seedCalo_etEMCalib(), t.seedCalo_etHadCalib(),
865 t.seedCalo_eta(), t.seedCalo_phi(), t.seedCalo_nIsolLooseTrk(),
866 t.seedTrk_EMRadius(), t.seedTrk_isolFrac(),
867 t.seedTrk_etChrgHadOverSumTrkPt(), t.seedTrk_isolFracWide(),
868 t.seedTrk_etHadAtEMScale())
870 fprint (f, t.seedTrk_etEMAtEMScale(), t.seedTrk_etEMCL(),
871 t.seedTrk_etChrgEM(), t.seedTrk_etNeuEM(),
872 t.seedTrk_etResNeuEM(), t.seedTrk_hadLeakEt(),
873 t.seedTrk_sumEMCellEtOverLeadTrkPt(), t.seedTrk_secMaxStripEt(),
874 t.seedTrk_stripWidth2(), t.seedTrk_nStrip())
876 fprint (f, t.seedTrk_etChrgHad(), t.seedTrk_nOtherCoreTrk(),
877 t.seedTrk_nIsolTrk(), t.seedTrk_etIsolEM(), t.seedTrk_etIsolHad())
878 fprint (f,
'\n %d loose tracks' % t.nLooseTrk())
879 looseTrks = t.looseTrk()
880 for i
in range(looseTrks.size()):
882 fprint (f,
'\n ', el.index(), el.dataID(),
883 t.seedTrk_etChrgEM01Trk(i), t.seedTrk_etResChrgEMTrk(i))
884 fprint (f,
'\n %d pi0s' % t.nPi0())
886 for i
in range(vec.size()):
889 fprint (f,
'\n ', el.dataID(), el.e())
890 fprint (f,
'\n pi0 sum:')
891 dump_HLV (t.sumPi0Vec(), f)
892 cl = t.cellEM012ClusterLink()
893 fprint (f,
'\n cluster:')
895 fprint (f, cl.index(), cl.dataID())
897 fprintln (f,
'(invalid)')
898 fprint (f,
'\n secvertex:')
900 dump_RecVertex (t.secVtx(), f)
◆ dump_TauCommonExtraDetails()
| def python.Dumpers.dump_TauCommonExtraDetails |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 931 of file Dumpers.py.
932 dump_TauDetail (t, f)
933 fprint (f, t.sumPtLooseTrk(), t.sumPtTrk(), t.seedCalo_nEMCell(),
934 t.seedCalo_stripEt(), t.seedCalo_EMCentFrac(),
935 t.seedCalo_sumCellEnergy(), t.seedCalo_sumEMCellEnergy())
937 dump_vvelccell (t.closestEtaTrkVertCell(), f)
939 dump_vvelccell (t.closestPhiTrkVertCell(), f)
941 dump_vvelccell (t.closestEtaTrkCell(), f)
943 dump_vvelccell (t.closestPhiTrkCell(), f)
945 dump_vvdouble (t.etaTrkCaloSamp(), f)
947 dump_vvdouble (t.phiTrkCaloSamp(), f)
949 dump_vvdouble (t.etaLooseTrkCaloSamp(), f)
951 dump_vvdouble (t.phiLooseTrkCaloSamp(), f)
◆ dump_TauDetail()
| def python.Dumpers.dump_TauDetail |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 711 of file Dumpers.py.
713 if nm.startswith(
'Analysis::'):
715 fprint (f,
'%s:' % nm)
◆ dump_TauDetailsContainer()
| def python.Dumpers.dump_TauDetailsContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2021 of file Dumpers.py.
2022 fprint (f,
'(Dumped as a part of Analysis::TauJetContainer)')
◆ dump_TauJet()
| def python.Dumpers.dump_TauJet |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 955 of file Dumpers.py.
956 dump_ParticleImpl (t, f)
957 fprint (f,
' %1d' % (t.author(),))
960 fprint (f,
'\n cl: %2d:' % t.clusterLink().
index())
961 dump_Fourvec (t.cluster(), f)
962 if t.cellClusterLink().
isValid():
965 fprint (f,
'\n ce: ')
966 dump_Fourvec (t.cellCluster(), f)
968 fprint (f,
'\n je: %2d:' % t.jetLink().
index())
970 if j.e() == 0
and j.phi() == 0
and j.eta() == 0:
971 with signalstate (j, PyAthena.P4SignalState.JETEMSCALE):
975 for i
in range (t.numTrack()):
976 el = t.trackLinkVector()[i]
978 fprint (f,
'\n t%d: %2d:' % (i,el.index()))
979 dump_Fourvec (t.track(i), f)
981 TJP = PyAthena.TauJetParameters
983 fprint (f,
'\n pid: %f %f %f %d %d %d' %
984 (pid.discriminant(0),
987 pid.flag (TJP.ElectronFlag),
988 pid.flag (TJP.EgammaFlag),
989 pid.flag (TJP.MuonFlag)))
990 if hasattr (TJP,
'TauCutLoose'):
991 flags = [TJP.TauCutLoose,
1000 if hasattr (TJP,
'TauRecOld'):
1001 flags.append (TJP.TauRecOld)
1002 if hasattr (TJP,
'Tau1P3POld'):
1003 flags.append (TJP.Tau1P3POld)
1004 fprint (f,
'\n ', [pid.isTau(ff)
for ff
in flags])
1006 fprint (f,
'\n ', pid.isTau())
1007 for i
in range (t.nDetails()):
1009 if t.detailElementLink(i).
isValid():
1011 if (hasattr (PyAthena.Analysis,
'Tau1P3PDetails')
and
1012 isinstance (d, PyAthena.Analysis.Tau1P3PDetails)):
1013 dump_Tau1P3PDetails (d, f)
1014 elif (hasattr (PyAthena.Analysis,
'TauRecDetails')
and
1015 isinstance (d, PyAthena.Analysis.TauRecDetails)):
1016 dump_TauRecDetails (d, f)
1017 elif (hasattr (PyAthena.Analysis,
'Tau1P3PExtraDetails')
and
1018 isinstance (d, PyAthena.Analysis.Tau1P3PExtraDetails)):
1019 dump_Tau1P3PExtraDetails (d, f)
1020 elif (hasattr (PyAthena.Analysis,
'TauRecExtraDetails')
and
1021 isinstance (d, PyAthena.Analysis.TauRecExtraDetails)):
1022 dump_TauRecExtraDetails (d, f)
1023 elif (hasattr (PyAthena.Analysis,
'TauPi0Details')
and
1024 isinstance (d, PyAthena.Analysis.TauPi0Details)):
1025 dump_TauPi0Details (d, f)
1026 elif isinstance (d, PyAthena.Analysis.TauCommonDetails):
1027 dump_TauCommonDetails (d, f)
1028 elif isinstance (d, PyAthena.Analysis.TauCommonExtraDetails):
1029 dump_TauCommonExtraDetails (d, f)
1031 fprint (f, t.detailName(i), d,
'(not dumped)')
1032 fprint (f,
'\n p: %f %f %f' %
◆ dump_TauPi0Candidate()
| def python.Dumpers.dump_TauPi0Candidate |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 804 of file Dumpers.py.
805 dump_HLV (t.hlv(), f)
807 for c
in t.pi0ClusterVec():
808 fprint (f, c.clusterLink().
index(),
', ')
◆ dump_TauPi0Cluster()
| def python.Dumpers.dump_TauPi0Cluster |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 813 of file Dumpers.py.
814 fprint (f, t.clusterLink().
index(),
824 t.asymmetryInEM1WRTTrk(),
829 t.firstEtaWRTClusterPosition_EM1(),
830 t.firstEtaWRTClusterPosition_EM2(),
831 t.secondEtaWRTClusterPosition_EM1(),
832 t.secondEtaWRTClusterPosition_EM2(),
◆ dump_TauPi0Details()
| def python.Dumpers.dump_TauPi0Details |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 838 of file Dumpers.py.
839 dump_TauDetail (t, f)
840 dump_HLV (t.visTauhlv(), f)
841 fprint (f,
' candidates')
842 for c
in t.pi0CandidateVector():
844 dump_TauPi0Candidate (c, f)
845 fprint (f,
' clusters')
846 for c
in t.pi0ClusterVector():
848 dump_TauPi0Cluster (c, f)
◆ dump_TauRecDetails()
| def python.Dumpers.dump_TauRecDetails |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 760 of file Dumpers.py.
761 dump_TauDetail (t, f)
763 fprint (f,
'%f %f %f %f %2d %f %f %f' %
765 t.isolationFraction(),
766 t.centralityFraction(),
773 for i
in range(t.numTrack()):
774 fprint (f,
'(%f %f) ' % (t.trackCaloEta(i), t.trackCaloPhi(i)))
776 dump_HLV (t.sumEM(), f)
778 dump_Threevec (t.secVertex().position(), f)
◆ dump_TauRecExtraDetails()
| def python.Dumpers.dump_TauRecExtraDetails |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 796 of file Dumpers.py.
797 dump_TauDetail (t, f)
798 fprint (f, t.numEMCells(), t.stripET(), t.emCentralityFraction(),
799 t.etHadAtEMScale(), t.etEMAtEMScale(), t.energy(), t.emEnergy(),
800 t.sumPTTracks(), t.seedType(),
tonone(t.analysisHelper()))
◆ dump_TgcBitmask()
| def python.Dumpers.dump_TgcBitmask |
( |
|
p, |
|
|
|
f, |
|
|
|
lab, |
|
|
|
fields |
|
) |
| |
Definition at line 5338 of file Dumpers.py.
5342 if getattr (p, ff): mask += val
5344 fprint (f, lab, hex (mask))
◆ dump_TgcClusterOnTrack()
| def python.Dumpers.dump_TgcClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2117 of file Dumpers.py.
2118 dump_MuonClusterOnTrack (p, f)
2119 dump_EL (p.prepRawDataLink(), f)
2120 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_TgcCoinData()
| def python.Dumpers.dump_TgcCoinData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4563 of file Dumpers.py.
4564 fprint (f, p.type(), p.channelIdIn().getString(), p.channelIdOut().getString(), p.identifyHash().
value())
4565 dump_IdentContIndex (p.getHashAndIndex(), f)
4566 fprint (f, p.isAside(), p.phi(), p.isInner(), p.isForward(), p.isStrip(), p.trackletId(), p.trackletIdStrip())
4567 fprint (f, p.widthIn(), p.widthOut())
4568 fprint (f, p.delta(), p.roi(), p.pt(), p.veto(), p.sub(), p.inner(), p.isPositiveDeltaR())
4569 if p.channelIdIn().get_compact() != 0:
4570 dump_AmgVector (p.posIn(), f, thresh=1e-8)
4571 dump_AmgVector (p.globalposIn(), f, thresh=1e-8)
4572 if p.channelIdOut().get_compact() != 0:
4573 dump_AmgVector (p.posOut(), f, thresh=1e-8)
4574 dump_AmgVector (p.globalposOut(), f, thresh=1e-8)
4576 dump_AmgMatrix (p.errMat(), f)
4577 if p.detectorElementIn():
4578 fprint (f, p.detectorElementIn().identifyHash().
value())
4580 fprint (f,
'(null detel)')
4581 if p.detectorElementOut():
4582 fprint (f, p.detectorElementOut().identifyHash().
value())
4584 fprint (f,
'(null detel)')
◆ dump_TgcCoinDataContainer()
| def python.Dumpers.dump_TgcCoinDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4726 of file Dumpers.py.
4727 dump_IDC (dump_TgcCoinData, p, f)
◆ dump_TgcPrepData()
| def python.Dumpers.dump_TgcPrepData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4556 of file Dumpers.py.
4557 dump_MuonCluster (p, f)
4558 fprint (f, p.getBcBitMap())
4559 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_TgcPrepDataContainer()
| def python.Dumpers.dump_TgcPrepDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4720 of file Dumpers.py.
4721 dump_IDC (dump_TgcPrepData, p, f)
◆ dump_TgcRawData()
| def python.Dumpers.dump_TgcRawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5310 of file Dumpers.py.
5311 fprint (f, p.bcTag(),
5313 p.subDetectorId(), p.rodId(), p.sswId(),
5314 p.slbId(), p.l1Id(), p.bcId(), p.slbType(),
5316 p.bitpos(), p.tracklet(), p.isAdjacent(),
5318 p.type(), p.isForward(), p.index(), p.position(),
5319 p.delta(), p.segment(), p.subMatrix(),
5321 p.sector(), p.chip(), p.isHipt(), p.hitId(), p.hsub(),
5322 p.isStrip(), p.inner(),
5324 p.cand3plus(), p.isMuplus(), p.threshold(), p.isOverlap(),
5325 p.isVeto(), p.roi(), p.innerflag(), p.coinflag(),
5327 p.nsweta(), p.nswphi(), p.nswsl(), p.nswcand(), p.nswdtheta(),
5328 p.nswphires(), p.nswlowres(), p.nswid(),
5330 p.rpceta(), p.rpcphi(), p.rpcflag(), p.rpcdeta(), p.rpcdphi(),
5332 p.ei(), p.fi(), p.cid(),
5334 p.tmdbmod(), p.tmdbbcid())
◆ dump_TgcRdo()
| def python.Dumpers.dump_TgcRdo |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5394 of file Dumpers.py.
5395 fprint (f, p.version(), p.identify(),
5396 p.subDetectorId(), p.rodId(), p.triggerType(),
5397 p.bcId(), p.l1Id(), p.orbit())
5398 dump_TgcRdo_Errors (p.errors(), f)
5399 dump_TgcRdo_RodStatus (p.rodStatus(), f)
5400 dump_TgcRdo_LocalStatus (p.localStatus(), f)
◆ dump_TgcRdo_Errors()
| def python.Dumpers.dump_TgcRdo_Errors |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5346 of file Dumpers.py.
5347 dump_TgcBitmask (p, f,
'err',
◆ dump_TgcRdo_LocalStatus()
| def python.Dumpers.dump_TgcRdo_LocalStatus |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5385 of file Dumpers.py.
5386 dump_TgcBitmask (p, f,
'local',
5388 'mergedTrackletBCs',
◆ dump_TgcRdo_RodStatus()
| def python.Dumpers.dump_TgcRdo_RodStatus |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5354 of file Dumpers.py.
5355 dump_TgcBitmask (p, f,
'rod',
◆ dump_TgcRdoContainer()
| def python.Dumpers.dump_TgcRdoContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5404 of file Dumpers.py.
5405 dump_IDC (dump_TgcRawData, p, f,
5406 extra_idc_dumper = dump_TgcRdo)
◆ dump_TGCSimHit()
| def python.Dumpers.dump_TGCSimHit |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5219 of file Dumpers.py.
5220 fprintln (f, p.TGCid(), p.globalTime())
5221 dump_Threevec (p.localPosition(), f)
5222 dump_Threevec (p.localDireCos(), f)
5223 fprint (f, p.stepLength(), p.energyDeposit(), p.particleEncoding(), p.kineticEnergy())
5224 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 4925 of file Dumpers.py.
4926 fprintln (f, data.get_unit(), data.get_type(), data.get_bsflags())
4931 fprint (f,
'Coll', beg.hashId().
value(), coll.size())
◆ dump_TileDigits()
| def python.Dumpers.dump_TileDigits |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4832 of file Dumpers.py.
4833 dump_TileRawData (p, f)
4834 fprint (f,
list(p.get_digits()))
◆ dump_TileDigitsContainer()
| def python.Dumpers.dump_TileDigitsContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4839 of file Dumpers.py.
4840 fprint (f, p.get_unit(), p.get_type(), p.get_bsflags())
4841 fprint (f, p.hashFunc().
max(), p.hashFunc().
offset(), p.hashFunc().
type())
4845 if hasattr(beg.__class__,
'__preinc__'):
4846 nextfunc = beg.__preinc__
4847 elif hasattr(beg.__class__,
'__next__'):
4848 nextfunc = beg.__next__
4854 beg.hashId().
value(),
4855 list(coll.getFragChipCRCWords()),
4856 list(coll.getFragChipCRCWordsHigh()),
4857 list(coll.getFragChipHeaderWords()),
4858 list(coll.getFragChipHeaderWordsHigh()),
4860 coll.getFragBCID(), coll.getFragSize())
4863 dump_TileDigits (x, f)
◆ dump_TileHit()
| def python.Dumpers.dump_TileHit |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4242 of file Dumpers.py.
4244 fprint (f, t.identify().getString(), [t.energy(i)
for i
in range(sz)],
4245 [t.time(i)
for i
in range(sz)])
◆ dump_TileL2()
| def python.Dumpers.dump_TileL2 |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4939 of file Dumpers.py.
4940 fprint (f, p.identify(), p.phi(0), p.cosphi(), p.sinphi())
4941 fprint (f, [p.sumE(i)
for i
in range(p.NsumE())])
4942 fprint (f, [p.eta(i)
for i
in range(p.NMuons())])
4943 fprint (f, [p.enemu0(i)
for i
in range(p.NMuons())])
4944 fprint (f, [p.enemu1(i)
for i
in range(p.NMuons())])
4945 fprint (f, [p.enemu2(i)
for i
in range(p.NMuons())])
4946 fprint (f, formatItemUsingLong ([p.qual(i)
for i
in range(p.NMuons())]))
4947 fprint (f, formatItemUsingLong ([p.val(i)
for i
in range(p.Ndata())]))
◆ dump_TileMu()
| def python.Dumpers.dump_TileMu |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4163 of file Dumpers.py.
4164 fprint (f, m.eta(), m.phi(), m.quality(),
list(m.enedep()))
◆ dump_TileMuFeature()
| def python.Dumpers.dump_TileMuFeature |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4120 of file Dumpers.py.
4121 fprint (f,
' ', m.eta(), m.phi(), m.quality(),
list(m.enedep()))
◆ dump_TileMuonReceiverObj()
| def python.Dumpers.dump_TileMuonReceiverObj |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4956 of file Dumpers.py.
4957 fprint (f, p.GetID(), list (p.GetDecision()),
4958 list(p.GetThresholds()),
list(p.GetEne()),
list(p.GetTime()))
◆ dump_TileRawChannel()
| def python.Dumpers.dump_TileRawChannel |
( |
|
data, |
|
|
|
f |
|
) |
| |
Definition at line 4870 of file Dumpers.py.
4871 dump_TileRawData (data, f)
4872 fprint (f, [data.amplitude(i)
for i
in range(data.size())])
4873 fprint (f, [data.time(i)
for i
in range(data.sizeTime())])
4874 fprint (f, [data.quality(i)
for i
in range(data.sizeQuality())])
4875 fprint (f, data.pedestal())
◆ dump_TileRawChannelCollection()
| def python.Dumpers.dump_TileRawChannelCollection |
( |
|
data, |
|
|
|
f |
|
) |
| |
Definition at line 4892 of file Dumpers.py.
4893 fprint (f,
'\n ', data.getFragGlobalCRC(),
4894 data.getFragDSPBCID(),
4896 data.getFragMemoryPar(),
4897 data.getFragSstrobe(),
4898 data.getFragDstrobe(),
4899 data.getFragHeaderBit(),
4900 data.getFragHeaderPar(),
4901 data.getFragSampleBit(),
4902 data.getFragSamplePar(),
4903 data.getFragFEChipMask(),
4904 data.getFragRODChipMask())
4905 dump_TileRawDataCollection (data, f)
◆ dump_TileRawChannelContainer()
| def python.Dumpers.dump_TileRawChannelContainer |
( |
|
data, |
|
|
|
f |
|
) |
| |
Definition at line 4910 of file Dumpers.py.
4911 fprintln (f, data.get_unit(), data.get_type(), data.get_bsflags())
4916 fprint (f,
'Coll', beg.hashId().
value(), coll.size())
4917 dump_TileRawChannelCollection (coll, f)
◆ dump_TileRawData()
| def python.Dumpers.dump_TileRawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4827 of file Dumpers.py.
4828 fprint (f, p.identify().getString())
◆ dump_TileRawDataCollection()
| def python.Dumpers.dump_TileRawDataCollection |
( |
|
data, |
|
|
|
f |
|
) |
| |
Definition at line 4880 of file Dumpers.py.
4881 fprint (f,
'\n ', data.identify(),
4884 data.getDetEvType(),
4888 dump_TileRawChannel (x, f)
◆ dump_TileTrackMuFeature()
| def python.Dumpers.dump_TileTrackMuFeature |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4125 of file Dumpers.py.
4127 fprint (f, m.PtTR_Trk(), m.EtaTR_Trk(), m.PhiTR_Trk(), m.Typ_IDTrk())
4128 fprint (f,
'\n ', m.pt(), m.eta(), m.phi(), m.m())
4129 fprint (f,
'\n ', m.TileMuLink().
isValid())
4131 fprintln (f, m.TileMuLink().dataID(), m.TileMuLink().
index())
4132 fprint (f,
'\n ', m.IDScanLink().
isValid())
4134 fprintln (f, m.IDScanLink().dataID(), m.IDScanLink().
index())
◆ dump_TileTTL1()
| def python.Dumpers.dump_TileTTL1 |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4951 of file Dumpers.py.
4952 fprint (f, p.identify().getString(),
list(p.fsamples()))
◆ dump_Track()
| def python.Dumpers.dump_Track |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2262 of file Dumpers.py.
2264 pm = p.trackParameters()
2265 for i
in range(len(pm)):
2267 dump_parameters (pm[i], f)
2269 for x
in p.measurementsOnTrack():
2271 dump_measurement (x, f)
2273 for x
in p.outliersOnTrack():
2275 dump_measurement (x, f)
2277 for x
in p.trackStateOnSurfaces():
2279 dump_TrackStateOnSurface (x, f)
2280 fprint (f,
'\n pp ')
2281 dump_parameters (p.perigeeParameters(), f)
2282 fprint (f,
'\n fq ')
2283 dump_FitQuality (p.fitQuality(), f)
2284 fprint (f,
'\n tm ')
2285 dump_TrackSummary (p.trackSummary(), f)
2286 fprint (f,
'\n ti ')
2287 dump_TrackInfo (p.info(), f)
◆ dump_TrackAssociation()
| def python.Dumpers.dump_TrackAssociation |
( |
|
a, |
|
|
|
f |
|
) |
| |
Definition at line 3501 of file Dumpers.py.
3502 dump_JetAssociationBase (a, f)
3503 fprint (f, a.nTracks())
3505 ROOT.SetOwnership (tr,
True)
3507 fprint (f, a.getTrackWeight (t))
◆ dump_TrackConstituents()
| def python.Dumpers.dump_TrackConstituents |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1279 of file Dumpers.py.
1281 ROOT.SetOwnership (tr,
True)
1283 fprint (f,
'\n tr: ')
1285 fprint (f, info.getTrackWeight(t))
◆ dump_TrackCountingInfo()
| def python.Dumpers.dump_TrackCountingInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1222 of file Dumpers.py.
1223 dump_BaseTagInfo (info, f)
1224 fprint (f,
'%d %f %f %f %f' %
1227 info.d0sig_abs_2nd(),
1229 info.d0sig_abs_3rd()))
◆ dump_TrackInfo()
| def python.Dumpers.dump_TrackInfo |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2255 of file Dumpers.py.
2256 fprint (f, p.trackFitter(), p.particleHypothesis())
2258 fprint (f, p.patternRecognition().
to_string())
◆ dump_TrackParticle()
| def python.Dumpers.dump_TrackParticle |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1596 of file Dumpers.py.
1599 if p.trackParameters().
size() > 0
and p.trackParameters()[-1]:
1600 dp = p.definingParameters()
1602 fprint (f,
"%f" % p.charge())
1605 fprint (f,
"%1d" % p.particleOriginType())
1610 vx = p.reconstructedVertex()
1612 dump_Threevec (vx.recVertex().position(), f)
1614 fprint (f, tonone (vx))
1615 if p.fitQuality() != fitQualityNull:
1617 dump_FitQuality (p.fitQuality(), f)
1618 if p.trackSummary():
1620 dump_TrackSummary (p.trackSummary(), f)
1622 dump_parameters (dp, f)
1624 for x
in p.trackParameters():
1626 dump_parameters (x, f)
◆ dump_TrackParticleAssocs()
| def python.Dumpers.dump_TrackParticleAssocs |
( |
|
a, |
|
|
|
f |
|
) |
| |
Definition at line 3445 of file Dumpers.py.
3446 return dump_Assocs (a, f, PyAthena.Rec.TrackParticleContainer)
◆ dump_TrackParticleTruth()
| def python.Dumpers.dump_TrackParticleTruth |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1390 of file Dumpers.py.
1391 fprint (f,
'%4d %f' % (p.particleLink().
barcode(), p.probability()))
1392 gp = p.particleLink().cptr()
1394 dump_HLV (gp.momentum(), f)
1396 fprint (f,
' (no part)')
◆ dump_TrackParticleTruthCollection()
| def python.Dumpers.dump_TrackParticleTruthCollection |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 1401 of file Dumpers.py.
1402 fprintln (f,
' ', c.trackParticleContainerLink().
isValid())
1403 elclass = PyAthena.ElementLink (PyAthena.Rec.TrackParticleContainer)
1404 for i
in range (c.size()):
1407 cont = PyAthena.Rec.TrackParticleContainer()
1408 el.toIndexedElement (cont, i)
1409 dump_TrackParticleTruth (c[PyAthena.Rec.TrackParticleTruthKey(el)], f)
◆ dump_TrackRecord()
| def python.Dumpers.dump_TrackRecord |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3226 of file Dumpers.py.
3227 dump_H3V (t.GetPosition(), f)
3228 dump_H3V (t.GetMomentum(), f)
3229 fprint (f, t.GetEnergy(),
◆ dump_TrackStateOnSurface()
| def python.Dumpers.dump_TrackStateOnSurface |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2242 of file Dumpers.py.
2243 dump_FitQuality (p.fitQualityOnSurface(), f)
2244 fprint (f,
'\n pm ')
2245 dump_parameters (p.trackParameters(), f)
2246 fprint (f,
'\n ms ')
2247 dump_measurement (p.measurementOnTrack(), f)
2248 fprint (f,
'\n me ')
2249 dump_materialeffects (p.materialEffectsOnTrack(), f)
2250 fprint (f,
'\n ae ')
2251 dump_AlignmentEffectsOnTrack (p.alignmentEffectsOnTrack(), f)
◆ dump_TrackSummary()
| def python.Dumpers.dump_TrackSummary |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1447 of file Dumpers.py.
1449 fprint (f,
'(null)')
1451 fprint (f, [info.get(i)
for i
in range(32)],
1452 [info.isHit(i)
for i
in range(21)])
◆ dump_TrackTruthCollection()
| def python.Dumpers.dump_TrackTruthCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2088 of file Dumpers.py.
2090 fprint (f,
'\n ', x.first.index())
2091 dump_HepMcParticleLink (x.second.particleLink(), f)
2092 fprint (f, x.second.probability())
◆ dump_Trig3Momentum()
| def python.Dumpers.dump_Trig3Momentum |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 3875 of file Dumpers.py.
3876 fprint (f, m.e(), m.eta(), m.phi(), m.inCone(), m.caloSample())
◆ dump_TrigCaloCluster()
| def python.Dumpers.dump_TrigCaloCluster |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 3730 of file Dumpers.py.
3731 fprint (f, c.rawEnergy(), c.rawEt(), c.rawEta(), c.rawPhi(), c.RoIword(),
3732 c.nCells(), c.quality())
3733 fprint (f,
'\n ', [c.rawEnergy(i)
for i
in range(25)])
◆ dump_TrigConfAlg()
| def python.Dumpers.dump_TrigConfAlg |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1876 of file Dumpers.py.
1877 ss = ROOT.ostringstream()
1879 fprint (f, p.index(), ss.str())
◆ dump_TrigConfChain()
| def python.Dumpers.dump_TrigConfChain |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1859 of file Dumpers.py.
1860 fprint (f, p.getName(), p.getChainName(), p.getLowerName(),
1861 p.getId(), p.getCounter(),
1862 p.getLowerId(), p.getLowerCounter(),
1863 p.getLevelId(), p.getPrescale(), p.getPassThrough())
1864 fprint (f,
'\n lower ids',
list(p.getLowerIds()))
1865 fprint (f,
'\n stream ps',
list(p.getStreamPS()))
1866 fprint (f,
'\n stream name',
list(p.getStream()))
1867 fprint (f,
'\n group',
list(p.getGroup()))
1868 fprint (f,
'\n EB hypo',
list(p.getEBHypo()))
1869 fprint (f,
'\n sigs')
1870 for s
in p.getSignature():
1872 dump_TrigConfSig (s, f)
◆ dump_TrigConfKeys()
| def python.Dumpers.dump_TrigConfKeys |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4513 of file Dumpers.py.
4514 fprint (f, p.smk(), p.l1psk(), p.hltpsk())
◆ dump_TrigConfSeq()
| def python.Dumpers.dump_TrigConfSeq |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1882 of file Dumpers.py.
1883 fprint (f, p.getName(), p.getIndex(), p.getId(), p.getTopoTE())
1884 fprint (f,
'\n algs')
1885 for a
in p.getAlg():
1887 dump_TrigConfAlg (a, f)
1888 fprint (f,
'\n input TE',
list(p.getInputTEs()))
◆ dump_TrigConfSig()
| def python.Dumpers.dump_TrigConfSig |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1854 of file Dumpers.py.
1855 fprint (f, p.getCounter(), p.getLogic(), p.getLabel(),
1856 list(p.getOutputTEs()))
◆ dump_TrigDecision()
| def python.Dumpers.dump_TrigDecision |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3089 of file Dumpers.py.
3090 fprint (f, t.masterKey())
3092 dump_Lvl1Result (t.getL1Result(), f)
3094 dump_HLTResult (t.getL2Result(), f)
3096 dump_HLTResult (t.getEFResult(), f)
◆ dump_TrigEFBjet()
| def python.Dumpers.dump_TrigEFBjet |
( |
|
j, |
|
|
|
f |
|
) |
| |
Definition at line 3779 of file Dumpers.py.
3781 fprint (f, j.isValid(), j.roiId())
3782 fprint (f,
'\n ', j.prmVtx(), j.xComb(), j.xIP1D(), j.xIP2D(),
3783 j.xIP3D(), j.xCHI2(), j.xSV(), j.xMVtx(), j.xEVtx(), j.xNVtx())
3784 fprint (f,
'\n ',
tonone(j.TrackCollection()),
3785 tonone(j.PrmVertexCollection()),
3786 tonone(j.SecVertexCollection()))
◆ dump_TrigEFBphys()
| def python.Dumpers.dump_TrigEFBphys |
( |
|
j, |
|
|
|
f |
|
) |
| |
Definition at line 3790 of file Dumpers.py.
3791 fprint (f, j.roiId(), j.particleType(), j.eta(), j.phi(),
3792 j.mass(), j.fitmass(), j.fitchi2(), j.fitndof(),
3793 j.fitx(), j.fity(), j.fitz())
3794 if j.pSecondDecay():
3795 fprint (f,
'\n second:')
3796 dump_TrigEFBphys (j.pSecondDecay(), f)
3797 vec = j.trackVector()
3798 for i
in range(len(vec)):
3800 fprint (f,
'\n tv:')
3802 fprint (f, t.dataID(), t.index())
3804 fprint (f,
'(invalid)')
◆ dump_TrigElectron()
| def python.Dumpers.dump_TrigElectron |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 3750 of file Dumpers.py.
3752 fprint (f, p.isValid(), p.roiId())
3753 fprint (f,
'\n ', p.trackAlgo(), p.trackIndx(), p.charge(),
3755 fprint (f,
'\n ', p.err_Pt(), p.err_eta(), p.err_phi(), p.err_Zvtx())
3756 fprint (f,
'\n ', p.trkClusDeta(), p.trkClusDphi(), p.EtOverPt())
◆ dump_TrigEMCluster()
| def python.Dumpers.dump_TrigEMCluster |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 3737 of file Dumpers.py.
3738 dump_TrigCaloCluster (c, f)
3739 fprint (f,
'\n ', c.energy(), c.et(), c.eta(), c.phi(),
3740 c.e237(), c.e277(), c.fracs1(), c.weta2(),
3741 c.ehad1(), c.Eta1(), c.emaxs1(), c.e2tsts1())
3742 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 3745 of file Dumpers.py.
3746 dump_TrigEMCluster (c, f)
◆ dump_TriggerInfo()
| def python.Dumpers.dump_TriggerInfo |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 2708 of file Dumpers.py.
2709 fprint (f, e.statusElement(), e.extendedLevel1ID(), e.level1TriggerType())
2710 fprint (f,
'\n l2:', formatItemUsingLong ([x
for x
in e.level2TriggerInfo()]))
2711 fprint (f,
'\n ef:', formatItemUsingLong ([x
for x
in e.eventFilterInfo()]))
2712 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 5163 of file Dumpers.py.
5164 fprint (f, p.eta(), p.phi(), p.key(), p.emError(), p.hadError(),
5165 p.emPeak(), p.emADCPeak(), p.hadPeak(), p.hadADCPeak(),
5168 list(p.emBCIDvec()),
list(p.hadBCIDvec()),
5169 list(p.emBCIDext()),
list(p.hadBCIDext()))
◆ dump_TrigHisto()
| def python.Dumpers.dump_TrigHisto |
( |
|
h, |
|
|
|
f |
|
) |
| |
Definition at line 3927 of file Dumpers.py.
3928 fprint (f,
"x:", h.nbins_x(), h.min_x(), h.max_x(),
'[')
3929 for x
in h.contents():
◆ dump_TrigHisto1D()
| def python.Dumpers.dump_TrigHisto1D |
( |
|
h, |
|
|
|
f |
|
) |
| |
Definition at line 3933 of file Dumpers.py.
3934 dump_TrigHisto (h, f)
◆ dump_TrigHisto2D()
| def python.Dumpers.dump_TrigHisto2D |
( |
|
h, |
|
|
|
f |
|
) |
| |
Definition at line 3936 of file Dumpers.py.
3937 fprint (f,
"y:", h.nbins_y(), h.min_y(), h.max_y())
3938 dump_TrigHisto (h, f)
◆ dump_TrigInDetTrack()
| def python.Dumpers.dump_TrigInDetTrack |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3291 of file Dumpers.py.
3292 fprint (f,
"%d %f %d %d %d %d" %
3299 fprint (f,
tonone(t.siSpacePoints),
tonone(t.trtDriftCircles))
3300 fprint (f,
'\n par')
3302 dump_TrigInDetTrackFitPar (t.param, f)
3305 fprint (f,
'\n end')
3307 dump_TrigInDetTrackFitPar (t.endParam, f)
◆ dump_TrigInDetTrackCollection()
| def python.Dumpers.dump_TrigInDetTrackCollection |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3772 of file Dumpers.py.
3773 fprintln (f,
' ROI ', t.RoI_ID())
3774 t2 = [PyTrigInDetTrack(tt)
for tt
in t]
3775 dump_list (t2, f, dump_TrigInDetTrack)
◆ dump_TrigInDetTrackFitPar()
| def python.Dumpers.dump_TrigInDetTrackFitPar |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 3272 of file Dumpers.py.
3273 fprint (f,
"%f %f %f %f %f %f %f %f %f %f %f %d" %
3284 p.surfaceCoordinate,
3287 fprint (f, [x
for x
in p.cov])
◆ dump_TrigInDetTrackTruth()
| def python.Dumpers.dump_TrigInDetTrackTruth |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3254 of file Dumpers.py.
3255 fprint (f, t.nrMatches())
3256 if t.nrMatches() == 0:
return
3257 fprint (f, t.bestMatch().
barcode(),
3261 t.nrCommonHitsBestSi(),
3262 t.nrCommonHitsBestTRT())
3265 t.nrCommonSiHits(i),
3266 t.nrCommonTRTHits(i))
3267 for i
in range(t.nrMatches())]))
3268 fprint (f, formatItemUsingLong ([(p.first, p.second)
for p
in t.getFamilyTree()]))
◆ dump_TrigInDetTrackTruthMap()
| def python.Dumpers.dump_TrigInDetTrackTruthMap |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 3370 of file Dumpers.py.
3373 tm = [(m.truthi(i), PyTrigInDetTrack(m.tracki(i)))
3375 tm.sort (key = cmp_to_key (_tmcmp))
3376 for (i, (truth, track))
in enumerate(tm):
3377 fprint (f,
'\n ', i)
3378 dump_TrigInDetTrackTruth (truth, f)
3380 dump_TrigInDetTrack (track, f)
◆ dump_TrigL2Bjet()
| def python.Dumpers.dump_TrigL2Bjet |
( |
|
j, |
|
|
|
f |
|
) |
| |
Definition at line 3808 of file Dumpers.py.
3810 fprint (f, j.isValid(), j.roiId())
3811 fprint (f,
'\n ', j.prmVtx(), j.xComb(), j.xIP1D(), j.xIP2D(),
3812 j.xIP3D(), j.xCHI2(), j.xSV(), j.xMVtx(), j.xEVtx(), j.xNVtx())
3814 tonone(j.TrackCollection()),
3815 tonone(j.PrmVertexCollection()),
3816 tonone(j.SecVertexCollection()))
◆ dump_TrigL2Bphys()
| def python.Dumpers.dump_TrigL2Bphys |
( |
|
j, |
|
|
|
f |
|
) |
| |
Definition at line 3820 of file Dumpers.py.
3821 fprint (f, j.roiId(), j.particleType(), j.eta(), j.phi(),
3822 j.mass(), j.fitmass(), j.fitchi2(), j.fitndof(),
3823 j.fitx(), j.fity(), j.fitz())
3824 if j.pSecondDecay():
3825 fprint (f,
'\n second:')
3826 dump_TrigL2Bphys (j.pSecondDecay(), f)
3830 tv = j.trackVector()
3831 for i
in range(tv.size()):
3833 fprint (f,
'\n tv:', t.dataID(), t.index())
◆ dump_TrigMissingET()
| def python.Dumpers.dump_TrigMissingET |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 3837 of file Dumpers.py.
3838 fprint (f,
' ', m.ex(), m.ey(), m.ez(), m.sumEt(), m.sumE(),
3839 m.RoIword(), m.getFlag(), m.getNumOfComponents())
3840 for ic
in range(m.getNumOfComponents()):
3841 fprint (f,
'\n ', m.getNameOfComponent(ic),
3842 m.getExComponent(ic), m.getEyComponent(ic),
3843 m.getEzComponent(ic), m.getSumEtComponent(ic),
3844 m.getSumEComponent(ic), m.getComponentCalib0(ic),
3845 m.getComponentCalib1(ic), m.getSumOfSigns(ic),
3846 m.getUsedChannels(ic), m.getStatus(ic))
◆ dump_TrigMissingET_nolist()
| def python.Dumpers.dump_TrigMissingET_nolist |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 3850 of file Dumpers.py.
3851 dump_TrigMissingET (m, f)
◆ dump_TrigMonAlg()
| def python.Dumpers.dump_TrigMonAlg |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1807 of file Dumpers.py.
1808 fprint (f, [ord(x)
for x
in p.getByte()],
list(p.getWord()))
◆ dump_TrigMonConfig()
| def python.Dumpers.dump_TrigMonConfig |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1891 of file Dumpers.py.
1892 fprint (f,
'r/e/lb', p.getRun(), p.getEvent(), p.getLumi(),
1893 'tm', p.getSec(), p.getNanoSec(),
1894 'keys', p.getMasterKey(), p.getHLTPrescaleKey(),
1895 p.getLVL1PrescaleKey())
1896 fprint (f,
'\n chains')
1897 for r
in p.getChainVec():
1899 dump_TrigConfChain (r, f)
1900 fprint (f,
'\n seqs')
1901 for r
in p.getSeqVec():
1903 dump_TrigMonSeq (r, f)
1904 fprint (f,
'\n key',
list(p.getVarKey()))
1905 fprint (f,
'\n val',
list(p.getVarVal()))
1906 fprint (f,
'\n pairkey',
list(p.getPairKey()))
1907 fprint (f,
'\n pairval',
list(p.getPairVal()))
◆ dump_TrigMonEvent()
| def python.Dumpers.dump_TrigMonEvent |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1828 of file Dumpers.py.
1829 fprint (f,
'r/e/lb/bc', p.getRun(), p.getEvent(), p.getLumi(), p.getBunchId(),
1830 'tm', p.getSec(), p.getNanoSec(),
'addl',
list(p.word()))
1831 fprint (f,
'\n robs')
1832 for r
in p.getROBVec():
1834 dump_TrigMonROB (r, f)
1835 fprint (f,
'\n rois')
1836 for r
in p.getRoiVec():
1838 dump_TrigMonRoi (r, f)
1839 fprint (f,
'\n seq2')
1840 for r
in p.getSeqVec():
1842 dump_TrigMonSeq (r, f)
1843 fprint (f,
'\n tes')
1844 for r
in p.getTEVec():
1846 dump_TrigMonTE (r, f)
1847 fprint (f,
'\n l1',
list(p.getL1Item()))
1848 fprint (f,
'\n hlt',
list(p.getChain()))
1849 fprint (f,
'\n key',
list(p.getVarKey()))
1850 fprint (f,
'\n val',
list(p.getVarVal()))
◆ dump_TrigMonROB()
| def python.Dumpers.dump_TrigMonROB |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1796 of file Dumpers.py.
1797 fprint (f, [(x.getROBId(), x.isStatusOk(), x.isStatusPrefetched(),
1798 x.getROBSize(), x.getEncodedState(), x.getHistory(),
1799 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 1811 of file Dumpers.py.
1812 fprint (f, p.getEncoded(),
list(p.getVarKey()),
list(p.getVarVal()))
1813 for a
in p.getAlg():
1815 dump_TrigMonAlg (a, f)
◆ dump_TrigMonTE()
| def python.Dumpers.dump_TrigMonTE |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1818 of file Dumpers.py.
1819 fprint (f, p.getId(),
1820 p.getIndex(), p.getType(),
1821 p.getActiveState(), p.getErrorState(), p.isTerminalNode(),
1822 p.isOutputL2Node(), p.isOutputEFNode(), p.isTopologicalTE(),
1823 list(p.getChildIndex()), list (p.getParentIndex()),
1824 list(p.getRoiId()),
list(p.getClid()),
1825 list(p.getVarKey()),
list(p.getVarVal()))
◆ dump_TrigMuonClusterFeature()
| def python.Dumpers.dump_TrigMuonClusterFeature |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4438 of file Dumpers.py.
4440 fprint (f, m.getNRoi(), m.getNTRK(), m.getNJet())
◆ dump_TrigMuonEF()
| def python.Dumpers.dump_TrigMuonEF |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4157 of file Dumpers.py.
4159 fprint (f, m.MuonCode(), m.RoINum(), m.charge())
◆ dump_TrigMuonEFInfo()
| def python.Dumpers.dump_TrigMuonEFInfo |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4340 of file Dumpers.py.
4341 fprint (f, t.RoINum())
4342 for tt
in t.TrackContainer():
4343 dump_TrigMuonEFInfoTrack (tt, f)
◆ dump_TrigMuonEFInfoTrack()
| def python.Dumpers.dump_TrigMuonEFInfoTrack |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4329 of file Dumpers.py.
4330 fprint (f,
'\n ', t.MuonType())
4331 fprint (f,
'\n spectrometer: ')
4332 dump_TrigMuonEFTrack (t.SpectrometerTrack(), f)
4333 fprint (f,
'\n extrapolated: ')
4334 dump_TrigMuonEFTrack (t.ExtrapolatedTrack(), f)
4335 fprint (f,
'\n combined: ')
4336 dump_TrigMuonEFTrack (t.CombinedTrack(), f)
◆ dump_TrigMuonEFIsolation()
| def python.Dumpers.dump_TrigMuonEFIsolation |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4461 of file Dumpers.py.
4462 fprint (f, m.sumTrkPtCone02(), m.sumTrkPtCone03(), m.trackPosition())
◆ dump_TrigMuonEFTrack()
| def python.Dumpers.dump_TrigMuonEFTrack |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4320 of file Dumpers.py.
4325 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 4444 of file Dumpers.py.
4445 fprint (f, [b.isPassing(i)
for i
in range(b.size())])
◆ dump_TrigPassFlags()
| def python.Dumpers.dump_TrigPassFlags |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4466 of file Dumpers.py.
4468 if hasattr (m,
'getNumObjects'):
4469 for i
in range (m.getNumObjects()):
4471 fprint (f, i,
list(m.getFlag(i,j)
for j
in range(m.getNumFlags(i))))
4473 for i
in range (m.size()):
4475 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 3760 of file Dumpers.py.
3762 fprint (f, p.isValid(), p.roiId())
3763 fprint (f,
'\n ', p.Et(), p.HadEt(), p.energyRatio(), p.rCore(),
3767 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 3866 of file Dumpers.py.
3867 fprint (f,
' ', d.roiId(), d.l1Id(), d.roiWord())
3868 dump_RoiDescriptor (d, f)
◆ dump_TrigRoiDescriptor_nolist()
| def python.Dumpers.dump_TrigRoiDescriptor_nolist |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 3870 of file Dumpers.py.
3871 dump_TrigRoiDescriptor (d, f)
◆ dump_TrigSpacePointCounts()
| def python.Dumpers.dump_TrigSpacePointCounts |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 3941 of file Dumpers.py.
3942 fprint (f, c.sctSpEndcapC(), c.sctSpBarrel(), c.sctSpEndcapA(),
'[')
3943 for id
in c.droppedSctModules():
3944 fprint (f, id.getString())
3946 fprint (f,
'\n clus endcap c: ')
3947 dump_TrigHisto2D (c.pixelClusEndcapC(), f)
3948 fprint (f,
'\n clus barrel: ')
3949 dump_TrigHisto2D (c.pixelClusBarrel(), f)
3950 fprint (f,
'\n clus endcap a: ')
3951 dump_TrigHisto2D (c.pixelClusEndcapA(), f)
◆ dump_TrigSpacePointCounts_nolist()
| def python.Dumpers.dump_TrigSpacePointCounts_nolist |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 3954 of file Dumpers.py.
3955 dump_TrigSpacePointCounts (c, f)
◆ dump_TrigT2Jet()
| def python.Dumpers.dump_TrigT2Jet |
( |
|
j, |
|
|
|
f |
|
) |
| |
Definition at line 3880 of file Dumpers.py.
3883 fprint (f,
' ', j.e(), j.ehad0(), j.eem0(), j.eta(), j.phi(), j.m(),
3888 dump_Trig3Momentum (m, f)
◆ dump_TrigT2Jet_nolist()
| def python.Dumpers.dump_TrigT2Jet_nolist |
( |
|
j, |
|
|
|
f |
|
) |
| |
Definition at line 3892 of file Dumpers.py.
3893 dump_TrigT2Jet (j, f)
◆ dump_TrigT2MbtsBits()
| def python.Dumpers.dump_TrigT2MbtsBits |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4272 of file Dumpers.py.
4273 if hasattr(t,
'triggerEnergies'):
4274 fprint (f,
list(t.triggerEnergies()),
list(t.triggerTimes()))
4276 fprint (f, t.mbtsWord(),
list(t.triggerTimes()))
◆ dump_TrigT2ZdcSignals()
| def python.Dumpers.dump_TrigT2ZdcSignals |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2015 of file Dumpers.py.
2016 fprint (f,
list(p.triggerEnergies()),
list(p.triggerTimes()))
◆ dump_TrigTau()
| def python.Dumpers.dump_TrigTau |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3716 of file Dumpers.py.
3718 fprint (f, t.roiId(), t.Zvtx(), t.err_Zvtx(), t.etCalibCluster(),
3719 t.simpleEtFlow(), t.nMatchedTracks())
3720 fprint (f,
'\n ',
tonone(t.tauCluster()),
3721 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 3909 of file Dumpers.py.
3911 dump_TrigCaloCluster (t, f)
3912 fprint (f,
'\n ', t.energy(), t.et(), t.EMCalibEnergy(), t.EMenergy(),
3913 t.HADenergy(), t.eta(), t.phi(), t.IsoFrac(), t.numStripCells(),
3914 t.stripWidth(), t.eCalib(), t.eEMCalib(), t.EMRadius2())
3916 fprint (f,
'\n %2d: '% s)
3917 fprint (f, t.energy(s))
3918 dump_TrigTauClusterDetails (t.clusterDetails(), f)
◆ dump_TrigTauCluster_nolist()
| def python.Dumpers.dump_TrigTauCluster_nolist |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3922 of file Dumpers.py.
3923 dump_TrigTauCluster (t, f)
◆ dump_TrigTauClusterDetails()
| def python.Dumpers.dump_TrigTauClusterDetails |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3897 of file Dumpers.py.
3900 fprint (f,
'\n EM%d: '% s)
3901 fprint (f, t.EMRadius(s), t.EMenergyWidth(s), t.EMenergyMedium(s),
3902 t.EMenergyWide(s), t.EMenergyNarrow(s))
3904 fprint (f,
'\n HAD%d: '% s)
3905 fprint (f, t.HADRadius(s), t.HADenergyWidth(s), t.HADenergyMedium(s),
3906 t.HADenergyWide(s), t.HADenergyNarrow(s))
◆ dump_TrigTauTracksInfo()
| def python.Dumpers.dump_TrigTauTracksInfo |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3959 of file Dumpers.py.
3962 fprint (f,
' ', t.roiId(), t.nCoreTracks(), t.nSlowTracks(),
3964 t.charge(), t.leadingTrackPt(), t.scalarPtSumCore(),
3965 t.scalarPtSumIso(), t.ptBalance())
3966 dump_Fourvec (t.threeFastestTracks(), f)
3967 if t.trackCollection():
3969 dump_TrigInDetTrackCollection (t.trackCollection(), f)
◆ dump_TrigTauTracksInfo_nolist()
| def python.Dumpers.dump_TrigTauTracksInfo_nolist |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3973 of file Dumpers.py.
3974 dump_TrigTauTracksInfo (t, f)
◆ dump_TrigTrackCounts()
| def python.Dumpers.dump_TrigTrackCounts |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3704 of file Dumpers.py.
3705 fprint (f,
'z0_pt:')
3706 dump_TrigHisto2D (t.z0_pt(), f)
3707 fprint (f,
'\neta_phi:')
3708 dump_TrigHisto2D (t.eta_phi(), f)
◆ dump_TrigTrackCounts_nolist()
| def python.Dumpers.dump_TrigTrackCounts_nolist |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3711 of file Dumpers.py.
3712 dump_TrigTrackCounts (t, f)
◆ dump_TrigTrtHitCounts()
| def python.Dumpers.dump_TrigTrtHitCounts |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4352 of file Dumpers.py.
4353 fprint (f,
' barrel')
4354 dump_TrigHisto1D (p.barrel(), f)
4355 fprint (f,
'\n endcapA')
4356 dump_TrigHisto1D (p.endcapA(), f)
4357 fprint (f,
'\n endcapC')
4358 dump_TrigHisto1D (p.endcapC(), f)
◆ dump_TrigVertex()
| def python.Dumpers.dump_TrigVertex |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 3665 of file Dumpers.py.
3666 dump_Threevec (v, f)
3667 fprint (f, v.algorithmId(), v.chi2(), v.ndof(), v.mass(),
3668 v.massVariance(), v.energyFraction(), v.nTwoTracksSecVtx())
3669 fprint (f,
'\n cov: ', [v.cov()[i]
for i
in range(6)])
3670 if v.tracks()
and v.tracks().
size() > 0:
3671 for (i, t)
in enumerate (v.tracks()):
3672 fprint (f,
'\n t%d'%i)
3674 fprint (f, p.a0(), p.z0(), p.phi0(), p.eta(), p.pT())
3675 if v.getMotherTrack():
3676 fprint (f,
'\n mother: ')
3677 dump_TrigInDetTrackFitPar (v.getMotherTrack(), f)
◆ dump_TrigVertexCounts()
| def python.Dumpers.dump_TrigVertexCounts |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 4455 of file Dumpers.py.
4457 formatItemUsingLong (
list(v.vtxNtrks())),
4458 list(v.vtxTrkPtSqSum()))
◆ dump_TRT_BSErrContainer()
| def python.Dumpers.dump_TRT_BSErrContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1766 of file Dumpers.py.
1767 fprint (f,
' Missing errors:', list (p.getMissingErrorSet()))
1768 fprint (f,
'\n Error errors:', list (p.getErrorErrorSet()))
1769 fprint (f,
'\n Sid errors:', list (p.getSidErrorSet()))
1770 fprint (f,
'\n L1 errors:', [(x.first, x.second)
for x
in p.getL1ErrorSet()])
1771 fprint (f,
'\n BCID errors:', [(x.first, x.second)
for x
in p.getBCIDErrorSet()])
1772 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 4636 of file Dumpers.py.
4637 dump_PrepRawData (p, f)
4638 fprint (f, p.getWord())
4639 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_TRT_DriftCircleContainer()
| def python.Dumpers.dump_TRT_DriftCircleContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4750 of file Dumpers.py.
4751 dump_IDC (dump_TRT_DriftCircle, p, f)
◆ dump_TRT_DriftCircleOnTrack()
| def python.Dumpers.dump_TRT_DriftCircleOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1671 of file Dumpers.py.
1672 dump_RIO_OnTrack (p, f)
1673 dump_AmgVector (p.globalPosition(), f)
1674 fprint (f, p.idDE().
value())
1675 dump_EL (p.prepRawDataLink(), f)
1676 fprint (f, p.status(), p.localAngle(), p.positionAlongWire())
1677 fprint (f, p.highLevel(), p.timeOverThreshold())
1678 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_TRT_RawDataContainer()
| def python.Dumpers.dump_TRT_RawDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4762 of file Dumpers.py.
4763 dump_IDC (dump_TRT_RDORawData, p, f)
◆ dump_TRT_RDORawData()
| def python.Dumpers.dump_TRT_RDORawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4654 of file Dumpers.py.
4655 dump_InDetRawData (p, f)
4656 fprint (f, p.highLevel(), p.timeOverThreshold(), p.driftTimeBin())
◆ dump_TRTUncompressedHit()
| def python.Dumpers.dump_TRTUncompressedHit |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4263 of file Dumpers.py.
4264 fprint (f, t.GetHitID(), t.truthBarcode(), t.GetParticleEncoding(),
4265 t.GetKineticEnergy(), t.GetEnergyDeposit(),
4266 t.GetPreStepX(), t.GetPreStepY(), t.GetPreStepZ(),
4267 t.GetPostStepX(), t.GetPostStepY(), t.GetPostStepZ(),
◆ dump_TruthInfo()
| def python.Dumpers.dump_TruthInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1045 of file Dumpers.py.
1046 dump_BaseTagInfo (info, f)
1047 fprint (f,
' %s %f %d ' %
1048 (info.jetTruthLabel(),
1049 info.deltaRMinTo (
'b'),
1051 dump_Threevec (info.BDecayVertex(), f)
◆ dump_TruthParticle()
| def python.Dumpers.dump_TruthParticle |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1355 of file Dumpers.py.
1356 dump_ParticleImpl (p, f)
1357 poltheta = fix_neg0 (p.polarization().theta())
1358 fprint (f,
' %3d %3d %f %f %d %d' %
1362 p.polarization().phi(),
1365 fprint (f,
'\n ', p.hasEtIsol())
1366 dump_HLV (p.genParticle().
momentum(), f)
1368 fprint (f,
'\n p0:')
1372 for i
in range(p.nParents()):
1374 mother = p.genMother(i)
1376 dump_HLV (mother.momentum(), f)
1377 dump_Fourvec (p.mother(mni), f)
1379 fprint (f,
'\n c0:')
1381 for i
in range(p.nDecay()):
1383 child = p.genChild(i)
1385 dump_HLV (child.momentum(), f)
1386 dump_Fourvec (p.child(mni), f)
◆ dump_TruthTrajectory()
| def python.Dumpers.dump_TruthTrajectory |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 1419 of file Dumpers.py.
1420 fprint (f, [l.barcode()
for l
in t])
◆ dump_Twovec()
| def python.Dumpers.dump_Twovec |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 303 of file Dumpers.py.
304 fprint (f,
"(%f %f)" % (v.x(), v.y()))
◆ dump_V0Candidate()
| def python.Dumpers.dump_V0Candidate |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 3657 of file Dumpers.py.
3658 fprint (f,
"V0Candidate", len(v.v0Hypothesis()))
3659 for h
in v.v0Hypothesis():
3661 dump_V0Hypothesis (h, f)
◆ dump_V0Hypothesis()
| def python.Dumpers.dump_V0Hypothesis |
( |
|
h, |
|
|
|
f |
|
) |
| |
Definition at line 3646 of file Dumpers.py.
3650 fprint (f,
'V0Hypothesis', h.positiveTrackID(),
3651 h.negativeTrackID(), h.hypothesisID())
3653 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 2569 of file Dumpers.py.
2570 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 906 of file Dumpers.py.
912 fprint (f,
'(', el.dataID(), el.index(),
') ')
914 fprint (f,
'(invEL) ')
◆ dump_VxCandidate()
| def python.Dumpers.dump_VxCandidate |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 2677 of file Dumpers.py.
2679 if isinstance (v, PyAthena.Trk.MVFVxCandidate):
2680 dump_MVFVxCandidate (v, f)
2681 elif (v.__class__ == PyAthena.Trk.VxCandidate
or
2682 isinstance (v, PyAthena.Trk.V0Hypothesis)):
2683 dump_VxCandidate1 (v, f)
2684 elif isinstance (v, PyAthena.Trk.ExtendedVxCandidate):
2685 dump_ExtendedVxCandidate (v, f)
2688 dump_VxCandidate1 (v, f)
◆ dump_VxCandidate1()
| def python.Dumpers.dump_VxCandidate1 |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 2645 of file Dumpers.py.
2646 dump_RecVertex (v.recVertex(), f)
2650 tav = v.vxTrackAtVertex()
2651 for i
in range(tav.size()):
2653 fprint (f,
'\n ',
typename(t.__class__))
2654 if isinstance (t, PyAthena.Trk.MVFVxTrackAtVertex):
2655 dump_MVFVxTrackAtVertex (t, f)
2656 elif t.__class__ == PyAthena.Trk.VxTrackAtVertex:
2657 dump_VxTrackAtVertex (t, f)
◆ dump_VxTrackAtVertex()
| def python.Dumpers.dump_VxTrackAtVertex |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 2604 of file Dumpers.py.
2605 dump_FitQuality (t.trackQuality(), f)
2606 fprint (f,
'%f %f' %
2607 (t.vtxCompatibility(),
2609 fprint (f,
tonone(t.linState()),
tonone(t.ImpactPoint3dAtaPlane()))
2610 if t.perigeeAtVertex():
2612 dump_parameters (t.perigeeAtVertex(), f)
2619 tel = PyAthena.ElementLink (
'DataVector<Trk::Track>')
2620 if not isinstance (t.trackOrParticleLink(), tel):
2623 trk = t.trackOrParticleLink().cptr()
2625 pm = trk.trackParameters()
2626 if pm
and len(pm) > 0:
2628 dump_parameters (perigee, f)
2630 if isinstance (t.trackOrParticleLink(), PyAthena.Trk.LinkToTrack):
2631 dump_LinkToTrack (t.trackOrParticleLink(), f)
2632 elif isinstance (t.trackOrParticleLink(),PyAthena.Trk.LinkToTrackParticleBase):
2633 dump_LinkToTrackParticleBase (t.trackOrParticleLink(), f)
2635 fprint (f, t.trackOrParticleLink())
◆ dump_xAOD()
| def python.Dumpers.dump_xAOD |
( |
|
o, |
|
|
|
f |
|
) |
| |
Definition at line 5696 of file Dumpers.py.
5697 fprint (f,
typename(o.__class__),
'\n ')
5698 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 5495 of file Dumpers.py.
5496 dump_HepMcParticleLink (p.first, f)
5497 dump_EL (p.second, f)
◆ dump_ZdcDigits()
| def python.Dumpers.dump_ZdcDigits |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5238 of file Dumpers.py.
5239 dump_ZdcRawData (p, f)
5240 fprint (f,
list(p.get_digits_gain0_delay0()))
5241 fprint (f,
list(p.get_digits_gain0_delay1()))
5242 fprint (f,
list(p.get_digits_gain1_delay0()))
5243 fprint (f,
list(p.get_digits_gain1_delay1()))
◆ dump_ZdcLucrod_Data()
| def python.Dumpers.dump_ZdcLucrod_Data |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5483 of file Dumpers.py.
5484 fprint (f,
'ld', p.GetLucrodID(),
'bcid', p.GetBCID(),
5485 'run', p.GetRunNumber(),
'l1id', p.GetLevel1ID(),
5486 'nbc', p.GetNumBCs(),
'stat', p.GetStatus(),
5487 'avga/c', p.GetTrigAvgA(), p.GetTrigAvgC(),
5488 'data',
list(p.GetTrigData()))
5489 for i
in range (p.GetChanDataSize()):
5490 ch = p.GetChanData(i)
5491 fprint (f,
'\n chan ', ch.id,
list(ch.waveform))
◆ dump_ZdcRawData()
| def python.Dumpers.dump_ZdcRawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5233 of file Dumpers.py.
5234 fprint (f, p.identify().getString())
◆ fix_neg0()
| def python.Dumpers.fix_neg0 |
( |
|
x, |
|
|
|
thresh = 0 |
|
) |
| |
library methods ---------------------------------------------------------—
Definition at line 200 of file Dumpers.py.
201 return 0
if x == 0
or abs(x) < thresh
else x
◆ format_dl()
| def python.Dumpers.format_dl |
( |
|
x | ) |
|
Definition at line 5504 of file Dumpers.py.
5507 key =
'(%d)' % x.key()
5508 return f
'DataLink({key})'
◆ format_el()
| def python.Dumpers.format_el |
( |
|
x | ) |
|
Definition at line 5509 of file Dumpers.py.
5510 if x.isDefaultIndex():
5514 key =
'(%d)' % x.key()
5515 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 5557 of file Dumpers.py.
5558 if isinstance(x, float):
5559 return format_float (x)
5560 if isinstance(x, int):
5561 return format_int (x)
5563 if tname.startswith (
'CxxUtils::range_with_conv<'):
5566 if tname.startswith (
'ROOT.'):
5568 if tname.startswith (
'ElementLink<'):
5569 return format_el (x)
5570 if tname.startswith (
'DataLink<'):
5571 return format_dl (x)
5572 if tname.startswith (
'std::vector<')
or tname.startswith (
'vector<'):
5573 ipos = tname.find(
'<')
5574 tname2 = tname[ipos+1:]
5575 if (tname2.startswith(
'char,')
or
5576 tname2.startswith(
'char>')
or
5577 tname2.startswith (
'unsigned char,')
or
5578 tname2.startswith (
'unsigned char>')):
5579 l =
', '.join ([
str(ord(x[i]))
for i
in range(len(x))])
5580 elif tname2.startswith(
'bool,')
or tname2 ==
'bool>':
5581 l =
', '.join ([
str(
bool(xx))
for xx
in x])
5584 return '[' + l +
']'
5585 if isinstance(x, PyAthena.xAOD.CaloClusterBadChannelData_v1):
5586 return '<BadChannel: %6.3f/%6.3f/%2d: %04x>' % \
5587 (x.eta(), x.phi(), x.layer(), x.badChannel())
5588 if tname ==
'set<unsigned int>':
5589 acls=getattr(PyAthena,
'PyDumper::PySTLAdaptor<std::set<unsigned int>')
5593 if tname.startswith (
'std::pair<')
or tname.startswith (
'pair<'):
5596 if tname ==
'Trk::VxTrackAtVertex':
5598 dump_VxTrackAtVertex (x, fout)
5599 out = fout.getvalue()
5600 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 160 of file Dumpers.py.
161 """Helper for doing formatting compatibly with py2.
163 Convert X to a string, but add a `L' to the ends of integers.
164 Can be used for formatting expressions that using longs in py2.
166 if isinstance (x, list):
167 sl = [formatItemUsingLong (xx)
for xx
in x]
168 return '[' +
', '.join (sl) +
']'
169 if isinstance (x, tuple):
170 sl = [formatItemUsingLong (xx)
for xx
in x]
171 return '(' +
', '.join (sl) +
')'
172 if isinstance (x, int):
174 if isinstance (x, forceInt):
176 if isinstance(x, ROOT.std.string):
◆ generic_dump_auxitem()
| def python.Dumpers.generic_dump_auxitem |
( |
|
x, |
|
|
|
auxid, |
|
|
|
f |
|
) |
| |
Definition at line 5605 of file Dumpers.py.
5606 if hasattr (x,
'container'):
5608 x.container().getConstStore().
getData(auxid)[0]
5610 fprint (f,
'<unavailable 1>')
5613 reg=ROOT.SG.AuxTypeRegistry.instance()
5614 tname = reg.getTypeName (auxid)
5615 ac = ROOT.SG.ConstAuxElement.TypelessConstAccessor (reg.getName(auxid))
5619 fprint (f,
'<unavailable 2>')
5622 obj = ROOT.TPython.CPPInstance_FromVoidPtr (buf, tname)
5624 fprint (f,
'<unknown %s>'%tname)
5626 fprint (f,
format_obj(obj, reg.getName(auxid)))
◆ genvertex_in_barcodes()
| def python.Dumpers.genvertex_in_barcodes |
( |
|
v | ) |
|
Definition at line 2813 of file Dumpers.py.
2814 if hasattr(v,
'particles_in_const_begin'):
2815 parts =
barcodes(v.particles_in_const_begin(),
2816 v.particles_in_const_end(),
2817 v.particles_in_size())
◆ genvertex_out_barcodes()
| def python.Dumpers.genvertex_out_barcodes |
( |
|
v | ) |
|
Definition at line 2822 of file Dumpers.py.
2823 if hasattr(v,
'particles_out_const_begin'):
2824 parts =
barcodes(v.particles_out_const_begin(),
2825 v.particles_out_const_end(),
2826 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 6141 of file Dumpers.py.
6142 """helper function to automatically retrieve the suitable dumper function
6143 given the name of a class or the class-type
6144 @param `klass' a string containing the name of a C++ type or a type
6145 @param `ofile' a file-like instance where to dump the objects' content
6146 @param `nmax` maximum number of container elements to dump
6148 if isinstance(klass, type):
6151 elif isinstance(klass, str):
6152 klass = getattr(PyAthena,klass)
6155 raise TypeError(
'expected a type or a string')
6159 dumpers = [ i
for i
in dumpspecs
if i[0] == klname ]
6160 if len(dumpers) != 1:
6161 raise RuntimeError(
'no suitable dumper function for class [%s]'%
6164 nolist = hasattr (fct,
'nolist')
and fct.nolist
6165 from functools
import partial
as _partial
6168 dumper = _partial(fct, f=ofile, nmax=nmax)
6170 dumper = _partial(fct, f=ofile)
6172 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 3387 of file Dumpers.py.
3388 bv = a.beginAssociation(obj)
3389 ev = a.endAssociation(obj)
3394 targ = bv.__deref__()
3396 except RuntimeError
as e:
3397 if e.args[0].find (
'dereferencing invalid ElementLink') >= 0:
3409 a.assocs (obj, coll)
◆ safe_float_vector()
| def python.Dumpers.safe_float_vector |
( |
|
v | ) |
|
Definition at line 130 of file Dumpers.py.
131 sa = ROOT.PyDumper.SafeFloatAccess(v)
132 return [sa[i]
for i
in range(len(v))]
◆ signalstate()
| def python.Dumpers.signalstate |
( |
|
o, |
|
|
|
state |
|
) |
| |
Definition at line 135 of file Dumpers.py.
136 if hasattr(o,
'setSignalState'):
137 old = o.signalState()
138 o.setSignalState (state)
140 o.setSignalState (old)
142 sh = PyAthena.SignalStateHelper (o)
143 sh.setSignalState (state)
◆ toiter()
| def python.Dumpers.toiter |
( |
|
beg, |
|
|
|
end |
|
) |
| |
◆ toiter1()
| def python.Dumpers.toiter1 |
( |
|
c | ) |
|
Definition at line 101 of file Dumpers.py.
102 return toiter (c.begin(), c.end())
◆ tonone()
| def python.Dumpers.tonone |
( |
|
x | ) |
|
Definition at line 114 of file Dumpers.py.
115 if not x:
return None
◆ typename()
| def python.Dumpers.typename |
( |
|
t | ) |
|
Definition at line 194 of file Dumpers.py.
195 return getattr (t,
'__cpp_name__', t.__name__)
◆ uf()
| def python.Dumpers.uf |
( |
|
x | ) |
|
Definition at line 441 of file Dumpers.py.
442 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 5541 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 5552 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