 |
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_TauShot (t, 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 2784 of file Dumpers.py.
2785 fn = getattr(e, a,
None)
2788 v = e.attribute_as_string(a)
2789 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 2791 of file Dumpers.py.
2792 fn = getattr(e, a,
None)
2795 return [typ(x)
for x
in e.attribute_as_string(a).
split()]
◆ _genevent_particles()
| def python.Dumpers._genevent_particles |
( |
|
e | ) |
|
|
private |
Definition at line 2806 of file Dumpers.py.
2807 if hasattr(e,
'particles_begin'):
2808 return toiter (e.particles_begin(), e.particles_end())
2809 return e.particles()
◆ _genevent_particles_size()
| def python.Dumpers._genevent_particles_size |
( |
|
e | ) |
|
|
private |
Definition at line 2798 of file Dumpers.py.
2799 if hasattr(e,
'particles_size'):
2800 return e.particles_size()
2801 return e.particles().
size()
◆ _genevent_signal_process_vertex()
| def python.Dumpers._genevent_signal_process_vertex |
( |
|
e | ) |
|
|
private |
Definition at line 2814 of file Dumpers.py.
2815 if hasattr(e,
'signal_process_vertex'):
2816 return e.signal_process_vertex()
2817 for v
in e.vertices():
2818 if v.attribute_as_string(
'signal_process_vertex') ==
'1':
◆ _genevent_vertices()
| def python.Dumpers._genevent_vertices |
( |
|
e | ) |
|
|
private |
Definition at line 2810 of file Dumpers.py.
2811 if hasattr(e,
'vertices_begin'):
2812 return toiter (e.vertices_begin(), e.vertices_end())
◆ _genevent_vertices_size()
| def python.Dumpers._genevent_vertices_size |
( |
|
e | ) |
|
|
private |
Definition at line 2802 of file Dumpers.py.
2803 if hasattr(e,
'vertices_size'):
2804 return e.vertices_size()
2805 return e.vertices().
size()
◆ _genvertex_particles_in_size()
| def python.Dumpers._genvertex_particles_in_size |
( |
|
e | ) |
|
|
private |
Definition at line 2821 of file Dumpers.py.
2822 if hasattr(e,
'particles_in_size'):
2823 return e.particles_in_size()
2824 return e.particles_in().
size()
◆ _genvertex_particles_out_size()
| def python.Dumpers._genvertex_particles_out_size |
( |
|
e | ) |
|
|
private |
Definition at line 2825 of file Dumpers.py.
2826 if hasattr(e,
'particles_out_size'):
2827 return e.particles_out_size()
2828 return e.particles_out().
size()
◆ _infoType()
| def python.Dumpers._infoType |
( |
|
i | ) |
|
|
private |
◆ _tmcmp()
| def python.Dumpers._tmcmp |
( |
|
x, |
|
|
|
y |
|
) |
| |
|
private |
Definition at line 3385 of file Dumpers.py.
3387 if x[0].nrMatches() > 0:
3388 xbc = x[0].bestSiMatch().
barcode()
3390 if y[0].nrMatches() > 0:
3391 ybc = y[0].bestSiMatch().
barcode()
3397 return cmp (x[1].chi2, y[1].chi2)
◆ asinh()
| def python.Dumpers.asinh |
( |
|
x | ) |
|
helper methods ---------------------------------------------------------—
Definition at line 88 of file Dumpers.py.
89 arg = math_sqrt (x*x+1) - x
92 return - math_log (arg)
◆ asint()
| def python.Dumpers.asint |
( |
|
x | ) |
|
◆ asint32()
| def python.Dumpers.asint32 |
( |
|
x | ) |
|
◆ barcodes()
| def python.Dumpers.barcodes |
( |
|
beg, |
|
|
|
end, |
|
|
|
sz |
|
) |
| |
Definition at line 2831 of file Dumpers.py.
2836 while beg != end
and sz > 0:
2840 out.append (x.barcode())
◆ boolvec()
| def python.Dumpers.boolvec |
( |
|
v | ) |
|
◆ cmp()
| def python.Dumpers.cmp |
( |
|
x, |
|
|
|
y |
|
) |
| |
Definition at line 36 of file Dumpers.py.
37 return (x > y) - (x < y)
◆ daz()
| def python.Dumpers.daz |
( |
|
f | ) |
|
◆ dump_AFP_RawCollectionHead()
| def python.Dumpers.dump_AFP_RawCollectionHead |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1948 of file Dumpers.py.
1949 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 1985 of file Dumpers.py.
1986 fprint (f, p.lvl1Id(), p.bcId(), p.lumiBlock(),
1987 p.timeStamp(), p.timeStampNS())
1988 fprint (f,
'\n si collections')
1989 for c
in p.collectionsSi():
1991 dump_AFP_SiRawCollection (c, f)
1992 fprint (f,
'\n tof collections')
1993 for c
in p.collectionsToF():
1995 dump_AFP_ToFRawCollection (c, f)
◆ dump_AFP_RawDataCommonHead()
| def python.Dumpers.dump_AFP_RawDataCommonHead |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1952 of file Dumpers.py.
1953 fprint (f, p.hitDiscConfig(), p.link())
◆ dump_AFP_SiRawCollection()
| def python.Dumpers.dump_AFP_SiRawCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1961 of file Dumpers.py.
1962 dump_AFP_RawCollectionHead (p, f)
1963 for r
in p.dataRecords():
1965 dump_AFP_SiRawData (r, f)
◆ dump_AFP_SiRawData()
| def python.Dumpers.dump_AFP_SiRawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1956 of file Dumpers.py.
1957 dump_AFP_RawDataCommonHead (p, f)
1958 fprint (f, p.column(), p.row(), p.timeOverThreshold())
◆ dump_AFP_ToFRawCollection()
| def python.Dumpers.dump_AFP_ToFRawCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1977 of file Dumpers.py.
1978 dump_AFP_RawCollectionHead (p, f)
1979 for r
in p.dataRecords():
1981 dump_AFP_ToFRawData (r, f)
◆ dump_AFP_ToFRawData()
| def python.Dumpers.dump_AFP_ToFRawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1968 of file Dumpers.py.
1969 dump_AFP_RawDataCommonHead (p, f)
1970 fprint (f, p.header(), p.edge(), p.channel())
1972 fprint (f, p.delayedTrigger(), p.triggerPattern())
1974 fprint (f, p.time(), p.pulseLength())
◆ dump_ALFA_RawData()
| def python.Dumpers.dump_ALFA_RawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1999 of file Dumpers.py.
2000 fprint (f, p.GetWordId_PMF(), p.GetPMFId_PMF(), p.GetMBId_PMF(),
2001 p.GetEventCount_PMF(), p.Get_bit16(), p.Get_bit18(),
2002 p.Get_bit26_27(), p.Get_bit24_27(), p.Get_error_bit17(),
2003 list(p.HitChan()), list (p.dataWords()))
◆ dump_ALFA_RawDataCollection()
| def python.Dumpers.dump_ALFA_RawDataCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2007 of file Dumpers.py.
2008 fprint (f,
'collection')
2009 fprint (f,
'mb', p.GetMBId_POT(),
'mrod', p.GetMrodId_POT(),
2010 'ec', p.GetEventCount_POT(),
2011 'scid', p.Get_scaler_POT(),
2012 'adc', p.Get_ADC1_POT(), p.Get_ADC2_POT(),
2013 'err', p.GetTrigSyncErr(),
2014 'pat', boolvec (p.Get_pattern_POT()))
2015 fprint (f,
'\n data')
2016 for r
in p.Get_POT_DATA():
2018 dump_ALFA_RawData (r, f)
2019 fprint (f,
'\n contents')
2022 dump_ALFA_RawData (r, f)
◆ dump_ALFA_RawDataContainer()
| def python.Dumpers.dump_ALFA_RawDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2027 of file Dumpers.py.
2028 if p.is_FullEVmarker(): fprint (f,
'fullev')
2029 if p.is_ROBmarker(): fprint (f,
'rob')
2030 if p.is_RODmarker(): fprint (f,
'rod')
2031 fprint (f,
'sd/mrod/l1/ecr/bc', p.subdetId(), p.mrodId(), p.lvl1Id(),
2032 p.ecrId(), p.bcId())
2033 fprint (f,
'\n run/typ/tt/evtyp', p.runNum(), p.runType(),
2034 p.trigtypeId(), p.DetEventType(),
2035 'ts', p.GetTimeStamp(), p.GetTimeStampns(),
2036 p.GetLumiBlock(), p.GetBCId())
2037 fprint (f,
'\n lvl1',
boolvec(p.GetLvl1Pattern_POT()))
2038 fprint (f,
'\n lvl2',
boolvec(p.GetLvl2Pattern_POT()))
2039 fprint (f,
'\n ef',
boolvec(p.GetEFPattern_POT()))
2042 dump_ALFA_RawDataCollection (c, f)
◆ dump_AlignmentEffectsOnTrack()
| def python.Dumpers.dump_AlignmentEffectsOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2260 of file Dumpers.py.
2262 fprint (f,
'(null)')
2264 fprint (f, p.deltaTranslation(), p.sigmaDeltaTrranslation(), p.deltaAngle(), p.sigmaDeltaAngle())
2265 for t
in p.vectorOfAffectedTSOS():
2266 fprint (f,
'\n ts ')
2267 dump_parameters (t.trackparameters(), f)
2268 fprint (f,
'\n sf ')
2269 dump_Surface (p.associatedSurface(), f)
◆ dump_AmgMatrix()
| def python.Dumpers.dump_AmgMatrix |
( |
|
m, |
|
|
|
f, |
|
|
|
thresh = 1e-38 |
|
) |
| |
Definition at line 304 of file Dumpers.py.
306 for r
in range(m.rows()):
308 for c
in range(m.cols()):
310 if abs(v) < thresh: v = 0
311 fprint (f,
'%#6.3g' % v)
◆ dump_AmgVector()
| def python.Dumpers.dump_AmgVector |
( |
|
m, |
|
|
|
f, |
|
|
|
thresh = 1e-38, |
|
|
|
prec = 3 |
|
) |
| |
Definition at line 316 of file Dumpers.py.
318 fprint (f,
'(null vector)')
321 for r
in range(m.rows()):
323 if abs(v) < thresh: v = 0
324 fprint (f,
'%#6.*g' % (prec, v))
◆ dump_associatedSurface()
| def python.Dumpers.dump_associatedSurface |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1576 of file Dumpers.py.
1577 if hasattr(p,
'hasSurface')
and not p.hasSurface():
1580 dump_surface (p.associatedSurface(), f)
◆ dump_Assocs()
| def python.Dumpers.dump_Assocs |
( |
|
a, |
|
|
|
f, |
|
|
|
colltype |
|
) |
| |
Definition at line 3445 of file Dumpers.py.
3446 bo = a.beginObject()
3450 obj = a.getObject(bo)
3452 errflag = safe_assocs (a, obj, coll, f)
3453 l.append ((obj, coll, errflag))
3456 l.sort (key=
lambda a: a[0].
pt(), reverse=
True)
3458 for obj, coll, errflag
in l:
3459 fprint (f,
'\n',
typename(obj.__class__))
3460 dump_Fourvec (obj, f)
3466 fprint (f,
' [Got invalid EL error]')
◆ dump_AtlfInfo()
| def python.Dumpers.dump_AtlfInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1264 of file Dumpers.py.
1265 dump_BaseTagInfo (info, f)
1266 fprint (f, info.isBTagged(), info.isTauTagged(), info.isTau1PTagged(),
1267 info.isTau3PTagged(), info.LightHypoCalFactor(),
1268 info.TauHypoCalFactor(), info.Tau1P3PHypoCalFactor(),
1269 info.BHypoCalFactor(),
1270 info.deltaRMinTo(
"b"),
1271 info.deltaRMinTo(
"c"),
1272 info.deltaRMinTo(
"t"))
◆ dump_Attribute()
| def python.Dumpers.dump_Attribute |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1758 of file Dumpers.py.
1759 if isinstance (p, str):
1762 ss = ROOT.std.ostringstream()
1763 p.toOutputStream (ss)
1764 fprint (f, ss.str())
◆ dump_AttributeList()
| def python.Dumpers.dump_AttributeList |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1767 of file Dumpers.py.
1771 ss = ROOT.std.ostringstream()
1777 if s[0] ==
'{': s = s[1:]
1778 if s[-1] ==
'}': s = s[:-1]
1779 for a
in s.split(
','):
1780 fprint (f,
' ', a,
'\n')
◆ dump_auxdata()
| def python.Dumpers.dump_auxdata |
( |
|
x, |
|
|
|
exclude = None, |
|
|
|
f = sys.stdout |
|
) |
| |
Definition at line 5706 of file Dumpers.py.
5707 reg=ROOT.SG.AuxTypeRegistry.instance()
5708 if cppyy.addressof (x) == 0:
5709 fprint (f,
'<null pointer>', x,
type(x))
5712 auxids = ROOT.PyDumper.Utils.getAuxIDVector (x)
5716 auxids = [(reg.getName(id), id)
for id
in auxids]
5718 for name, auxid
in auxids:
5719 if exclude
and name
in exclude:
continue
5720 if name.endswith (
'_linked'):
continue
5721 fprint (f, name +
': ')
5722 dump_auxitem (x, auxid, f)
◆ dump_auxitem()
| def python.Dumpers.dump_auxitem |
( |
|
x, |
|
|
|
auxid, |
|
|
|
f = sys.stdout |
|
) |
| |
Definition at line 5661 of file Dumpers.py.
5662 if hasattr (x,
'container'):
5663 auxdata = x.container().getConstStore().
getData(auxid)
5666 fprint (f,
'<unavailable>')
5671 fprint (f,
'<unavailable 4>')
5674 reg=ROOT.SG.AuxTypeRegistry.instance()
5675 tname = reg.getTypeName (auxid)
5676 atomic = reg.getFlags (auxid) & ROOT.SG.AuxVarFlags.Atomic
5678 ac_cl = atomic_accessors.get (tname)
5680 ac_cl = accessors.get (tname)
5682 if not ac_cl
and tname.startswith (
'SG::JaggedVecElt<'):
5683 ac_cl = getattr (ROOT,
'SG::ConstAccessor<' + tname +
' >')
5685 accessors[tname] = ac_cl
5687 if not ac_cl
and tname.startswith (
'SG::PackedLink<')
or tname.startswith (
'std::vector<SG::PackedLink<'):
5688 ac_cl = getattr (ROOT,
'SG::ConstAccessor<' + tname +
' >')
5690 accessors[tname] = ac_cl
5694 ac = ac_cl(reg.getName(auxid))
5699 val =
'<unavailable 5>'
5702 generic_dump_auxitem (x, auxid, f)
◆ dump_BaseTagInfo()
| def python.Dumpers.dump_BaseTagInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1070 of file Dumpers.py.
1071 fprint (f,
' '.join ([
'%f'%x
for x
in info.tagLikelihood()]),
1072 info.weight(), info.isValid())
◆ dump_BCM_RDO()
| def python.Dumpers.dump_BCM_RDO |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5212 of file Dumpers.py.
5213 fprint (f,
'[', p.getWord1(), p.getWord2(),
']')
◆ dump_BCM_RDO_Collection()
| def python.Dumpers.dump_BCM_RDO_Collection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5217 of file Dumpers.py.
5218 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 4262 of file Dumpers.py.
4263 fprint (f, t.cellID().getString(), t.particleID(),
4264 [t.energy(i)
for i
in range(4)])
◆ dump_CaloCell()
| def python.Dumpers.dump_CaloCell |
( |
|
l, |
|
|
|
f |
|
) |
| |
Definition at line 2590 of file Dumpers.py.
2591 fprint (f, l.ID().getString())
2592 if l.__class__ == PyAthena.TileCell:
2593 fprint (f,
'%.2f %.2f %d %d %d ' % (l.ene1(), l.time1(), l.qual1(), l.qbit1(), l.gain1()))
2594 fprint (f,
'%.2f %.2f %d %d %d ' % (l.ene2(), l.time2(), l.qual2(), l.qbit2(), l.gain2()))
2596 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 2567 of file Dumpers.py.
2572 el = beg.getElement()
2573 if last != el.dataID():
2576 fprint (f, el.index())
◆ dump_CaloCluster()
| def python.Dumpers.dump_CaloCluster |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 2518 of file Dumpers.py.
2521 fprint (f,
"%3d %f %f %f %f %f %d %d %d" %
2522 (c.getClusterSize(),
2531 fprint (f, c.getRecoStatus().getStatusWord())
2532 beg = c.beginMoment()
2535 fprint (f,
'\n mom %d %f' % (c.getMomentType(beg),
2536 c.getMomentValue(beg)))
2539 for i
in range (c.nSamples()):
2540 fprint (f,
'\n %2d %d %d %d %f %f %f %f %f %f %f %f %f %f %f' %
2542 c.is_valid_sampling(i),
◆ dump_CaloClusterCellLink()
| def python.Dumpers.dump_CaloClusterCellLink |
( |
|
l, |
|
|
|
f |
|
) |
| |
Definition at line 2581 of file Dumpers.py.
2585 fprint (f,
'%d/%f' % (beg.index(), beg.weight()))
◆ dump_CaloClusterMomentStore()
| def python.Dumpers.dump_CaloClusterMomentStore |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4199 of file Dumpers.py.
4203 fprint (f,
'\n ', beg.getMomentType(), beg.getMoment().getValue())
◆ dump_CaloClusters_sorted()
| def python.Dumpers.dump_CaloClusters_sorted |
( |
|
l, |
|
|
|
f, |
|
|
|
nmax = None |
|
) |
| |
Definition at line 2560 of file Dumpers.py.
2562 ll.sort (key=
lambda a: a.pt(), reverse=
True)
2563 dump_list (ll, f, dump_CaloCluster, nmax=nmax)
◆ dump_CaloEnergy()
| def python.Dumpers.dump_CaloEnergy |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 613 of file Dumpers.py.
614 dump_EnergyLoss (p, f)
615 fprint (f,
'%d %f %f %f %f' %
618 p.caloLRLikelihood(),
619 p.fsrCandidateEnergy(),
621 fprint (f, p.deltaEParam(), p.sigmaMinusDeltaEParam(), p.sigmaPlusDeltaEParam(), p.deltaEMeas(), p.sigmaDeltaEMeas())
622 fprint (f,
'\n deposits:')
623 for d
in p.depositInCalo():
624 fprint (f,
" (%d %f %f)" %
625 (d.subCaloId(), d.energyDeposited(), d.muonEnergyLoss()))
◆ dump_CaloSamplingData()
| def python.Dumpers.dump_CaloSamplingData |
( |
|
s, |
|
|
|
f |
|
) |
| |
Definition at line 4208 of file Dumpers.py.
4209 nsamp = s.getNumberOfSamplings()
4210 for i
in range(
min(10, s.getNumberOfVariableTypes())):
4212 slist = [s.retrieveData(i, samp)
for samp
in range(nsamp)]
4213 fprint (f,
'\n ', i, slist)
◆ dump_CaloShower()
| def python.Dumpers.dump_CaloShower |
( |
|
s, |
|
|
|
f |
|
) |
| |
Definition at line 4217 of file Dumpers.py.
4218 fprint (f,
' moments:')
4219 dump_CaloClusterMomentStore (s.getMomentStore(), f)
4220 fprint (f,
'\n sampling data:')
4221 dump_CaloSamplingData (s.getSamplingStore(), f)
◆ dump_CaloTopoTowerContainer()
| def python.Dumpers.dump_CaloTopoTowerContainer |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4234 of file Dumpers.py.
4236 dump_CaloTowerContainer (t, f)
4237 fprint (f,
' ', t.GetMinimumCellEnergy(),
4238 t.GetMinimumClusterEnergy(),
4239 t.GetUseCellWeights(),
4243 t.GetCellESignificanceThreshold(),
4244 t.GetCaloSelection())
4245 ci = t.GetCaloIndices()
4247 fprint (f, [ci[i]
for i
in range(ci.size())])
4250 if l.isValid(): fprintln (f, l.dataID())
4251 else: fprintln (f,
'(null)')
4255 if t.GetCellToClusterMap():
4256 fprintln (f,
' ', t.GetCellToClusterMap().
size())
4258 fprintln (f,
' (null)')
◆ dump_CaloTowerContainer()
| def python.Dumpers.dump_CaloTowerContainer |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4226 of file Dumpers.py.
4228 fprintln (f, t.neta(), t.etamin(), t.deta(),
4229 t.nphi(), t.phimin(), t.dphi())
◆ dump_ChamberT0s()
| def python.Dumpers.dump_ChamberT0s |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4463 of file Dumpers.py.
4464 for p
in m.getAllT0s():
4465 fprintln (f,
' ', p.first.getString(), p.second)
◆ dump_clist()
| def python.Dumpers.dump_clist |
( |
|
l, |
|
|
|
f |
|
) |
| |
Definition at line 3712 of file Dumpers.py.
3720 fprint (f,
'%f, ' % last)
3722 fprint (f,
'%d*%f, ' % (n, last))
3729 fprint (f,
'%f, ' % last)
3731 fprint (f,
'%d*%f, ' % (n, last))
◆ dump_ClusterSplitProbabilityContainer()
| def python.Dumpers.dump_ClusterSplitProbabilityContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2083 of file Dumpers.py.
2084 for x
in p.splitProbMap():
2085 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 4993 of file Dumpers.py.
4994 fprint (f, p.crate(), p.dataID(), p.peak(),
4995 formatItemUsingLong (
list(p.HitsVec0())),
4996 formatItemUsingLong (
list(p.HitsVec1())),
4997 list(p.ErrorVec0()),
4998 list(p.ErrorVec1()))
◆ dump_CMMEtSums()
| def python.Dumpers.dump_CMMEtSums |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5002 of file Dumpers.py.
5003 fprint (f, p.crate(), p.dataID(), p.peak(),
5004 formatItemUsingLong (
list(p.EtVec())),
5005 formatItemUsingLong (
list(p.ExVec())),
5006 formatItemUsingLong (
list(p.EyVec())),
5007 list(p.EtErrorVec()),
5008 list(p.ExErrorVec()),
5009 list(p.EyErrorVec()))
◆ dump_CMMJetHits()
| def python.Dumpers.dump_CMMJetHits |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5013 of file Dumpers.py.
5014 fprint (f, p.crate(), p.dataID(), p.peak(),
5015 formatItemUsingLong (
list(p.HitsVec())),
◆ dump_CMMRoI()
| def python.Dumpers.dump_CMMRoI |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5021 of file Dumpers.py.
5022 fprint (f, p.jetEtRoiWord(),
◆ dump_CombinedMuonFeature()
| def python.Dumpers.dump_CombinedMuonFeature |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4169 of file Dumpers.py.
4172 fprint (f, m.pt(), m.eta(), m.phi(), m.m(), m.sigma_pt())
4173 if m.IDTrackLink().
isValid()
and m.IDTrack():
4175 dump_TrigInDetTrack (PyTrigInDetTrack(m.IDTrack()), f)
4176 if m.muFastTrackLink().
isValid()
and m.muFastTrack():
4177 fprint (f,
'\n fast')
4178 dump_MuonFeature (m.muFastTrack(), f)
◆ dump_CombinedMuonFeature_nolist()
| def python.Dumpers.dump_CombinedMuonFeature_nolist |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4183 of file Dumpers.py.
4184 dump_CombinedMuonFeature (m, f)
◆ dump_CompetingMuonClustersOnTrack()
| def python.Dumpers.dump_CompetingMuonClustersOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1740 of file Dumpers.py.
1741 dump_CompetingRIOsOnTrack (p, f)
1742 dump_AmgVector (p.globalPosition(), f)
1743 dump_associatedSurface (p, f)
1744 for r
in p.containedROTs():
1745 fprint (f,
'\n mc ')
1746 dump_MuonClusterOnTrack (r, f)
◆ dump_CompetingRIOsOnTrack()
| def python.Dumpers.dump_CompetingRIOsOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1724 of file Dumpers.py.
1725 dump_MeasurementBase (p, f)
1726 fprint (f, p.indexOfMaxAssignProb())
1727 sz = p.numberOfContainedROTs()
1728 fprint (f, [p.assignmentProbability(i)
for i
in range(sz)])
◆ dump_ComTime()
| def python.Dumpers.dump_ComTime |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2134 of file Dumpers.py.
2135 fprint (f, p.getTTCTime(), p.getTime())
2136 dump_H3V (p.GetCounterPosition(), f)
2137 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 5029 of file Dumpers.py.
5030 fprint (f, p.crate(), p.module(), p.peak(),
5031 formatItemUsingLong (
list(p.HitsVec0())),
5032 formatItemUsingLong (
list(p.HitsVec1())))
◆ dump_CPMRoI()
| def python.Dumpers.dump_CPMRoI |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5036 of file Dumpers.py.
5037 fprint (f, p.roiWord())
◆ dump_CPMTower()
| def python.Dumpers.dump_CPMTower |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5041 of file Dumpers.py.
5042 fprint (f, p.eta(), p.phi(), p.peak(),
5043 list(p.emEnergyVec()),
5044 list(p.hadEnergyVec()),
5045 list(p.emErrorVec()),
5046 list(p.hadErrorVec()))
◆ dump_CscClusterOnTrack()
| def python.Dumpers.dump_CscClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2174 of file Dumpers.py.
2175 dump_MuonClusterOnTrack (p, f)
2176 dump_EL (p.prepRawDataLink(), f)
2177 fprint (f, p.status(), p.timeStatus(), p.time())
2178 if p.detectorElement():
2179 fprint (f, p.detectorElement().identifyHash().
value())
2181 fprint (f,
'(null detEl)')
◆ dump_CscMcData()
| def python.Dumpers.dump_CscMcData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4804 of file Dumpers.py.
4805 fprint (f, p.energy(), p.ypos(), p.zpos(), p.charge())
◆ dump_CscPrepData()
| def python.Dumpers.dump_CscPrepData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4572 of file Dumpers.py.
4573 dump_MuonCluster (p, f)
4574 fprint (f, p.charge(), p.time(), p.status(), p.timeStatus())
4575 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_CscPrepDataContainer()
| def python.Dumpers.dump_CscPrepDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4727 of file Dumpers.py.
4728 dump_IDC (dump_CscPrepData, p, f)
◆ dump_CscRawData()
| def python.Dumpers.dump_CscRawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5325 of file Dumpers.py.
5326 fprint (f, p.address(), p.hashId(), p.identify(), p.rpuID(),
5327 p.time(), p.width(), p.isTimeComputed(),
list(p.samples()))
◆ dump_CscRawDataContainer()
| def python.Dumpers.dump_CscRawDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5331 of file Dumpers.py.
5332 dump_IDC (dump_CscRawData, p, f,
5333 extra_idc_dumper =
lambda p, f: \
5334 fprint (f, p.identify(), p.rodId(), p.subDetectorId(),
5335 p.samplingPhase(), p.triggerType(), p.firstBitSummary(),
5336 p.eventType(), p.scaAddress(),
5337 list(p.rpuID()), [ord(c)
for c
in p.dataType()]))
◆ dump_CscSimData()
| def python.Dumpers.dump_CscSimData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4809 of file Dumpers.py.
4810 fprint (f, p.word())
4811 for d
in p.getdeposits():
4812 dump_HepMcParticleLink (d.first, f)
4813 dump_CscMcData (d.second, f)
◆ dump_CscSimDataCollection()
| def python.Dumpers.dump_CscSimDataCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4818 of file Dumpers.py.
4820 fprint (f, elt.first.getString())
4821 dump_CscSimData (elt.second, f)
◆ dump_CSCSimHit()
| def python.Dumpers.dump_CSCSimHit |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5224 of file Dumpers.py.
5225 fprint (f, p.CSCid(), p.globalTime(), p.energyDeposit())
5226 dump_Threevec (p.getHitStart(), f)
5227 dump_Threevec (p.getHitEnd(), f)
5228 fprint (f, p.particleID(), p.kineticEnergy())
5229 dump_HepMcParticleLink (p.particleLink(), f)
◆ dump_CscStripPrepData()
| def python.Dumpers.dump_CscStripPrepData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4579 of file Dumpers.py.
4580 dump_MuonCluster (p, f)
4581 fprint (f, p.timeOfFirstSample(), p.samplingPhase(), p.samplingTime())
4582 fprint (f,
list(p.sampleCharges()))
4583 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_CscStripPrepDataContainer()
| def python.Dumpers.dump_CscStripPrepDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4733 of file Dumpers.py.
4734 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 5051 of file Dumpers.py.
5052 fprint (f, p.getCTPVersionNumber(),
5053 p.getCTPVersion().getVersionNumber(),
5054 formatItemUsingLong (
list(p.getDataWords())),
5055 p.getL1AcceptBunchPosition(),
5057 p.getNumberOfBunches(),
5058 p.getNumberOfAdditionalWords())
◆ dump_CTPConfig()
| def python.Dumpers.dump_CTPConfig |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 3203 of file Dumpers.py.
3204 dump_L1DataBaseclass (c, f)
◆ dump_CTPResult()
| def python.Dumpers.dump_CTPResult |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5127 of file Dumpers.py.
5128 dump_ROIBHeader (p.header(), f)
5129 for r
in p.roIVec():
5131 dump_ROIBTrailer (p.trailer(), f)
◆ dump_CTPRoI()
| def python.Dumpers.dump_CTPRoI |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5122 of file Dumpers.py.
5123 fprint (f, p.roIWord())
◆ dump_CurvilinearParameters()
| def python.Dumpers.dump_CurvilinearParameters |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1598 of file Dumpers.py.
1599 dump_ParametersBase (info, f)
1600 fprint (f,
'\n curvilinear')
1601 fprint (f, info.cIdentifier())
1602 mat = info.measurementFrame()
1603 dump_AmgVector (mat.col(0), f)
1604 dump_AmgVector (mat.col(1), f)
1605 dump_AmgVector (mat.col(2), f)
◆ dump_CylinderSurface()
| def python.Dumpers.dump_CylinderSurface |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1531 of file Dumpers.py.
1532 dump_Surface (info, f)
◆ dump_DetailedTrackTruthCollection()
| def python.Dumpers.dump_DetailedTrackTruthCollection |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 1456 of file Dumpers.py.
1457 fprint (f,
' ', c.trackCollectionLink().
key(), c.size())
1459 fprint (f,
'\n %3d' % p.first.index(),
' common ')
1460 dump_SubDetHitStatistics (p.second.statsCommon(), f)
1461 fprint (f,
'\n ',
' track ')
1462 dump_SubDetHitStatistics (p.second.statsTrack(), f)
1463 fprint (f,
'\n ',
' truth ')
1464 dump_SubDetHitStatistics (p.second.statsTruth(), f)
1465 fprint (f,
'\n ',
' trajectory ')
1466 dump_TruthTrajectory (p.second.trajectory(), f)
◆ dump_DetStatus()
| def python.Dumpers.dump_DetStatus |
( |
|
s, |
|
|
|
f |
|
) |
| |
Definition at line 3268 of file Dumpers.py.
3269 fprintln (f, s.code(),
◆ dump_DetStatusMap()
| def python.Dumpers.dump_DetStatusMap |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 3278 of file Dumpers.py.
3281 dump_DetStatus (e.second, f)
◆ dump_DiscSurface()
| def python.Dumpers.dump_DiscSurface |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1536 of file Dumpers.py.
1537 dump_Surface (info, f)
◆ dump_eflowObject()
| def python.Dumpers.dump_eflowObject |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 4510 of file Dumpers.py.
4512 fprint (f, e.eflowType(), e.isValid(), e.d0(), e.z0(),
4513 e.getPassEOverPCheck(), e.getIsSubtracted(),
4514 e.getIsDuplicated(), e.getCaloRecoStatus().getStatusWord())
4515 for i
in range(e.numTrack()):
4516 fprint (f,
'\n tk: ')
4517 dump_EL (e.trackLink(i), f)
4518 for i
in range(e.numClus()):
4519 fprint (f,
'\n cl: ')
4520 dump_EL (e.clusLink(i), f)
4521 fprint (f,
'\n mu: ')
4522 dump_EL (e.muonLink(), f)
4523 fprint (f,
'\n cv: ')
4524 dump_EL (e.conversionLink(), f)
◆ dump_eflowObjectContainer()
| def python.Dumpers.dump_eflowObjectContainer |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 4529 of file Dumpers.py.
4530 print (c.missET(), c.sumET(), c.pTx(), c.pTy(), c.numEf(),
4531 c.numPhot(), c.numEle(), c.numMuo(), c.isValid(),
4532 c.circularity(), c.thrust(), c.oblateness(),
4534 dump_list (c, f, dump_eflowObject)
◆ dump_egamma()
| def python.Dumpers.dump_egamma |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 547 of file Dumpers.py.
549 dump_ParticleImpl (e, f)
550 fprint (f,
"\n %d %d %d" % (e.author(), e.isem(), e.isemse()))
551 if e.clusterElementLink().
isValid():
552 fprint (f,
'\n cl: %2d:' % e.clusterElementLink().
index())
553 dump_Fourvec (e.cluster(), f)
554 for i
in range(e.nTrackParticles()):
555 tp = e.trackParticleElementLink(i)
557 fprint (f,
'\n tp: %2d:' %tp.index())
558 dump_Fourvec (e.trackParticle(i), f)
559 for i
in range(e.nConversions()):
560 cv = e.conversionElementLink(i)
562 fprint (f,
'\n cv: %2d:' % cv.index())
563 dump_Threevec (e.conversion(i).recVertex().position(), f)
564 for i
in range (e.nDetails()):
565 if e.detailElementLink(i).
isValid():
567 fprint (f,
'\n %s: ' % d.className())
568 if isinstance (d, PyAthena.EMConvert):
569 dump_EMConvert (d, f)
570 elif isinstance (d, PyAthena.EMBremFit):
571 dump_EMBremFit (d, f)
572 elif isinstance (d, PyAthena.EMTrackMatch):
573 dump_EMTrackMatch (d, f)
574 elif isinstance (d, PyAthena.EMShower):
576 elif isinstance (d, PyAthena.EMErrorDetail):
577 dump_EMErrorDetail (d, f)
578 elif isinstance (d, PyAthena.EMTrackFit):
579 dump_EMTrackFit (d, f)
583 fprint (f,
'\n Detail link %d not valid; skipped.' % i)
585 pid = PyAthena.egammaPIDObs
587 pid = PyAthena.egammaPID
588 fprint (f,
'\n pid: %g %g %f %g %f %f' %
589 (e.egammaID(pid.ElectronWeight), e.egammaID(pid.BgWeight),
590 e.egammaID(pid.NeuralNet), e.egammaID(pid.Hmatrix),
591 e.egammaID(pid.IsolationLikelihood_jets),
592 e.egammaID(pid.IsolationLikelihood_HQDelectrons)))
◆ dump_egDetailContainer()
| def python.Dumpers.dump_egDetailContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2058 of file Dumpers.py.
2059 fprint (f,
'(Dumped as a part of egamma)')
◆ dump_EL()
| def python.Dumpers.dump_EL |
( |
|
l, |
|
|
|
f |
|
) |
| |
Definition at line 329 of file Dumpers.py.
332 pos2 = nm.rfind (
'>')
333 nm = nm[pos1+1:pos2].strip()
337 nm = nm +
'/%s[%d]' % (l.dataID(), l.index())
◆ dump_Electron()
| def python.Dumpers.dump_Electron |
( |
|
e, |
|
|
|
f |
|
) |
| |
◆ dump_ElectronAssociation()
| def python.Dumpers.dump_ElectronAssociation |
( |
|
a, |
|
|
|
f |
|
) |
| |
Definition at line 3505 of file Dumpers.py.
3506 dump_JetAssociationBase (a, f)
3509 fprint (f, a.getElectronWeight (ele))
3510 dump_Fourvec (ele, f)
◆ dump_ElectronConstituent()
| def python.Dumpers.dump_ElectronConstituent |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1320 of file Dumpers.py.
1322 dump_Fourvec (info.electron(), f)
1323 fprint (f, info.getElectronWeight (info.electron()))
◆ dump_ElectronMuonTopoInfo()
| def python.Dumpers.dump_ElectronMuonTopoInfo |
( |
|
a, |
|
|
|
f |
|
) |
| |
Definition at line 3480 of file Dumpers.py.
3481 fprint (f, a.RoiWord(), a.DeltaPhi(), a.DeltaR(), a.InvMass(),
3482 a.ElecValid(), a.OppositeCharge(), a.VertexState())
◆ dump_EMBremFit()
| def python.Dumpers.dump_EMBremFit |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 379 of file Dumpers.py.
381 iperr = d.bremInvpTerr()
383 if iperr==-999: iperr = 0
386 if br == -999: br = 0
387 if bx == -999: bx = 0
390 if nt == -999: nt = 0
391 if nr == -999: nr = 0
394 if d0 == -999: d0 = 0
395 if phi0 == -999: phi0 = 0
396 fprint (f,
"%f %f %f %f %f %2d %2d %2d %2d %f %f" %
397 (ip*1e6, br, bx, iperr*1e6,
398 d.bremClusterRadius(), d.bremFitStatus(), d.bremErrorFlag(),
400 fprint (f, d.bremZ0(), d.bremDzDr(), d.bremNZ(), d.bremFitChi2())
◆ dump_EMConvert()
| def python.Dumpers.dump_EMConvert |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 375 of file Dumpers.py.
376 fprint (f, d.convTrackMatch(), d.convAngleMatch())
◆ dump_EMErrorDetail()
| def python.Dumpers.dump_EMErrorDetail |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 442 of file Dumpers.py.
443 fprint (f, d.linkIndex())
445 uf(d.EMconvertedphoton_perigee_d0()),
446 uf(d.EMconvertedphoton_perigee_z0()),
447 uf(d.EMconvertedphoton_perigee_phi0()),
448 uf(d.EMconvertedphoton_perigee_theta()),
449 uf(d.EMconvertedphoton_perigee_eta()),
450 uf(d.EMconvertedphoton_perigee_momentum()),
451 uf(d.EMconvertedphoton_perigee_Covd0d0 ()),
452 uf(d.EMconvertedphoton_perigee_Covd0z0 ()),
453 uf(d.EMconvertedphoton_perigee_Covd0phi ()),
454 uf(d.EMconvertedphoton_perigee_Covd0theta ()),
455 uf(d.EMconvertedphoton_perigee_Covz0z0 ()),
456 uf(d.EMconvertedphoton_perigee_Covz0phi ()),
457 uf(d.EMconvertedphoton_perigee_Covz0theta ()),
458 uf(d.EMconvertedphoton_perigee_Covphiphi ()),
459 uf(d.EMconvertedphoton_perigee_Covphitheta ()),
460 uf(d.EMconvertedphoton_perigee_Covthetatheta ()))
462 uf(d.EMtrack_perigee_d0 ()),
463 uf(d.EMtrack_perigee_phi0 ()),
464 uf(d.EMtrack_perigee_z0 ()),
465 uf(d.EMtrack_perigee_theta ()),
466 uf(d.EMtrack_perigee_eta ()),
467 uf(d.EMtrack_perigee_momentum ()),
468 uf(d.EMtrack_perigee_Covd0d0 ()),
469 uf(d.EMtrack_perigee_Covd0z0 ()),
470 uf(d.EMtrack_perigee_Covd0phi ()),
471 uf(d.EMtrack_perigee_Covd0theta ()),
472 uf(d.EMtrack_perigee_Covz0z0 ()),
473 uf(d.EMtrack_perigee_Covz0phi ()),
474 uf(d.EMtrack_perigee_Covz0theta ()),
475 uf(d.EMtrack_perigee_Covphiphi ()),
476 uf(d.EMtrack_perigee_Covphitheta ()),
477 uf(d.EMtrack_perigee_Covthetatheta ()))
479 uf(d.EMphoton_eta ()),
480 uf(d.EMphoton_phi0 ()),
481 uf(d.EMphoton_Eclus ()),
482 uf(d.EMphoton_Covetaeta ()),
483 uf(d.EMphoton_Covetaphi ()),
484 uf(d.EMphoton_CovetaEclus ()),
485 uf(d.EMphoton_Covphiphi ()),
486 uf(d.EMphoton_CovphiEclus ()),
487 uf(d.EMphoton_CovEclusEclus ()))
489 uf(d.EMtrack_comb_Covd0d0 ()),
490 uf(d.EMtrack_comb_Covd0z0 ()),
491 uf(d.EMtrack_comb_Covd0phi ()),
492 uf(d.EMtrack_comb_Covd0eta ()),
493 uf(d.EMtrack_comb_Covd0P ()),
494 uf(d.EMtrack_comb_Covz0z0 ()),
495 uf(d.EMtrack_comb_Covz0phi ()),
496 uf(d.EMtrack_comb_Covz0eta ()),
497 uf(d.EMtrack_comb_Covz0P ()),
498 uf(d.EMtrack_comb_Covphiphi ()),
499 uf(d.EMtrack_comb_Covphieta ()),
500 uf(d.EMtrack_comb_CovphiP ()),
501 uf(d.EMtrack_comb_Covetaeta ()),
502 uf(d.EMtrack_comb_CovetaP ()),
503 uf(d.EMtrack_comb_CovPP ()))
◆ dump_EMShower()
| def python.Dumpers.dump_EMShower |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 410 of file Dumpers.py.
412 if weta1 < -10: weta1 = 0
414 if pos7 < -10: pos7 = 0
416 if not hasattr(d,
'etconoisedR04Sig2'):
417 d.etconoisedR04Sig2 = d.etconoise20
418 d.etconoisedR04Sig3 = d.etconoise30
419 fprint (f, d.e011(), d.e033(), d.ethad1(),
420 d.ethad(), d.ehad1(), d.f1(), d.f3(), d.f1core(), d.f3core(),
421 d.e233(), d.e235(), d.e255(), d.e237(), d.e277(), d.e333(),
422 d.e335(), d.e337(), d.e377(), weta1, d.weta2(), d.e2ts1(),
423 d.e2tsts1(), d.fracs1(), d.widths1(), d.widths2(),
424 d.poscs1(), d.poscs2(), d.asy1(), d.pos(), pos7, d.barys1(),
425 d.wtots1(), d.emins1(), d.emaxs1(), d.etcone(), d.etcone20(),
426 d.etcone30(), d.etcone40(),
427 d.etconoisedR04Sig2(), d.etconoisedR04Sig3(),
429 if hasattr (d,
'e131'):
430 fprint (f, d.e131(), d.e1153(), d.iso())
432 fprint (f, d.e132(), d.e1152(), d.r33over37allcalo())
◆ dump_EmTau_ROI()
| def python.Dumpers.dump_EmTau_ROI |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2983 of file Dumpers.py.
2985 fprint (f,
"%d %f %f %f %f %f %f %d" %
2994 for (n,v)
in zip (m.getThresholdNames(), m.getThresholdValues()):
◆ dump_EMTauResult()
| def python.Dumpers.dump_EMTauResult |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5153 of file Dumpers.py.
5154 dump_ROIBHeader (p.header(), f)
5155 for r
in p.roIVec():
5156 dump_EMTauRoI (r, f)
5157 dump_ROIBTrailer (p.trailer(), f)
◆ dump_EMTauRoI()
| def python.Dumpers.dump_EMTauRoI |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5148 of file Dumpers.py.
5149 fprint (f, p.roIWord())
◆ dump_EMTrackFit()
| def python.Dumpers.dump_EMTrackFit |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 507 of file Dumpers.py.
509 d.track_perigee_d0 (),
510 d.track_perigee_phi0 (),
511 d.track_perigee_qOverP(),
512 d.track_perigee_z0 (),
513 d.track_perigee_theta (),
514 d.track_perigee_Covd0d0 (),
515 d.track_perigee_Covd0z0 (),
516 d.track_perigee_Covd0phi (),
517 d.track_perigee_Covd0theta (),
518 d.track_perigee_Covd0qOverP (),
519 d.track_perigee_Covz0z0 (),
520 d.track_perigee_Covz0phi (),
521 d.track_perigee_Covz0theta (),
522 d.track_perigee_Covz0qOverP (),
523 d.track_perigee_Covphiphi (),
524 d.track_perigee_Covphitheta (),
525 d.track_perigee_CovphiqOverP (),
526 d.track_perigee_Covthetatheta (),
527 d.track_perigee_CovthetaqOverP (),
528 d.track_perigee_CovqOverPqOverP ())
530 d.track_LastM_loc1 (),
531 d.track_LastM_loc2 (),
532 d.track_LastM_phi (),
533 d.track_LastM_theta (),
534 d.track_LastM_qOverP (),
535 d.bremTrackAuthor (),
541 d.bremMaterialTraversed (),
◆ dump_EMTrackMatch()
| def python.Dumpers.dump_EMTrackMatch |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 403 of file Dumpers.py.
404 fprint (f,
"%f %f %4d %4d" %
405 (d.deltaEta(2), d.deltaPhi(2),
406 d.trackNumber(), d.tracksInBroadWindow()))
407 fprint (f, d.trackRefit(), d.isPrimary())
◆ dump_EnergyLoss()
| def python.Dumpers.dump_EnergyLoss |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 604 of file Dumpers.py.
608 fprint (f, p.deltaE(), p.sigmaDeltaE(), p.sigmaMinusDeltaE(), p.sigmaPlusDeltaE())
609 fprint (f, p.meanIoni(), p.sigmaIoni(), p.meanRad(), p.sigmaRad(), p.length())
◆ dump_EnergySum_ROI()
| def python.Dumpers.dump_EnergySum_ROI |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 3020 of file Dumpers.py.
3021 fprint (f,
"%d %d %d %f %f %f %f %f %d %d %d %d %d %d" %
3034 m.getThrPatSummET(),
3035 m.getThrPatMissET()))
3036 fprint (f, [t
for t
in m.getThresholds()])
◆ dump_EventBookkeeper()
| def python.Dumpers.dump_EventBookkeeper |
( |
|
p, |
|
|
|
f, |
|
|
|
level = 0 |
|
) |
| |
Definition at line 5278 of file Dumpers.py.
5279 fprint (f, p.getName(), p.getDescription(), p.getInputStream(), p.getOutputStream(), p.getLogic(), p.getNAcceptedEvents(), p.getNWeightedAcceptedEvents(), p.getCycle())
5280 for c
in list(p.getChildrenEventBookkeepers()):
5281 fprint (f,
'\n ' + (
' '*level))
5282 dump_EventBookkeeper (c, f, level+1)
◆ dump_EventID()
| def python.Dumpers.dump_EventID |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 2723 of file Dumpers.py.
2724 fprint (f,
'%9d %9d %9d %9d %9d %9d' %
2728 e.time_stamp_ns_offset(),
2730 e.bunch_crossing_id()))
◆ dump_EventInfo()
| def python.Dumpers.dump_EventInfo |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 2748 of file Dumpers.py.
2749 fprint (f, e.clID())
2750 dump_EventID (e.event_ID(), f)
2752 fprint (f, e.actualInteractionsPerCrossing(), e.averageInteractionsPerCrossing())
2753 for i
in range(ROOT.EventInfo.nDets):
2754 fprint (f,
'\n det', i, e.eventFlags(i), e.errorState(i))
2756 dump_EventType (e.event_type(), f)
2758 dump_TriggerInfo (e.trigger_info(), f)
◆ dump_EventStreamInfo()
| def python.Dumpers.dump_EventStreamInfo |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 2771 of file Dumpers.py.
2772 fprint (f,
'nevents: ', e.getNumberOfEvents())
2775 fprint (f,
'\nproc tags: ',
list(e.getProcessingTags()))
2776 fprint (f,
'\nitem list: ',
formatItemUsingLong([(p.first, p.second)
for p
in e.getItemList()]))
2777 for typ
in list(e.getEventTypes()):
2779 dump_EventType (typ, f)
◆ dump_EventType()
| def python.Dumpers.dump_EventType |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 2734 of file Dumpers.py.
2735 fprint (f, e.typeToString(), e.user_type(), e.mc_event_weight())
◆ dump_ExtendedVxCandidate()
| def python.Dumpers.dump_ExtendedVxCandidate |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 3667 of file Dumpers.py.
3668 dump_VxCandidate1 (c, f)
3670 if c.fullCovariance():
3671 dump_AmgMatrix (c.fullCovariance(), f)
◆ dump_FitQuality()
| def python.Dumpers.dump_FitQuality |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1470 of file Dumpers.py.
1472 fprint (f,
'(null)')
1474 fprint (f,
'%f %f' % (info.chiSquared(), info.doubleNumberDoF()))
◆ dump_Fourvec()
| def python.Dumpers.dump_Fourvec |
( |
|
v, |
|
|
|
f, |
|
|
|
parens = 1 |
|
) |
| |
Definition at line 233 of file Dumpers.py.
234 ParticleImpl_EEtaPhiM = getattr(PyAthena,
'ParticleImpl<NavigableTerminalNode,P4ImplEEtaPhiM,ParticleEvent::Base>')
238 if isinstance(v, (PyAthena.P4EEtaPhiMBase, ParticleImpl_EEtaPhiM, PyAthena.xAOD.IParticle))
or \
239 isinstance(vmom, PyAthena.P4BaseEEtaPhiM):
246 elif isinstance (v, PyAthena.P4PtEtaPhiMBase)
or \
247 isinstance (vmom, PyAthena.P4BasePtEtaPhiM):
251 elif isinstance (v, PyAthena.P4IPtCotThPhiMBase)
or \
252 isinstance (vmom, PyAthena.P4BaseIPtCotThPhiM):
258 if ipt == 0
and m == 0
and cotth == 0
and v.phi() == 0:
262 aux = math_hypot(1, cotth)
263 eta = math_log ((aux-cotth) / (aux+cotth))
272 m2 = v.e()**2 - v.px()**2 - v.py()**2 - v.pz()**2
274 m = - math_sqrt (-m2)
279 pt = math_hypot (v.px(), v.py())
286 eta = asinh (v.pz() / pt)
289 if parens: fprint (f,
'(')
290 fprint (f,
"%f %f %f %f" % (pt, eta, v.phi(), m))
291 if parens: fprint (f,
')')
◆ dump_GbbNNTagInfo()
| def python.Dumpers.dump_GbbNNTagInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1290 of file Dumpers.py.
1291 dump_BaseTagInfo (info, f)
1292 fprint (f, info.nMatchingTracks(), info.trkJetWidth(),
1293 info.trkJetMaxDeltaR())
◆ dump_GenericResult()
| def python.Dumpers.dump_GenericResult |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3060 of file Dumpers.py.
3061 fprint (f,
"%d %d %d" %
◆ dump_GenEvent()
| def python.Dumpers.dump_GenEvent |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 2928 of file Dumpers.py.
2929 fprint (f,
'%d %d %f %f %f %d %d' %
2937 fprint (f,
'\n wt', [w
for w
in e.weights()], \
2942 dump_GenVertex (sv, f)
2947 dump_GenVertex (v, f)
2954 dump_GenParticle (p, f)
◆ dump_GenParticle()
| def python.Dumpers.dump_GenParticle |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2889 of file Dumpers.py.
2890 fprint (f,
"%d %5s %d %d" %
2892 PDG.pdgid_to_name(p.pdg_id()),
2893 p.parent_event().event_number(),
2895 if p.production_vertex():
2896 s =
str(_gen_barcode (p.production_vertex())) +
'('
2897 parts = genvertex_in_barcodes (p.production_vertex())
2898 for bc
in parts: s +=
'%d ' % bc
2899 if len(parts) > 3: s +=
'...'
2905 s = str (_gen_barcode (p.end_vertex())) +
'(->'
2906 parts = genvertex_out_barcodes (p.end_vertex())
2907 for bc
in parts: s +=
'%d ' % bc
2908 if len(parts) > 3: s +=
'...'
2913 dump_HLV (p.momentum(), f)
2914 if hasattr (p,
'polarization'):
2915 pol = p.polarization()
2916 poltheta = fix_neg0 (pol.theta())
2917 fprint (f,
"%f %f" % (poltheta, pol.phi()))
2918 if pol.normal3d().
theta() != 0
or pol.normal3d().
phi() != 0:
2919 fprint (f,
"%f %f" %
2920 (pol.normal3d().
theta(), pol.normal3d().
phi()))
2922 poltheta = fix_neg0 (
_gen_attr(p,
'theta', float))
2924 fprint (f,
"%f %f" % (poltheta, polphi))
◆ dump_GenVertex()
| def python.Dumpers.dump_GenVertex |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 2862 of file Dumpers.py.
2863 fprint (f,
"%d %d %d %d %d" %
2864 (v.status()
if hasattr(v,
'status')
else v.id(),
2866 v.parent_event().event_number(),
2869 dump_Threevec (v.position(), f)
2870 fprint (f,
'%f ' % v.position().
t())
2871 if not hasattr(v,
'weights'):
2873 elif v.weights().
size() == 0:
2876 ww =
list(v.weights())
2877 fprintln (f, [w
for w
in ww])
◆ dump_H3V()
| def python.Dumpers.dump_H3V |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 203 of file Dumpers.py.
204 fprint (f,
"(%f %f %f)" %
205 (v.perp(),v.eta(),v.phi()))
◆ dump_HepMcParticleLink()
| def python.Dumpers.dump_HepMcParticleLink |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4280 of file Dumpers.py.
4281 fprint (f, p.barcode(), p.eventIndex())
◆ dump_HLTAODConfigData()
| def python.Dumpers.dump_HLTAODConfigData |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 3186 of file Dumpers.py.
3189 for c
in d.getChainList().
chains():
3191 dump_HLTChain (c, f)
3192 for c
in d.getSequenceList().sequences():
3194 dump_HLTSequence (c, f)
◆ dump_HLTChain()
| def python.Dumpers.dump_HLTChain |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 3155 of file Dumpers.py.
3156 fprint (f, c.chain_name(),
3160 c.lower_chain_name(),
3161 c.lower_chain_counter(),
3165 c.lower_chain_hash_id())
3166 for s
in c.signatureList():
3167 dump_HLTSignature (s, f)
3168 fprint (f, [t.bit()
for t
in c.triggerTypeList()])
3169 for s
in c.streamTagList():
3170 dump_HLTStreamTag (s, f)
3171 fprint (f, [s
for s
in c.groupList()])
◆ dump_HLTResult()
| def python.Dumpers.dump_HLTResult |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3069 of file Dumpers.py.
3070 dump_GenericResult (t, f)
3071 fprint (f,
"%d %d %d %d %d %d %d %d %d %d %d %d" %
3072 (t.getHLTResultClassVersion(),
3075 t.getHLTStatus().code,
3076 t.getLvlConverterStatus().code,
3079 t.getNumOfSatisfiedSigs(),
3080 t.isCreatedOutsideHLT(),
3081 t.isHLTResultTruncated(),
3085 fprint (f, [i
for i
in t.partSizes()])
3086 fprint (f, [i
for i
in t.getNavigationResult()])
3087 fprint (f, [i
for i
in t.getChainResult()])
3088 fprint (f, [i
for i
in t.getNavigationResultCuts()])
◆ dump_HLTResultMT()
| def python.Dumpers.dump_HLTResultMT |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 3093 of file Dumpers.py.
3094 fprint (f,
'version', p.getVersion())
3095 fprint (f,
'\n streamtags',
list(p.getStreamTags()))
3098 fprint (f,
'\n hltbits',
list(p.getHltBitsAsWords()))
3099 fprint (f,
'\n data size', p.getSerialisedData().
size())
3101 fprint (f,
'\n status',
list(p.getStatus()))
3102 fprint (f,
'\n trunc', p.severeTruncation(),
list(p.getTruncatedModuleIds()))
◆ dump_HLTSequence()
| def python.Dumpers.dump_HLTSequence |
( |
|
s, |
|
|
|
f |
|
) |
| |
Definition at line 3175 of file Dumpers.py.
3177 dump_HLTTriggerElement (s.outputTE(), f)
3178 dump_HLTTriggerElement (s.topoStartTE(), f)
3179 for t
in s.inputTEs():
3180 dump_HLTTriggerElement (t, f)
3181 fprint (f, [a
for a
in s.algorithms()],
')')
◆ dump_HLTSignature()
| def python.Dumpers.dump_HLTSignature |
( |
|
s, |
|
|
|
f |
|
) |
| |
Definition at line 3136 of file Dumpers.py.
3137 fprint (f,
'(', s.signature_counter(),
3140 for e
in s.outputTEs():
3141 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 3131 of file Dumpers.py.
3132 fprint (f, e.id(), e.name())
◆ dump_HLV()
| def python.Dumpers.dump_HLV |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 208 of file Dumpers.py.
209 m2 = v.e()**2 - v.px()**2 - v.py()**2 - v.pz()**2
211 m2 = fix_neg0 (m2, 1e-3)
213 m = - math_sqrt (-m2)
219 pt = math_hypot (v.px(), v.py())
226 eta = asinh (v.pz() / pt)
228 fprint (f,
"(%f %f %f %f)" %
229 (v.perp(),eta,v.phi(), m))
◆ dump_IDC()
| def python.Dumpers.dump_IDC |
( |
|
payload_dumper, |
|
|
|
p, |
|
|
|
f, |
|
|
|
extra_idc_dumper = None |
|
) |
| |
Definition at line 4697 of file Dumpers.py.
4697 def dump_IDC (payload_dumper, p, f, extra_idc_dumper = None):
4700 if hasattr(beg.__class__,
'__preinc__'):
4701 nextfunc = beg.__preinc__
4702 elif hasattr(beg.__class__,
'__next__'):
4703 nextfunc = beg.__next__
4708 if hasattr (coll,
'identifyHash'):
4709 hash = coll.identifyHash().
value()
4711 hash = coll.identifierHash().
value()
4712 fprint (f,
'IDC', beg.hashId().
value(), hash, coll.size())
4713 if hasattr (coll,
'type'):
4714 fprint (f, coll.type())
4715 if extra_idc_dumper:
4716 extra_idc_dumper (coll, f)
4719 payload_dumper (x, f)
◆ dump_IDCInDetBSErrContainer()
| def python.Dumpers.dump_IDCInDetBSErrContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1790 of file Dumpers.py.
1791 for x
in p.getAll():
1792 fprint (f,
'\n ', x.first, x.second)
◆ dump_IdentContIndex()
| def python.Dumpers.dump_IdentContIndex |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4549 of file Dumpers.py.
4550 fprint (f, p.collHash(), p.objIndex())
◆ dump_INav4MomAssocs()
| def python.Dumpers.dump_INav4MomAssocs |
( |
|
a, |
|
|
|
f |
|
) |
| |
Definition at line 3471 of file Dumpers.py.
3472 return dump_Assocs (a, f, PyAthena.DataVector(PyAthena.INavigable4Momentum))
◆ dump_InDetLowBetaCandidate()
| def python.Dumpers.dump_InDetLowBetaCandidate |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4401 of file Dumpers.py.
4402 if p == InDetLowBetaCandidateNull:
4403 fprint (f,
'(null)')
4405 if hasattr (p,
'getTRTInverseBeta'):
4406 fprint (f, p.getTRTCorrBitsOverThreshold(),
4407 p.getTRTInverseBeta(),
4408 p.getTRTInverseBetaError(),
4409 p.getTRTNLastBits())
4411 fprint (f, p.getTRTCorrBitsOverThreshold(),
4412 p.getTRTTrailingEdge(),
4413 p.getTRTTrailingEdgeError(),
4414 p.getTRTNLastBits())
4415 others = (p.getTRTdEdx(),
4416 p.getTRTLikelihoodBeta(),
4417 p.getTRTLikelihoodError(),
4418 p.getTRTHighTbits(),)
4419 if max(others)!=0
or min(others) != 0:
4420 for o
in others: fprint (f, o)
◆ dump_InDetRawData()
| def python.Dumpers.dump_InDetRawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4674 of file Dumpers.py.
4675 fprint (f, p.identify().getString(), p.getWord())
◆ dump_InDetSimData()
| def python.Dumpers.dump_InDetSimData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2089 of file Dumpers.py.
2091 fprint (f,
'(null)')
2093 fprint (f, p.word())
2094 for d
in p.getdeposits():
2096 dump_HepMcParticleLink (d.first, f)
2097 fprint (f, d.second)
◆ dump_InDetSimDataCollection()
| def python.Dumpers.dump_InDetSimDataCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2102 of file Dumpers.py.
2103 getData = ROOT.InDetSimDataHelpers.getData
2104 for id
in ROOT.InDetSimDataHelpers.identifiers(p):
2105 fprint (f,
'\n ', id.getString())
2106 dump_InDetSimData (getData (p, id), f)
◆ dump_InDetTime()
| def python.Dumpers.dump_InDetTime |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1784 of file Dumpers.py.
1785 fprint (f, p.first, p.second)
◆ dump_IPInfoBase()
| def python.Dumpers.dump_IPInfoBase |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1146 of file Dumpers.py.
1147 dump_BaseTagInfo (info, f)
1148 fprint (f, info.nbTracks())
◆ dump_IPInfoPlus()
| def python.Dumpers.dump_IPInfoPlus |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1137 of file Dumpers.py.
1138 dump_BaseTagInfo (info, f)
1139 fprint (f,
' %d' % info.numTrackInfo())
1140 for i
in range(info.numTrackInfo()):
1142 dump_IPTrackInfo (info.getTrackInfo(i), f)
◆ dump_IPTrackInfo()
| def python.Dumpers.dump_IPTrackInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1122 of file Dumpers.py.
1123 dump_Fourvec (info.track(), f)
1124 fprint (f,
' %d %s %d %f %f %f %f %f %f %f' %
1125 (info.trackGrade().gradeNumber(),
1126 info.trackGrade().gradeString(),
1129 info.d0Significance(),
1131 info.z0Significance(),
1132 info.trackWeight2D(),
1133 info.trackWeight3D(),
1134 info.trackProbJP()))
◆ dump_IsoMuonFeature()
| def python.Dumpers.dump_IsoMuonFeature |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4340 of file Dumpers.py.
4342 fprint (f,
'\n ', m.getEtInnerConeEC(), m.getEtOuterConeEC(),
4343 m.getEtInnerConeHC(), m.getEtOuterConeHC())
4344 fprint (f,
'\n ', m.getNTracksCone(), m.getSumPtTracksCone(),
4345 m.getPtMuTracksCone())
4346 fprint (f,
'\n ', m.getRoiIdMu(), m.getPtMu(), m.getEtaMu(),
4347 m.getPhiMu(), m.getLArWeight(), m.getTileWeight())
◆ dump_ISvxAssociation()
| def python.Dumpers.dump_ISvxAssociation |
( |
|
a, |
|
|
|
f |
|
) |
| |
Definition at line 3543 of file Dumpers.py.
3544 dump_JetAssociationBase (a, f)
3547 for v
in vi.vertices():
3548 dump_Threevec (v.position(), f)
◆ dump_ITrackLink()
| def python.Dumpers.dump_ITrackLink |
( |
|
l, |
|
|
|
f |
|
) |
| |
Definition at line 2612 of file Dumpers.py.
2616 pm = trk.trackParameters()
2617 if pm
and len(pm) > 0:
2619 dump_parameters (perigee, f)
◆ dump_JEMEtSums()
| def python.Dumpers.dump_JEMEtSums |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5070 of file Dumpers.py.
5071 fprint (f, p.crate(), p.module(), p.peak(),
5072 formatItemUsingLong (
list(p.EtVec())),
5073 formatItemUsingLong (
list(p.ExVec())),
5074 formatItemUsingLong (
list(p.EyVec())))
◆ dump_JEMHits()
| def python.Dumpers.dump_JEMHits |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5078 of file Dumpers.py.
5079 fprint (f, p.crate(), p.module(), p.peak(),
5080 formatItemUsingLong (
list(p.JetHitsVec())))
◆ dump_JEMRoI()
| def python.Dumpers.dump_JEMRoI |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5084 of file Dumpers.py.
5085 fprint (f, p.roiWord())
◆ dump_Jet()
| def python.Dumpers.dump_Jet |
( |
|
j, |
|
|
|
f |
|
) |
| |
Definition at line 3555 of file Dumpers.py.
3556 if j.e() == 0
and j.phi() == 0
and j.eta() == 0:
3557 with signalstate (j, PyAthena.P4SignalState.JETEMSCALE):
3558 dump_ParticleImpl (j, f)
3560 dump_ParticleImpl (j, f)
3561 fprint (f,
'\n %s %f' %
3563 j.getFlavourTagWeight(),))
3565 tower_constituents_p =
False
3566 if j.firstConstituent() != j.lastConstituent():
3567 if isinstance (j.getContainer(j.firstConstituent()),
3568 PyAthena.CaloTowerContainer):
3569 tower_constituents_p =
True
3570 elif j.firstConstituent().__deref__():
3571 ss =
asint(j.constituentSignalState())
3572 j.setConstituentSignalState (PyAthena.P4SignalState.CALIBRATED)
3573 dump_HLV (j.constituent_sum4Mom(), f)
3574 j.setConstituentSignalState (ss)
3575 fprint (f, [x
for x
in j.combinedLikelihood()])
3576 fprint (f,
'\n moms ')
3577 for mk
in j.getMomentKeys():
3578 if mk
in [
'Timing',
'LArQuality']:
continue
3579 mom = j.getMoment (mk,
False)
3581 fprint (f, mk, j.getMoment (mk,
True))
3582 if hasattr(j,
'getJetTime'):
3583 fprint (f,
'\n timing ', j.getJetTime(),
3584 ' qual ', j.getJetQuality())
3586 fprint (f,
'\n timing ', j.getMoment(
'Timing',
True),
3587 ' qual ', j.getMoment(
'LArQuality',
True))
3588 fprint (f,
'\n assoc ')
3589 for ak
in j.getAssociationKeys():
3590 ass = j.getAssociationBase(ak)
3591 if ass == jetAssocNull :
continue
3592 fprint (f,
'\n ', ak)
3593 if isinstance (ass, PyAthena.Analysis.ElectronAssociation):
3594 dump_ElectronAssociation (ass, f)
3595 elif isinstance (ass, PyAthena.Analysis.PhotonAssociation):
3596 dump_PhotonAssociation (ass, f)
3597 elif isinstance (ass, PyAthena.Analysis.MuonAssociation):
3598 dump_MuonAssociation (ass, f)
3599 elif isinstance (ass, PyAthena.Analysis.TrackAssociation):
3600 dump_TrackAssociation (ass, f)
3601 elif isinstance (ass, PyAthena.Analysis.ISvxAssociation):
3602 dump_ISvxAssociation (ass, f)
3605 ti = j.jetTagInfoVector()
3606 fprint (f,
'\n tag info:')
3610 ti.sort (key=_infoType)
3613 fprint (f,
'\n (null)')
3615 fprint (f,
'\n %s %s: %f: '
3616 % (info.infoType(),
typename(info.__class__), j.getFlavourTagWeight (info.infoType())))
3617 if isinstance (info, PyAthena.Analysis.TruthInfo):
3618 dump_TruthInfo (info, f)
3619 elif isinstance (info, PyAthena.Analysis.SoftLeptonTruthInfo):
3620 dump_SoftLeptonTruthInfo (info, f)
3621 elif isinstance (info, PyAthena.Analysis.SecVtxInfo):
3622 dump_SecVtxInfo (info, f)
3623 elif isinstance (info, PyAthena.Analysis.IPInfoPlus):
3624 dump_IPInfoPlus (info, f)
3625 elif isinstance (info, PyAthena.Analysis.IPInfoBase):
3626 dump_IPInfoBase (info, f)
3627 elif isinstance (info, PyAthena.Analysis.SVInfoBase):
3628 dump_SVInfoBase (info, f)
3629 elif isinstance (info, PyAthena.Analysis.SVInfoPlus):
3630 dump_SVInfoPlus (info, f)
3631 elif isinstance (info, PyAthena.Analysis.MultiSVInfoPlus):
3632 dump_MultiSVInfoPlus (info, f)
3633 elif isinstance (info, PyAthena.Analysis.JetProbInfoBase):
3634 dump_JetProbInfoBase (info, f)
3635 elif isinstance (info, PyAthena.Analysis.SoftElectronInfo):
3636 dump_SoftElectronInfo (info, f)
3637 elif isinstance (info, PyAthena.Analysis.JetFitterTagInfo):
3638 dump_JetFitterTagInfo (info, f)
3639 elif (hasattr (PyAthena.Analysis,
'TrackCountingInfo')
and
3640 isinstance (info, PyAthena.Analysis.TrackCountingInfo)):
3641 dump_TrackCountingInfo (info, f)
3642 elif isinstance (info, PyAthena.Analysis.AtlfInfo):
3643 dump_AtlfInfo (info, f)
3644 elif isinstance (info, PyAthena.Analysis.SoftMuonInfo):
3645 dump_SoftMuonInfo (info, f)
3646 elif info.__class__
is PyAthena.Analysis.BaseTagInfo:
3647 dump_BaseTagInfo (info, f)
3648 elif info.__class__
is PyAthena.Analysis.GbbNNTagInfo:
3649 dump_GbbNNTagInfo (info, f)
3652 if tower_constituents_p:
3653 fprint (f,
'\n (not dumping tower constituents)')
3655 fprint (f,
'\n constituents:')
3656 for c
in toiter (j.firstConstituent(), j.lastConstituent()):
3662 fprint (f, j.getWeight (c))
◆ dump_Jet_ROI()
| def python.Dumpers.dump_Jet_ROI |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2999 of file Dumpers.py.
3001 fprint (f,
"%d %d %f %f %f" %
3007 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 1297 of file Dumpers.py.
1298 fprint (f, [info.energyInSample(i)
for i
in range(8)],
1299 info.energyInCryostat(), info.wtCryo(), info.jet())
◆ dump_JetElement()
| def python.Dumpers.dump_JetElement |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5089 of file Dumpers.py.
5090 fprint (f, p.eta(), p.phi(), p.key(), p.peak(),
5091 list(p.emEnergyVec()),
5092 list(p.hadEnergyVec()),
5093 list(p.emErrorVec()),
5094 list(p.hadErrorVec()),
5095 list(p.linkErrorVec()))
◆ dump_JetEnergyResult()
| def python.Dumpers.dump_JetEnergyResult |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5140 of file Dumpers.py.
5141 dump_ROIBHeader (p.header(), f)
5142 for r
in p.roIVec():
5143 dump_JetEnergyRoI (r, f)
5144 dump_ROIBTrailer (p.trailer(), f)
◆ dump_JetEnergyRoI()
| def python.Dumpers.dump_JetEnergyRoI |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5135 of file Dumpers.py.
5136 fprint (f, p.roIWord())
◆ dump_JetET_ROI()
| def python.Dumpers.dump_JetET_ROI |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 3012 of file Dumpers.py.
3013 fprint (f,
"%d %d" %
3015 m.getThrPattern(),))
3016 fprint (f, [t
for t
in m.getThresholds()])
◆ dump_JetFitterTagInfo()
| def python.Dumpers.dump_JetFitterTagInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1239 of file Dumpers.py.
1240 dump_BaseTagInfo (info, f)
1241 fprint (f,
'%d %d %d %f %f %f %f %f' %
1243 info.nSingleTracks(),
1244 info.nTracksAtVtx(),
1245 info.energyFraction(),
1247 info.significance3d(),
◆ dump_JetKeyDescriptorCollection()
| def python.Dumpers.dump_JetKeyDescriptorCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2070 of file Dumpers.py.
2071 fprint (f,
'(Dumped as a part of jets)')
◆ dump_JetMomentMapCollection()
| def python.Dumpers.dump_JetMomentMapCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2064 of file Dumpers.py.
2065 fprint (f,
'(Dumped as a part of jets)')
◆ dump_JetProbInfoBase()
| def python.Dumpers.dump_JetProbInfoBase |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1216 of file Dumpers.py.
1217 dump_BaseTagInfo (info, f)
1218 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 5161 of file Dumpers.py.
5162 fprint (f, p.getSourceID(),
5163 list(p.getErrors()),
5164 list(p.getDataWords()),
5165 list(p.getStatusWords()))
◆ dump_L1TopoResult()
| def python.Dumpers.dump_L1TopoResult |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5169 of file Dumpers.py.
5170 dump_ROIBHeader (p.header(), f)
5171 dump_L1TopoRDO (p.rdo(), f)
5172 dump_ROIBTrailer (p.trailer(), f)
◆ dump_LArDigit()
| def python.Dumpers.dump_LArDigit |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5259 of file Dumpers.py.
5260 fprint (f, p.channelID().getString(), p.gain(),
list(p.samples()))
◆ dump_LArFebErrorSummary()
| def python.Dumpers.dump_LArFebErrorSummary |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2076 of file Dumpers.py.
2077 for x
in p.get_all_febs():
2078 fprint (f,
'\n ', x.first, x.second)
◆ dump_LArFebHeader()
| def python.Dumpers.dump_LArFebHeader |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1807 of file Dumpers.py.
1808 fprint (f,
'feb', p.FEBId().getString(), p.FebELVL1Id(), p.FebBCId(),
1809 'febh', p.FormatVersion(), p.SourceId(),
1810 p.RunNumber(), p.ELVL1Id(), p.BCId(), p.LVL1TigType(),
1812 'dsp', p.DspCodeVersion(), p.DspEventCounter(),
1813 'res', p.RodResults1Size(), p.RodResults2Size(), p.RodRawDataSize(),
1814 p.NbSamples(), p.NbSweetCells1(), p.NbSweetCells2(),
1815 p.OnlineChecksum(), p.OfflineChecksum(), p.RodStatus(),
1817 list(p.FebCtrl1()),
list(p.FebCtrl2()),
list(p.FebCtrl3()))
◆ dump_LArHit()
| def python.Dumpers.dump_LArHit |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4268 of file Dumpers.py.
4269 fprint (f, t.cellID().getString(), t.energy(), t.time())
◆ dump_LArNoisyROSummary()
| def python.Dumpers.dump_LArNoisyROSummary |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4425 of file Dumpers.py.
4426 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 1821 of file Dumpers.py.
1822 fprint (f, p.identify().getString(), p.energy(), p.time(),
1823 p.quality(), p.provenance(), p.gain())
◆ dump_LArTTL1()
| def python.Dumpers.dump_LArTTL1 |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2127 of file Dumpers.py.
2128 fprint (f, p.ttOnlineID().getString(), p.ttOfflineID().getString(),
◆ dump_LineSaggingDescriptor()
| def python.Dumpers.dump_LineSaggingDescriptor |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1541 of file Dumpers.py.
1542 os = ROOT.ostringstream()
1544 s = os.str().replace (
'\n',
';')
◆ dump_LinkToTrack()
| def python.Dumpers.dump_LinkToTrack |
( |
|
l, |
|
|
|
f |
|
) |
| |
Definition at line 2623 of file Dumpers.py.
2624 dump_ITrackLink (l, f)
2625 fprint (f,
'\n ', l.isValid(), l.index(), l.dataID())
◆ dump_LinkToTrackParticleBase()
| def python.Dumpers.dump_LinkToTrackParticleBase |
( |
|
l, |
|
|
|
f |
|
) |
| |
Definition at line 2629 of file Dumpers.py.
2630 dump_ITrackLink (l, f)
2631 fprint (f, l.isValid(), l.index(), l.dataID())
◆ dump_list()
| def python.Dumpers.dump_list |
( |
|
l, |
|
|
|
f, |
|
|
|
dumper, |
|
|
|
nmax = None |
|
) |
| |
Definition at line 5746 of file Dumpers.py.
5746 def dump_list (l, f, dumper, nmax = None):
5749 if nmax
is not None and i >= nmax:
break
◆ dump_LocalParameters()
| def python.Dumpers.dump_LocalParameters |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1661 of file Dumpers.py.
1662 dump_AmgVector (p, f)
1663 fprint (f, p.parameterKey())
◆ dump_LUCID_RawData()
| def python.Dumpers.dump_LUCID_RawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5204 of file Dumpers.py.
5205 fprint (f, p.getStatus(),
5206 p.getWord0(), p.getWord1(), p.getWord2() , p.getWord3(),
5207 p.getWord0p(), p.getWord1p(), p.getWord2p(), p.getWord3p(),
5208 p.getWord0n(), p.getWord1n(), p.getWord2n(), p.getWord3n())
◆ dump_LVL1_ROI()
| def python.Dumpers.dump_LVL1_ROI |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3041 of file Dumpers.py.
3042 for m
in t.getMuonROIs():
3044 dump_Muon_ROI (m, f)
3045 for m
in t.getEmTauROIs():
3047 dump_EmTau_ROI (m, f)
3048 for m
in t.getJetROIs():
3051 for m
in t.getJetEtROIs():
3053 dump_JetET_ROI (m, f)
3054 for m
in t.getEnergySumROIs():
3056 dump_EnergySum_ROI (m, f)
◆ dump_Lvl1AODConfigData()
| def python.Dumpers.dump_Lvl1AODConfigData |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 3227 of file Dumpers.py.
3228 fprint (f, d.masterKey())
3229 fprint (f,
'\nit', [s
for s
in d.getItems()])
3230 fprint (f,
'\nmu', [s
for s
in d.getMuonThresholds()])
3231 fprint (f,
'\nem', [s
for s
in d.getEMTauThresholds()])
3232 fprint (f,
'\njt', [s
for s
in d.getJetThresholds()])
3233 fprint (f,
'\nfj', [s
for s
in d.getForwardJetThresholds()])
3234 fprint (f,
'\net', [s
for s
in d.getTotalEtThresholds()])
3235 fprint (f,
'\nje', [s
for s
in d.getJetEtThresholds()])
3236 fprint (f,
'\nms', [s
for s
in d.getMissingEtThresholds()])
3239 dump_CTPConfig (d.ctpConfig(), f)
3243 if d.thresholdConfig():
3244 fprint (f, d.thresholdConfig())
◆ dump_Lvl1AODPrescaleConfigData()
| def python.Dumpers.dump_Lvl1AODPrescaleConfigData |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 3251 of file Dumpers.py.
3252 fprint (f, d.masterKey())
3253 fprint (f, [i
for i
in d.getPrescales()])
◆ dump_Lvl1Result()
| def python.Dumpers.dump_Lvl1Result |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3107 of file Dumpers.py.
3108 fprint (f, t.isConfigured(),
3110 t.anyActiveL1ItemAfterVeto(),
3112 fprint (f,
'\n ', [i
for i
in t.itemsPassed()])
3113 fprint (f,
'\n ', [i
for i
in t.itemsBeforePrescale()])
3114 fprint (f,
'\n ', [i
for i
in t.itemsAfterPrescale()])
3115 fprint (f,
'\n ', [i
for i
in t.itemsAfterVeto()])
◆ dump_materialeffects()
| def python.Dumpers.dump_materialeffects |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2249 of file Dumpers.py.
2251 fprint (f,
'(null)')
2254 fprint (f, nm +
': ')
2255 if nm ==
'Trk::MaterialEffectsOnTrack':
2256 dump_MaterialEffectsOnTrack (p, f)
◆ dump_MaterialEffectsBase()
| def python.Dumpers.dump_MaterialEffectsBase |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2227 of file Dumpers.py.
2228 fprint (f, p.dumpType(), p.thicknessInX0())
2229 dump_associatedSurface (p, f)
◆ dump_MaterialEffectsOnTrack()
| def python.Dumpers.dump_MaterialEffectsOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2242 of file Dumpers.py.
2243 dump_MaterialEffectsBase (p, f)
2244 dump_ScatteringAngles (p.scatteringAngles(), f)
2245 dump_EnergyLoss (p.energyLoss(), f)
◆ dump_MdtAmtHit()
| def python.Dumpers.dump_MdtAmtHit |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5441 of file Dumpers.py.
5442 fprint (f, p.tdcId(), p.channelId(), p.leading(), p.coarse(), p.fine(),
5443 p.width(), p.isMasked(),
list(p.dataWords()))
◆ dump_MdtCsmContainer()
| def python.Dumpers.dump_MdtCsmContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5447 of file Dumpers.py.
5448 dump_IDC (dump_MdtAmtHit, p, f,
5449 extra_idc_dumper =
lambda p, f: \
5450 fprint (f, p.identify().getString(),
5451 p.SubDetId(), p.MrodId(), p.CsmId()))
◆ dump_MdtDriftCircleOnTrack()
| def python.Dumpers.dump_MdtDriftCircleOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1713 of file Dumpers.py.
1714 dump_RIO_OnTrack (p, f)
1715 dump_AmgVector (p.globalPosition(), f, thresh=1e-8)
1716 dump_EL (p.prepRawDataLink(), f)
1717 fprint (f, p.status(), p.localAngle(), p.positionAlongWire())
1719 fprint (f, p.detectorElement().identifyHash().
value())
1720 dump_StraightLineSurface (p.associatedSurface(), f)
◆ dump_MdtPrepData()
| def python.Dumpers.dump_MdtPrepData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4619 of file Dumpers.py.
4620 dump_MuonCluster (p, f)
4621 fprint (f, p.tdc(), p.adc(), p.status())
4622 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_MdtPrepDataContainer()
| def python.Dumpers.dump_MdtPrepDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4763 of file Dumpers.py.
4764 dump_IDC (dump_MdtPrepData, p, f)
◆ dump_MDTSimHit()
| def python.Dumpers.dump_MDTSimHit |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5233 of file Dumpers.py.
5234 fprint (f, p.MDTid(), p.globalTime(), p.driftRadius())
5235 dump_Threevec (p.localPosition(), f)
5236 fprint (f, p.stepLength(), p.energyDeposit(), p.particleEncoding(), p.kineticEnergy())
5237 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 2192 of file Dumpers.py.
2194 fprint (f,
'(null)')
2197 fprint (f, nm +
': ')
2198 if nm ==
'InDet::PixelClusterOnTrack':
2199 dump_PixelClusterOnTrack (p, f)
2200 elif nm ==
'InDet::SCT_ClusterOnTrack':
2201 dump_SCT_ClusterOnTrack (p, f)
2202 elif nm ==
'InDet::TRT_DriftCircleOnTrack':
2203 dump_TRT_DriftCircleOnTrack (p, f)
2204 elif nm ==
'Muon::MdtDriftCircleOnTrack':
2205 dump_MdtDriftCircleOnTrack (p, f)
2206 elif nm ==
'Muon::MdtDriftCircleOnTrack':
2207 dump_MdtDriftCircleOnTrack (p, f)
2208 elif nm ==
'Muon::CompetingMuonClustersOnTrack':
2209 dump_CompetingMuonClustersOnTrack (p, f)
2210 elif nm ==
'Muon::RpcClusterOnTrack':
2211 dump_RpcClusterOnTrack (p, f)
2212 elif nm ==
'Muon::TgcClusterOnTrack':
2213 dump_TgcClusterOnTrack (p, f)
2214 elif nm ==
'Muon::sTgcClusterOnTrack':
2215 dump_sTgcClusterOnTrack (p, f)
2216 elif nm ==
'Muon::MMClusterOnTrack':
2217 dump_MMClusterOnTrack (p, f)
2218 elif nm ==
'Muon::CscClusterOnTrack':
2219 dump_CscClusterOnTrack (p, f)
2220 elif nm ==
'Trk::PseudoMeasurementOnTrack':
2221 dump_PseudoMeasurementOnTrack (p, f)
◆ dump_MeasurementBase()
| def python.Dumpers.dump_MeasurementBase |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1667 of file Dumpers.py.
1668 dump_LocalParameters (p.localParameters(), f)
1669 dump_AmgMatrix (p.localCovariance(), f)
◆ dump_MissingET()
| def python.Dumpers.dump_MissingET |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2332 of file Dumpers.py.
2333 fprint (f,
'%d %f %f %f %f %f' %
2343 fprint (f,
'\n %d %f %f %f' %
◆ dump_MissingEtCalo()
| def python.Dumpers.dump_MissingEtCalo |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2493 of file Dumpers.py.
2494 dump_MissingET (m, f)
2495 fprintln (f,
' ', m.calibType())
2497 fprintln (f,
' %d %d %f %f %f' %
◆ dump_MissingETComposition()
| def python.Dumpers.dump_MissingETComposition |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4447 of file Dumpers.py.
4448 for p
in toiter1 (m):
4449 fprint (f,
' ',
typename(p.__class__))
4451 fprint (f,
'(null)')
4456 fprint (f,
' [', w.wet(), w.wpx(), w.wpy(), w.statusWord(),
']')
4457 except RuntimeError:
◆ dump_MissingETSig()
| def python.Dumpers.dump_MissingETSig |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2353 of file Dumpers.py.
2354 fprint (f,
"%f %f" %
2357 fprint (f,
"\n %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f" %
2374 fprint (f,
"\n %f %f %f %f %f %f %f %f" %
2383 fprint (f,
"\n %f %f %f %f" %
◆ dump_MissingETSigHypo()
| def python.Dumpers.dump_MissingETSigHypo |
( |
|
h, |
|
|
|
f |
|
) |
| |
Definition at line 2391 of file Dumpers.py.
2397 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" %
2426 dump_Fourvec (h.getObject(), f)
2428 fprint (f,
'\n %d %f %f %f %f %f' %
2435 fprint (f,
'\n ', [x
for x
in toiter1(h)])
◆ dump_MissingETSigObject()
| def python.Dumpers.dump_MissingETSigObject |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2439 of file Dumpers.py.
2441 fprint (f,
" %d %d %d %d %d %d %d %d %d %f %f %f %f %f %f %f %f %f %f %f " %
2442 (m.isValidDefault(),
2447 m.getDefaultType().
type(),
2450 m.getType(0).
type(),
2462 fprint (f,
'\n %f %f %f %f %f %f %f %d %d %d' %
2474 fprint (f,
'\n ', [i
for i
in m.types()])
2476 fprint (f,
'\n %d %f %f %f %f %f' %
2484 [x
for x
in toiter1 (m.getExcess())],
2485 [x
for x
in toiter1 (m.getDeficit())])
2486 dump_MissingETSigHypo (m.getHypo(), f)
2487 dump_MissingETSigHypo (m.getDefaultHypo(), f)
2488 dump_MissingETSigHypo (m.getHypo(0), f)
◆ dump_MissingEtTruth()
| def python.Dumpers.dump_MissingEtTruth |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2507 of file Dumpers.py.
2508 dump_MissingET (m, f)
2510 fprintln (f,
' %d %f %f %f' %
◆ dump_MM_RawData()
| def python.Dumpers.dump_MM_RawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5466 of file Dumpers.py.
5467 fprint (f, p.identify().getString(), p.channel(), p.relBcid(),
5468 p.time(), p.charge(),
5469 p.timeAndChargeInCounts())
◆ dump_MM_RawDataContainer()
| def python.Dumpers.dump_MM_RawDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5473 of file Dumpers.py.
5474 dump_IDC (dump_MM_RawData, p, f)
◆ dump_MMClusterOnTrack()
| def python.Dumpers.dump_MMClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2162 of file Dumpers.py.
2163 dump_MuonClusterOnTrack (p, f)
2164 dump_EL (p.prepRawDataLink(), f)
2165 fprint (f, p.detectorElement().identifyHash().
value())
2166 fprint (f,
'\n stripDriftDists: ',
list(p.stripDriftDists()))
2167 fprint (f,
'\n stripDriftDistErrors:')
2168 for m
in p.stripDriftDistErrors():
2170 dump_AmgMatrix (m, f)
◆ dump_MuCTPI_RDO()
| def python.Dumpers.dump_MuCTPI_RDO |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5063 of file Dumpers.py.
5065 formatItemUsingLong (
list(p.getAllCandidateMultiplicities())),
5066 formatItemUsingLong (
list(p.dataWord())))
◆ dump_MuCTPIResult()
| def python.Dumpers.dump_MuCTPIResult |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5114 of file Dumpers.py.
5115 dump_ROIBHeader (p.header(), f)
5116 for r
in p.roIVec():
5117 dump_MuCTPIRoI (r, f)
5118 dump_ROIBTrailer (p.trailer(), f)
◆ dump_MuCTPIRoI()
| def python.Dumpers.dump_MuCTPIRoI |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5109 of file Dumpers.py.
5110 fprint (f, p.roIWord())
◆ dump_MultiSVInfoPlus()
| def python.Dumpers.dump_MultiSVInfoPlus |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1189 of file Dumpers.py.
1190 dump_BaseTagInfo (info, f)
1191 fprint (f, info.getNGTrackInJet(),
1192 info.getNGTrackInSvx(),
1196 fprint (f,
'\n verts: ')
1197 for i
in range (info.numVtxInfo()):
1198 fprint (f,
'\n %d: ' % i)
1199 vx = info.getVtxInfo(i)
1200 fprint (f, vx.getMass(), vx.getPt(), vx.getEta(), vx.getPhi(),
1201 vx.getEnergyFraction(), vx.getNormDist(), vx.numTrackInfo())
1202 fprint (f,
'\n vert: ')
1203 dump_RecVertex (vx.getRecSvx(), f)
1204 fprint (f,
'\n tracks: ')
1207 ti = [vx.getTrackInfo(i)
for i
in range(vx.numTrackInfo())]
1208 ti.sort (key=
lambda a: a.track().
pt(), reverse=
True)
1209 i = vx.numTrackInfo()-1
1211 fprint (f,
'\n %d: ' % i)
1212 dump_SVTrackInfo (tt, f)
◆ dump_Muon()
| def python.Dumpers.dump_Muon |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 629 of file Dumpers.py.
630 dump_ParticleImpl (m, f)
631 fprint (f,
' %1d' % m.author())
632 if m.inDetTrackLink().
isValid():
633 fprint (f,
'\n idtp: %2d:' % m.inDetTrackLink().
index())
634 dump_Fourvec (m.inDetTrackParticle(), f)
636 if hasattr(m,
'muonSpTrackLink')
and m.muonSpTrackLink().
isValid():
637 fprint (f,
'\n sptp: %2d:' % m.muonSpTrackLink().
index())
638 dump_Fourvec (m.muonSpectrometerTrackParticle(), f)
639 if m.muonExtrapTrackLink().
isValid():
640 fprint (f,
'\n mxtp: %2d:' % m.muonExtrapTrackLink().
index())
641 dump_Fourvec (m.muonExtrapolatedTrackParticle(), f)
642 if m.innerExtrapTrackLink().
isValid():
643 fprint (f,
'\n ixtp: %2d:' % m.innerExtrapTrackLink().
index())
644 dump_Fourvec (m.innerExtrapolatedTrackParticle(), f)
645 if m.combinedTrackLink().
isValid():
646 fprint (f,
'\n cmtp: %2d:' % m.combinedTrackLink().
index())
647 dump_Fourvec (m.combinedMuonTrackParticle(), f)
649 fprint (f,
'\n cl: %2d:' % m.clusterLink().
index())
650 dump_Fourvec (m.cluster(), f)
651 fprint (f,
'\n a: %f %f %d %f %d %f %d' %
652 (m.matchChi2(), m.matchChi2OverDoF(), m.matchNumberDoF(),
653 m.fitChi2(), m.fitNumberDoF(), m.fitChi2OverDoF(),
655 fprint (f,
'\n b: %d %d %d %d %d %d %d %d %d %d %d %d' %
656 (m.numberOfInnermostPixelLayerHits(),
657 m.numberOfPixelHits(),
660 m.numberOfTRTHighThresholdHits(),
661 m.numberOfInnermostPixelLayerSharedHits(),
662 m.numberOfPixelSharedHits(),
663 m.numberOfPixelHoles(),
664 m.numberOfSCTSharedHits(),
665 m.numberOfSCTHoles(),
666 m.numberOfTRTOutliers(),
667 m.numberOfTRTHighThresholdOutliers()))
668 fprint (f,
'\n c: %d %d %d %d %d %d %d %d %d %d %d %d %d %d' %
669 (m.numberOfMDTHits(),
670 m.numberOfMDTHoles(),
671 m.numberOfCSCEtaHits(),
672 m.numberOfCSCEtaHoles(),
673 m.numberOfCSCPhiHits(),
674 m.numberOfCSCPhiHoles(),
675 m.numberOfRPCEtaHits(),
676 m.numberOfRPCEtaHoles(),
677 m.numberOfRPCPhiHits(),
678 m.numberOfRPCPhiHoles(),
679 m.numberOfTGCEtaHits(),
680 m.numberOfTGCEtaHoles(),
681 m.numberOfTGCPhiHits(),
682 m.numberOfTGCPhiHoles()))
683 fprint (f,
'\n d: %d %d %f %f %f %f %f %f' %
684 (m.numberOfGangedPixels(),
685 m.numberOfOutliersOnTrack(),
687 m.segmentChi2OverDoF(),
692 fprint (f,
'\n e: %f %f %d %d' %
693 (m.parameter(etcone10),
694 m.parameter(nucone10),
695 m.alsoFoundByLowPt(),
696 m.alsoFoundByCaloMuonId()))
697 fprint (f,
'\n f:', [i
for i
in m.associatedEtaDigits()])
698 fprint (f,
'\n h:', [i
for i
in m.associatedPhiDigits()])
699 fprint (f,
'\n i:', [i
for i
in m.segmentEtaDigits()])
700 fprint (f,
'\n j:', [i
for i
in m.segmentPhiDigits()])
701 caloe = m.caloEnergyLoss()
704 dump_CaloEnergy (caloe, f)
◆ dump_Muon_ROI()
| def python.Dumpers.dump_Muon_ROI |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 2966 of file Dumpers.py.
2968 fprint (f,
"%d %s %f %d %d %d %d %d %d %d %d" %
2974 m.getSectorAddress(),
2975 m.isFirstCandidate(),
2976 m.isMoreCandInRoI(),
2977 m.isMoreCandInSector(),
◆ dump_MuonAssociation()
| def python.Dumpers.dump_MuonAssociation |
( |
|
a, |
|
|
|
f |
|
) |
| |
Definition at line 3523 of file Dumpers.py.
3524 dump_JetAssociationBase (a, f)
3527 fprint (f, a.getMuonWeight (muo))
3528 dump_Fourvec (muo, f)
◆ dump_MuonCluster()
| def python.Dumpers.dump_MuonCluster |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4566 of file Dumpers.py.
4567 dump_PrepRawData (p, f)
4568 dump_AmgVector (p.globalPosition(), f, thresh=1e-8, prec=4)
◆ dump_MuonClusterOnTrack()
| def python.Dumpers.dump_MuonClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1732 of file Dumpers.py.
1733 dump_RIO_OnTrack (p, f)
1734 dump_AmgVector (p.globalPosition(), f, 1e-12, 4)
1735 fprint (f, p.positionAlongStrip())
◆ dump_MuonConstituent()
| def python.Dumpers.dump_MuonConstituent |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1329 of file Dumpers.py.
1331 dump_Fourvec (info.muon(), f)
1332 fprint (f, info.getMuonWeight (info.muon()))
◆ dump_MuonFeature()
| def python.Dumpers.dump_MuonFeature |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4009 of file Dumpers.py.
4010 fprint (f,
' ', m.roiId(), m.saddress(), m.pt(), m.radius(),
4011 m.eta(), m.phi(), m.dir_phi(), m.zeta(), m.dir_zeta(), m.beta(),
4012 m.sp1_r(), m.sp1_z(), m.sp1_slope(),
4013 m.sp2_r(), m.sp2_z(), m.sp2_slope(),
4014 m.sp3_r(), m.sp3_z(), m.sp3_slope(),
4015 m.br_radius(), m.br_sagitta(), m.ec_alpha(), m.ec_beta(),
4016 m.dq_var1(), m.dq_var2(), m.algoId())
◆ dump_MuonFeature_nolist()
| def python.Dumpers.dump_MuonFeature_nolist |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4019 of file Dumpers.py.
4020 dump_MuonFeature (m, f)
◆ dump_MuonFeatureDetails()
| def python.Dumpers.dump_MuonFeatureDetails |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4024 of file Dumpers.py.
4025 fprint (f, m.extension_capacity(),
4026 m.max_rob_capacity(),
4027 m.max_csm_capacity(),
4028 m.max_lvl1_emu_capacity(),
4029 m.max_rpc_hits_capacity(),
4030 m.max_tgc_hits_capacity(),
4031 m.max_mdt_hits_capacity(),
4032 m.id(), m.te_id(), m.error())
4034 m.lvl1_id(), m.lumi_block(), m.muondetmask(),
4035 m.roi_id(), m.roi_system(), m.roi_subsystem(),
4036 m.roi_sector(), m.roi_number(), m.roi_threshold(),
4037 daz(m.roi_eta()),
daz(m.roi_phi()),
4038 m.rpc_pad_error(), m.tgc_rdo_error())
4040 m.rpc1_x(), m.rpc1_y(), m.rpc1_z(),
4041 m.rpc2_x(), m.rpc2_y(), m.rpc2_z(),
4042 m.rpc3_x(), m.rpc3_y(), m.rpc3_z())
4044 m.tgc_Mid1_eta(), m.tgc_Mid1_phi(), m.tgc_Mid1_r(), m.tgc_Mid1_z(),
4045 m.tgc_Mid2_eta(), m.tgc_Mid2_phi(), m.tgc_Mid2_r(), m.tgc_Mid2_z(),
4046 m.tgc_Mid_rho_chi2(), m.tgc_Mid_rho_N(),
4047 m.tgc_Mid_phi_chi2(), m.tgc_Mid_phi_N())
4049 m.tgc_Inn_eta(), m.tgc_Inn_phi(),
4050 m.tgc_Inn_r(), m.tgc_Inn_z(),
4051 m.tgc_Inn_rho_std(), m.tgc_Inn_rho_N(),
4052 m.tgc_Inn_phi_std(), m.tgc_Inn_phi_N(),
4055 m.mdt_Inner_slope(),
4056 m.mdt_Inner_intercept(),
4059 m.mdt_Inner_fit_chi(),
4060 m.mdt_Middle_slope(),
4061 m.mdt_Middle_intercept(),
4064 m.mdt_Middle_fit_chi(),
4065 m.mdt_Outer_slope(),
4066 m.mdt_Outer_intercept(),
4069 m.mdt_Outer_fit_chi())
4071 m.Address(), m.Sagitta(), m.Radius(), m.Slope(), m.Intercept(),
4072 m.Alpha(), m.Beta(), m.DeltaR(), m.Speed_over_c(),
4073 m.PhiMap(), m.Phi(), m.PhiDir(), m.Pt(), m.Charge())
4081 m.eta_high_0_lay0(),
4082 m.eta_high_1_lay0(),
4083 m.eta_high_0_lay1(),
4084 m.eta_high_1_lay1(),
4091 m.phi_high_0_lay0(),
4092 m.phi_high_1_lay0(),
4093 m.phi_high_0_lay1(),
4094 m.phi_high_1_lay1())
4096 fprint (f,
'\n ', formatItemUsingLong (
list(m.rob_id())))
4097 fprint (f,
'\n ', formatItemUsingLong (
list(m.csm_id())))
4098 fprint (f,
'\n ', formatItemUsingLong (
list(m.csm_size())))
4099 fprint (f,
'\n ', formatItemUsingLong (
list(m.csm_error())))
4100 fprint (f,
'\n ', formatItemUsingLong (
list(m.removed_rob_id())))
4101 fprint (f,
'\n ', formatItemUsingLong (
list(m.removed_csm_id())))
4102 fprint (f,
'\n ', formatItemUsingLong (
list(m.lvl1_emulation())))
4103 fprint (f,
'\n ', formatItemUsingLong (
list(m.pad_hit_onlineId())))
4104 fprint (f,
'\n ', formatItemUsingLong (
list(m.pad_hit_code())))
4114 fprint (f,
'\n ', formatItemUsingLong (
list(m.tgc_Inn_rho_hit_in_seg())))
4119 fprint (f,
'\n ', formatItemUsingLong (
list(m.tgc_Inn_phi_hit_in_seg())))
4124 fprint (f,
'\n ', formatItemUsingLong (
list(m.tgc_Mid_rho_hit_in_seg())))
4129 fprint (f,
'\n ', formatItemUsingLong (
list(m.tgc_Mid_phi_hit_in_seg())))
4130 fprint (f,
'\n ', formatItemUsingLong (
list(m.mdt_onlineId())))
4131 fprint (f,
'\n ', formatItemUsingLong (
list(m.mdt_offlineId())))
4138 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension0())))
4139 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension1())))
4140 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension2())))
4141 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension3())))
4142 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension4())))
4143 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension5())))
4144 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension6())))
4145 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension7())))
4146 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension8())))
4147 fprint (f,
'\n ', formatItemUsingLong (
list(m.extension9())))
◆ dump_MuonMcData()
| def python.Dumpers.dump_MuonMcData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4826 of file Dumpers.py.
4827 fprint (f, p.firstEntry(), p.secondEntry())
◆ dump_MuonSimData()
| def python.Dumpers.dump_MuonSimData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4831 of file Dumpers.py.
4832 fprint (f, p.word())
4833 dump_AmgVector (p.globalPosition(), f)
4834 for d
in p.getdeposits():
4835 dump_HepMcParticleLink (d.first, f)
4836 dump_MuonMcData (d.second, f)
◆ dump_MuonSimDataCollection()
| def python.Dumpers.dump_MuonSimDataCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4841 of file Dumpers.py.
4843 fprint (f, elt.first.getString())
4844 dump_MuonSimData (elt.second, f)
◆ dump_MuonSpShower()
| def python.Dumpers.dump_MuonSpShower |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 3486 of file Dumpers.py.
3487 fprint (f,
"%f %f %d %d %d %d %d %d %d" %
3490 m.numberOfTriggerHits(),
3491 m.numberOfInnerHits(),
3492 m.numberOfMiddleHits(),
3493 m.numberOfOuterHits(),
3494 m.numberOfInnerSegments(),
3495 m.numberOfMiddleSegments(),
3496 m.numberOfOuterSegments()))
◆ dump_MvfFitInfo()
| def python.Dumpers.dump_MvfFitInfo |
( |
|
v, |
|
|
|
f |
|
) |
| |
◆ dump_MVFVxCandidate()
| def python.Dumpers.dump_MVFVxCandidate |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 2701 of file Dumpers.py.
2702 dump_VxCandidate1 (v, f)
2703 fprint (f,
'\n ', v.isInitialized(),
'fi')
2704 dump_MvfFitInfo (v.vertexFitInfo(), f)
◆ dump_MVFVxTrackAtVertex()
| def python.Dumpers.dump_MVFVxTrackAtVertex |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 2670 of file Dumpers.py.
2671 dump_VxTrackAtVertex (t, f)
2672 fprint (f,
'\n ',
tonone(t.linkToVertices()))
◆ dump_NSW_PadTriggerData()
| def python.Dumpers.dump_NSW_PadTriggerData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5478 of file Dumpers.py.
5479 fprint (f, p.getSourceid(), p.getFlags(), p.getEc(), p.getFragid(),
5480 p.getSecid(), p.getSpare(), p.getOrbit(), p.getBcid(), p.getL1id(),
5481 p.getOrbitid(), p.getOrbit1(), p.getStatus(),
5482 p.getNumberOfHits(), p.getNumberOfPfebs(), p.getNumberOfTriggers(),
5483 p.getNumberOfBcids(),
5484 list(p.getHitRelBcids()),
5485 list(p.getHitPfebs()),
5486 list(p.getHitTdsChannels()),
5487 list(p.getHitVmmChannels()),
5488 list(p.getHitVmms()),
5489 list(p.getHitPadChannels()),
5490 list(p.getPfebAddrs()),
5491 list(p.getPfebNChannels()),
5492 list(p.getPfebDisconnecteds()),
5493 list(p.getTriggerBandIds()),
5494 list(p.getTriggerPhiIds()),
5495 list(p.getTriggerRelBcids()),
5496 list(p.getBcidRels()),
5497 list(p.getBcidStatuses()),
5498 list(p.getBcidMultZeros()),
5499 list(p.getBcidMultiplicities()))
◆ dump_NSW_PadTriggerDataContainer()
| def python.Dumpers.dump_NSW_PadTriggerDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5503 of file Dumpers.py.
5507 dump_NSW_PadTriggerData (beg.cptr(), f)
◆ dump_parameters()
| def python.Dumpers.dump_parameters |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1609 of file Dumpers.py.
1613 if typename(p.__class__).startswith (
'DataModel_detail::ElementProxy<'):
1617 elif (
typename(p.__class__).startswith (
'Trk::ParametersT<')
or
1618 typename(p.__class__).startswith (
'Trk::ParametersBase<')):
1619 dump_ParametersBase (p, f)
1620 elif typename(p.__class__).startswith (
'Trk::CurvilinearParametersT<'):
1621 dump_CurvilinearParameters (p, f)
◆ dump_ParametersBase()
| def python.Dumpers.dump_ParametersBase |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1584 of file Dumpers.py.
1585 dump_AmgVector (info.parameters(), f)
1586 dump_Threevec (info.momentum(), f)
1587 dump_Threevec (info.position(), f)
1588 dump_Twovec (info.localPosition(), f)
1589 fprint (f,
"%f" % (info.charge(),))
1590 if info.covariance():
1591 fprint (f,
'\n cov')
1592 dump_AmgMatrix (info.covariance(), f)
1594 dump_associatedSurface (info, f)
◆ dump_ParticleBase()
| def python.Dumpers.dump_ParticleBase |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 342 of file Dumpers.py.
343 dump_Fourvec (e, f, 0)
344 orig = e.originLink()
346 charge =
"%f" % e.charge()
349 fprint (f,
" %1d %1d %4d %s" %
350 (e.dataType(), e.hasPdgId(),
asint32(e.pdgId()), charge))
352 fprint (f,
"%1d"%orig.index())
353 dump_Threevec (e.origin().position(), f)
355 fprint (f,
"(no orig)")
◆ dump_ParticleImpl()
| def python.Dumpers.dump_ParticleImpl |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 359 of file Dumpers.py.
360 dump_Fourvec (p, f, 0)
366 fprint (f,
' %d %s %5d ' %
367 (p.dataType(), c,
asint32(p.pdgId())))
369 dump_Threevec (p.origin().position(), f)
371 fprint (f,
"(no orig)")
◆ dump_ParticleJet()
| def python.Dumpers.dump_ParticleJet |
( |
|
j, |
|
|
|
f |
|
) |
| |
Definition at line 1337 of file Dumpers.py.
1338 dump_ParticleBase (j, f)
1339 fprint (f,
'\n %s %f %f' %
1343 fprint (f, [x
for x
in j.combinedLikelihood()])
1344 ti = j.jetTagInfoVector()
1346 fprint (f,
'\n %s: ' % info.infoType())
1347 if isinstance (info, PyAthena.Analysis.TruthInfo):
1348 dump_TruthInfo (info, f)
1349 elif isinstance (info, PyAthena.Analysis.SoftLeptonTruthInfo):
1350 dump_SoftLeptonTruthInfo (info, f)
1351 elif isinstance (info, PyAthena.Analysis.SecVtxInfo):
1352 dump_SecVtxInfo (info, f)
1353 elif isinstance (info, PyAthena.Analysis.IPInfoPlus):
1354 dump_IPInfoPlus (info, f)
1355 elif isinstance (info, PyAthena.Analysis.IPInfoBase):
1356 dump_IPInfoBase (info, f)
1357 elif isinstance (info, PyAthena.Analysis.SVInfoBase):
1358 dump_SVInfoBase (info, f)
1359 elif isinstance (info, PyAthena.Analysis.JetProbInfoBase):
1360 dump_JetProbInfoBase (info, f)
1361 elif isinstance (info, PyAthena.Analysis.SoftElectronInfo):
1362 dump_SoftElectronInfo (info, f)
1363 elif isinstance (info, PyAthena.Analysis.JetFitterTagInfo):
1364 dump_JetFitterTagInfo (info, f)
1365 elif isinstance (info, PyAthena.Analysis.BaseTagInfo):
1366 dump_BaseTagInfo (info, f)
1370 for c
in j.constituentKeys():
1371 fprint (f,
'\n %s: ' % c)
1372 info = j.constituent (c)
1373 if isinstance (info, PyAthena.Analysis.JetConstituent):
1374 dump_JetConstituent (info, f)
1375 elif isinstance (info, PyAthena.Analysis.TrackConstituents):
1376 dump_TrackConstituents (info, f)
1377 elif isinstance (info, PyAthena.Analysis.ElectronConstituent):
1378 dump_ElectronConstituent (info, f)
1379 elif isinstance (info, PyAthena.Analysis.MuonConstituent):
1380 dump_MuonConstituent (info, f)
◆ dump_PerigeeSurface()
| def python.Dumpers.dump_PerigeeSurface |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1516 of file Dumpers.py.
1517 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 3514 of file Dumpers.py.
3515 dump_JetAssociationBase (a, f)
3518 fprint (f, a.getPhotonWeight (gam))
3519 dump_Fourvec (gam, f)
◆ dump_PileUpEventInfo()
| def python.Dumpers.dump_PileUpEventInfo |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 2763 of file Dumpers.py.
2764 dump_EventInfo (e, f)
2765 for (i,s)
in enumerate (toiter (e.beginSubEvt(), e.endSubEvt())):
2766 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 4653 of file Dumpers.py.
4654 dump_SiCluster (p, f)
4655 fprint (f, p.omegax(), p.omegay(), list (p.totList()))
4656 fprint (f, p.totalToT(),
list(p.chargeList()), p.totalCharge())
4657 fprint (f, p.isFake(), p.isAmbiguous(), p.LVL1A(), p.splitInfoRaw(), p.tooBigToBeSplit())
◆ dump_PixelClusterContainer()
| def python.Dumpers.dump_PixelClusterContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4769 of file Dumpers.py.
4770 dump_IDC (dump_PixelCluster, p, f)
◆ dump_PixelClusterOnTrack()
| def python.Dumpers.dump_PixelClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1686 of file Dumpers.py.
1687 dump_SiClusterOnTrack (p, f)
1688 dump_EL (p.prepRawDataLink(), f)
1689 fprint (f, p.hasClusterAmbiguity(), p.isFake(), p.energyLoss())
1690 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_PixelGangedClusterAmbiguities()
| def python.Dumpers.dump_PixelGangedClusterAmbiguities |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4850 of file Dumpers.py.
4852 dump_SiCluster (elt.first, f)
4853 dump_SiCluster (elt.second, f)
◆ dump_PixelRawDataContainer()
| def python.Dumpers.dump_PixelRawDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4787 of file Dumpers.py.
4788 dump_IDC (dump_PixelRDORawData, p, f)
◆ dump_PixelRDORawData()
| def python.Dumpers.dump_PixelRDORawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4679 of file Dumpers.py.
4680 dump_InDetRawData (p, f)
4681 fprint (f, p.getToT(), p.getBCID(), p.getLVL1A(), p.getLVL1ID())
◆ dump_PlaneSurface()
| def python.Dumpers.dump_PlaneSurface |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1521 of file Dumpers.py.
1522 dump_Surface (info, f)
◆ dump_PRD_MultiTruthCollection()
| def python.Dumpers.dump_PRD_MultiTruthCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2111 of file Dumpers.py.
2112 for x
in ROOT.TrkTruthDataHelpers.getData (p):
2113 fprint (f,
'\n ', x.first.getString())
2114 dump_HepMcParticleLink (x.second, f)
◆ dump_PrepRawData()
| def python.Dumpers.dump_PrepRawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4554 of file Dumpers.py.
4555 fprint (f, p.identify().getString())
4556 dump_IdentContIndex (p.getHashAndIndex(), f)
4557 dump_AmgVector (p.localPosition(), f)
4558 dump_AmgMatrix (p.localCovariance(), f)
4560 for i
in p.rdoList():
4561 fprint (f, i.getString())
◆ dump_PseudoMeasurementOnTrack()
| def python.Dumpers.dump_PseudoMeasurementOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2185 of file Dumpers.py.
2186 dump_MeasurementBase (p, f)
2187 dump_AmgVector (p.globalPosition(), f)
2188 dump_associatedSurface (p, f)
◆ dump_RawInfoSummaryForTag()
| def python.Dumpers.dump_RawInfoSummaryForTag |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4439 of file Dumpers.py.
4441 if a.startswith (
'get'):
4442 fprintln (f, a[3:]+
':', getattr(p, a)())
◆ dump_RecoTimingObj()
| def python.Dumpers.dump_RecoTimingObj |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 4538 of file Dumpers.py.
4539 fprintln (f, list (c))
◆ dump_RecVertex()
| def python.Dumpers.dump_RecVertex |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 2605 of file Dumpers.py.
2607 dump_FitQuality (v.fitQuality(), f)
2608 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 1673 of file Dumpers.py.
1674 dump_MeasurementBase (p, f)
1675 fprint (f, p.identify().getString())
◆ dump_ROIBHeader()
| def python.Dumpers.dump_ROIBHeader |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5099 of file Dumpers.py.
5100 fprint (f, formatItemUsingLong (
list(p.header())))
◆ dump_RoIBResult()
| def python.Dumpers.dump_RoIBResult |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5177 of file Dumpers.py.
5178 fprint (f,
'MuCTPI:')
5179 dump_MuCTPIResult (p.muCTPIResult(), f)
5180 fprint (f,
'\nCTP:')
5181 dump_CTPResult (p.cTPResult(), f)
5182 for r
in p.jetEnergyResult():
5183 fprint (f,
'\nJetEnergy:')
5185 for r
in p.eMTauResult():
5186 fprint (f,
'\nEMTau:')
5188 for r
in p.l1TopoResult():
5189 fprint (f,
'\nL1Topo:')
◆ dump_ROIBTrailer()
| def python.Dumpers.dump_ROIBTrailer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5104 of file Dumpers.py.
5105 fprint (f, formatItemUsingLong (
list(p.trailer())))
◆ dump_RoiDescriptor()
| def python.Dumpers.dump_RoiDescriptor |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 3886 of file Dumpers.py.
3888 d.version(), d.isFullscan(),
3889 d.eta(), d.etaPlus(), d.etaMinus(),
3890 d.phi(), d.phiPlus(), d.phiMinus(),
3891 d.zed(), d.zedPlus(), d.zedMinus(),
3892 d.composite(), d.manageConstituents(), d.size(),
3893 formatItemUsingLong ([d.at(i).
roiId()
for i
in range(d.size())]))
◆ dump_RpcClusterOnTrack()
| def python.Dumpers.dump_RpcClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1750 of file Dumpers.py.
1751 dump_MuonClusterOnTrack (p, f)
1752 dump_EL (p.prepRawDataLink(), f)
1753 fprint (f, p.time())
1754 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_RpcCoinData()
| def python.Dumpers.dump_RpcCoinData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4632 of file Dumpers.py.
4633 dump_RpcPrepData (p, f)
4634 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 4739 of file Dumpers.py.
4740 dump_IDC (dump_RpcCoinData, p, f)
◆ dump_RpcCoinMatrix()
| def python.Dumpers.dump_RpcCoinMatrix |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5291 of file Dumpers.py.
5292 fprint (f, p.identify().getString(), p.onlineId(), p.crc(), p.fel1Id(), p.febcId())
5295 dump_RpcFiredChannel (chan, f)
◆ dump_RpcFiredChannel()
| def python.Dumpers.dump_RpcFiredChannel |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5286 of file Dumpers.py.
5287 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 5300 of file Dumpers.py.
5301 dump_IDC (dump_RpcCoinMatrix, p, f,
5302 extra_idc_dumper =
lambda p, f: \
5303 fprint (f, p.identify().getString(), p.onlineId(), p.lvl1Id(), p.bcId(),
5304 p.sector(), p.status(), p.errorCode()))
◆ dump_RpcPrepData()
| def python.Dumpers.dump_RpcPrepData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4626 of file Dumpers.py.
4627 fprint (f, p.time(), p.ambiguityFlag())
4628 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_RpcPrepDataContainer()
| def python.Dumpers.dump_RpcPrepDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4745 of file Dumpers.py.
4746 dump_IDC (dump_RpcPrepData, p, f)
◆ dump_RpcSectorLogic()
| def python.Dumpers.dump_RpcSectorLogic |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5314 of file Dumpers.py.
5315 fprint (f, p.sectorId(), p.fel1Id(), p.bcid(), p.errorCode(), p.crc(),
5316 p.hasMoreThan2TriggerCand(),
5317 list (p.counters()),
5318 list (p.triggerRates()))
5321 dump_RpcSLTriggerHit (hit, f)
◆ dump_RPCSimHit()
| def python.Dumpers.dump_RPCSimHit |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5241 of file Dumpers.py.
5242 fprint (f, p.RPCid(), p.globalTime())
5243 dump_Threevec (p.localPosition(), f)
5244 dump_Threevec (p.postLocalPosition(), f)
5245 fprint (f, p.stepLength(), p.energyDeposit(), p.particleEncoding(), p.kineticEnergy())
5246 dump_HepMcParticleLink (p.particleLink(), f)
◆ dump_RpcSLTriggerHit()
| def python.Dumpers.dump_RpcSLTriggerHit |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5308 of file Dumpers.py.
5309 fprint (f,
'hit', p.rowinBcid(), p.padId(), p.ptId(), p.roi(),
5310 p.outerPlane(), p.overlapPhi(), p.overlapEta(),
5311 p.triggerBcid(), p.isInput())
◆ dump_SaggedLineSurface()
| def python.Dumpers.dump_SaggedLineSurface |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1549 of file Dumpers.py.
1550 dump_StraightLineSurface (info, f)
1552 dump_LineSaggingDescriptor (info.distortionDescriptor())
◆ dump_ScatteringAngles()
| def python.Dumpers.dump_ScatteringAngles |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2233 of file Dumpers.py.
2237 fprint (f,
daz(p.deltaPhi()),
daz(p.deltaTheta()))
2238 fprint (f, p.sigmaDeltaPhi(), p.sigmaDeltaTheta())
◆ dump_SCT_Cluster()
| def python.Dumpers.dump_SCT_Cluster |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4661 of file Dumpers.py.
4662 dump_SiCluster (p, f)
4663 fprint (f, p.hitsInThirdTimeBin())
◆ dump_SCT_ClusterContainer()
| def python.Dumpers.dump_SCT_ClusterContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4775 of file Dumpers.py.
4776 dump_IDC (dump_SCT_Cluster, p, f)
◆ dump_SCT_ClusterOnTrack()
| def python.Dumpers.dump_SCT_ClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1694 of file Dumpers.py.
1695 dump_SiClusterOnTrack (p, f)
1696 dump_EL (p.prepRawDataLink(), f)
1697 fprint (f, p.positionAlongStrip())
1698 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_SCT_RawDataContainer()
| def python.Dumpers.dump_SCT_RawDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4799 of file Dumpers.py.
4800 dump_IDC (dump_SCT_RDORawData, p, f)
◆ dump_SCT_RDORawData()
| def python.Dumpers.dump_SCT_RDORawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4691 of file Dumpers.py.
4692 dump_InDetRawData (p, f)
4693 fprint (f, p.getGroupSize())
◆ dump_SecVtxInfo()
| def python.Dumpers.dump_SecVtxInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1107 of file Dumpers.py.
1108 dump_BaseTagInfo (info, f)
1109 fprint (f,
'\n %d %d %d %d %f %f %f %f %f' %
1111 info.numSelTracksForFit(),
1113 info.NumberOfG2TrackVertices(),
1115 info.rphidistance(),
1118 info.energyFraction()))
1119 return dump_Threevec (info.secVertexPos().position(), f)
◆ dump_Segment()
| def python.Dumpers.dump_Segment |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2322 of file Dumpers.py.
2323 dump_MeasurementBase (p, f)
2324 fprint (f, p.author())
2325 dump_FitQuality (p.fitQuality(), f)
2326 for x
in p.containedMeasurements():
2327 dump_measurement (x, f)
◆ dump_SETrackInfo()
| def python.Dumpers.dump_SETrackInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1222 of file Dumpers.py.
1223 dump_Fourvec (info.electron(), f)
1224 fprint (f,
'%f %f' % (info.d0Value(), info.pTrel()),
1225 [x
for x
in info.tagLikelihood()])
◆ dump_SiCluster()
| def python.Dumpers.dump_SiCluster |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4644 of file Dumpers.py.
4645 dump_PrepRawData (p, f)
4646 fprint (f, p.gangedPixel())
4647 dump_AmgVector (p.globalPosition(), f)
4648 dump_SiWidth (p.width(), f)
4649 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_SiClusterOnTrack()
| def python.Dumpers.dump_SiClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1679 of file Dumpers.py.
1680 dump_RIO_OnTrack (p, f)
1681 fprint (f, p.idDE().
value(), p.isBroadCluster())
1682 dump_AmgVector (p.globalPosition(), f)
◆ dump_SiHit()
| def python.Dumpers.dump_SiHit |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4285 of file Dumpers.py.
4286 fprint (f, t.identify())
4287 dump_Threevec (t.localStartPosition(), f)
4288 dump_Threevec (t.localEndPosition(), f)
4289 fprint (f, t.energyLoss(), t.meanTime(), t.truthBarcode())
4290 dump_HepMcParticleLink (t.particleLink(), f)
◆ dump_SiWidth()
| def python.Dumpers.dump_SiWidth |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4638 of file Dumpers.py.
4639 dump_AmgVector (p.colRow(), f)
4640 dump_AmgVector (p.widthPhiRZ(), f)
◆ dump_SkimDecision()
| def python.Dumpers.dump_SkimDecision |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4433 of file Dumpers.py.
4434 fprint (f, p.getName(), p.isAccepted())
◆ dump_SLTrueInfo()
| def python.Dumpers.dump_SLTrueInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1086 of file Dumpers.py.
1087 fprint (f,
'%d %d %d %d %d %d ' %
1094 dump_H3V (info.momentum(), f)
1096 dump_H3V (info.prodvtx(), f)
◆ dump_SMTrackInfo()
| def python.Dumpers.dump_SMTrackInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1276 of file Dumpers.py.
1277 dump_ParticleImpl (info.muon(), f)
1278 fprint (f, info.d0Value(), info.pTrel(),
list(info.tagLikelihood()))
◆ dump_SoftElectronInfo()
| def python.Dumpers.dump_SoftElectronInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1229 of file Dumpers.py.
1230 dump_BaseTagInfo (info, f)
1231 fprint (f,
' '.
join([
'%f'%x
for x
in info.vectorTrackProb()]),
1232 info.nTrackProb(), info.numTrackInfo())
1233 for i
in range(info.numTrackInfo()):
1235 dump_SETrackInfo (info.getTrackInfo(i), f)
◆ dump_SoftLeptonTruthInfo()
| def python.Dumpers.dump_SoftLeptonTruthInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1099 of file Dumpers.py.
1100 dump_BaseTagInfo (info, f)
1101 for i
in range (info.numSLTrueInfo()):
1103 dump_SLTrueInfo (info.getSLTrueInfo(i), f)
◆ dump_SoftMuonInfo()
| def python.Dumpers.dump_SoftMuonInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1282 of file Dumpers.py.
1283 dump_BaseTagInfo (info, f)
1284 for i
in range (info.numTrackInfo()):
1286 dump_SMTrackInfo (info.getTrackInfo(i), f)
◆ dump_STGC_RawData()
| def python.Dumpers.dump_STGC_RawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5455 of file Dumpers.py.
5456 fprint (f, p.identify().getString(), p.bcTag(), p.time(), p.tdo(), p.charge(),
5457 p.isDead(), p.timeAndChargeInCounts())
◆ dump_STGC_RawDataContainer()
| def python.Dumpers.dump_STGC_RawDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5461 of file Dumpers.py.
5462 dump_IDC (dump_STGC_RawData, p, f)
◆ dump_sTgcClusterOnTrack()
| def python.Dumpers.dump_sTgcClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2155 of file Dumpers.py.
2156 dump_MuonClusterOnTrack (p, f)
2157 dump_EL (p.prepRawDataLink(), f)
2158 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_StraightLineSurface()
| def python.Dumpers.dump_StraightLineSurface |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1526 of file Dumpers.py.
1527 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 1487 of file Dumpers.py.
1488 fprint (f,
typename(info.__class__) +
':')
1489 dump_Threevec (info.center(), f)
1490 dump_Threevec (PyAthena.Trk.Surface.normal (info), f)
1491 if (isinstance (info, PyAthena.Trk.DiscSurface)
and
1492 typename(info.bounds().__class__).find (
'NoBounds') >= 0):
1493 bd_class = info.bounds().__class__
1494 fprint (f,
'(no bounds)')
1495 elif (isinstance (info, PyAthena.Trk.CylinderSurface)
and
1496 (
not info.hasBounds()
or not info.bounds())):
1497 fprint (f,
'(no bounds)')
1498 bd_class = PyAthena.Trk.CylinderBounds
1500 dump_Threevec (info.globalReferencePoint(), f)
1501 bd_class = info.bounds().__class__
1502 if isinstance (info, PyAthena.Trk.CylinderSurface):
1503 dump_AmgVector (info.rotSymmetryAxis(), f)
1505 dump_AmgMatrix (info.transform().
matrix(), f, thresh=1e-8)
1507 layer = tonone (info.associatedLayer())
1509 layer = typename (info.associatedLayer().__class__)
1510 fprint (f,
'\n ly', layer)
1511 fprint (f,
'\n bd',
typename(bd_class))
1513 info.associatedDetectorElementIdentifier().getString())
◆ dump_surface()
| def python.Dumpers.dump_surface |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1556 of file Dumpers.py.
1559 elif isinstance (p, PyAthena.Trk.PerigeeSurface):
1560 dump_PerigeeSurface (p, f)
1561 elif isinstance (p, PyAthena.Trk.PlaneSurface):
1562 dump_PlaneSurface (p, f)
1563 elif isinstance (p, PyAthena.Trk.StraightLineSurface):
1564 dump_StraightLineSurface (p, f)
1565 elif isinstance (p, PyAthena.Trk.CylinderSurface):
1566 dump_CylinderSurface (p, f)
1567 elif isinstance (p, PyAthena.Trk.DiscSurface):
1568 dump_DiscSurface (p, f)
1569 elif isinstance (p, PyAthena.Trk.SaggedLineSurface):
1570 dump_SaggedLineSurface (p, f)
◆ dump_SVInfoBase()
| def python.Dumpers.dump_SVInfoBase |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1152 of file Dumpers.py.
1153 dump_BaseTagInfo (info, f)
◆ dump_SVInfoPlus()
| def python.Dumpers.dump_SVInfoPlus |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1166 of file Dumpers.py.
1167 dump_BaseTagInfo (info, f)
1168 fprint (f, info.getNGTrackInJet(),
1169 info.getNGTrackInSvx(),
1172 info.getEnergyFraction(),
1174 info.numTrackInfo())
1175 fprint (f,
'\n vert: ')
1176 dump_RecVertex (info.getRecSvx(), f)
1177 fprint (f,
'\n tracks: ')
1180 ti = [info.getTrackInfo(i)
for i
in range(info.numTrackInfo())]
1181 ti.sort (key=
lambda a: a.track().
pt(), reverse=
True)
1182 i = info.numTrackInfo()-1
1184 fprint (f,
'\n %d: ' % i)
1185 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 743 of file Dumpers.py.
744 dump_TauDetail (t, f)
745 fprint (f,
' %f %1d %f %f %1d %1d %f %f %f %f' %
750 t.nAssocTracksCore(),
751 t.nAssocTracksIsol(),
757 fprint (f,
' %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f' %
758 (t.isolationFraction(),
765 t.etChrgHADoverPttot(),
772 t.etResChrgEMTrk(0)))
774 dump_HLV (t.sumEM(), f)
776 dump_Threevec (t.secVertex().position(), f)
777 if t.cellEM012Cluster():
778 dump_Fourvec (t.cellEM012Cluster(), f)
779 for i
in range(t.numPi0()):
780 fprint (f,
'\n pi: ')
781 dump_Fourvec (t.pi0 (i), f)
◆ dump_Tau1P3PExtraDetails()
| def python.Dumpers.dump_Tau1P3PExtraDetails |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 807 of file Dumpers.py.
808 dump_TauDetail (t, f)
809 fprint (f, t.sumPTTracks())
814 for tr
in range(t.ntrack()):
815 for s
in range(t.nsamp()):
816 fprint (f,
'\n ', tr, s,
817 t.etaTrackCaloSamp(tr,s), t.phiTrackCaloSamp(tr,s))
◆ dump_TauCommonDetails()
| def python.Dumpers.dump_TauCommonDetails |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 883 of file Dumpers.py.
884 dump_TauDetail (t, f)
885 fprint (f, t.ipZ0SinThetaSigLeadTrk(), t.etOverPtLeadTrk(),
886 t.leadTrkPt(), t.ipSigLeadTrk(), t.ipSigLeadLooseTrk(),
887 t.etOverPtLeadLooseTrk(), t.leadLooseTrkPt(), t.chrgLooseTrk(),
888 t.massTrkSys(), t.trkWidth2())
890 fprint (f, t.trFlightPathSig(), t.etEflow(), t.seedCalo_EMRadius(),
891 t.seedCalo_hadRadius(), t.seedCalo_etEMAtEMScale(),
892 t.seedCalo_etHadAtEMScale(), t.seedCalo_isolFrac(),
893 t.seedCalo_centFrac(), t.seedCalo_stripWidth2(), t.seedCalo_nStrip())
895 fprint (f, t.seedCalo_etEMCalib(), t.seedCalo_etHadCalib(),
896 t.seedCalo_eta(), t.seedCalo_phi(), t.seedCalo_nIsolLooseTrk(),
897 t.seedTrk_EMRadius(), t.seedTrk_isolFrac(),
898 t.seedTrk_etChrgHadOverSumTrkPt(), t.seedTrk_isolFracWide(),
899 t.seedTrk_etHadAtEMScale())
901 fprint (f, t.seedTrk_etEMAtEMScale(), t.seedTrk_etEMCL(),
902 t.seedTrk_etChrgEM(), t.seedTrk_etNeuEM(),
903 t.seedTrk_etResNeuEM(), t.seedTrk_hadLeakEt(),
904 t.seedTrk_sumEMCellEtOverLeadTrkPt(), t.seedTrk_secMaxStripEt(),
905 t.seedTrk_stripWidth2(), t.seedTrk_nStrip())
907 fprint (f, t.seedTrk_etChrgHad(), t.seedTrk_nOtherCoreTrk(),
908 t.seedTrk_nIsolTrk(), t.seedTrk_etIsolEM(), t.seedTrk_etIsolHad())
909 fprint (f,
'\n %d loose tracks' % t.nLooseTrk())
910 looseTrks = t.looseTrk()
911 for i
in range(looseTrks.size()):
913 fprint (f,
'\n ', el.index(), el.dataID(),
914 t.seedTrk_etChrgEM01Trk(i), t.seedTrk_etResChrgEMTrk(i))
915 fprint (f,
'\n %d pi0s' % t.nPi0())
917 for i
in range(vec.size()):
920 fprint (f,
'\n ', el.dataID(), el.e())
921 fprint (f,
'\n pi0 sum:')
922 dump_HLV (t.sumPi0Vec(), f)
923 cl = t.cellEM012ClusterLink()
924 fprint (f,
'\n cluster:')
926 fprint (f, cl.index(), cl.dataID())
928 fprintln (f,
'(invalid)')
929 fprint (f,
'\n secvertex:')
931 dump_RecVertex (t.secVtx(), f)
◆ dump_TauCommonExtraDetails()
| def python.Dumpers.dump_TauCommonExtraDetails |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 962 of file Dumpers.py.
963 dump_TauDetail (t, f)
964 fprint (f, t.sumPtLooseTrk(), t.sumPtTrk(), t.seedCalo_nEMCell(),
965 t.seedCalo_stripEt(), t.seedCalo_EMCentFrac(),
966 t.seedCalo_sumCellEnergy(), t.seedCalo_sumEMCellEnergy())
968 dump_vvelccell (t.closestEtaTrkVertCell(), f)
970 dump_vvelccell (t.closestPhiTrkVertCell(), f)
972 dump_vvelccell (t.closestEtaTrkCell(), f)
974 dump_vvelccell (t.closestPhiTrkCell(), f)
976 dump_vvdouble (t.etaTrkCaloSamp(), f)
978 dump_vvdouble (t.phiTrkCaloSamp(), f)
980 dump_vvdouble (t.etaLooseTrkCaloSamp(), f)
982 dump_vvdouble (t.phiLooseTrkCaloSamp(), f)
◆ dump_TauDetail()
| def python.Dumpers.dump_TauDetail |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 736 of file Dumpers.py.
738 if nm.startswith(
'Analysis::'):
740 fprint (f,
'%s:' % nm)
◆ dump_TauDetailsContainer()
| def python.Dumpers.dump_TauDetailsContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2052 of file Dumpers.py.
2053 fprint (f,
'(Dumped as a part of Analysis::TauJetContainer)')
◆ dump_TauJet()
| def python.Dumpers.dump_TauJet |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 986 of file Dumpers.py.
987 dump_ParticleImpl (t, f)
988 fprint (f,
' %1d' % (t.author(),))
991 fprint (f,
'\n cl: %2d:' % t.clusterLink().
index())
992 dump_Fourvec (t.cluster(), f)
993 if t.cellClusterLink().
isValid():
996 fprint (f,
'\n ce: ')
997 dump_Fourvec (t.cellCluster(), f)
999 fprint (f,
'\n je: %2d:' % t.jetLink().
index())
1001 if j.e() == 0
and j.phi() == 0
and j.eta() == 0:
1002 with signalstate (j, PyAthena.P4SignalState.JETEMSCALE):
1006 for i
in range (t.numTrack()):
1007 el = t.trackLinkVector()[i]
1009 fprint (f,
'\n t%d: %2d:' % (i,el.index()))
1010 dump_Fourvec (t.track(i), f)
1012 TJP = PyAthena.TauJetParameters
1014 fprint (f,
'\n pid: %f %f %f %d %d %d' %
1015 (pid.discriminant(0),
1016 pid.discriminant(1),
1017 pid.discriminant(2),
1018 pid.flag (TJP.ElectronFlag),
1019 pid.flag (TJP.EgammaFlag),
1020 pid.flag (TJP.MuonFlag)))
1021 if hasattr (TJP,
'TauCutLoose'):
1022 flags = [TJP.TauCutLoose,
1031 if hasattr (TJP,
'TauRecOld'):
1032 flags.append (TJP.TauRecOld)
1033 if hasattr (TJP,
'Tau1P3POld'):
1034 flags.append (TJP.Tau1P3POld)
1035 fprint (f,
'\n ', [pid.isTau(ff)
for ff
in flags])
1037 fprint (f,
'\n ', pid.isTau())
1038 for i
in range (t.nDetails()):
1040 if t.detailElementLink(i).
isValid():
1042 if (hasattr (PyAthena.Analysis,
'Tau1P3PDetails')
and
1043 isinstance (d, PyAthena.Analysis.Tau1P3PDetails)):
1044 dump_Tau1P3PDetails (d, f)
1045 elif (hasattr (PyAthena.Analysis,
'TauRecDetails')
and
1046 isinstance (d, PyAthena.Analysis.TauRecDetails)):
1047 dump_TauRecDetails (d, f)
1048 elif (hasattr (PyAthena.Analysis,
'Tau1P3PExtraDetails')
and
1049 isinstance (d, PyAthena.Analysis.Tau1P3PExtraDetails)):
1050 dump_Tau1P3PExtraDetails (d, f)
1051 elif (hasattr (PyAthena.Analysis,
'TauRecExtraDetails')
and
1052 isinstance (d, PyAthena.Analysis.TauRecExtraDetails)):
1053 dump_TauRecExtraDetails (d, f)
1054 elif (hasattr (PyAthena.Analysis,
'TauPi0Details')
and
1055 isinstance (d, PyAthena.Analysis.TauPi0Details)):
1056 dump_TauPi0Details (d, f)
1057 elif isinstance (d, PyAthena.Analysis.TauCommonDetails):
1058 dump_TauCommonDetails (d, f)
1059 elif isinstance (d, PyAthena.Analysis.TauCommonExtraDetails):
1060 dump_TauCommonExtraDetails (d, f)
1062 fprint (f, t.detailName(i), d,
'(not dumped)')
1063 fprint (f,
'\n p: %f %f %f' %
◆ dump_TauPi0Candidate()
| def python.Dumpers.dump_TauPi0Candidate |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 829 of file Dumpers.py.
830 dump_HLV (t.hlv(), f)
832 for c
in t.pi0ClusterVec():
833 fprint (f, c.clusterLink().
index(),
', ')
◆ dump_TauPi0Cluster()
| def python.Dumpers.dump_TauPi0Cluster |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 838 of file Dumpers.py.
839 fprint (f, t.clusterLink().
index(),
849 t.asymmetryInEM1WRTTrk(),
854 t.firstEtaWRTClusterPosition_EM1(),
855 t.firstEtaWRTClusterPosition_EM2(),
856 t.secondEtaWRTClusterPosition_EM1(),
857 t.secondEtaWRTClusterPosition_EM2(),
859 for s
in t.tauShotVec():
860 fprint (f,
'\n shot ')
◆ dump_TauPi0Details()
| def python.Dumpers.dump_TauPi0Details |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 866 of file Dumpers.py.
867 dump_TauDetail (t, f)
868 dump_HLV (t.visTauhlv(), f)
869 fprint (f,
' candidates')
870 for c
in t.pi0CandidateVector():
872 dump_TauPi0Candidate (c, f)
873 fprint (f,
' clusters')
874 for c
in t.pi0ClusterVector():
876 dump_TauPi0Cluster (c, f)
877 for s
in t.shotVector():
878 fprint (f,
'\n shot ')
◆ dump_TauRecDetails()
| def python.Dumpers.dump_TauRecDetails |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 785 of file Dumpers.py.
786 dump_TauDetail (t, f)
788 fprint (f,
'%f %f %f %f %2d %f %f %f' %
790 t.isolationFraction(),
791 t.centralityFraction(),
798 for i
in range(t.numTrack()):
799 fprint (f,
'(%f %f) ' % (t.trackCaloEta(i), t.trackCaloPhi(i)))
801 dump_HLV (t.sumEM(), f)
803 dump_Threevec (t.secVertex().position(), f)
◆ dump_TauRecExtraDetails()
| def python.Dumpers.dump_TauRecExtraDetails |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 821 of file Dumpers.py.
822 dump_TauDetail (t, f)
823 fprint (f, t.numEMCells(), t.stripET(), t.emCentralityFraction(),
824 t.etHadAtEMScale(), t.etEMAtEMScale(), t.energy(), t.emEnergy(),
825 t.sumPTTracks(), t.seedType(),
tonone(t.analysisHelper()))
◆ dump_TauShot()
| def python.Dumpers.dump_TauShot |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 708 of file Dumpers.py.
709 dump_EL (t.clusterLink(), f)
711 dump_EL (t.seedLink(), f)
712 fprint (f,
' %d %d %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f' %
719 t.sdevEta5_WRTmean(),
720 t.sdevEta5_WRTmode(),
◆ dump_TgcBitmask()
| def python.Dumpers.dump_TgcBitmask |
( |
|
p, |
|
|
|
f, |
|
|
|
lab, |
|
|
|
fields |
|
) |
| |
Definition at line 5369 of file Dumpers.py.
5373 if getattr (p, ff): mask += val
5375 fprint (f, lab, hex (mask))
◆ dump_TgcClusterOnTrack()
| def python.Dumpers.dump_TgcClusterOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2148 of file Dumpers.py.
2149 dump_MuonClusterOnTrack (p, f)
2150 dump_EL (p.prepRawDataLink(), f)
2151 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_TgcCoinData()
| def python.Dumpers.dump_TgcCoinData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4594 of file Dumpers.py.
4595 fprint (f, p.type(), p.channelIdIn().getString(), p.channelIdOut().getString(), p.identifyHash().
value())
4596 dump_IdentContIndex (p.getHashAndIndex(), f)
4597 fprint (f, p.isAside(), p.phi(), p.isInner(), p.isForward(), p.isStrip(), p.trackletId(), p.trackletIdStrip())
4598 fprint (f, p.widthIn(), p.widthOut())
4599 fprint (f, p.delta(), p.roi(), p.pt(), p.veto(), p.sub(), p.inner(), p.isPositiveDeltaR())
4600 if p.channelIdIn().get_compact() != 0:
4601 dump_AmgVector (p.posIn(), f, thresh=1e-8)
4602 dump_AmgVector (p.globalposIn(), f, thresh=1e-8)
4603 if p.channelIdOut().get_compact() != 0:
4604 dump_AmgVector (p.posOut(), f, thresh=1e-8)
4605 dump_AmgVector (p.globalposOut(), f, thresh=1e-8)
4607 dump_AmgMatrix (p.errMat(), f)
4608 if p.detectorElementIn():
4609 fprint (f, p.detectorElementIn().identifyHash().
value())
4611 fprint (f,
'(null detel)')
4612 if p.detectorElementOut():
4613 fprint (f, p.detectorElementOut().identifyHash().
value())
4615 fprint (f,
'(null detel)')
◆ dump_TgcCoinDataContainer()
| def python.Dumpers.dump_TgcCoinDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4757 of file Dumpers.py.
4758 dump_IDC (dump_TgcCoinData, p, f)
◆ dump_TgcPrepData()
| def python.Dumpers.dump_TgcPrepData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4587 of file Dumpers.py.
4588 dump_MuonCluster (p, f)
4589 fprint (f, p.getBcBitMap())
4590 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_TgcPrepDataContainer()
| def python.Dumpers.dump_TgcPrepDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4751 of file Dumpers.py.
4752 dump_IDC (dump_TgcPrepData, p, f)
◆ dump_TgcRawData()
| def python.Dumpers.dump_TgcRawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5341 of file Dumpers.py.
5342 fprint (f, p.bcTag(),
5344 p.subDetectorId(), p.rodId(), p.sswId(),
5345 p.slbId(), p.l1Id(), p.bcId(), p.slbType(),
5347 p.bitpos(), p.tracklet(), p.isAdjacent(),
5349 p.type(), p.isForward(), p.index(), p.position(),
5350 p.delta(), p.segment(), p.subMatrix(),
5352 p.sector(), p.chip(), p.isHipt(), p.hitId(), p.hsub(),
5353 p.isStrip(), p.inner(),
5355 p.cand3plus(), p.isMuplus(), p.threshold(), p.isOverlap(),
5356 p.isVeto(), p.roi(), p.innerflag(), p.coinflag(),
5358 p.nsweta(), p.nswphi(), p.nswsl(), p.nswcand(), p.nswdtheta(),
5359 p.nswphires(), p.nswlowres(), p.nswid(),
5361 p.rpceta(), p.rpcphi(), p.rpcflag(), p.rpcdeta(), p.rpcdphi(),
5363 p.ei(), p.fi(), p.cid(),
5365 p.tmdbmod(), p.tmdbbcid())
◆ dump_TgcRdo()
| def python.Dumpers.dump_TgcRdo |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5425 of file Dumpers.py.
5426 fprint (f, p.version(), p.identify(),
5427 p.subDetectorId(), p.rodId(), p.triggerType(),
5428 p.bcId(), p.l1Id(), p.orbit())
5429 dump_TgcRdo_Errors (p.errors(), f)
5430 dump_TgcRdo_RodStatus (p.rodStatus(), f)
5431 dump_TgcRdo_LocalStatus (p.localStatus(), f)
◆ dump_TgcRdo_Errors()
| def python.Dumpers.dump_TgcRdo_Errors |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5377 of file Dumpers.py.
5378 dump_TgcBitmask (p, f,
'err',
◆ dump_TgcRdo_LocalStatus()
| def python.Dumpers.dump_TgcRdo_LocalStatus |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5416 of file Dumpers.py.
5417 dump_TgcBitmask (p, f,
'local',
5419 'mergedTrackletBCs',
◆ dump_TgcRdo_RodStatus()
| def python.Dumpers.dump_TgcRdo_RodStatus |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5385 of file Dumpers.py.
5386 dump_TgcBitmask (p, f,
'rod',
◆ dump_TgcRdoContainer()
| def python.Dumpers.dump_TgcRdoContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5435 of file Dumpers.py.
5436 dump_IDC (dump_TgcRawData, p, f,
5437 extra_idc_dumper = dump_TgcRdo)
◆ dump_TGCSimHit()
| def python.Dumpers.dump_TGCSimHit |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5250 of file Dumpers.py.
5251 fprintln (f, p.TGCid(), p.globalTime())
5252 dump_Threevec (p.localPosition(), f)
5253 dump_Threevec (p.localDireCos(), f)
5254 fprint (f, p.stepLength(), p.energyDeposit(), p.particleEncoding(), p.kineticEnergy())
5255 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 4956 of file Dumpers.py.
4957 fprintln (f, data.get_unit(), data.get_type(), data.get_bsflags())
4962 fprint (f,
'Coll', beg.hashId().
value(), coll.size())
◆ dump_TileDigits()
| def python.Dumpers.dump_TileDigits |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4863 of file Dumpers.py.
4864 dump_TileRawData (p, f)
4865 fprint (f,
list(p.get_digits()))
◆ dump_TileDigitsContainer()
| def python.Dumpers.dump_TileDigitsContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4870 of file Dumpers.py.
4871 fprint (f, p.get_unit(), p.get_type(), p.get_bsflags())
4872 fprint (f, p.hashFunc().
max(), p.hashFunc().
offset(), p.hashFunc().
type())
4876 if hasattr(beg.__class__,
'__preinc__'):
4877 nextfunc = beg.__preinc__
4878 elif hasattr(beg.__class__,
'__next__'):
4879 nextfunc = beg.__next__
4885 beg.hashId().
value(),
4886 list(coll.getFragChipCRCWords()),
4887 list(coll.getFragChipCRCWordsHigh()),
4888 list(coll.getFragChipHeaderWords()),
4889 list(coll.getFragChipHeaderWordsHigh()),
4891 coll.getFragBCID(), coll.getFragSize())
4894 dump_TileDigits (x, f)
◆ dump_TileHit()
| def python.Dumpers.dump_TileHit |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4273 of file Dumpers.py.
4275 fprint (f, t.identify().getString(), [t.energy(i)
for i
in range(sz)],
4276 [t.time(i)
for i
in range(sz)])
◆ dump_TileL2()
| def python.Dumpers.dump_TileL2 |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4970 of file Dumpers.py.
4971 fprint (f, p.identify(), p.phi(0), p.cosphi(), p.sinphi())
4972 fprint (f, [p.sumE(i)
for i
in range(p.NsumE())])
4973 fprint (f, [p.eta(i)
for i
in range(p.NMuons())])
4974 fprint (f, [p.enemu0(i)
for i
in range(p.NMuons())])
4975 fprint (f, [p.enemu1(i)
for i
in range(p.NMuons())])
4976 fprint (f, [p.enemu2(i)
for i
in range(p.NMuons())])
4977 fprint (f, formatItemUsingLong ([p.qual(i)
for i
in range(p.NMuons())]))
4978 fprint (f, formatItemUsingLong ([p.val(i)
for i
in range(p.Ndata())]))
◆ dump_TileMu()
| def python.Dumpers.dump_TileMu |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4194 of file Dumpers.py.
4195 fprint (f, m.eta(), m.phi(), m.quality(),
list(m.enedep()))
◆ dump_TileMuFeature()
| def python.Dumpers.dump_TileMuFeature |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4151 of file Dumpers.py.
4152 fprint (f,
' ', m.eta(), m.phi(), m.quality(),
list(m.enedep()))
◆ dump_TileMuonReceiverObj()
| def python.Dumpers.dump_TileMuonReceiverObj |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4987 of file Dumpers.py.
4988 fprint (f, p.GetID(), list (p.GetDecision()),
4989 list(p.GetThresholds()),
list(p.GetEne()),
list(p.GetTime()))
◆ dump_TileRawChannel()
| def python.Dumpers.dump_TileRawChannel |
( |
|
data, |
|
|
|
f |
|
) |
| |
Definition at line 4901 of file Dumpers.py.
4902 dump_TileRawData (data, f)
4903 fprint (f, [data.amplitude(i)
for i
in range(data.size())])
4904 fprint (f, [data.time(i)
for i
in range(data.sizeTime())])
4905 fprint (f, [data.quality(i)
for i
in range(data.sizeQuality())])
4906 fprint (f, data.pedestal())
◆ dump_TileRawChannelCollection()
| def python.Dumpers.dump_TileRawChannelCollection |
( |
|
data, |
|
|
|
f |
|
) |
| |
Definition at line 4923 of file Dumpers.py.
4924 fprint (f,
'\n ', data.getFragGlobalCRC(),
4925 data.getFragDSPBCID(),
4927 data.getFragMemoryPar(),
4928 data.getFragSstrobe(),
4929 data.getFragDstrobe(),
4930 data.getFragHeaderBit(),
4931 data.getFragHeaderPar(),
4932 data.getFragSampleBit(),
4933 data.getFragSamplePar(),
4934 data.getFragFEChipMask(),
4935 data.getFragRODChipMask())
4936 dump_TileRawDataCollection (data, f)
◆ dump_TileRawChannelContainer()
| def python.Dumpers.dump_TileRawChannelContainer |
( |
|
data, |
|
|
|
f |
|
) |
| |
Definition at line 4941 of file Dumpers.py.
4942 fprintln (f, data.get_unit(), data.get_type(), data.get_bsflags())
4947 fprint (f,
'Coll', beg.hashId().
value(), coll.size())
4948 dump_TileRawChannelCollection (coll, f)
◆ dump_TileRawData()
| def python.Dumpers.dump_TileRawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4858 of file Dumpers.py.
4859 fprint (f, p.identify().getString())
◆ dump_TileRawDataCollection()
| def python.Dumpers.dump_TileRawDataCollection |
( |
|
data, |
|
|
|
f |
|
) |
| |
Definition at line 4911 of file Dumpers.py.
4912 fprint (f,
'\n ', data.identify(),
4915 data.getDetEvType(),
4919 dump_TileRawChannel (x, f)
◆ dump_TileTrackMuFeature()
| def python.Dumpers.dump_TileTrackMuFeature |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4156 of file Dumpers.py.
4158 fprint (f, m.PtTR_Trk(), m.EtaTR_Trk(), m.PhiTR_Trk(), m.Typ_IDTrk())
4159 fprint (f,
'\n ', m.pt(), m.eta(), m.phi(), m.m())
4160 fprint (f,
'\n ', m.TileMuLink().
isValid())
4162 fprintln (f, m.TileMuLink().dataID(), m.TileMuLink().
index())
4163 fprint (f,
'\n ', m.IDScanLink().
isValid())
4165 fprintln (f, m.IDScanLink().dataID(), m.IDScanLink().
index())
◆ dump_TileTTL1()
| def python.Dumpers.dump_TileTTL1 |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4982 of file Dumpers.py.
4983 fprint (f, p.identify().getString(),
list(p.fsamples()))
◆ dump_Track()
| def python.Dumpers.dump_Track |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2293 of file Dumpers.py.
2295 pm = p.trackParameters()
2296 for i
in range(len(pm)):
2298 dump_parameters (pm[i], f)
2300 for x
in p.measurementsOnTrack():
2302 dump_measurement (x, f)
2304 for x
in p.outliersOnTrack():
2306 dump_measurement (x, f)
2308 for x
in p.trackStateOnSurfaces():
2310 dump_TrackStateOnSurface (x, f)
2311 fprint (f,
'\n pp ')
2312 dump_parameters (p.perigeeParameters(), f)
2313 fprint (f,
'\n fq ')
2314 dump_FitQuality (p.fitQuality(), f)
2315 fprint (f,
'\n tm ')
2316 dump_TrackSummary (p.trackSummary(), f)
2317 fprint (f,
'\n ti ')
2318 dump_TrackInfo (p.info(), f)
◆ dump_TrackAssociation()
| def python.Dumpers.dump_TrackAssociation |
( |
|
a, |
|
|
|
f |
|
) |
| |
Definition at line 3532 of file Dumpers.py.
3533 dump_JetAssociationBase (a, f)
3534 fprint (f, a.nTracks())
3536 ROOT.SetOwnership (tr,
True)
3538 fprint (f, a.getTrackWeight (t))
◆ dump_TrackConstituents()
| def python.Dumpers.dump_TrackConstituents |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1310 of file Dumpers.py.
1312 ROOT.SetOwnership (tr,
True)
1314 fprint (f,
'\n tr: ')
1316 fprint (f, info.getTrackWeight(t))
◆ dump_TrackCountingInfo()
| def python.Dumpers.dump_TrackCountingInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1253 of file Dumpers.py.
1254 dump_BaseTagInfo (info, f)
1255 fprint (f,
'%d %f %f %f %f' %
1258 info.d0sig_abs_2nd(),
1260 info.d0sig_abs_3rd()))
◆ dump_TrackInfo()
| def python.Dumpers.dump_TrackInfo |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2286 of file Dumpers.py.
2287 fprint (f, p.trackFitter(), p.particleHypothesis())
2289 fprint (f, p.patternRecognition().
to_string())
◆ dump_TrackParticle()
| def python.Dumpers.dump_TrackParticle |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1627 of file Dumpers.py.
1630 if p.trackParameters().
size() > 0
and p.trackParameters()[-1]:
1631 dp = p.definingParameters()
1633 fprint (f,
"%f" % p.charge())
1636 fprint (f,
"%1d" % p.particleOriginType())
1641 vx = p.reconstructedVertex()
1643 dump_Threevec (vx.recVertex().position(), f)
1645 fprint (f, tonone (vx))
1646 if p.fitQuality() != fitQualityNull:
1648 dump_FitQuality (p.fitQuality(), f)
1649 if p.trackSummary():
1651 dump_TrackSummary (p.trackSummary(), f)
1653 dump_parameters (dp, f)
1655 for x
in p.trackParameters():
1657 dump_parameters (x, f)
◆ dump_TrackParticleAssocs()
| def python.Dumpers.dump_TrackParticleAssocs |
( |
|
a, |
|
|
|
f |
|
) |
| |
Definition at line 3476 of file Dumpers.py.
3477 return dump_Assocs (a, f, PyAthena.Rec.TrackParticleContainer)
◆ dump_TrackParticleTruth()
| def python.Dumpers.dump_TrackParticleTruth |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1421 of file Dumpers.py.
1422 fprint (f,
'%4d %f' % (p.particleLink().
barcode(), p.probability()))
1423 gp = p.particleLink().cptr()
1425 dump_HLV (gp.momentum(), f)
1427 fprint (f,
' (no part)')
◆ dump_TrackParticleTruthCollection()
| def python.Dumpers.dump_TrackParticleTruthCollection |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 1432 of file Dumpers.py.
1433 fprintln (f,
' ', c.trackParticleContainerLink().
isValid())
1434 elclass = PyAthena.ElementLink (PyAthena.Rec.TrackParticleContainer)
1435 for i
in range (c.size()):
1438 cont = PyAthena.Rec.TrackParticleContainer()
1439 el.toIndexedElement (cont, i)
1440 dump_TrackParticleTruth (c[PyAthena.Rec.TrackParticleTruthKey(el)], f)
◆ dump_TrackRecord()
| def python.Dumpers.dump_TrackRecord |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3257 of file Dumpers.py.
3258 dump_H3V (t.GetPosition(), f)
3259 dump_H3V (t.GetMomentum(), f)
3260 fprint (f, t.GetEnergy(),
◆ dump_TrackStateOnSurface()
| def python.Dumpers.dump_TrackStateOnSurface |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2273 of file Dumpers.py.
2274 dump_FitQuality (p.fitQualityOnSurface(), f)
2275 fprint (f,
'\n pm ')
2276 dump_parameters (p.trackParameters(), f)
2277 fprint (f,
'\n ms ')
2278 dump_measurement (p.measurementOnTrack(), f)
2279 fprint (f,
'\n me ')
2280 dump_materialeffects (p.materialEffectsOnTrack(), f)
2281 fprint (f,
'\n ae ')
2282 dump_AlignmentEffectsOnTrack (p.alignmentEffectsOnTrack(), f)
◆ dump_TrackSummary()
| def python.Dumpers.dump_TrackSummary |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1478 of file Dumpers.py.
1480 fprint (f,
'(null)')
1482 fprint (f, [info.get(i)
for i
in range(32)],
1483 [info.isHit(i)
for i
in range(21)])
◆ dump_TrackTruthCollection()
| def python.Dumpers.dump_TrackTruthCollection |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2119 of file Dumpers.py.
2121 fprint (f,
'\n ', x.first.index())
2122 dump_HepMcParticleLink (x.second.particleLink(), f)
2123 fprint (f, x.second.probability())
◆ dump_Trig3Momentum()
| def python.Dumpers.dump_Trig3Momentum |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 3906 of file Dumpers.py.
3907 fprint (f, m.e(), m.eta(), m.phi(), m.inCone(), m.caloSample())
◆ dump_TrigCaloCluster()
| def python.Dumpers.dump_TrigCaloCluster |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 3761 of file Dumpers.py.
3762 fprint (f, c.rawEnergy(), c.rawEt(), c.rawEta(), c.rawPhi(), c.RoIword(),
3763 c.nCells(), c.quality())
3764 fprint (f,
'\n ', [c.rawEnergy(i)
for i
in range(25)])
◆ dump_TrigConfAlg()
| def python.Dumpers.dump_TrigConfAlg |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1907 of file Dumpers.py.
1908 ss = ROOT.ostringstream()
1910 fprint (f, p.index(), ss.str())
◆ dump_TrigConfChain()
| def python.Dumpers.dump_TrigConfChain |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1890 of file Dumpers.py.
1891 fprint (f, p.getName(), p.getChainName(), p.getLowerName(),
1892 p.getId(), p.getCounter(),
1893 p.getLowerId(), p.getLowerCounter(),
1894 p.getLevelId(), p.getPrescale(), p.getPassThrough())
1895 fprint (f,
'\n lower ids',
list(p.getLowerIds()))
1896 fprint (f,
'\n stream ps',
list(p.getStreamPS()))
1897 fprint (f,
'\n stream name',
list(p.getStream()))
1898 fprint (f,
'\n group',
list(p.getGroup()))
1899 fprint (f,
'\n EB hypo',
list(p.getEBHypo()))
1900 fprint (f,
'\n sigs')
1901 for s
in p.getSignature():
1903 dump_TrigConfSig (s, f)
◆ dump_TrigConfKeys()
| def python.Dumpers.dump_TrigConfKeys |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4544 of file Dumpers.py.
4545 fprint (f, p.smk(), p.l1psk(), p.hltpsk())
◆ dump_TrigConfSeq()
| def python.Dumpers.dump_TrigConfSeq |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1913 of file Dumpers.py.
1914 fprint (f, p.getName(), p.getIndex(), p.getId(), p.getTopoTE())
1915 fprint (f,
'\n algs')
1916 for a
in p.getAlg():
1918 dump_TrigConfAlg (a, f)
1919 fprint (f,
'\n input TE',
list(p.getInputTEs()))
◆ dump_TrigConfSig()
| def python.Dumpers.dump_TrigConfSig |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1885 of file Dumpers.py.
1886 fprint (f, p.getCounter(), p.getLogic(), p.getLabel(),
1887 list(p.getOutputTEs()))
◆ dump_TrigDecision()
| def python.Dumpers.dump_TrigDecision |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3120 of file Dumpers.py.
3121 fprint (f, t.masterKey())
3123 dump_Lvl1Result (t.getL1Result(), f)
3125 dump_HLTResult (t.getL2Result(), f)
3127 dump_HLTResult (t.getEFResult(), f)
◆ dump_TrigEFBjet()
| def python.Dumpers.dump_TrigEFBjet |
( |
|
j, |
|
|
|
f |
|
) |
| |
Definition at line 3810 of file Dumpers.py.
3812 fprint (f, j.isValid(), j.roiId())
3813 fprint (f,
'\n ', j.prmVtx(), j.xComb(), j.xIP1D(), j.xIP2D(),
3814 j.xIP3D(), j.xCHI2(), j.xSV(), j.xMVtx(), j.xEVtx(), j.xNVtx())
3815 fprint (f,
'\n ',
tonone(j.TrackCollection()),
3816 tonone(j.PrmVertexCollection()),
3817 tonone(j.SecVertexCollection()))
◆ dump_TrigEFBphys()
| def python.Dumpers.dump_TrigEFBphys |
( |
|
j, |
|
|
|
f |
|
) |
| |
Definition at line 3821 of file Dumpers.py.
3822 fprint (f, j.roiId(), j.particleType(), j.eta(), j.phi(),
3823 j.mass(), j.fitmass(), j.fitchi2(), j.fitndof(),
3824 j.fitx(), j.fity(), j.fitz())
3825 if j.pSecondDecay():
3826 fprint (f,
'\n second:')
3827 dump_TrigEFBphys (j.pSecondDecay(), f)
3828 vec = j.trackVector()
3829 for i
in range(len(vec)):
3831 fprint (f,
'\n tv:')
3833 fprint (f, t.dataID(), t.index())
3835 fprint (f,
'(invalid)')
◆ dump_TrigElectron()
| def python.Dumpers.dump_TrigElectron |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 3781 of file Dumpers.py.
3783 fprint (f, p.isValid(), p.roiId())
3784 fprint (f,
'\n ', p.trackAlgo(), p.trackIndx(), p.charge(),
3786 fprint (f,
'\n ', p.err_Pt(), p.err_eta(), p.err_phi(), p.err_Zvtx())
3787 fprint (f,
'\n ', p.trkClusDeta(), p.trkClusDphi(), p.EtOverPt())
◆ dump_TrigEMCluster()
| def python.Dumpers.dump_TrigEMCluster |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 3768 of file Dumpers.py.
3769 dump_TrigCaloCluster (c, f)
3770 fprint (f,
'\n ', c.energy(), c.et(), c.eta(), c.phi(),
3771 c.e237(), c.e277(), c.fracs1(), c.weta2(),
3772 c.ehad1(), c.Eta1(), c.emaxs1(), c.e2tsts1())
3773 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 3776 of file Dumpers.py.
3777 dump_TrigEMCluster (c, f)
◆ dump_TriggerInfo()
| def python.Dumpers.dump_TriggerInfo |
( |
|
e, |
|
|
|
f |
|
) |
| |
Definition at line 2739 of file Dumpers.py.
2740 fprint (f, e.statusElement(), e.extendedLevel1ID(), e.level1TriggerType())
2741 fprint (f,
'\n l2:', formatItemUsingLong ([x
for x
in e.level2TriggerInfo()]))
2742 fprint (f,
'\n ef:', formatItemUsingLong ([x
for x
in e.eventFilterInfo()]))
2743 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 5194 of file Dumpers.py.
5195 fprint (f, p.eta(), p.phi(), p.key(), p.emError(), p.hadError(),
5196 p.emPeak(), p.emADCPeak(), p.hadPeak(), p.hadADCPeak(),
5199 list(p.emBCIDvec()),
list(p.hadBCIDvec()),
5200 list(p.emBCIDext()),
list(p.hadBCIDext()))
◆ dump_TrigHisto()
| def python.Dumpers.dump_TrigHisto |
( |
|
h, |
|
|
|
f |
|
) |
| |
Definition at line 3958 of file Dumpers.py.
3959 fprint (f,
"x:", h.nbins_x(), h.min_x(), h.max_x(),
'[')
3960 for x
in h.contents():
◆ dump_TrigHisto1D()
| def python.Dumpers.dump_TrigHisto1D |
( |
|
h, |
|
|
|
f |
|
) |
| |
Definition at line 3964 of file Dumpers.py.
3965 dump_TrigHisto (h, f)
◆ dump_TrigHisto2D()
| def python.Dumpers.dump_TrigHisto2D |
( |
|
h, |
|
|
|
f |
|
) |
| |
Definition at line 3967 of file Dumpers.py.
3968 fprint (f,
"y:", h.nbins_y(), h.min_y(), h.max_y())
3969 dump_TrigHisto (h, f)
◆ dump_TrigInDetTrack()
| def python.Dumpers.dump_TrigInDetTrack |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3322 of file Dumpers.py.
3323 fprint (f,
"%d %f %d %d %d %d" %
3330 fprint (f,
tonone(t.siSpacePoints),
tonone(t.trtDriftCircles))
3331 fprint (f,
'\n par')
3333 dump_TrigInDetTrackFitPar (t.param, f)
3336 fprint (f,
'\n end')
3338 dump_TrigInDetTrackFitPar (t.endParam, f)
◆ dump_TrigInDetTrackCollection()
| def python.Dumpers.dump_TrigInDetTrackCollection |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3803 of file Dumpers.py.
3804 fprintln (f,
' ROI ', t.RoI_ID())
3805 t2 = [PyTrigInDetTrack(tt)
for tt
in t]
3806 dump_list (t2, f, dump_TrigInDetTrack)
◆ dump_TrigInDetTrackFitPar()
| def python.Dumpers.dump_TrigInDetTrackFitPar |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 3303 of file Dumpers.py.
3304 fprint (f,
"%f %f %f %f %f %f %f %f %f %f %f %d" %
3315 p.surfaceCoordinate,
3318 fprint (f, [x
for x
in p.cov])
◆ dump_TrigInDetTrackTruth()
| def python.Dumpers.dump_TrigInDetTrackTruth |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3285 of file Dumpers.py.
3286 fprint (f, t.nrMatches())
3287 if t.nrMatches() == 0:
return
3288 fprint (f, t.bestMatch().
barcode(),
3292 t.nrCommonHitsBestSi(),
3293 t.nrCommonHitsBestTRT())
3296 t.nrCommonSiHits(i),
3297 t.nrCommonTRTHits(i))
3298 for i
in range(t.nrMatches())]))
3299 fprint (f, formatItemUsingLong ([(p.first, p.second)
for p
in t.getFamilyTree()]))
◆ dump_TrigInDetTrackTruthMap()
| def python.Dumpers.dump_TrigInDetTrackTruthMap |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 3401 of file Dumpers.py.
3404 tm = [(m.truthi(i), PyTrigInDetTrack(m.tracki(i)))
3406 tm.sort (key = cmp_to_key (_tmcmp))
3407 for (i, (truth, track))
in enumerate(tm):
3408 fprint (f,
'\n ', i)
3409 dump_TrigInDetTrackTruth (truth, f)
3411 dump_TrigInDetTrack (track, f)
◆ dump_TrigL2Bjet()
| def python.Dumpers.dump_TrigL2Bjet |
( |
|
j, |
|
|
|
f |
|
) |
| |
Definition at line 3839 of file Dumpers.py.
3841 fprint (f, j.isValid(), j.roiId())
3842 fprint (f,
'\n ', j.prmVtx(), j.xComb(), j.xIP1D(), j.xIP2D(),
3843 j.xIP3D(), j.xCHI2(), j.xSV(), j.xMVtx(), j.xEVtx(), j.xNVtx())
3845 tonone(j.TrackCollection()),
3846 tonone(j.PrmVertexCollection()),
3847 tonone(j.SecVertexCollection()))
◆ dump_TrigL2Bphys()
| def python.Dumpers.dump_TrigL2Bphys |
( |
|
j, |
|
|
|
f |
|
) |
| |
Definition at line 3851 of file Dumpers.py.
3852 fprint (f, j.roiId(), j.particleType(), j.eta(), j.phi(),
3853 j.mass(), j.fitmass(), j.fitchi2(), j.fitndof(),
3854 j.fitx(), j.fity(), j.fitz())
3855 if j.pSecondDecay():
3856 fprint (f,
'\n second:')
3857 dump_TrigL2Bphys (j.pSecondDecay(), f)
3861 tv = j.trackVector()
3862 for i
in range(tv.size()):
3864 fprint (f,
'\n tv:', t.dataID(), t.index())
◆ dump_TrigMissingET()
| def python.Dumpers.dump_TrigMissingET |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 3868 of file Dumpers.py.
3869 fprint (f,
' ', m.ex(), m.ey(), m.ez(), m.sumEt(), m.sumE(),
3870 m.RoIword(), m.getFlag(), m.getNumOfComponents())
3871 for ic
in range(m.getNumOfComponents()):
3872 fprint (f,
'\n ', m.getNameOfComponent(ic),
3873 m.getExComponent(ic), m.getEyComponent(ic),
3874 m.getEzComponent(ic), m.getSumEtComponent(ic),
3875 m.getSumEComponent(ic), m.getComponentCalib0(ic),
3876 m.getComponentCalib1(ic), m.getSumOfSigns(ic),
3877 m.getUsedChannels(ic), m.getStatus(ic))
◆ dump_TrigMissingET_nolist()
| def python.Dumpers.dump_TrigMissingET_nolist |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 3881 of file Dumpers.py.
3882 dump_TrigMissingET (m, f)
◆ dump_TrigMonAlg()
| def python.Dumpers.dump_TrigMonAlg |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1838 of file Dumpers.py.
1839 fprint (f, [ord(x)
for x
in p.getByte()],
list(p.getWord()))
◆ dump_TrigMonConfig()
| def python.Dumpers.dump_TrigMonConfig |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1922 of file Dumpers.py.
1923 fprint (f,
'r/e/lb', p.getRun(), p.getEvent(), p.getLumi(),
1924 'tm', p.getSec(), p.getNanoSec(),
1925 'keys', p.getMasterKey(), p.getHLTPrescaleKey(),
1926 p.getLVL1PrescaleKey())
1927 fprint (f,
'\n chains')
1928 for r
in p.getChainVec():
1930 dump_TrigConfChain (r, f)
1931 fprint (f,
'\n seqs')
1932 for r
in p.getSeqVec():
1934 dump_TrigMonSeq (r, f)
1935 fprint (f,
'\n key',
list(p.getVarKey()))
1936 fprint (f,
'\n val',
list(p.getVarVal()))
1937 fprint (f,
'\n pairkey',
list(p.getPairKey()))
1938 fprint (f,
'\n pairval',
list(p.getPairVal()))
◆ dump_TrigMonEvent()
| def python.Dumpers.dump_TrigMonEvent |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1859 of file Dumpers.py.
1860 fprint (f,
'r/e/lb/bc', p.getRun(), p.getEvent(), p.getLumi(), p.getBunchId(),
1861 'tm', p.getSec(), p.getNanoSec(),
'addl',
list(p.word()))
1862 fprint (f,
'\n robs')
1863 for r
in p.getROBVec():
1865 dump_TrigMonROB (r, f)
1866 fprint (f,
'\n rois')
1867 for r
in p.getRoiVec():
1869 dump_TrigMonRoi (r, f)
1870 fprint (f,
'\n seq2')
1871 for r
in p.getSeqVec():
1873 dump_TrigMonSeq (r, f)
1874 fprint (f,
'\n tes')
1875 for r
in p.getTEVec():
1877 dump_TrigMonTE (r, f)
1878 fprint (f,
'\n l1',
list(p.getL1Item()))
1879 fprint (f,
'\n hlt',
list(p.getChain()))
1880 fprint (f,
'\n key',
list(p.getVarKey()))
1881 fprint (f,
'\n val',
list(p.getVarVal()))
◆ dump_TrigMonROB()
| def python.Dumpers.dump_TrigMonROB |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1827 of file Dumpers.py.
1828 fprint (f, [(x.getROBId(), x.isStatusOk(), x.isStatusPrefetched(),
1829 x.getROBSize(), x.getEncodedState(), x.getHistory(),
1830 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 1842 of file Dumpers.py.
1843 fprint (f, p.getEncoded(),
list(p.getVarKey()),
list(p.getVarVal()))
1844 for a
in p.getAlg():
1846 dump_TrigMonAlg (a, f)
◆ dump_TrigMonTE()
| def python.Dumpers.dump_TrigMonTE |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1849 of file Dumpers.py.
1850 fprint (f, p.getId(),
1851 p.getIndex(), p.getType(),
1852 p.getActiveState(), p.getErrorState(), p.isTerminalNode(),
1853 p.isOutputL2Node(), p.isOutputEFNode(), p.isTopologicalTE(),
1854 list(p.getChildIndex()), list (p.getParentIndex()),
1855 list(p.getRoiId()),
list(p.getClid()),
1856 list(p.getVarKey()),
list(p.getVarVal()))
◆ dump_TrigMuonClusterFeature()
| def python.Dumpers.dump_TrigMuonClusterFeature |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4469 of file Dumpers.py.
4471 fprint (f, m.getNRoi(), m.getNTRK(), m.getNJet())
◆ dump_TrigMuonEF()
| def python.Dumpers.dump_TrigMuonEF |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4188 of file Dumpers.py.
4190 fprint (f, m.MuonCode(), m.RoINum(), m.charge())
◆ dump_TrigMuonEFInfo()
| def python.Dumpers.dump_TrigMuonEFInfo |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4371 of file Dumpers.py.
4372 fprint (f, t.RoINum())
4373 for tt
in t.TrackContainer():
4374 dump_TrigMuonEFInfoTrack (tt, f)
◆ dump_TrigMuonEFInfoTrack()
| def python.Dumpers.dump_TrigMuonEFInfoTrack |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4360 of file Dumpers.py.
4361 fprint (f,
'\n ', t.MuonType())
4362 fprint (f,
'\n spectrometer: ')
4363 dump_TrigMuonEFTrack (t.SpectrometerTrack(), f)
4364 fprint (f,
'\n extrapolated: ')
4365 dump_TrigMuonEFTrack (t.ExtrapolatedTrack(), f)
4366 fprint (f,
'\n combined: ')
4367 dump_TrigMuonEFTrack (t.CombinedTrack(), f)
◆ dump_TrigMuonEFIsolation()
| def python.Dumpers.dump_TrigMuonEFIsolation |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4492 of file Dumpers.py.
4493 fprint (f, m.sumTrkPtCone02(), m.sumTrkPtCone03(), m.trackPosition())
◆ dump_TrigMuonEFTrack()
| def python.Dumpers.dump_TrigMuonEFTrack |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4351 of file Dumpers.py.
4356 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 4475 of file Dumpers.py.
4476 fprint (f, [b.isPassing(i)
for i
in range(b.size())])
◆ dump_TrigPassFlags()
| def python.Dumpers.dump_TrigPassFlags |
( |
|
m, |
|
|
|
f |
|
) |
| |
Definition at line 4497 of file Dumpers.py.
4499 if hasattr (m,
'getNumObjects'):
4500 for i
in range (m.getNumObjects()):
4502 fprint (f, i,
list(m.getFlag(i,j)
for j
in range(m.getNumFlags(i))))
4504 for i
in range (m.size()):
4506 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 3791 of file Dumpers.py.
3793 fprint (f, p.isValid(), p.roiId())
3794 fprint (f,
'\n ', p.Et(), p.HadEt(), p.energyRatio(), p.rCore(),
3798 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 3897 of file Dumpers.py.
3898 fprint (f,
' ', d.roiId(), d.l1Id(), d.roiWord())
3899 dump_RoiDescriptor (d, f)
◆ dump_TrigRoiDescriptor_nolist()
| def python.Dumpers.dump_TrigRoiDescriptor_nolist |
( |
|
d, |
|
|
|
f |
|
) |
| |
Definition at line 3901 of file Dumpers.py.
3902 dump_TrigRoiDescriptor (d, f)
◆ dump_TrigSpacePointCounts()
| def python.Dumpers.dump_TrigSpacePointCounts |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 3972 of file Dumpers.py.
3973 fprint (f, c.sctSpEndcapC(), c.sctSpBarrel(), c.sctSpEndcapA(),
'[')
3974 for id
in c.droppedSctModules():
3975 fprint (f, id.getString())
3977 fprint (f,
'\n clus endcap c: ')
3978 dump_TrigHisto2D (c.pixelClusEndcapC(), f)
3979 fprint (f,
'\n clus barrel: ')
3980 dump_TrigHisto2D (c.pixelClusBarrel(), f)
3981 fprint (f,
'\n clus endcap a: ')
3982 dump_TrigHisto2D (c.pixelClusEndcapA(), f)
◆ dump_TrigSpacePointCounts_nolist()
| def python.Dumpers.dump_TrigSpacePointCounts_nolist |
( |
|
c, |
|
|
|
f |
|
) |
| |
Definition at line 3985 of file Dumpers.py.
3986 dump_TrigSpacePointCounts (c, f)
◆ dump_TrigT2Jet()
| def python.Dumpers.dump_TrigT2Jet |
( |
|
j, |
|
|
|
f |
|
) |
| |
Definition at line 3911 of file Dumpers.py.
3914 fprint (f,
' ', j.e(), j.ehad0(), j.eem0(), j.eta(), j.phi(), j.m(),
3919 dump_Trig3Momentum (m, f)
◆ dump_TrigT2Jet_nolist()
| def python.Dumpers.dump_TrigT2Jet_nolist |
( |
|
j, |
|
|
|
f |
|
) |
| |
Definition at line 3923 of file Dumpers.py.
3924 dump_TrigT2Jet (j, f)
◆ dump_TrigT2MbtsBits()
| def python.Dumpers.dump_TrigT2MbtsBits |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4303 of file Dumpers.py.
4304 if hasattr(t,
'triggerEnergies'):
4305 fprint (f,
list(t.triggerEnergies()),
list(t.triggerTimes()))
4307 fprint (f, t.mbtsWord(),
list(t.triggerTimes()))
◆ dump_TrigT2ZdcSignals()
| def python.Dumpers.dump_TrigT2ZdcSignals |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 2046 of file Dumpers.py.
2047 fprint (f,
list(p.triggerEnergies()),
list(p.triggerTimes()))
◆ dump_TrigTau()
| def python.Dumpers.dump_TrigTau |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3747 of file Dumpers.py.
3749 fprint (f, t.roiId(), t.Zvtx(), t.err_Zvtx(), t.etCalibCluster(),
3750 t.simpleEtFlow(), t.nMatchedTracks())
3751 fprint (f,
'\n ',
tonone(t.tauCluster()),
3752 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 3940 of file Dumpers.py.
3942 dump_TrigCaloCluster (t, f)
3943 fprint (f,
'\n ', t.energy(), t.EMCalibEnergy(), t.EMenergy(),
3944 t.HADenergy(), t.eta(), t.phi(), t.IsoFrac(), t.numStripCells(),
3945 t.stripWidth(), t.eCalib(), t.eEMCalib(), t.EMRadius2())
3947 fprint (f,
'\n %2d: '% s)
3948 fprint (f, t.energy(s))
3949 dump_TrigTauClusterDetails (t.clusterDetails(), f)
◆ dump_TrigTauCluster_nolist()
| def python.Dumpers.dump_TrigTauCluster_nolist |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3953 of file Dumpers.py.
3954 dump_TrigTauCluster (t, f)
◆ dump_TrigTauClusterDetails()
| def python.Dumpers.dump_TrigTauClusterDetails |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3928 of file Dumpers.py.
3931 fprint (f,
'\n EM%d: '% s)
3932 fprint (f, t.EMRadius(s), t.EMenergyWidth(s), t.EMenergyMedium(s),
3933 t.EMenergyWide(s), t.EMenergyNarrow(s))
3935 fprint (f,
'\n HAD%d: '% s)
3936 fprint (f, t.HADRadius(s), t.HADenergyWidth(s), t.HADenergyMedium(s),
3937 t.HADenergyWide(s), t.HADenergyNarrow(s))
◆ dump_TrigTauTracksInfo()
| def python.Dumpers.dump_TrigTauTracksInfo |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3990 of file Dumpers.py.
3993 fprint (f,
' ', t.roiId(), t.nCoreTracks(), t.nSlowTracks(),
3995 t.charge(), t.leadingTrackPt(), t.scalarPtSumCore(),
3996 t.scalarPtSumIso(), t.ptBalance())
3997 dump_Fourvec (t.threeFastestTracks(), f)
3998 if t.trackCollection():
4000 dump_TrigInDetTrackCollection (t.trackCollection(), f)
◆ dump_TrigTauTracksInfo_nolist()
| def python.Dumpers.dump_TrigTauTracksInfo_nolist |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4004 of file Dumpers.py.
4005 dump_TrigTauTracksInfo (t, f)
◆ dump_TrigTrackCounts()
| def python.Dumpers.dump_TrigTrackCounts |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3735 of file Dumpers.py.
3736 fprint (f,
'z0_pt:')
3737 dump_TrigHisto2D (t.z0_pt(), f)
3738 fprint (f,
'\neta_phi:')
3739 dump_TrigHisto2D (t.eta_phi(), f)
◆ dump_TrigTrackCounts_nolist()
| def python.Dumpers.dump_TrigTrackCounts_nolist |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 3742 of file Dumpers.py.
3743 dump_TrigTrackCounts (t, f)
◆ dump_TrigTrtHitCounts()
| def python.Dumpers.dump_TrigTrtHitCounts |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4383 of file Dumpers.py.
4384 fprint (f,
' barrel')
4385 dump_TrigHisto1D (p.barrel(), f)
4386 fprint (f,
'\n endcapA')
4387 dump_TrigHisto1D (p.endcapA(), f)
4388 fprint (f,
'\n endcapC')
4389 dump_TrigHisto1D (p.endcapC(), f)
◆ dump_TrigVertex()
| def python.Dumpers.dump_TrigVertex |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 3696 of file Dumpers.py.
3697 dump_Threevec (v, f)
3698 fprint (f, v.algorithmId(), v.chi2(), v.ndof(), v.mass(),
3699 v.massVariance(), v.energyFraction(), v.nTwoTracksSecVtx())
3700 fprint (f,
'\n cov: ', [v.cov()[i]
for i
in range(6)])
3701 if v.tracks()
and v.tracks().
size() > 0:
3702 for (i, t)
in enumerate (v.tracks()):
3703 fprint (f,
'\n t%d'%i)
3705 fprint (f, p.a0(), p.z0(), p.phi0(), p.eta(), p.pT())
3706 if v.getMotherTrack():
3707 fprint (f,
'\n mother: ')
3708 dump_TrigInDetTrackFitPar (v.getMotherTrack(), f)
◆ dump_TrigVertexCounts()
| def python.Dumpers.dump_TrigVertexCounts |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 4486 of file Dumpers.py.
4488 formatItemUsingLong (
list(v.vtxNtrks())),
4489 list(v.vtxTrkPtSqSum()))
◆ dump_TRT_BSErrContainer()
| def python.Dumpers.dump_TRT_BSErrContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1797 of file Dumpers.py.
1798 fprint (f,
' Missing errors:', list (p.getMissingErrorSet()))
1799 fprint (f,
'\n Error errors:', list (p.getErrorErrorSet()))
1800 fprint (f,
'\n Sid errors:', list (p.getSidErrorSet()))
1801 fprint (f,
'\n L1 errors:', [(x.first, x.second)
for x
in p.getL1ErrorSet()])
1802 fprint (f,
'\n BCID errors:', [(x.first, x.second)
for x
in p.getBCIDErrorSet()])
1803 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 4667 of file Dumpers.py.
4668 dump_PrepRawData (p, f)
4669 fprint (f, p.getWord())
4670 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_TRT_DriftCircleContainer()
| def python.Dumpers.dump_TRT_DriftCircleContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4781 of file Dumpers.py.
4782 dump_IDC (dump_TRT_DriftCircle, p, f)
◆ dump_TRT_DriftCircleOnTrack()
| def python.Dumpers.dump_TRT_DriftCircleOnTrack |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1702 of file Dumpers.py.
1703 dump_RIO_OnTrack (p, f)
1704 dump_AmgVector (p.globalPosition(), f)
1705 fprint (f, p.idDE().
value())
1706 dump_EL (p.prepRawDataLink(), f)
1707 fprint (f, p.status(), p.localAngle(), p.positionAlongWire())
1708 fprint (f, p.highLevel(), p.timeOverThreshold())
1709 fprint (f, p.detectorElement().identifyHash().
value())
◆ dump_TRT_RawDataContainer()
| def python.Dumpers.dump_TRT_RawDataContainer |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4793 of file Dumpers.py.
4794 dump_IDC (dump_TRT_RDORawData, p, f)
◆ dump_TRT_RDORawData()
| def python.Dumpers.dump_TRT_RDORawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 4685 of file Dumpers.py.
4686 dump_InDetRawData (p, f)
4687 fprint (f, p.highLevel(), p.timeOverThreshold(), p.driftTimeBin())
◆ dump_TRTUncompressedHit()
| def python.Dumpers.dump_TRTUncompressedHit |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 4294 of file Dumpers.py.
4295 fprint (f, t.GetHitID(), t.truthBarcode(), t.GetParticleEncoding(),
4296 t.GetKineticEnergy(), t.GetEnergyDeposit(),
4297 t.GetPreStepX(), t.GetPreStepY(), t.GetPreStepZ(),
4298 t.GetPostStepX(), t.GetPostStepY(), t.GetPostStepZ(),
◆ dump_TruthInfo()
| def python.Dumpers.dump_TruthInfo |
( |
|
info, |
|
|
|
f |
|
) |
| |
Definition at line 1076 of file Dumpers.py.
1077 dump_BaseTagInfo (info, f)
1078 fprint (f,
' %s %f %d ' %
1079 (info.jetTruthLabel(),
1080 info.deltaRMinTo (
'b'),
1082 dump_Threevec (info.BDecayVertex(), f)
◆ dump_TruthParticle()
| def python.Dumpers.dump_TruthParticle |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 1386 of file Dumpers.py.
1387 dump_ParticleImpl (p, f)
1388 poltheta = fix_neg0 (p.polarization().
theta())
1389 fprint (f,
' %3d %3d %f %f %d %d' %
1393 p.polarization().
phi(),
1396 fprint (f,
'\n ', p.hasEtIsol())
1397 dump_HLV (p.genParticle().
momentum(), f)
1399 fprint (f,
'\n p0:')
1403 for i
in range(p.nParents()):
1405 mother = p.genMother(i)
1407 dump_HLV (mother.momentum(), f)
1408 dump_Fourvec (p.mother(mni), f)
1410 fprint (f,
'\n c0:')
1412 for i
in range(p.nDecay()):
1414 child = p.genChild(i)
1416 dump_HLV (child.momentum(), f)
1417 dump_Fourvec (p.child(mni), f)
◆ dump_TruthTrajectory()
| def python.Dumpers.dump_TruthTrajectory |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 1450 of file Dumpers.py.
1451 fprint (f, [l.barcode()
for l
in t])
◆ dump_Twovec()
| def python.Dumpers.dump_Twovec |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 300 of file Dumpers.py.
301 fprint (f,
"(%f %f)" % (v.x(), v.y()))
◆ dump_V0Candidate()
| def python.Dumpers.dump_V0Candidate |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 3688 of file Dumpers.py.
3689 fprint (f,
"V0Candidate", len(v.v0Hypothesis()))
3690 for h
in v.v0Hypothesis():
3692 dump_V0Hypothesis (h, f)
◆ dump_V0Hypothesis()
| def python.Dumpers.dump_V0Hypothesis |
( |
|
h, |
|
|
|
f |
|
) |
| |
Definition at line 3677 of file Dumpers.py.
3681 fprint (f,
'V0Hypothesis', h.positiveTrackID(),
3682 h.negativeTrackID(), h.hypothesisID())
3684 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 2600 of file Dumpers.py.
2601 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 937 of file Dumpers.py.
943 fprint (f,
'(', el.dataID(), el.index(),
') ')
945 fprint (f,
'(invEL) ')
◆ dump_VxCandidate()
| def python.Dumpers.dump_VxCandidate |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 2708 of file Dumpers.py.
2710 if isinstance (v, PyAthena.Trk.MVFVxCandidate):
2711 dump_MVFVxCandidate (v, f)
2712 elif (v.__class__ == PyAthena.Trk.VxCandidate
or
2713 isinstance (v, PyAthena.Trk.V0Hypothesis)):
2714 dump_VxCandidate1 (v, f)
2715 elif isinstance (v, PyAthena.Trk.ExtendedVxCandidate):
2716 dump_ExtendedVxCandidate (v, f)
2719 dump_VxCandidate1 (v, f)
◆ dump_VxCandidate1()
| def python.Dumpers.dump_VxCandidate1 |
( |
|
v, |
|
|
|
f |
|
) |
| |
Definition at line 2676 of file Dumpers.py.
2677 dump_RecVertex (v.recVertex(), f)
2681 tav = v.vxTrackAtVertex()
2682 for i
in range(tav.size()):
2684 fprint (f,
'\n ',
typename(t.__class__))
2685 if isinstance (t, PyAthena.Trk.MVFVxTrackAtVertex):
2686 dump_MVFVxTrackAtVertex (t, f)
2687 elif t.__class__ == PyAthena.Trk.VxTrackAtVertex:
2688 dump_VxTrackAtVertex (t, f)
◆ dump_VxTrackAtVertex()
| def python.Dumpers.dump_VxTrackAtVertex |
( |
|
t, |
|
|
|
f |
|
) |
| |
Definition at line 2635 of file Dumpers.py.
2636 dump_FitQuality (t.trackQuality(), f)
2637 fprint (f,
'%f %f' %
2638 (t.vtxCompatibility(),
2640 fprint (f,
tonone(t.linState()),
tonone(t.ImpactPoint3dAtaPlane()))
2641 if t.perigeeAtVertex():
2643 dump_parameters (t.perigeeAtVertex(), f)
2650 tel = PyAthena.ElementLink (
'DataVector<Trk::Track>')
2651 if not isinstance (t.trackOrParticleLink(), tel):
2654 trk = t.trackOrParticleLink().cptr()
2656 pm = trk.trackParameters()
2657 if pm
and len(pm) > 0:
2659 dump_parameters (perigee, f)
2661 if isinstance (t.trackOrParticleLink(), PyAthena.Trk.LinkToTrack):
2662 dump_LinkToTrack (t.trackOrParticleLink(), f)
2663 elif isinstance (t.trackOrParticleLink(),PyAthena.Trk.LinkToTrackParticleBase):
2664 dump_LinkToTrackParticleBase (t.trackOrParticleLink(), f)
2666 fprint (f, t.trackOrParticleLink())
◆ dump_xAOD()
| def python.Dumpers.dump_xAOD |
( |
|
o, |
|
|
|
f |
|
) |
| |
Definition at line 5727 of file Dumpers.py.
5728 fprint (f,
typename(o.__class__),
'\n ')
5729 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 5526 of file Dumpers.py.
5527 dump_HepMcParticleLink (p.first, f)
5528 dump_EL (p.second, f)
◆ dump_ZdcDigits()
| def python.Dumpers.dump_ZdcDigits |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5269 of file Dumpers.py.
5270 dump_ZdcRawData (p, f)
5271 fprint (f,
list(p.get_digits_gain0_delay0()))
5272 fprint (f,
list(p.get_digits_gain0_delay1()))
5273 fprint (f,
list(p.get_digits_gain1_delay0()))
5274 fprint (f,
list(p.get_digits_gain1_delay1()))
◆ dump_ZdcLucrod_Data()
| def python.Dumpers.dump_ZdcLucrod_Data |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5514 of file Dumpers.py.
5515 fprint (f,
'ld', p.GetLucrodID(),
'bcid', p.GetBCID(),
5516 'run', p.GetRunNumber(),
'l1id', p.GetLevel1ID(),
5517 'nbc', p.GetNumBCs(),
'stat', p.GetStatus(),
5518 'avga/c', p.GetTrigAvgA(), p.GetTrigAvgC(),
5519 'data',
list(p.GetTrigData()))
5520 for i
in range (p.GetChanDataSize()):
5521 ch = p.GetChanData(i)
5522 fprint (f,
'\n chan ', ch.id,
list(ch.waveform))
◆ dump_ZdcRawData()
| def python.Dumpers.dump_ZdcRawData |
( |
|
p, |
|
|
|
f |
|
) |
| |
Definition at line 5264 of file Dumpers.py.
5265 fprint (f, p.identify().getString())
◆ fix_neg0()
| def python.Dumpers.fix_neg0 |
( |
|
x, |
|
|
|
thresh = 0 |
|
) |
| |
library methods ---------------------------------------------------------—
Definition at line 199 of file Dumpers.py.
200 return 0
if x == 0
or abs(x) < thresh
else x
◆ format_dl()
| def python.Dumpers.format_dl |
( |
|
x | ) |
|
Definition at line 5535 of file Dumpers.py.
5538 key =
'(%d)' % x.key()
5539 return f
'DataLink({key})'
◆ format_el()
| def python.Dumpers.format_el |
( |
|
x | ) |
|
Definition at line 5540 of file Dumpers.py.
5541 if x.isDefaultIndex():
5545 key =
'(%d)' % x.key()
5546 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 5588 of file Dumpers.py.
5589 if isinstance(x, float):
5590 return format_float (x)
5591 if isinstance(x, int):
5592 return format_int (x)
5594 if tname.startswith (
'CxxUtils::range_with_conv<'):
5597 if tname.startswith (
'ROOT.'):
5599 if tname.startswith (
'ElementLink<'):
5600 return format_el (x)
5601 if tname.startswith (
'DataLink<'):
5602 return format_dl (x)
5603 if tname.startswith (
'std::vector<')
or tname.startswith (
'vector<'):
5604 ipos = tname.find(
'<')
5605 tname2 = tname[ipos+1:]
5606 if (tname2.startswith(
'char,')
or
5607 tname2.startswith(
'char>')
or
5608 tname2.startswith (
'unsigned char,')
or
5609 tname2.startswith (
'unsigned char>')):
5610 l =
', '.join ([
str(ord(x[i]))
for i
in range(len(x))])
5611 elif tname2.startswith(
'bool,')
or tname2 ==
'bool>':
5612 l =
', '.join ([
str(
bool(xx))
for xx
in x])
5615 return '[' + l +
']'
5616 if isinstance(x, PyAthena.xAOD.CaloClusterBadChannelData_v1):
5617 return '<BadChannel: %6.3f/%6.3f/%2d: %04x>' % \
5618 (x.eta(), x.phi(), x.layer(), x.badChannel())
5619 if tname ==
'set<unsigned int>':
5620 acls=getattr(PyAthena,
'PyDumper::PySTLAdaptor<std::set<unsigned int>')
5624 if tname.startswith (
'std::pair<')
or tname.startswith (
'pair<'):
5627 if tname ==
'Trk::VxTrackAtVertex':
5629 dump_VxTrackAtVertex (x, fout)
5630 out = fout.getvalue()
5631 return '{' + out.replace(
'\n',
'; ') +
'}'
◆ formatItemUsingLong()
| def python.Dumpers.formatItemUsingLong |
( |
|
x | ) |
|
Helper for doing formatting compatibly with py2.
Convert X to a string, but add a `L' to the ends of integers.
Can be used for formatting expressions that using longs in py2.
Definition at line 159 of file Dumpers.py.
160 """Helper for doing formatting compatibly with py2.
162 Convert X to a string, but add a `L' to the ends of integers.
163 Can be used for formatting expressions that using longs in py2.
165 if isinstance (x, list):
166 sl = [formatItemUsingLong (xx)
for xx
in x]
167 return '[' +
', '.join (sl) +
']'
168 if isinstance (x, tuple):
169 sl = [formatItemUsingLong (xx)
for xx
in x]
170 return '(' +
', '.join (sl) +
')'
171 if isinstance (x, int):
173 if isinstance (x, forceInt):
175 if isinstance(x, ROOT.std.string):
◆ generic_dump_auxitem()
| def python.Dumpers.generic_dump_auxitem |
( |
|
x, |
|
|
|
auxid, |
|
|
|
f |
|
) |
| |
Definition at line 5636 of file Dumpers.py.
5637 if hasattr (x,
'container'):
5639 x.container().getConstStore().
getData(auxid)[0]
5641 fprint (f,
'<unavailable 1>')
5644 reg=ROOT.SG.AuxTypeRegistry.instance()
5645 tname = reg.getTypeName (auxid)
5646 ac = ROOT.SG.ConstAuxElement.TypelessConstAccessor (reg.getName(auxid))
5650 fprint (f,
'<unavailable 2>')
5653 obj = ROOT.TPython.CPPInstance_FromVoidPtr (buf, tname)
5655 fprint (f,
'<unknown %s>'%tname)
5657 fprint (f,
format_obj(obj, reg.getName(auxid)))
◆ genvertex_in_barcodes()
| def python.Dumpers.genvertex_in_barcodes |
( |
|
v | ) |
|
Definition at line 2844 of file Dumpers.py.
2845 if hasattr(v,
'particles_in_const_begin'):
2846 parts =
barcodes(v.particles_in_const_begin(),
2847 v.particles_in_const_end(),
2848 v.particles_in_size())
◆ genvertex_out_barcodes()
| def python.Dumpers.genvertex_out_barcodes |
( |
|
v | ) |
|
Definition at line 2853 of file Dumpers.py.
2854 if hasattr(v,
'particles_out_const_begin'):
2855 parts =
barcodes(v.particles_out_const_begin(),
2856 v.particles_out_const_end(),
2857 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 6172 of file Dumpers.py.
6173 """helper function to automatically retrieve the suitable dumper function
6174 given the name of a class or the class-type
6175 @param `klass' a string containing the name of a C++ type or a type
6176 @param `ofile' a file-like instance where to dump the objects' content
6177 @param `nmax` maximum number of container elements to dump
6179 if isinstance(klass, type):
6182 elif isinstance(klass, str):
6183 klass = getattr(PyAthena,klass)
6186 raise TypeError(
'expected a type or a string')
6190 dumpers = [ i
for i
in dumpspecs
if i[0] == klname ]
6191 if len(dumpers) != 1:
6192 raise RuntimeError(
'no suitable dumper function for class [%s]'%
6195 nolist = hasattr (fct,
'nolist')
and fct.nolist
6196 from functools
import partial
as _partial
6199 dumper = _partial(fct, f=ofile, nmax=nmax)
6201 dumper = _partial(fct, f=ofile)
6203 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 3418 of file Dumpers.py.
3419 bv = a.beginAssociation(obj)
3420 ev = a.endAssociation(obj)
3425 targ = bv.__deref__()
3427 except RuntimeError
as e:
3428 if e.args[0].find (
'dereferencing invalid ElementLink') >= 0:
3440 a.assocs (obj, coll)
◆ safe_float_vector()
| def python.Dumpers.safe_float_vector |
( |
|
v | ) |
|
Definition at line 129 of file Dumpers.py.
130 sa = ROOT.PyDumper.SafeFloatAccess(v)
131 return [sa[i]
for i
in range(len(v))]
◆ signalstate()
| def python.Dumpers.signalstate |
( |
|
o, |
|
|
|
state |
|
) |
| |
Definition at line 134 of file Dumpers.py.
135 if hasattr(o,
'setSignalState'):
136 old = o.signalState()
137 o.setSignalState (state)
139 o.setSignalState (old)
141 sh = PyAthena.SignalStateHelper (o)
142 sh.setSignalState (state)
◆ toiter()
| def python.Dumpers.toiter |
( |
|
beg, |
|
|
|
end |
|
) |
| |
◆ toiter1()
| def python.Dumpers.toiter1 |
( |
|
c | ) |
|
Definition at line 100 of file Dumpers.py.
101 return toiter (c.begin(), c.end())
◆ tonone()
| def python.Dumpers.tonone |
( |
|
x | ) |
|
Definition at line 113 of file Dumpers.py.
114 if not x:
return None
◆ typename()
| def python.Dumpers.typename |
( |
|
t | ) |
|
Definition at line 193 of file Dumpers.py.
194 return getattr (t,
'__cpp_name__', t.__name__)
◆ uf()
| def python.Dumpers.uf |
( |
|
x | ) |
|
Definition at line 438 of file Dumpers.py.
439 if abs(x) < 1e-38:
return 0
◆ __author__
| string python.Dumpers.__author__ = "Scott Snyder, Sebastien Binet" |
|
private |
◆ __doc__
| string python.Dumpers.__doc__ = """python library to dump various EDM classes""" |
|
private |
◆ __version__
| string python.Dumpers.__version__ = "$Revision: 1.32 $" |
|
private |
◆ accessors
| dictionary python.Dumpers.accessors |
Initial value:
2 'char' : char_accessor,
3 'unsigned char' : uchar_accessor,
Definition at line 5572 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 5583 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)
Scalar phi() const
phi method
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)
Scalar theta() const
theta method
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