]>
Commit | Line | Data |
---|---|---|
79e35bac | 1 | /************************************************************************** |
2 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
3 | * * | |
4 | * Author: The ALICE Off-line Project. * | |
5 | * Contributors are mentioned in the code where appropriate. * | |
6 | * * | |
7 | * Permission to use, copy, modify and distribute this software and its * | |
8 | * documentation strictly for non-commercial purposes is hereby granted * | |
9 | * without fee, provided that the above copyright notice appears in all * | |
10 | * copies and that both the copyright notice and this permission notice * | |
11 | * appear in the supporting documentation. The authors make no claims * | |
12 | * about the suitability of this software for any purpose. It is * | |
13 | * provided "as is" without express or implied warranty. * | |
14 | **************************************************************************/ | |
15 | ||
16 | /* $Id$ */ | |
17 | // Author: Andrei Gheata, 05/01/2010 | |
18 | ||
19 | #include "AliTrigScheduler.h" | |
20 | ||
21 | #include <TMath.h> | |
22 | #include <TList.h> | |
23 | #include <TObjArray.h> | |
24 | #include "AliTrigScheduledEntry.h" | |
25 | ||
26 | ClassImp(AliTrigScheduledGroup) | |
27 | ||
28 | //============================================================================== | |
29 | // | |
30 | // AliTrigScheduledGroup - A group of scheduled entries that will simply be | |
31 | // fired-up sequentially. The group delay in global time | |
32 | // units is the latest start time of the contained | |
33 | // entries. A group has a priority assigned by the | |
34 | // owner scheduler object. Groups are fired-up according | |
35 | // a programable sequence. | |
36 | // | |
37 | //============================================================================== | |
38 | ||
39 | //______________________________________________________________________________ | |
40 | AliTrigScheduledGroup::AliTrigScheduledGroup() | |
41 | :TNamed(), | |
42 | fPriority(0), | |
43 | fDelay(0), | |
44 | fEntries(NULL) | |
45 | { | |
46 | // I/O constructor. | |
47 | } | |
48 | ||
49 | //______________________________________________________________________________ | |
50 | AliTrigScheduledGroup::AliTrigScheduledGroup(const char *name, Int_t priority) | |
51 | :TNamed(name,""), | |
52 | fPriority(priority), | |
53 | fDelay(0), | |
54 | fEntries(new TObjArray()) | |
55 | { | |
56 | // Constructor. | |
57 | } | |
58 | ||
59 | //______________________________________________________________________________ | |
60 | AliTrigScheduledGroup::~AliTrigScheduledGroup() | |
61 | { | |
62 | // Destructor. | |
63 | if (fEntries) delete fEntries; | |
64 | } | |
65 | ||
66 | //______________________________________________________________________________ | |
67 | void AliTrigScheduledGroup::AddEntry(AliTrigScheduledEntry *entry) | |
68 | { | |
69 | // Add a scheduled entry to the group. There is no check if an entry was added twice ! | |
70 | if (!fEntries) fEntries = new TObjArray(); | |
71 | fEntries->Add(entry); | |
72 | } | |
73 | ||
74 | //______________________________________________________________________________ | |
75 | void AliTrigScheduledGroup::FireUp(Int_t time) | |
76 | { | |
77 | // Fire-up all entries in the group. | |
78 | Int_t nentries = GetNentries(); | |
79 | AliTrigScheduledEntry *entry; | |
80 | for (Int_t i=0; i<nentries; i++) { | |
81 | entry = (AliTrigScheduledEntry*)fEntries->At(i); | |
82 | entry->FireUp(time); | |
83 | } | |
84 | } | |
85 | ||
86 | //______________________________________________________________________________ | |
87 | Int_t AliTrigScheduledGroup::GetNentries() const | |
88 | { | |
89 | // Get number of scheduled entries in the group. | |
90 | return (fEntries)?fEntries->GetEntriesFast():0; | |
91 | } | |
92 | ||
93 | //______________________________________________________________________________ | |
94 | void AliTrigScheduledGroup::Print(Option_t *option) const | |
95 | { | |
96 | // Print the group content. | |
97 | Int_t nentries = GetNentries(); | |
98 | printf("Group: %s containing %d entries.\n", GetName(), nentries); | |
99 | TString opt(option); | |
100 | opt.ToUpper(); | |
101 | // Check if details are requested. | |
102 | if (!opt.Contains("D")) return; | |
103 | for (Int_t i=0; i<nentries; i++) { | |
104 | printf(" %d: ", i); | |
105 | fEntries->At(i)->Print(option); | |
106 | } | |
107 | } | |
108 | ||
109 | //______________________________________________________________________________ | |
110 | void AliTrigScheduledGroup::RemoveEntry(AliTrigScheduledEntry *entry) | |
111 | { | |
112 | // Remove an entry. | |
113 | if (!fEntries) return; | |
114 | fEntries->RecursiveRemove(entry); | |
115 | fEntries->Compress(); | |
116 | } | |
117 | ||
118 | ClassImp(AliTrigScheduledSequence) | |
119 | ||
120 | //============================================================================== | |
121 | // | |
122 | // AliTrigScheduledSequence - A programable group sequence. Scheduled groups | |
123 | // are owned and controlled by a trigger scheduler. They | |
124 | // are fired-up in such a sequence. A sequence supports some | |
125 | // default modes but can also be programed manually. | |
126 | // | |
127 | //============================================================================== | |
128 | ||
129 | //______________________________________________________________________________ | |
130 | AliTrigScheduledSequence::AliTrigScheduledSequence() | |
131 | :TNamed(), | |
132 | fScheduler(NULL), | |
133 | fNgroups(0), | |
134 | fType(AliTrigScheduledSequence::kDefault), | |
135 | fArray(NULL) | |
136 | { | |
137 | // I/O constructor | |
138 | } | |
139 | ||
140 | //______________________________________________________________________________ | |
141 | AliTrigScheduledSequence::AliTrigScheduledSequence(const char *name, AliTrigScheduler *scheduler) | |
142 | :TNamed(name,""), | |
143 | fScheduler(scheduler), | |
144 | fNgroups(scheduler->GetNgroups()), | |
145 | fType(AliTrigScheduledSequence::kDefault), | |
146 | fArray(NULL) | |
147 | { | |
148 | // Constructor | |
149 | if (fNgroups) { | |
150 | fArray = new Int_t[fNgroups]; | |
151 | for (Int_t i=0; i<fNgroups; i++) fArray[i] = i; | |
152 | } | |
153 | } | |
154 | ||
155 | //______________________________________________________________________________ | |
156 | AliTrigScheduledSequence::~AliTrigScheduledSequence() | |
157 | { | |
158 | // Destructor. | |
159 | if (fArray) delete [] fArray; | |
160 | } | |
161 | ||
162 | //______________________________________________________________________________ | |
163 | void AliTrigScheduledSequence::Print(Option_t *) const | |
164 | { | |
165 | // Print the sequence. | |
166 | printf("Sequence: %s scheduled by: %s\n", GetName(), fScheduler->GetName()); | |
167 | printf(" type: %d sequence: ", (Int_t)fType); | |
168 | for (Int_t i=0; i<fNgroups; i++) printf("%d ", fArray[i]); | |
169 | printf("\n"); | |
170 | } | |
171 | ||
172 | //______________________________________________________________________________ | |
173 | void AliTrigScheduledSequence::SortArray(Int_t *array, Bool_t increasing) | |
174 | { | |
175 | // Sort the internal sequence array. | |
176 | Int_t *ind = new Int_t[fNgroups]; | |
177 | TMath::Sort(fNgroups, array, ind, !increasing); | |
178 | memcpy(fArray, ind, fNgroups*sizeof(Int_t)); | |
179 | delete [] ind; | |
180 | } | |
181 | ||
182 | //______________________________________________________________________________ | |
183 | void AliTrigScheduledSequence::Sort(ESortingType type, Int_t *sequence) | |
184 | { | |
185 | // Sort the group sequence according a predefined type. The sequence | |
186 | // custom input array is considered only for kCustom type. | |
187 | Int_t i; | |
188 | Int_t *array = 0; | |
189 | switch (type) { | |
190 | case AliTrigScheduledSequence::kDefault: | |
191 | // Just ID permutation | |
192 | for (i=0; i<fNgroups; i++) fArray[i] = i; | |
193 | break; | |
194 | case AliTrigScheduledSequence::kTimeInc: | |
195 | // Sort by increasing start time | |
196 | array = new Int_t[fNgroups]; | |
197 | for (i=0; i<fNgroups; i++) { | |
198 | array[i] = fScheduler->GetScheduledGroup(i)->GetDelay(); | |
199 | } | |
200 | SortArray(array, kTRUE); | |
201 | break; | |
202 | case AliTrigScheduledSequence::kTimeDec: | |
203 | // Sort by decreasing start time | |
204 | array = new Int_t[fNgroups]; | |
205 | for (i=0; i<fNgroups; i++) { | |
206 | array[i] = fScheduler->GetScheduledGroup(i)->GetDelay(); | |
207 | } | |
208 | SortArray(array, kFALSE); | |
209 | break; | |
210 | case AliTrigScheduledSequence::kPriorityInc: | |
211 | // Sort by increasing priority | |
212 | array = new Int_t[fNgroups]; | |
213 | for (i=0; i<fNgroups; i++) { | |
214 | array[i] = fScheduler->GetScheduledGroup(i)->GetPriority(); | |
215 | } | |
216 | SortArray(array, kTRUE); | |
217 | break; | |
218 | case AliTrigScheduledSequence::kPriorityDec: | |
219 | // Sort by decreasing priority | |
220 | array = new Int_t[fNgroups]; | |
221 | for (i=0; i<fNgroups; i++) { | |
222 | array[i] = fScheduler->GetScheduledGroup(i)->GetPriority(); | |
223 | } | |
224 | SortArray(array, kFALSE); | |
225 | break; | |
226 | case AliTrigScheduledSequence::kCustom: | |
227 | if (!sequence) { | |
228 | Error("Sort", "Sequence array must be provided for custom type"); | |
229 | return; | |
230 | } | |
231 | memcpy(fArray, sequence, fNgroups*sizeof(Int_t)); | |
232 | } | |
233 | if (array) delete [] array; | |
234 | } | |
235 | ||
236 | ClassImp(AliTrigScheduler) | |
237 | ||
238 | //============================================================================== | |
239 | // AliTrigScheduler - Device response function scheduler. Every device has a | |
240 | // scheduler, but the same scheduler can replay responses of | |
241 | // several devices. A scheduler holds groups of scheduled | |
242 | // entries. The groups can be replayed in programable | |
243 | // sequences. A default group and sequence are always created. | |
244 | //============================================================================== | |
245 | ||
246 | //______________________________________________________________________________ | |
247 | AliTrigScheduler::AliTrigScheduler() | |
248 | :TNamed(), | |
249 | fNgroups(0), | |
250 | fGroups(NULL), | |
251 | fSequences(NULL), | |
252 | fCurrentSequence(NULL) | |
253 | { | |
254 | // I/O constructor. | |
255 | } | |
256 | ||
257 | //______________________________________________________________________________ | |
258 | AliTrigScheduler::AliTrigScheduler(const char *name) | |
259 | :TNamed(name,""), | |
260 | fNgroups(0), | |
261 | fGroups(new TObjArray()), | |
262 | fSequences(new TObjArray()), | |
263 | fCurrentSequence(NULL) | |
264 | { | |
265 | // Constructor. | |
266 | AddGroup("default"); | |
267 | AddSequence("default"); | |
268 | } | |
269 | ||
270 | //______________________________________________________________________________ | |
271 | AliTrigScheduler::~AliTrigScheduler() | |
272 | { | |
273 | // Destructor. | |
274 | if (fGroups) {fGroups->Delete(); delete fGroups;} | |
275 | if (fSequences) {fSequences->Delete(); delete fSequences;} | |
276 | } | |
277 | ||
278 | //______________________________________________________________________________ | |
279 | void AliTrigScheduler::AddScheduledEntry(AliTrigScheduledEntry *entry, const char *togroup) | |
280 | { | |
281 | // Add a scheduled entry to a given group. | |
282 | AliTrigScheduledGroup *group = GetScheduledGroup(togroup); | |
283 | if (!group) { | |
284 | Error("AddScheduledEntry", "Group %s does not exist in scheduler %s", togroup, GetName()); | |
285 | return; | |
286 | } | |
287 | group->AddEntry(entry); | |
288 | } | |
289 | ||
290 | //______________________________________________________________________________ | |
291 | AliTrigScheduledGroup *AliTrigScheduler::AddGroup(const char *groupname) | |
292 | { | |
293 | // Add a group to the list of groups. | |
294 | if (!fGroups) fGroups = new TObjArray(); | |
295 | if (fGroups->FindObject(groupname)) { | |
296 | Error("AddGroup", "Scheduler %s contains already a group named: %s", GetName(), groupname); | |
297 | return NULL; | |
298 | } | |
299 | AliTrigScheduledGroup *group = new AliTrigScheduledGroup(groupname); | |
300 | fGroups->Add(group); | |
301 | return group; | |
302 | } | |
303 | ||
304 | //______________________________________________________________________________ | |
305 | AliTrigScheduledGroup *AliTrigScheduler::AddGroup(AliTrigScheduledGroup *group) | |
306 | { | |
307 | // Add a group to the list of groups. | |
308 | if (!fGroups) fGroups = new TObjArray(); | |
309 | if (fGroups->FindObject(group->GetName())) { | |
310 | Error("AddGroup", "Scheduler %s contains already a group named: %s", GetName(), group->GetName()); | |
311 | return NULL; | |
312 | } | |
313 | fGroups->Add(group); | |
314 | return group; | |
315 | } | |
316 | ||
317 | //______________________________________________________________________________ | |
318 | AliTrigScheduledSequence *AliTrigScheduler::AddSequence(const char *seqname, AliTrigScheduledSequence::ESortingType type, Int_t *sequence) | |
319 | { | |
320 | // Add a sequence to the scheduler. Becomes the current sequence. | |
321 | if (!fSequences) fSequences = new TObjArray(); | |
322 | if (fSequences->FindObject(seqname)) { | |
323 | Error("AddSequence", "Scheduler %s contains already a sequence named: %s", GetName(), seqname); | |
324 | return NULL; | |
325 | } | |
326 | AliTrigScheduledSequence *seq = new AliTrigScheduledSequence(seqname, (AliTrigScheduler*)this); | |
327 | seq->Sort(type, sequence); | |
328 | fCurrentSequence = seq; | |
329 | return seq; | |
330 | } | |
331 | ||
332 | //______________________________________________________________________________ | |
333 | void AliTrigScheduler::FireUp(Int_t time) | |
334 | { | |
335 | // Fire-up groups in the order given by the current sequence. | |
336 | if (!fCurrentSequence) Fatal("FireUp", "No scheduled sequence booked for scheduler: %s", GetName()); | |
337 | Int_t *sequence = fCurrentSequence->GetArray(); | |
338 | AliTrigScheduledGroup *group; | |
339 | for (Int_t i=0; i<fNgroups; i++) { | |
340 | group = GetScheduledGroup(sequence[i]); | |
341 | group->FireUp(time); | |
342 | } | |
343 | } | |
344 | ||
345 | //______________________________________________________________________________ | |
346 | AliTrigScheduledGroup *AliTrigScheduler::GetScheduledGroup(Int_t i) const | |
347 | { | |
348 | // Get i-th registered group (scheduling order does not matter, only group addition order). | |
349 | return (AliTrigScheduledGroup*)fGroups->At(i); | |
350 | } | |
351 | ||
352 | //______________________________________________________________________________ | |
353 | AliTrigScheduledGroup *AliTrigScheduler::GetScheduledGroup(const char *name) const | |
354 | { | |
355 | // Get a scheduled group by name. | |
356 | return (AliTrigScheduledGroup*)fGroups->FindObject(name); | |
357 | } | |
358 | ||
359 | //______________________________________________________________________________ | |
360 | void AliTrigScheduler::SetGroupPriority(const char *groupname, Int_t priority) | |
361 | { | |
362 | // Set the priority of a group. | |
363 | AliTrigScheduledGroup *group = GetScheduledGroup(groupname); | |
364 | if (!group) { | |
365 | Error("SetGroupPriority", "Scheduler %s has no group named: %s", GetName(), groupname); | |
366 | return; | |
367 | } | |
368 | group->SetPriority(priority); | |
369 | } | |
370 |