50 m_tf(tf), m_TrackCands() {
76 vector<L1MuBMTrack*> mycands;
79 for (
int wedge = 0; wedge < 12; wedge++ ) {
80 vector<const L1MuBMTrack*> wscand =
m_tf.
ws(wedge)->
tracks();
81 vector<const L1MuBMTrack*>::iterator iter = wscand.begin();
82 while ( iter != wscand.end() ) {
83 if ( *iter && !(*iter)->empty() )
84 mycands.push_back(const_cast<L1MuBMTrack*>(*iter) );
91 cout <<
"BM Muon Sorter input: " 92 << mycands.size() << endl;
93 vector<L1MuBMTrack*>::const_iterator iter;
94 for ( iter = mycands.begin(); iter != mycands.end(); iter++ ) {
95 if (*iter ) (*iter)->print();
103 vector<L1MuBMTrack*>::iterator it = mycands.begin();
104 while ( it != mycands.end() ) {
105 if ( *it && (*it)->empty() ) {
107 it = mycands.begin();
continue;
116 int number_of_tracks = 0;
117 vector<L1MuBMTrack*>::const_iterator iter1 = mycands.begin();
118 while ( iter1 != mycands.end() ) {
119 if ( *iter1 && number_of_tracks < 4 ) {
135 vector<const L1MuBMTrack*>::iterator iter;
149 cout <<
"Muon candidates found by the barrel MTTF : " 151 vector<const L1MuBMTrack*>::const_iterator iter =
m_TrackCands.begin();
153 if ( *iter )
cout << *(*iter) << endl;
171 typedef vector<L1MuBMTrack*>::iterator TI;
172 for ( TI iter1 = cands.begin(); iter1 != cands.end(); iter1++ ) {
173 if ( *iter1 ==
nullptr )
continue;
174 if ( (*iter1)->empty() )
continue;
176 int qual1 = (*iter1)->quality();
177 for ( TI iter2 = cands.begin(); iter2 != cands.end(); iter2++ ) {
178 if ( *iter2 ==
nullptr )
continue;
179 if ( *iter1 == *iter2 )
continue;
180 if ( (*iter2)->empty() )
continue;
182 int qual2 = (*iter2)->quality();
183 if (sp1 == sp2 )
continue;
185 if ( topology == -1 )
continue;
188 int adr1 = (*iter1)->address(
stat);
189 int adr2 = (*iter2)->address(
stat);
190 if ( adr1 == 15 || adr2 == 15 )
continue;
191 switch ( topology ) {
193 if ( adr1 > 7 )
continue;
194 if ( adr2 > 3 && adr2 < 8 )
continue;
195 int adr_shift = ( adr2 > 7 ) ? -8 : 4;
196 if ( adr1 == adr2+adr_shift ) countTS++;
200 if ( adr2 > 7 )
continue;
201 if ( adr1 > 3 && adr1 < 8 )
continue;
202 int adr_shift = ( adr2 > 3 ) ? -4 : 8;
203 if ( adr1 == adr2+adr_shift ) countTS++;
207 if ( ( adr1 == 6 && adr2 == 0 ) ||
208 ( adr1 == 7 && adr2 == 1 ) ||
209 ( adr1 == 2 && adr2 == 8 ) ||
210 ( adr1 == 3 && adr2 == 9 ) ) countTS++;
214 if ( ( adr1 == 2 && adr2 == 4 ) ||
215 ( adr1 == 3 && adr2 == 5 ) ||
216 ( adr1 == 10 && adr2 == 0 ) ||
217 ( adr1 == 11 && adr2 == 1 ) ) countTS++;
221 if ( ( adr1 == 0 && adr2 == 8 ) ||
222 ( adr1 == 1 && adr2 == 9 ) ||
223 ( adr1 == 4 && adr2 == 0 ) ||
224 ( adr1 == 5 && adr2 == 1 ) ) countTS++;
228 if ( ( adr1 == 0 && adr2 == 4 ) ||
229 ( adr1 == 1 && adr2 == 5 ) ||
230 ( adr1 == 8 && adr2 == 0 ) ||
231 ( adr1 == 9 && adr2 == 1 ) ) countTS++;
238 if ( qual1 < qual2 ) {
240 cout <<
"Muon Sorter cancel : "; (*iter1)->print();
247 cout <<
"Muon Sorter cancel : "; (*iter2)->print();
259 for ( TI iter1 = cands.begin(); iter1 != cands.end(); iter1++ ) {
260 if ( *iter1 ==
nullptr )
continue;
261 if ( (*iter1)->empty() )
continue;
262 int phi1 = (*iter1)->phi();
263 int pt1 = (*iter1)->pt();
264 int qual1 = (*iter1)->quality();
265 for ( TI iter2 = cands.begin(); iter2 != cands.end(); iter2++ ) {
266 if ( *iter2 ==
nullptr )
continue;
267 if ( *iter1 == *iter2 )
continue;
268 if ( (*iter2)->empty() )
continue;
269 int phi2 = (*iter2)->phi();
270 int pt2 = (*iter2)->pt();
271 int qual2 = (*iter2)->quality();
272 int w1 = (*iter1)->getStartTSphi().wheel();
273 int w2 = (*iter2)->getStartTSphi().wheel();
274 int phidiff = (phi2 - phi1)%144;
275 if ( phidiff >= 72 ) phidiff -= 144;
276 if ( phidiff < -72 ) phidiff += 144;
277 if (
abs(phidiff) < 2 && (w1 ==
w2) ) {
278 int rank1 = 10 * pt1 + qual1;
279 int rank2 = 10 * pt2 + qual2;
281 cout <<
"========================================" << endl;
282 cout <<
" special cancellation : " << endl;
283 (*iter1)->print();
if ( rank1 < rank2 )
cout <<
"cancelled" << endl;
284 (*iter2)->print();
if ( rank1 >= rank2 )
cout <<
"cancelled" << endl;
285 cout <<
"========================================" << endl;
287 if ( rank1 >= rank2 ) (*iter2)->disable();
288 if ( rank1 < rank2 ) { (*iter1)->disable();
break; }
321 int sector1 = spid1.
sector();
322 int wheel1 = spid1.
wheel();
324 int sector2 = spid2.
sector();
325 int wheel2 = spid2.
wheel();
327 int sectordiff = (sector2 - sector1)%12;
328 if ( sectordiff >= 6 ) sectordiff -= 12;
329 if ( sectordiff < -6 ) sectordiff += 12;
331 if (
abs(sectordiff) == 1 ) {
333 if ( wheel1 == wheel2 ) topology = (sectordiff > 0) ? 1 : 2;
334 if ( wheel1 == +1 && wheel2 == -1 ) topology = (sectordiff > 0) ? 5 : 6;
335 if ( ( wheel1 == -2 && wheel2 == -3 ) ||
336 ( wheel1 == -1 && wheel2 == -2 ) ||
337 ( wheel1 == +1 && wheel2 == +2 ) ||
338 ( wheel1 == +2 && wheel2 == +3 ) ) topology = (sectordiff > 0) ? 3 : 4;
void reset() override
reset Muon Sorter
common ppss p3p6s2 common epss epspn46 common const1 w2
CaloTopology const * topology(0)
void runCOL(std::vector< L1MuBMTrack * > &) const
run the Cancel Out Logic of the muon sorter
const std::vector< const L1MuBMTrack * > & tracks() const
return vector of muon candidates
L1MuBMMuonSorter(const L1MuBMTrackFinder &)
constructor
double phidiff(double phi)
Normalized difference in azimuthal angles to a range between .
int numberOfTracks() const
return number of found muon candidates after sorter
const L1MuBMWedgeSorter * ws(int id) const
get a pointer to a Wedge Sorter, index [0-11]
int sector() const
return sector number
Abs< T >::type abs(const T &t)
void print() const
print results after sorting
static bool rank(const L1MuBMTrack *first, const L1MuBMTrack *second)
define a rank for muon candidates
static int neighbour(const L1MuBMSecProcId &spid1, const L1MuBMSecProcId &spid2)
find out if two Sector Processors are neighbours
const L1MuBMTrackFinder & m_tf
std::vector< const L1MuBMTrack * > m_TrackCands
void run() override
run Muon Sorter
~L1MuBMMuonSorter() override
destructor
int wheel() const
return wheel number