HLT/MUON/src/Tracking/EventHandler.hpp

   1 ////////////////////////////////////////////////////////////////////////////////
   2 //
   3 // Author: Artur Szostak
   4 // Email:  artur@alice.phy.uct.ac.za | artursz@iafrica.com
   5 //
   6 ////////////////////////////////////////////////////////////////////////////////
   7
   8 #ifndef dHLT_TRACKING_EVENT_HANDLER_HPP
   9 #define dHLT_TRACKING_EVENT_HANDLER_HPP
  10
  11 #include <vector>
  12 #include <algorithm>
  13
  14 #include "Buffers/RegionTree.hpp"
  15 #include "Buffers/List.hpp"
  16 #include "Buffers/CountedList.hpp"
  17 #include "Buffers/LookupTable.hpp"
  18
  19 #include "IOInterface.hpp"
  20 #include "Tracking/Tracker.hpp"
  21 #include "Error.hpp"
  22
  23
  24 /*
  25 ostream& operator << (ostream& os, const dHLT::EventID& id)
  26 {
  27         os << "[" << id.bunch << ", " << id.timestamp << "]";
  28         return os;
  29 };
  30 */
  31
  32
  33 namespace dHLT
  34 {
  35 namespace Tracking
  36 {
  37
  38
  39 using dHLT::Buffers::List;
  40 using dHLT::Buffers::CountedList;
  41 using dHLT::Buffers::LookupTable;
  42
  43
  44 class IOHandler;
  45
  46
  47
  48 /////////////////////////////////////////////////////////////////////////////////////////////////
  49
  50 class RegionRegistrationTable
  51 {
  52 public:
  53
  54         struct ClusterBlockRecord
  55         {
  56                 ClusterPoint* clusters;
  57                 UInt count;
  58
  59                 ClusterBlockRecord() {};
  60
  61                 ClusterBlockRecord(ClusterPoint* clusters, UInt count)
  62                 {
  63                         this->clusters = clusters;
  64                         this->count = count;
  65                 };
  66
  67                 friend bool operator == (const ClusterBlockRecord& a, const ClusterBlockRecord& b)
  68                 {
  69                         return a.clusters == b.clusters and a.count == b.count;
  70                 };
  71         };
  72
  73         typedef List<ClusterBlockRecord> ClusterBlockList;
  74
  75
  76         struct TrackerRecord
  77         {
  78                 Tracker* tracker;
  79                 void* tag;
  80
  81                 TrackerRecord(Tracker* newtracker = NULL, void* newtag = NULL)
  82                 {
  83                         tracker = newtracker;
  84                         tag = newtag;
  85                 };
  86
  87                 friend bool operator == (const TrackerRecord& a, const TrackerRecord& b)
  88                 {
  89                         return a.tracker == b.tracker and a.tag == b.tag;
  90                 };
  91
  92                 friend bool operator != (const TrackerRecord& a, const TrackerRecord& b)
  93                 {
  94                         return not (a == b);
  95                 };
  96         };
  97
  98         typedef List<TrackerRecord> TrackerRecordList;
  99
 100
 101         bool AddRequest(
 102                         Tracker* tracker, const void* tag,
 103                         const ChamberID chamber, const UInt left, const UInt bottom, const UChar level,
 104                         ClusterBlockList& foundlist
 105                 )
 106         {
 107                 AddRequestHandler addrequest(tracker, tag, &foundlist);
 108                 regions.ForAllOverlapping(chamber, left, bottom, level, addrequest);
 109                 return addrequest.endofclusters;
 110         };
 111
 112
 113         void AddClusters(
 114                         const ClusterPoint* clusters, const UInt count,
 115                         const ChamberID chamber, const UInt left, const UInt bottom, const UChar level,
 116                         TrackerRecordList& foundlist
 117                 )
 118         {
 119                 AddClustersHandler addblock(clusters, count, &foundlist);
 120                 regions.ForAllOverlapping(chamber, left, bottom, level, addblock);
 121         };
 122
 123
 124         void MarkEndOfClusters(
 125                         const ChamberID chamber, const UInt left, const UInt bottom, const UChar level,
 126                         TrackerRecordList& foundlist
 127                 )
 128         {
 129                 MarkEndOfClustersHandler markendofclusters(&foundlist);
 130                 regions.ForAllOverlapping(chamber, left, bottom, level, markendofclusters);
 131         };
 132
 133
 134 private:
 135
 136         struct TreeRecord
 137         {
 138                 bool endofclusters;
 139                 bool forchildren;     // Set to true if end of clusters flag applies for all children.
 140                 ClusterBlockList clusterblocks;  // The cluster blocks returned so far.
 141                 TrackerRecordList trackers;      // Trackers interested in the region.
 142
 143                 TreeRecord()
 144                 {
 145                         endofclusters = forchildren = false;
 146                 };
 147         };
 148
 149         typedef Buffers::RegionTree<TreeRecord> Tree;
 150
 151
 152         class AddRequestHandler : public Tree::Handler
 153         {
 154         public:
 155
 156                 inline AddRequestHandler(Tracker* tracker, const void* tag, ClusterBlockList* output)
 157                 {
 158                         Assert( output != NULL );
 159                         data.tracker = tracker;
 160                         data.tag =  const_cast<void*>( tag );
 161                         foundlist = output;
 162
 163                         // since we do an and operation on endofclusters, it must be initialised to true.
 164                         endofclusters = true;
 165                 };
 166
 167                 inline void AddTo(Tree::Node* node)
 168                 {
 169                         endofclusters = endofclusters & node->data.endofclusters;
 170                         node->data.trackers.Add(data);
 171                 };
 172
 173                 inline void Initialise(Tree::Node* node, Tree::Node* parent)
 174                 {
 175                         node->data.endofclusters = parent->data.endofclusters & parent->data.forchildren;
 176                 };
 177
 178                 inline void FoundOverlapping(Tree::Node* node)
 179                 {
 180                         for (ClusterBlockList::Iterator block = node->data.clusterblocks.First();
 181                                 block != node->data.clusterblocks.End();
 182                                 block++
 183                                 )
 184                         {
 185                                 foundlist->AddUniquely(*block);
 186                         };
 187                 };
 188
 189                 inline void FoundContained(Tree::Node* node)
 190                 {
 191                         for (ClusterBlockList::Iterator block = node->data.clusterblocks.First();
 192                                 block != node->data.clusterblocks.End();
 193                                 block++
 194                                 )
 195                         {
 196                                 foundlist->AddUniquely(*block);
 197                         };
 198                 };
 199
 200                 TrackerRecord data;
 201                 ClusterBlockList* foundlist;
 202                 bool endofclusters;
 203         };
 204
 205
 206         class AddClustersHandler : public Tree::Handler
 207         {
 208         public:
 209
 210                 inline AddClustersHandler(const ClusterPoint* clusters, const UInt count, TrackerRecordList* output)
 211                 {
 212                         Assert( output != NULL );
 213                         data.clusters = const_cast<ClusterPoint*>( clusters );
 214                         data.count = count;
 215                         foundlist = output;
 216                 };
 217
 218                 inline void AddTo(Tree::Node* node)
 219                 {
 220                         node->data.clusterblocks.Add(data);
 221                 };
 222
 223                 inline void Initialise(Tree::Node* node, Tree::Node* parent)
 224                 {
 225                         node->data.endofclusters = parent->data.endofclusters & parent->data.forchildren;
 226                 };
 227
 228                 inline void FoundOverlapping(Tree::Node* node)
 229                 {
 230                         for (TrackerRecordList::Iterator tracker = node->data.trackers.First();
 231                                 tracker != node->data.trackers.End();
 232                                 tracker++
 233                                 )
 234                         {
 235                                 foundlist->AddUniquely(*tracker);
 236                         };
 237                 };
 238
 239                 inline void FoundContained(Tree::Node* node)
 240                 {
 241                         for (TrackerRecordList::Iterator tracker = node->data.trackers.First();
 242                                 tracker != node->data.trackers.End();
 243                                 tracker++
 244                                 )
 245                         {
 246                                 foundlist->AddUniquely(*tracker);
 247                         };
 248                 };
 249
 250                 ClusterBlockRecord data;
 251                 TrackerRecordList* foundlist;
 252         };
 253
 254
 255         class MarkEndOfClustersHandler : public Tree::Handler
 256         {
 257         public:
 258
 259                 inline MarkEndOfClustersHandler(TrackerRecordList* output)
 260                 {
 261                         Assert( output != NULL );
 262                         foundlist = output;
 263                 };
 264
 265                 inline void AddTo(Tree::Node* node)
 266                 {
 267                         node->data.forchildren = true;
 268                 };
 269
 270                 inline void InitialiseFirst(Tree::Node* node)
 271                 {
 272                         node->data.endofclusters = true;
 273                         node->data.forchildren = false;
 274                 };
 275
 276                 inline void Initialise(Tree::Node* node, Tree::Node* parent)
 277                 {
 278                         node->data.endofclusters = true;
 279                         node->data.forchildren = false;
 280                 };
 281
 282                 inline void FoundOverlapping(Tree::Node* node)
 283                 {
 284                         node->data.endofclusters = true;
 285                         node->data.forchildren = false;
 286                 };
 287
 288                 inline void FoundContained(Tree::Node* node)
 289                 {
 290                         node->data.endofclusters = true;
 291                         node->data.forchildren = true;
 292
 293                         for (TrackerRecordList::Iterator tracker = node->data.trackers.First();
 294                                 tracker != node->data.trackers.End();
 295                                 tracker++
 296                                 )
 297                         {
 298                                 foundlist->AddUniquely(*tracker);
 299                         };
 300                 };
 301
 302                 TrackerRecordList* foundlist;
 303         };
 304
 305
 306         Tree regions;
 307 };
 308
 309
 310 /////////////////////////////////////////////////////////////////////////////////////////////
 311
 312
 313 class EventHandler : public TrackerCallback
 314 {
 315 public:
 316
 317         EventHandler(const EventID event)
 318         {
 319                 eventid = event;
 320                 iohandler = NULL;
 321                 trackblock = NULL;
 322                 maxtrackcount = currenttrackcount = newtrackcount = 0;
 323                 endoftriggers = false;
 324                 endofrequests_count = 0;
 325         };
 326
 327         virtual ~EventHandler() {};
 328
 329         void AddTriggers(const TriggerRecord* triggers, const UInt count);
 330
 331         void EndOfTriggers();
 332
 333         void AddClusters(const ROI region, const ClusterPoint* clusters, const UInt count);
 334
 335         void EndOfClusters(const ROI region);
 336
 337
 338         // TrackerCallback methods
 339
 340         virtual void RequestClusters(
 341                         Tracker* tracker,
 342                         const Float left, const Float right, const Float bottom, const Float top,
 343                         const ChamberID chamber, const void* tag
 344                 );
 345
 346         virtual void EndOfClusterRequests(Tracker* tracker);
 347
 348         virtual void FoundTrack(Tracker* tracker);
 349
 350         virtual void NoTrackFound(Tracker* tracker);
 351
 352         void CheckForTotalEndOfRequests();
 353
 354         void CheckForEndOfTracks();
 355
 356         EventID Key() const { return eventid; };
 357         EventID Event() const { return eventid; };
 358
 359         IOHandler* GetIOHandler() const { return iohandler; };
 360         void SetIOHandler(IOHandler* handler) { iohandler = handler; };
 361
 362 private:
 363
 364         typedef CountedList<Tracker*> TrackerList;
 365
 366         /*
 367         class TrackerList : public List<Tracker*>
 368         {
 369         public:
 370                 TrackerList() : List<Tracker*>()
 371                 {
 372                         count = 0;
 373                 }
 374
 375                 Tracker** Add()
 376                 {
 377                         count++;
 378                         return List<Tracker*>::Add();
 379                 };
 380
 381
 382                 Tracker** AddNew(Tracker* data)
 383                 {
 384                         count++;
 385                         return List<Tracker*>::AddNew(data);
 386                 };
 387
 388                 Tracker** AddUniquely(Tracker* data)
 389                 {
 390                         Tracker** result = Find(data);
 391                         if (result == NULL)
 392                         {
 393                                 count++;
 394                                 return AddNew(data);
 395                         }
 396                         else
 397                                 return result;
 398                 };
 399
 400                 void Remove(const UInt index)
 401                 {
 402                         List<Tracker*>::Remove(index);
 403                         count--;
 404                 };
 405
 406                 bool Remove(Tracker* data)
 407                 {
 408                         bool removed = List<Tracker*>::Remove(data);
 409                         if (removed)
 410                                 count--;
 411                         return removed;
 412                 };
 413
 414                 void Remove(Iterator& iter)
 415                 {
 416                         List<Tracker*>::Remove(iter);
 417                         count--;
 418                 };
 419
 420                 void Clear()
 421                 {
 422                         List<Tracker*>::Clear();
 423                         count = 0;
 424                 };
 425
 426                 UInt Count() const
 427                 {
 428                         return count;
 429                 };
 430
 431         private:
 432
 433                 UInt count;
 434         };
 435         */
 436
 437
 438         EventID eventid;
 439         IOHandler* iohandler;
 440
 441         Track* trackblock;
 442         UInt maxtrackcount, currenttrackcount, newtrackcount;
 443
 444         bool endoftriggers;
 445         UInt endofrequests_count;
 446
 447         TrackerList trackers;
 448         RegionRegistrationTable registration_table;
 449 };
 450
 451
 452 } // Tracking
 453 } // dHLT
 454
 455 #endif // dHLT_TRACKING_EVENT_HANDLER_HPP