source: JEM-EUSO/esaf_cc_at_lal/packages/simulation/detector/electronics/src/TriggerEngine.cc @ 114

// ESAF : Euso Simulation and Analysis Framework
// $Id: TriggerEngine.cc 2967 2011-07-14 15:23:29Z fenu $
// M. Pallavicini created Oct, 24 2003

#include "TriggerEngine.hh"
#include "PersistencyTriggerEngine.hh"
#include "ChipTrackingTrgEngine.hh"
#include "ChipTrackingTrgEngine0.hh"
#include "ChipTrackingTrgEngine1.hh"
#include "ChipTrackingTrgEngine2.hh"
#include "ChipTrackingTrgEngine3.hh"
#include "ChipTrackingTrgEngine4.hh"
#include "SignalChipTrackingTrgEngine.hh"
#include "CellTrackingTrgEngine.hh"
#include "LblChipTrackingTrgEngine.hh"
#include "PTTTrigger.hh"
#include "LTTTrigger.hh"
#include "CCB_LTTTrigger.hh"

ClassImp (TriggerEngine)
// trigger word
     Int_t TriggerEngine::fTriggerWord = 0;

//trg words of child triggers
map < Int_t, Int_t > TriggerEngine::fTrgWords;

// map with all engines
map < ETriggerTypeIdentifier, TriggerEngine * >*TriggerEngine::fEngines = 0;

//______________________________________________________________________________
TriggerEngine::TriggerEngine (const string & name, ETriggerTypeIdentifier id):
EsafConfigurable ()
{
  // 
  // Constructor
  // 
  fName = name;
  fHasTriggered = kFALSE;
  fTrgId = id;
  fTriggerWord = 0;
  fGtuTrigger=0;
  fGtuTriggerCCB=0;
}

//______________________________________________________________________________
TriggerEngine::~TriggerEngine ()
{
  // 
  // Destructor
  // 
}


//______________________________________________________________________________
map < ETriggerTypeIdentifier,
  TriggerEngine * >&TriggerEngine::GetEngines (ETriggerTypeIdentifier type)
{
  // 
  // return the map of engines
  // basically a factory method for all trigger algorithms
  // right now static: the same trigger structure for all macrocells
  // easy to generalize to macrocell dependent trigger code 
  //

  if (fEngines)
    {
      return *fEngines;
    }
  fEngines = new map < ETriggerTypeIdentifier, TriggerEngine * >;
  if (type & kPersistencyTrigger)
    {
      (*fEngines)[kPersistencyTrigger] = new PersistencyTriggerEngine ();
      cout << " *** Trigger: Persistency trigger enabled" << endl;
    }
  if (type & kContiguityTrigger)
    {
      // to be done
    }
  if (type & kChipTrackingTrigger)
    {
      (*fEngines)[kChipTrackingTrigger] = new ChipTrackingTrgEngine ();
      cout << " *** Trigger: Chip Tracking trigger enabled" << endl;
    }
  if (type & kChipTrackingTrigger0)
    {
      (*fEngines)[kChipTrackingTrigger0] = new ChipTrackingTrgEngine0 ();
      cout << " *** Trigger: Chip Tracking 0 trigger enabled" << endl;
    }
  if (type & kChipTrackingTrigger1)
    {
      (*fEngines)[kChipTrackingTrigger1] = new ChipTrackingTrgEngine1 ();
      cout << " *** Trigger: Chip Tracking 1 trigger enabled" << endl;
    }
  if (type & kChipTrackingTrigger2)
    {
      (*fEngines)[kChipTrackingTrigger2] = new ChipTrackingTrgEngine2 ();
      cout << " *** Trigger: Chip Tracking 2 trigger enabled" << endl;
    }
  if (type & kChipTrackingTrigger3)
    {
      (*fEngines)[kChipTrackingTrigger3] = new ChipTrackingTrgEngine3 ();
      cout << " *** Trigger: Chip Tracking 3 trigger enabled" << endl;
    }
  if (type & kChipTrackingTrigger4)
    {
      (*fEngines)[kChipTrackingTrigger4] = new ChipTrackingTrgEngine4 ();
      cout << " *** Trigger: Chip Tracking 4 trigger enabled" << endl;
    }
  if (type & kSignalChipTrackingTrigger)
    {
      (*fEngines)[kSignalChipTrackingTrigger] =
        new SignalChipTrackingTrgEngine ();
      cout << " *** Trigger: Signal Chip Tracking trigger enabled" << endl;
    }
  if (type & kCellTrackingTrigger)
    {
      (*fEngines)[kCellTrackingTrigger] = new CellTrackingTrgEngine ();
      cout << " *** Trigger: Cell Tracking trigger enabled" << endl;
    }
  if (type & kLblChipTrackingTrigger)
    {
      (*fEngines)[kLblChipTrackingTrigger] = new LblChipTrackingTrgEngine ();
      cout << " *** Trigger: Lbl Chip Tracking trigger enabled" << endl;
    }

  if (type & kPTTTrigger)
    {
      (*fEngines)[kPTTTrigger] = new PTTTrigger ();
      cout << " *** Trigger: PTTTrigger  trigger enabled" << endl;
    }

  if (type & kLTTTrigger)
    {
      (*fEngines)[kLTTTrigger] = new LTTTrigger ();
      cout << " *** Trigger: LTT  trigger enabled" << endl;
    }

 if (type & kCCB_LTTTrigger)
    {
      (*fEngines)[kCCB_LTTTrigger] = new CCB_LTTTrigger ();
      cout << " *** Trigger: CCB_LTT  trigger enabled" << endl;
    }



  return *fEngines;
}

void
TriggerEngine::SetTrigger (Int_t word)
{
  //
  // set the chip tracking trigger engines word 
  // 
  fHasTriggered = kTRUE;
  fTriggerWord |= (Int_t) GetTriggerId ();
  if (fTrgWords.count ((Int_t) GetTriggerId ()) == 0)
    fTrgWords[(Int_t) GetTriggerId ()] = word;
  else
    fTrgWords[(Int_t) GetTriggerId ()] |= word;
}