1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
17 // Author: Andrei Gheata, 05/01/2010
19 #include "AliTrigScheduler.h"
23 #include <TObjArray.h>
24 #include "AliTrigScheduledEntry.h"
26 ClassImp(AliTrigScheduledGroup)
28 //==============================================================================
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.
37 //==============================================================================
39 //______________________________________________________________________________
40 AliTrigScheduledGroup::AliTrigScheduledGroup()
49 //______________________________________________________________________________
50 AliTrigScheduledGroup::AliTrigScheduledGroup(const char *name, Int_t priority)
54 fEntries(new TObjArray())
59 //______________________________________________________________________________
60 AliTrigScheduledGroup::~AliTrigScheduledGroup()
63 if (fEntries) delete fEntries;
66 //______________________________________________________________________________
67 void AliTrigScheduledGroup::AddEntry(AliTrigScheduledEntry *entry)
69 // Add a scheduled entry to the group. There is no check if an entry was added twice !
70 if (!fEntries) fEntries = new TObjArray();
74 //______________________________________________________________________________
75 void AliTrigScheduledGroup::FireUp(Int_t time)
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);
86 //______________________________________________________________________________
87 Int_t AliTrigScheduledGroup::GetNentries() const
89 // Get number of scheduled entries in the group.
90 return (fEntries)?fEntries->GetEntriesFast():0;
93 //______________________________________________________________________________
94 void AliTrigScheduledGroup::Print(Option_t *option) const
96 // Print the group content.
97 Int_t nentries = GetNentries();
98 printf("Group: %s containing %d entries.\n", GetName(), nentries);
101 // Check if details are requested.
102 if (!opt.Contains("D")) return;
103 for (Int_t i=0; i<nentries; i++) {
105 fEntries->At(i)->Print(option);
109 //______________________________________________________________________________
110 void AliTrigScheduledGroup::RemoveEntry(AliTrigScheduledEntry *entry)
113 if (!fEntries) return;
114 fEntries->RecursiveRemove(entry);
115 fEntries->Compress();
118 ClassImp(AliTrigScheduledSequence)
120 //==============================================================================
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.
127 //==============================================================================
129 //______________________________________________________________________________
130 AliTrigScheduledSequence::AliTrigScheduledSequence()
134 fType(AliTrigScheduledSequence::kDefault),
140 //______________________________________________________________________________
141 AliTrigScheduledSequence::AliTrigScheduledSequence(const char *name, AliTrigScheduler *scheduler)
143 fScheduler(scheduler),
144 fNgroups(scheduler->GetNgroups()),
145 fType(AliTrigScheduledSequence::kDefault),
150 fArray = new Int_t[fNgroups];
151 for (Int_t i=0; i<fNgroups; i++) fArray[i] = i;
155 //______________________________________________________________________________
156 AliTrigScheduledSequence::~AliTrigScheduledSequence()
159 if (fArray) delete [] fArray;
162 //______________________________________________________________________________
163 void AliTrigScheduledSequence::Print(Option_t *) const
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]);
172 //______________________________________________________________________________
173 void AliTrigScheduledSequence::SortArray(Int_t *array, Bool_t increasing)
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));
182 //______________________________________________________________________________
183 void AliTrigScheduledSequence::Sort(ESortingType type, Int_t *sequence)
185 // Sort the group sequence according a predefined type. The sequence
186 // custom input array is considered only for kCustom type.
190 case AliTrigScheduledSequence::kDefault:
191 // Just ID permutation
192 for (i=0; i<fNgroups; i++) fArray[i] = i;
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();
200 SortArray(array, kTRUE);
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();
208 SortArray(array, kFALSE);
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();
216 SortArray(array, kTRUE);
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();
224 SortArray(array, kFALSE);
226 case AliTrigScheduledSequence::kCustom:
228 Error("Sort", "Sequence array must be provided for custom type");
231 memcpy(fArray, sequence, fNgroups*sizeof(Int_t));
233 if (array) delete [] array;
236 ClassImp(AliTrigScheduler)
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 //==============================================================================
246 //______________________________________________________________________________
247 AliTrigScheduler::AliTrigScheduler()
252 fCurrentSequence(NULL)
257 //______________________________________________________________________________
258 AliTrigScheduler::AliTrigScheduler(const char *name)
261 fGroups(new TObjArray()),
262 fSequences(new TObjArray()),
263 fCurrentSequence(NULL)
267 AddSequence("default");
270 //______________________________________________________________________________
271 AliTrigScheduler::~AliTrigScheduler()
274 if (fGroups) {fGroups->Delete(); delete fGroups;}
275 if (fSequences) {fSequences->Delete(); delete fSequences;}
278 //______________________________________________________________________________
279 void AliTrigScheduler::AddScheduledEntry(AliTrigScheduledEntry *entry, const char *togroup)
281 // Add a scheduled entry to a given group.
282 AliTrigScheduledGroup *group = GetScheduledGroup(togroup);
284 Error("AddScheduledEntry", "Group %s does not exist in scheduler %s", togroup, GetName());
287 group->AddEntry(entry);
290 //______________________________________________________________________________
291 AliTrigScheduledGroup *AliTrigScheduler::AddGroup(const char *groupname)
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);
299 AliTrigScheduledGroup *group = new AliTrigScheduledGroup(groupname);
304 //______________________________________________________________________________
305 AliTrigScheduledGroup *AliTrigScheduler::AddGroup(AliTrigScheduledGroup *group)
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());
317 //______________________________________________________________________________
318 AliTrigScheduledSequence *AliTrigScheduler::AddSequence(const char *seqname, AliTrigScheduledSequence::ESortingType type, Int_t *sequence)
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);
326 AliTrigScheduledSequence *seq = new AliTrigScheduledSequence(seqname, (AliTrigScheduler*)this);
327 seq->Sort(type, sequence);
328 fCurrentSequence = seq;
332 //______________________________________________________________________________
333 void AliTrigScheduler::FireUp(Int_t time)
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]);
345 //______________________________________________________________________________
346 AliTrigScheduledGroup *AliTrigScheduler::GetScheduledGroup(Int_t i) const
348 // Get i-th registered group (scheduling order does not matter, only group addition order).
349 return (AliTrigScheduledGroup*)fGroups->At(i);
352 //______________________________________________________________________________
353 AliTrigScheduledGroup *AliTrigScheduler::GetScheduledGroup(const char *name) const
355 // Get a scheduled group by name.
356 return (AliTrigScheduledGroup*)fGroups->FindObject(name);
359 //______________________________________________________________________________
360 void AliTrigScheduler::SetGroupPriority(const char *groupname, Int_t priority)
362 // Set the priority of a group.
363 AliTrigScheduledGroup *group = GetScheduledGroup(groupname);
365 Error("SetGroupPriority", "Scheduler %s has no group named: %s", GetName(), groupname);
368 group->SetPriority(priority);