ATLAS Offline Software
Functions
ActsTrackingPassFlags Namespace Reference

Functions

def deactivateAthenaComponents (icf)
 
def createActsTrackingPassFlags ()
 
def createActsHeavyIonTrackingPassFlags ()
 
def createActsLargeRadiusTrackingPassFlags ()
 
def createActsConversionTrackingPassFlags ()
 
def createActsLowPtTrackingPassFlags ()
 
def createActsValidateClustersTrackingPassFlags ()
 
def createActsValidateSpacePointsTrackingPassFlags ()
 
def createActsValidateSeedsTrackingPassFlags ()
 
def createActsValidateConversionSeedsTrackingPassFlags ()
 
def createActsValidateLargeRadiusSeedsTrackingPassFlags ()
 
def createActsValidateTracksTrackingPassFlags ()
 
def createActsValidateAmbiguityResolutionTrackingPassFlags ()
 

Function Documentation

◆ createActsConversionTrackingPassFlags()

def ActsTrackingPassFlags.createActsConversionTrackingPassFlags ( )

Definition at line 75 of file ActsTrackingPassFlags.py.

75 def createActsConversionTrackingPassFlags():
76  icf = createITkConversionTrackingPassFlags()
77  icf.extension = "ActsConversion"
78  deactivateAthenaComponents(icf)
79  icf.doActsCluster = True
80  icf.doActsSpacePoint = True
81  icf.doActsSeed = True
82  icf.doActsTrack = True
83  # Ambiguity resolution can follow if ActsTrack is
84  # enabled. Ambi. can be activated/deactivated with
85  # the flag: Acts.doAmbiguityResolution
86  icf.doActsAmbiguityResolution = lambda pcf: pcf.Acts.doAmbiguityResolution
87  # Mark as secondary pass
88  icf.isSecondaryPass = True
89  return icf
90 

◆ createActsHeavyIonTrackingPassFlags()

def ActsTrackingPassFlags.createActsHeavyIonTrackingPassFlags ( )

Definition at line 32 of file ActsTrackingPassFlags.py.

32 def createActsHeavyIonTrackingPassFlags():
33  icf = createITkHeavyIonTrackingPassFlags()
34  icf.extension = "ActsHeavyIon"
35  deactivateAthenaComponents(icf)
36  icf.doAthenaCluster = True
37  icf.doAthenaToActsCluster = True
38  icf.doActsSpacePoint = True
39  icf.doActsSeed = True
40  icf.doActsTrack = True
41  icf.minPTSeed = 0.4
42  # If we do not want acts ambi resolution, first do the track convertion
43  # and then the Athena ambi
44  icf.doActsToAthenaTrack = lambda pcf : not pcf.Acts.doAmbiguityResolution
45  icf.doAthenaAmbiguityResolution = lambda pcf : not pcf.Acts.doAmbiguityResolution
46  # If we want acts ambi, first do the ambi and then convert the tracks
47  # without Athena ambi
48  icf.doActsAmbiguityResolution = lambda pcf : pcf.Acts.doAmbiguityResolution
49  icf.doActsToAthenaResolvedTrack = lambda pcf : pcf.Acts.doAmbiguityResolution
50 
51  # Deactivate CTIDE processor fit
52  icf.doAmbiguityProcessorTrackFit = False
53 
54  return icf
55 

◆ createActsLargeRadiusTrackingPassFlags()

def ActsTrackingPassFlags.createActsLargeRadiusTrackingPassFlags ( )

Definition at line 56 of file ActsTrackingPassFlags.py.

56 def createActsLargeRadiusTrackingPassFlags():
57  icf = createITkLargeD0TrackingPassFlags()
58  icf.extension = "ActsLargeRadius"
59  deactivateAthenaComponents(icf)
60  icf.doActsCluster = True
61  icf.doActsSpacePoint = True
62  icf.doActsSeed = True
63  icf.doActsTrack = True
64  # Ambiguity resolution can follow if ActsTrack is
65  # enabled. Ambi. can be activated/deactivated with
66  # the flag: Acts.doAmbiguityResolution
67  icf.doActsAmbiguityResolution = lambda pcf: pcf.Acts.doAmbiguityResolution
68  # Mark as secondary pass
69  icf.isSecondaryPass = True
70  # For the time being we do not store sepate containers for LRT (to be revised)
71  # In Athena this is handled by the Tracking.storeSeparateLargeD0Container flag
72  icf.storeSeparateContainer = False
73  return icf
74 

◆ createActsLowPtTrackingPassFlags()

def ActsTrackingPassFlags.createActsLowPtTrackingPassFlags ( )

Definition at line 91 of file ActsTrackingPassFlags.py.

91 def createActsLowPtTrackingPassFlags():
92  icf = createITkLowPtTrackingPassFlags()
93  icf.extension = "ActsLowPt"
94  deactivateAthenaComponents(icf)
95  icf.doActsCluster = True
96  icf.doActsSpacePoint = True
97  icf.doActsSeed = True
98  icf.doActsTrack = True
99  # Ambiguity resolution can follow if ActsTrack is
100  # enabled. Ambi. can be activated/deactivated with
101  # the flag: Acts.doAmbiguityResolution
102  icf.doActsAmbiguityResolution = lambda pcf: pcf.Acts.doAmbiguityResolution
103  # Mark as secondary pass
104  icf.isSecondaryPass = True
105  # For the time being we do not store sepate containers for this pass (to be revised)
106  # In Athena this is handled by the Tracking.storeSeparateLargeD0Container flag
107  icf.storeSeparateContainer = False
108  return icf
109 

◆ createActsTrackingPassFlags()

def ActsTrackingPassFlags.createActsTrackingPassFlags ( )

Definition at line 17 of file ActsTrackingPassFlags.py.

17 def createActsTrackingPassFlags():
18  icf = createITkTrackingPassFlags()
19  icf.extension = "Acts"
20  deactivateAthenaComponents(icf)
21  icf.doActsCluster = True
22  icf.doActsSpacePoint = True
23  icf.doActsSeed = True
24  icf.doActsTrack = True
25  # Ambiguity resolution can follow if ActsTrack is
26  # enabled. Ambi. can be activated/deactivated with
27  # the flag: Acts.doAmbiguityResolution
28  icf.doActsAmbiguityResolution = lambda pcf: pcf.Acts.doAmbiguityResolution
29 
30  return icf
31 

◆ createActsValidateAmbiguityResolutionTrackingPassFlags()

def ActsTrackingPassFlags.createActsValidateAmbiguityResolutionTrackingPassFlags ( )

Definition at line 200 of file ActsTrackingPassFlags.py.

200 def createActsValidateAmbiguityResolutionTrackingPassFlags():
201  icf = createITkTrackingPassFlags()
202  icf.extension = "ActsValidateAmbiguityResolution"
203  deactivateAthenaComponents(icf)
204  # The sequence will schedule Athena algorithms from clustering to
205  # track reconstruction, but not the ambi. resolution
206  # We convert tracks, run the acts ambi. resolution and convert
207  # resolved tracks back to Athena EDM
208  icf.doAthenaCluster = True
209  icf.doAthenaSpacePoint = True
210  icf.doAthenaSeed = True
211  icf.doAthenaTrack = True
212  icf.doAthenaToActsTrack = True
213  icf.doActsAmbiguityResolution = True
214  icf.doActsToAthenaResolvedTrack = True
215  return icf

◆ createActsValidateClustersTrackingPassFlags()

def ActsTrackingPassFlags.createActsValidateClustersTrackingPassFlags ( )

Definition at line 110 of file ActsTrackingPassFlags.py.

110 def createActsValidateClustersTrackingPassFlags():
111  icf = createITkTrackingPassFlags()
112  icf.extension = "ActsValidateClusters"
113  deactivateAthenaComponents(icf)
114  icf.doActsCluster = True
115  icf.doActsToAthenaCluster = True
116  icf.doAthenaSpacePoint = True
117  icf.doAthenaSeed = True
118  icf.doAthenaTrack = True
119  icf.doAthenaAmbiguityResolution = True
120  return icf
121 

◆ createActsValidateConversionSeedsTrackingPassFlags()

def ActsTrackingPassFlags.createActsValidateConversionSeedsTrackingPassFlags ( )

Definition at line 148 of file ActsTrackingPassFlags.py.

148 def createActsValidateConversionSeedsTrackingPassFlags():
149  icf = createActsConversionTrackingPassFlags()
150  icf.extension = "ActsValidateConversionSeeds"
151  deactivateAthenaComponents(icf)
152  icf.doAthenaCluster = True
153  icf.doAthenaSpacePoint = True
154  icf.doAthenaToActsSpacePoint = True
155  icf.doActsToAthenaSeed = True
156  icf.doAthenaTrack = True
157  icf.doAthenaAmbiguityResolution = True
158  icf.isSecondaryPass = False
159  return icf
160 

◆ createActsValidateLargeRadiusSeedsTrackingPassFlags()

def ActsTrackingPassFlags.createActsValidateLargeRadiusSeedsTrackingPassFlags ( )

Definition at line 161 of file ActsTrackingPassFlags.py.

161 def createActsValidateLargeRadiusSeedsTrackingPassFlags():
162  icf = createActsLargeRadiusTrackingPassFlags()
163  icf.extension = "ActsValidateLargeRadiusSeeds"
164  deactivateAthenaComponents(icf)
165  icf.doAthenaCluster = True
166  icf.doAthenaSpacePoint = True
167  icf.doAthenaToActsSpacePoint = True
168  icf.doActsToAthenaSeed = True
169  icf.doAthenaTrack = True
170  icf.doAthenaAmbiguityResolution = True
171  icf.isSecondaryPass = False
172  return icf
173 

◆ createActsValidateSeedsTrackingPassFlags()

def ActsTrackingPassFlags.createActsValidateSeedsTrackingPassFlags ( )

Definition at line 136 of file ActsTrackingPassFlags.py.

136 def createActsValidateSeedsTrackingPassFlags():
137  icf = createITkTrackingPassFlags()
138  icf.extension = "ActsValidateSeeds"
139  deactivateAthenaComponents(icf)
140  icf.doAthenaCluster = True
141  icf.doAthenaSpacePoint = True
142  icf.doAthenaToActsSpacePoint = True
143  icf.doActsToAthenaSeed = True
144  icf.doAthenaTrack = True
145  icf.doAthenaAmbiguityResolution = True
146  return icf
147 

◆ createActsValidateSpacePointsTrackingPassFlags()

def ActsTrackingPassFlags.createActsValidateSpacePointsTrackingPassFlags ( )

Definition at line 122 of file ActsTrackingPassFlags.py.

122 def createActsValidateSpacePointsTrackingPassFlags():
123  icf = createITkTrackingPassFlags()
124  icf.extension = "ActsValidateSpacePoints"
125  deactivateAthenaComponents(icf)
126  icf.doAthenaCluster = True
127  icf.doAthenaToActsCluster = True
128  icf.doActsSpacePoint = True
129  # we should schedule here the Acts -> Athena SP converter, but that is not available yet
130  # so we go for the seeding convertion (i.e. ActsTrk::SiSpacePointSeedMaker)
131  icf.doActsToAthenaSeed = True
132  icf.doAthenaTrack = True
133  icf.doAthenaAmbiguityResolution = True
134  return icf
135 

◆ createActsValidateTracksTrackingPassFlags()

def ActsTrackingPassFlags.createActsValidateTracksTrackingPassFlags ( )

Definition at line 174 of file ActsTrackingPassFlags.py.

174 def createActsValidateTracksTrackingPassFlags():
175  icf = createITkTrackingPassFlags()
176  icf.extension = lambda pcf : "ActsValidateTracks" if not pcf.Acts.doAmbiguityResolution else "ActsValidateResolvedTracks"
177  deactivateAthenaComponents(icf)
178  # sequence is still a work in progress
179  # Requires Athena cluster and cluster EDM converter
180  # for adding decoration to cluster objects
181  # It produces Athena TrackCollection EDM
182  icf.doAthenaCluster = True
183  icf.doAthenaToActsCluster = True
184  icf.doActsSpacePoint = True
185  icf.doActsSeed = True
186  icf.doActsTrack = True
187  # If we do not want acts ambi resolution, first do the track convertion
188  # and then the Athena ambi
189  icf.doActsToAthenaTrack = lambda pcf : not pcf.Acts.doAmbiguityResolution
190  icf.doAthenaAmbiguityResolution = lambda pcf : not pcf.Acts.doAmbiguityResolution
191  # If we want acts ambi, first do the ambi and then convert the tracks
192  # without Athena ambi
193  icf.doActsAmbiguityResolution = lambda pcf : pcf.Acts.doAmbiguityResolution
194  icf.doActsToAthenaResolvedTrack = lambda pcf : pcf.Acts.doAmbiguityResolution
195 
196  # Deactivate CTIDE processor fit
197  icf.doAmbiguityProcessorTrackFit = False
198  return icf
199 

◆ deactivateAthenaComponents()

def ActsTrackingPassFlags.deactivateAthenaComponents (   icf)

Definition at line 5 of file ActsTrackingPassFlags.py.

5 def deactivateAthenaComponents(icf):
6  icf.doAthenaCluster = False
7  icf.doAthenaSpacePoint = False
8  icf.doAthenaSeed = False
9  icf.doAthenaTrack = False
10  icf.doAthenaAmbiguityResolution = False
11  icf.doActsCluster = False
12  icf.doActsSpacePoint = False
13  icf.doActsSeed = False
14  icf.doActsTrack = False
15  icf.doActsAmbiguityResolution = False
16 
ActsTrackingPassFlags.createActsValidateClustersTrackingPassFlags
def createActsValidateClustersTrackingPassFlags()
Definition: ActsTrackingPassFlags.py:110
ActsTrackingPassFlags.createActsValidateSeedsTrackingPassFlags
def createActsValidateSeedsTrackingPassFlags()
Definition: ActsTrackingPassFlags.py:136
ActsTrackingPassFlags.createActsLowPtTrackingPassFlags
def createActsLowPtTrackingPassFlags()
Definition: ActsTrackingPassFlags.py:91
ActsTrackingPassFlags.createActsValidateSpacePointsTrackingPassFlags
def createActsValidateSpacePointsTrackingPassFlags()
Definition: ActsTrackingPassFlags.py:122
python.TrackingPassFlags.createITkHeavyIonTrackingPassFlags
def createITkHeavyIonTrackingPassFlags()
Heavyion mode #######################.
Definition: TrackingPassFlags.py:238
ActsTrackingPassFlags.deactivateAthenaComponents
def deactivateAthenaComponents(icf)
Definition: ActsTrackingPassFlags.py:5
python.TrackingPassFlags.createITkConversionTrackingPassFlags
def createITkConversionTrackingPassFlags()
ITkConversion mode ########################.
Definition: TrackingPassFlags.py:578
ActsTrackingPassFlags.createActsValidateLargeRadiusSeedsTrackingPassFlags
def createActsValidateLargeRadiusSeedsTrackingPassFlags()
Definition: ActsTrackingPassFlags.py:161
ActsTrackingPassFlags.createActsValidateTracksTrackingPassFlags
def createActsValidateTracksTrackingPassFlags()
Definition: ActsTrackingPassFlags.py:174
ActsTrackingPassFlags.createActsValidateConversionSeedsTrackingPassFlags
def createActsValidateConversionSeedsTrackingPassFlags()
Definition: ActsTrackingPassFlags.py:148
python.TrackingPassFlags.createITkLowPtTrackingPassFlags
def createITkLowPtTrackingPassFlags()
ITk LowPt mode ####################.
Definition: TrackingPassFlags.py:384
ActsTrackingPassFlags.createActsLargeRadiusTrackingPassFlags
def createActsLargeRadiusTrackingPassFlags()
Definition: ActsTrackingPassFlags.py:56
ActsTrackingPassFlags.createActsTrackingPassFlags
def createActsTrackingPassFlags()
Definition: ActsTrackingPassFlags.py:17
ActsTrackingPassFlags.createActsValidateAmbiguityResolutionTrackingPassFlags
def createActsValidateAmbiguityResolutionTrackingPassFlags()
Definition: ActsTrackingPassFlags.py:200
ActsTrackingPassFlags.createActsHeavyIonTrackingPassFlags
def createActsHeavyIonTrackingPassFlags()
Definition: ActsTrackingPassFlags.py:32
python.TrackingPassFlags.createITkTrackingPassFlags
def createITkTrackingPassFlags()
ITk mode ####################.
Definition: TrackingPassFlags.py:121
python.TrackingPassFlags.createITkLargeD0TrackingPassFlags
def createITkLargeD0TrackingPassFlags()
ITk LRT mode ####################.
Definition: TrackingPassFlags.py:316
ActsTrackingPassFlags.createActsConversionTrackingPassFlags
def createActsConversionTrackingPassFlags()
Definition: ActsTrackingPassFlags.py:75
Generated on Thu Nov 7 2024 22:09:01 for ATLAS Offline Software by   doxygen 1.8.18