#include "AliTrigScheduler.h"
#include <TMath.h>
#include <TList.h>
#include <TObjArray.h>
#include "AliTrigScheduledEntry.h"
ClassImp(AliTrigScheduledGroup)
AliTrigScheduledGroup::AliTrigScheduledGroup()
:TNamed(),
fPriority(0),
fDelay(0),
fEntries(NULL)
{
}
AliTrigScheduledGroup::AliTrigScheduledGroup(const char *name, Int_t priority)
:TNamed(name,""),
fPriority(priority),
fDelay(0),
fEntries(new TObjArray())
{
}
AliTrigScheduledGroup::~AliTrigScheduledGroup()
{
if (fEntries) delete fEntries;
}
void AliTrigScheduledGroup::AddEntry(AliTrigScheduledEntry *entry)
{
if (!fEntries) fEntries = new TObjArray();
fEntries->Add(entry);
}
void AliTrigScheduledGroup::FireUp(Int_t time)
{
Int_t nentries = GetNentries();
AliTrigScheduledEntry *entry;
for (Int_t i=0; i<nentries; i++) {
entry = (AliTrigScheduledEntry*)fEntries->At(i);
entry->FireUp(time);
}
}
Int_t AliTrigScheduledGroup::GetNentries() const
{
return (fEntries)?fEntries->GetEntriesFast():0;
}
void AliTrigScheduledGroup::Print(Option_t *option) const
{
Int_t nentries = GetNentries();
printf("Group: %s containing %d entries.\n", GetName(), nentries);
TString opt(option);
opt.ToUpper();
if (!opt.Contains("D")) return;
for (Int_t i=0; i<nentries; i++) {
printf(" %d: ", i);
fEntries->At(i)->Print(option);
}
}
void AliTrigScheduledGroup::RemoveEntry(AliTrigScheduledEntry *entry)
{
if (!fEntries) return;
fEntries->RecursiveRemove(entry);
fEntries->Compress();
}
ClassImp(AliTrigScheduledSequence)
AliTrigScheduledSequence::AliTrigScheduledSequence()
:TNamed(),
fScheduler(NULL),
fNgroups(0),
fType(AliTrigScheduledSequence::kDefault),
fArray(NULL)
{
}
AliTrigScheduledSequence::AliTrigScheduledSequence(const char *name, AliTrigScheduler *scheduler)
:TNamed(name,""),
fScheduler(scheduler),
fNgroups(scheduler->GetNgroups()),
fType(AliTrigScheduledSequence::kDefault),
fArray(NULL)
{
if (fNgroups) {
fArray = new Int_t[fNgroups];
for (Int_t i=0; i<fNgroups; i++) fArray[i] = i;
}
}
AliTrigScheduledSequence::~AliTrigScheduledSequence()
{
if (fArray) delete [] fArray;
}
void AliTrigScheduledSequence::Print(Option_t *) const
{
printf("Sequence: %s scheduled by: %s\n", GetName(), fScheduler->GetName());
printf(" type: %d sequence: ", (Int_t)fType);
for (Int_t i=0; i<fNgroups; i++) printf("%d ", fArray[i]);
printf("\n");
}
void AliTrigScheduledSequence::SortArray(Int_t *array, Bool_t increasing)
{
Int_t *ind = new Int_t[fNgroups];
TMath::Sort(fNgroups, array, ind, !increasing);
memcpy(fArray, ind, fNgroups*sizeof(Int_t));
delete [] ind;
}
void AliTrigScheduledSequence::Sort(ESortingType type, Int_t *sequence)
{
Int_t i;
Int_t *array = 0;
switch (type) {
case AliTrigScheduledSequence::kDefault:
for (i=0; i<fNgroups; i++) fArray[i] = i;
break;
case AliTrigScheduledSequence::kTimeInc:
array = new Int_t[fNgroups];
for (i=0; i<fNgroups; i++) {
array[i] = fScheduler->GetScheduledGroup(i)->GetDelay();
}
SortArray(array, kTRUE);
break;
case AliTrigScheduledSequence::kTimeDec:
array = new Int_t[fNgroups];
for (i=0; i<fNgroups; i++) {
array[i] = fScheduler->GetScheduledGroup(i)->GetDelay();
}
SortArray(array, kFALSE);
break;
case AliTrigScheduledSequence::kPriorityInc:
array = new Int_t[fNgroups];
for (i=0; i<fNgroups; i++) {
array[i] = fScheduler->GetScheduledGroup(i)->GetPriority();
}
SortArray(array, kTRUE);
break;
case AliTrigScheduledSequence::kPriorityDec:
array = new Int_t[fNgroups];
for (i=0; i<fNgroups; i++) {
array[i] = fScheduler->GetScheduledGroup(i)->GetPriority();
}
SortArray(array, kFALSE);
break;
case AliTrigScheduledSequence::kCustom:
if (!sequence) {
Error("Sort", "Sequence array must be provided for custom type");
return;
}
memcpy(fArray, sequence, fNgroups*sizeof(Int_t));
}
if (array) delete [] array;
}
ClassImp(AliTrigScheduler)
AliTrigScheduler::AliTrigScheduler()
:TNamed(),
fNgroups(0),
fGroups(NULL),
fSequences(NULL),
fCurrentSequence(NULL)
{
}
AliTrigScheduler::AliTrigScheduler(const char *name)
:TNamed(name,""),
fNgroups(0),
fGroups(new TObjArray()),
fSequences(new TObjArray()),
fCurrentSequence(NULL)
{
AddGroup("default");
AddSequence("default");
}
AliTrigScheduler::~AliTrigScheduler()
{
if (fGroups) {fGroups->Delete(); delete fGroups;}
if (fSequences) {fSequences->Delete(); delete fSequences;}
}
void AliTrigScheduler::AddScheduledEntry(AliTrigScheduledEntry *entry, const char *togroup)
{
AliTrigScheduledGroup *group = GetScheduledGroup(togroup);
if (!group) {
Error("AddScheduledEntry", "Group %s does not exist in scheduler %s", togroup, GetName());
return;
}
group->AddEntry(entry);
}
AliTrigScheduledGroup *AliTrigScheduler::AddGroup(const char *groupname)
{
if (!fGroups) fGroups = new TObjArray();
if (fGroups->FindObject(groupname)) {
Error("AddGroup", "Scheduler %s contains already a group named: %s", GetName(), groupname);
return NULL;
}
AliTrigScheduledGroup *group = new AliTrigScheduledGroup(groupname);
fGroups->Add(group);
return group;
}
AliTrigScheduledGroup *AliTrigScheduler::AddGroup(AliTrigScheduledGroup *group)
{
if (!fGroups) fGroups = new TObjArray();
if (fGroups->FindObject(group->GetName())) {
Error("AddGroup", "Scheduler %s contains already a group named: %s", GetName(), group->GetName());
return NULL;
}
fGroups->Add(group);
return group;
}
AliTrigScheduledSequence *AliTrigScheduler::AddSequence(const char *seqname, AliTrigScheduledSequence::ESortingType type, Int_t *sequence)
{
if (!fSequences) fSequences = new TObjArray();
if (fSequences->FindObject(seqname)) {
Error("AddSequence", "Scheduler %s contains already a sequence named: %s", GetName(), seqname);
return NULL;
}
AliTrigScheduledSequence *seq = new AliTrigScheduledSequence(seqname, (AliTrigScheduler*)this);
seq->Sort(type, sequence);
fCurrentSequence = seq;
return seq;
}
void AliTrigScheduler::FireUp(Int_t time)
{
if (!fCurrentSequence) Fatal("FireUp", "No scheduled sequence booked for scheduler: %s", GetName());
Int_t *sequence = fCurrentSequence->GetArray();
AliTrigScheduledGroup *group;
for (Int_t i=0; i<fNgroups; i++) {
group = GetScheduledGroup(sequence[i]);
group->FireUp(time);
}
}
AliTrigScheduledGroup *AliTrigScheduler::GetScheduledGroup(Int_t i) const
{
return (AliTrigScheduledGroup*)fGroups->At(i);
}
AliTrigScheduledGroup *AliTrigScheduler::GetScheduledGroup(const char *name) const
{
return (AliTrigScheduledGroup*)fGroups->FindObject(name);
}
void AliTrigScheduler::SetGroupPriority(const char *groupname, Int_t priority)
{
AliTrigScheduledGroup *group = GetScheduledGroup(groupname);
if (!group) {
Error("SetGroupPriority", "Scheduler %s has no group named: %s", GetName(), groupname);
return;
}
group->SetPriority(priority);
}