RWGCF converted to native cmake
[u/mrichter/AliRoot.git] / TRIGGER / AliTrigScheduler.h
1 #ifndef ALITRIGSCHEDULER_H
2 #define ALITRIGSCHEDULER_H
3 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4  * See cxx source for full Copyright notice                               */
5
6 /* $Id$ */
7 // Author: Andrei Gheata, 27/07/2009
8
9 #ifndef ROOT_TNamed
10 #include "TNamed.h"
11 #endif
12
13 //==============================================================================
14 //
15 //   AliTrigScheduledGroup - A group of scheduled entries that will simply be
16 //                           fired-up sequentially. The group delay in global time
17 //                           units is the latest start time of the contained
18 //                           entries. A group has a priority assigned by the
19 //                           owner scheduler object. Groups are fired-up according
20 //                           a programable sequence.
21 //
22 //==============================================================================
23
24 class TObjArray;
25 class AliTrigScheduledEntry;
26 class AliTrigScheduler;
27
28 //______________________________________________________________________________
29 class AliTrigScheduledGroup : public TNamed {
30
31 private:
32   Int_t                     fPriority;     // Group priority
33   Int_t                     fDelay;        // Group max. delay.
34   TObjArray                *fEntries;      // List of scheduled entries
35
36 private:
37   AliTrigScheduledGroup(const AliTrigScheduledGroup &other);
38   AliTrigScheduledGroup &operator=(const AliTrigScheduledGroup &other);
39
40 public:  
41   AliTrigScheduledGroup();
42   AliTrigScheduledGroup(const char *name, Int_t priority=0);
43   virtual ~AliTrigScheduledGroup();
44   
45   void                      AddEntry(AliTrigScheduledEntry *entry);
46   void                      FireUp(Int_t time);
47   TObjArray                *GetScheduledEntries() const {return fEntries;}
48   Int_t                     GetNentries() const;
49   Int_t                     GetPriority() const {return fPriority;}
50   Int_t                     GetDelay()    const {return fDelay;}
51   virtual void              Print(Option_t *option) const;
52   void                      RemoveEntry(AliTrigScheduledEntry *entry);  
53   void                      SetPriority(Int_t priority) {fPriority = priority;}
54     
55   ClassDef(AliTrigScheduledGroup, 1) // Groups of scheduled response functions
56 };   
57
58 //==============================================================================
59 //
60 //   AliTrigScheduledSequence - A programable group sequence. Scheduled groups
61 //                      are owned and controlled by a trigger scheduler. They
62 //                      are fired-up in such a sequence. A sequence supports some
63 //                      default modes but can also be programed manually.
64 //
65 //==============================================================================
66
67 //______________________________________________________________________________
68 class AliTrigScheduledSequence : public TNamed {
69
70 public:
71 enum ESortingType {
72   kDefault       = 0,
73   kTimeInc       = 1,
74   kTimeDec       = 2,
75   kPriorityInc   = 3,
76   kPriorityDec   = 4,
77   kCustom        = 5
78 };  
79
80 private:
81   AliTrigScheduler         *fScheduler;    // Scheduler to which the sequence applies
82   Int_t                     fNgroups;      // Number of groups
83   ESortingType              fType;         // Sorting type
84   Int_t                    *fArray;        //[fNgroups] Array specifying the sequence
85
86 private:
87   AliTrigScheduledSequence(const AliTrigScheduledSequence &other);
88   AliTrigScheduledSequence &operator=(const AliTrigScheduledSequence &other);
89   void                      SortArray(Int_t *array, Bool_t increasing);
90
91 public:
92   AliTrigScheduledSequence();
93   AliTrigScheduledSequence(const char *name, AliTrigScheduler *scheduler);
94   virtual ~AliTrigScheduledSequence();
95   
96   Int_t                    *GetArray() const {return fArray;}
97   Int_t                     GetNgroups() const {return fNgroups;}
98   AliTrigScheduler         *GetScheduler() const {return fScheduler;}
99   ESortingType              GetSortingType() const {return fType;}
100   virtual void              Print(Option_t *option) const;
101   void                      Sort(ESortingType type, Int_t *sequence=0);
102   
103   ClassDef(AliTrigScheduledSequence, 1)  // Class for a scheduled group sequence
104 };
105
106 //==============================================================================
107 //
108 //   AliTrigScheduler - Device response function scheduler. Every device has a
109 //                      scheduler, but the same scheduler can replay responses of
110 //                      several devices. A scheduler holds groups of scheduled 
111 //                      entries. The groups can be replayed in programable
112 //                      sequences. A default group and sequence are always created.
113 //
114 //==============================================================================
115
116 class AliTrigScheduledGroup;
117 class AliTrigScheduledSequence;
118
119 //______________________________________________________________________________
120 class AliTrigScheduler : public TNamed {
121
122 private:
123   Int_t                     fNgroups;      // Number of scheduled groups (at least one)
124   TObjArray                *fGroups;       // List of groups of response functions
125   TObjArray                *fSequences;    // List of group replay sequences
126   AliTrigScheduledSequence *fCurrentSequence; // Current group replay sequence
127
128 private:
129   AliTrigScheduler(const AliTrigScheduler &other);
130   AliTrigScheduler &operator=(const AliTrigScheduler &other);
131
132 public:
133   AliTrigScheduler();
134   AliTrigScheduler(const char *name);
135   virtual ~AliTrigScheduler();
136   
137   void                      AddScheduledEntry(AliTrigScheduledEntry *entry, const char *togroup="default");
138   AliTrigScheduledGroup    *AddGroup(const char *groupname);
139   AliTrigScheduledGroup    *AddGroup(AliTrigScheduledGroup *group);
140   AliTrigScheduledSequence *AddSequence(const char *seqname, AliTrigScheduledSequence::ESortingType type=AliTrigScheduledSequence::kDefault, 
141                                         Int_t *sequence = 0);
142   void                      FireUp(Int_t time);
143   AliTrigScheduledSequence *GetCurrentSequence() const {return fCurrentSequence;}
144   Int_t                     GetNgroups() const {return fNgroups;}
145   TObjArray                *GetScheduledGroups() const {return fGroups;}
146   AliTrigScheduledGroup    *GetScheduledGroup(Int_t i) const;
147   AliTrigScheduledGroup    *GetScheduledGroup(const char *name) const;
148   void                      SetCurrentSequence(AliTrigScheduledSequence *seq) {fCurrentSequence = seq;}
149   void                      SetGroupPriority(const char *groupname, Int_t priority);
150      
151   ClassDef(AliTrigScheduler,1)  // Trigger scheduler class
152 };
153 #endif