source: JEM-EUSO/esaf_cc_at_lal/packages/simulation/detector/electronics/include/MacroCellData.hh @ 114

// ESAF : Euso Simulation and Analysis Framework
// class MacroCellData
// these objects are the output from the simulation of a whole
// macrocell for an event
// M. Pallavicini - created
// modified 24/10/2003; trigger implemented as visitor of the class
//                      many trigger algorythms handled independently
//

#ifndef _MACROCELLDATA_HH_
#define _MACROCELLDATA_HH_

#include <map>
#include <string>
#include "ChipGtuData.hh"

class ChipGtuData;
class MacroCellHit;
class MacroCell;

class MacroCellData
{
public:

  // ctor
  MacroCellData (MacroCell *);

  // dtor
  virtual ~ MacroCellData ();

  // add data from front end to macrocell
  void Add (Int_t, ChipGtuData *);

  // simulate Macrocell response for a single GTU
  void BuildGtu (Int_t);

  // check if two GTUs have contiguous hits
  Bool_t CheckContiguity (Int_t gtu1, Int_t gtu2);

  // simulate event response for GTU and trigger
  // many different trigger algorithms are handled as visitors
  void SimulateTrigger ();

  // returns true if a trigger occurred
  Bool_t HasTriggered () const
  {
    return (Bool_t) fTriggered;
  }

  //comunication LTT third level
  inline void SetLTTTrigger (Int_t val)
  {
    ftest_triggerLTT = val;
  }
  inline Int_t GetLTTTrigger ()
  {
    return ftest_triggerLTT;
  }

  inline void SetLTTTriggerMaxCounts (Int_t val)
  {
    fup_countsLTT = val;
  }
  inline Int_t GetLTTTriggerMaxCounts ()
  {
    return fup_countsLTT;
  }

  inline void SetLTTTriggerMaxGtu (Int_t val)
  {
    fGTU_upLTT = val;
  }
  inline Int_t GetLTTTriggerMaxGtu ()
  {
    return fGTU_upLTT;
  }

  inline void SetLTTTriggerMaxRow (Int_t val)
  {
    frow_upLTT = val;
  }
  inline Int_t GetLTTTriggerMaxRow ()
  {
    return frow_upLTT;
  }

  inline void SetLTTTriggerMaxCol (Int_t val)
  {
    fcol_upLTT = val;
  }
  inline Int_t GetLTTTriggerMaxCol ()
  {
    return fcol_upLTT;
  }

  inline void SetLTTTriggerChipID (Int_t val)
  {
    fchip_ID_upLTT = val;
  }
  inline Int_t GetLTTTriggerChipID ()
  {
    return fchip_ID_upLTT;
  }

  inline void SetLTTTriggerMaxDir (Int_t val)
  {
    fdir_upLTT = val;
  }
  inline Int_t GetLTTTriggerMaxDir ()
  {
    return fdir_upLTT;
  }

  inline void SetLTTTriggerPdmID (Int_t val)
  {
    fPdmID_LTT = val;
  }
  inline Int_t GetLTTTriggerPdmID ()
  {
    return fPdmID_LTT;
  }

  //comunication PTT third level
  inline void SetPTTTrigger (Int_t val)
  {
    ftest_triggerPTT = val;
  }
  inline Int_t GetPTTTrigger ()
  {
    return ftest_triggerPTT;
  }

  inline void SetPTTTriggerMaxCounts (Int_t val)
  {
    fup_countsPTT = val;
  }
  inline Int_t GetPTTTriggerMaxCounts ()
  {
    return fup_countsPTT;
  }

  inline void SetPTTTriggerMaxGtu (Int_t val)
  {
    fGTU_upPTT = val;
  }
  inline Int_t GetPTTTriggerMaxGtu ()
  {
    return fGTU_upPTT;
  }

  inline void SetPTTTriggerMaxRow (Int_t val)
  {
    frow_upPTT = val;
  }
  inline Int_t GetPTTTriggerMaxRow ()
  {
    return frow_upPTT;
  }

  inline void SetPTTTriggerMaxCol (Int_t val)
  {
    fcol_upPTT = val;
  }
  inline Int_t GetPTTTriggerMaxCol ()
  {
    return fcol_upPTT;
  }

  inline void SetPTTTriggerChipID (Int_t val)
  {
    fchip_ID_upPTT = val;
  }
  inline Int_t GetPTTTriggerChipID ()
  {
    return fchip_ID_upPTT;
  }

  inline void SetPTTTriggerPdmID(Int_t val)
  {
    fPdmID_PTT = val;
  }

  inline Int_t GetPTTTriggerPdmID()
  {
    return fPdmID_PTT;
  }


  inline void SetCCB_LTTTrigger (Int_t val)
  {
    ftest_triggerCCB_LTT = val;
  }
  inline Int_t GetCCB_LTTTrigger ()
  {
    return ftest_triggerCCB_LTT;
  }

  inline void SetCCB_LTTTriggerMaxCounts (Int_t val)
  {
    fup_countsCCB_LTT = val;
  }
  inline Int_t GetCCB_LTTTriggerMaxCounts ()
  {
    return fup_countsCCB_LTT;
  }

  inline void SetCCB_LTTTriggerMaxGtu (Int_t val)
  {
    fGTU_upCCB_LTT = val;
  }
  inline Int_t GetCCB_LTTTriggerMaxGtu ()
  {
    return fGTU_upCCB_LTT;
  }

  inline void SetCCB_LTTTriggerMaxRow (Int_t val)
  {
    frow_upCCB_LTT = val;
  }
  inline Int_t GetCCB_LTTTriggerMaxRow ()
  {
    return frow_upCCB_LTT;
  }

  inline void SetCCB_LTTTriggerMaxCol (Int_t val)
  {
    fcol_upCCB_LTT = val;
  }
  inline Int_t GetCCB_LTTTriggerMaxCol ()
  {
    return fcol_upCCB_LTT;
  }

  inline void SetCCB_LTTTriggerChipID (Int_t val)
  {
    fchip_ID_upCCB_LTT = val;
  }
  inline Int_t GetCCB_LTTTriggerChipID ()
  {
    return fchip_ID_upCCB_LTT;
  }

  inline void SetCCB_LTTTriggerMaxDir (Int_t val)
  {
    fdir_upCCB_LTT = val;
  }
  inline Int_t GetCCB_LTTTriggerMaxDir ()
  {
    return fdir_upCCB_LTT;
  }

  inline void SetCCB_LTTTriggerPdmID (Int_t val)
  {
    fPdmID_CCB_LTT = val;
  }

  inline Int_t GetCCB_LTTTriggerPdmID ()
  {
    return fPdmID_CCB_LTT;
  }



  // pointer to parent MacroCell
  inline MacroCell *Cell ()
  {
    return pCell;
  }

  // is there any data ?
  inline Bool_t IsEmpty () const
  {
    return fEmpty;
  }
  inline void SetEmpty (Bool_t val = kTRUE)
  {
    fEmpty = val;
  }

  // infos about GTUs
  inline Int_t GtuStart () const
  {
    return fGtuStart;
  }
  inline Int_t GtuEnd () const
  {
    return fGtuEnd;
  }
  inline Int_t GtuTrigger () const
  {
    return fGtuTrigger;
  }
  inline Int_t NGtus () const
  {
    return fNumActiveGtus;
  }

  // time in ns of the first edge of the first GTU for this event
  // the time is measured from the Photons time
  Double_t GtuTimeStart ();

  // same for second edge of last GTU
  Double_t GtuTimeEnd ();

  // return vector of hits for one gtu; no checks on boundaries
  vector < MacroCellHit * >*Hits (Int_t gtu)
  {
    return fData[gtu];
  }

  // return point to hit iH for gtu iGtu; no checks on boundaries
  MacroCellHit *Hit (Int_t iGtu, Int_t iHit)
  {
    return ((*fData[iGtu])[iHit]);
  }

  // returns total number of MacroCellHit objects
  Int_t NumMacroCellHits ();

  // returns the chipgtudata of a chip in a given gtu
  ChipGtuData *GetChipGtuData (Int_t chip, Int_t gtu);

  // dump some data on string
  string & Dump ();

  virtual Bool_t ClearMemory ();
  // physically release the memory allocated by the arrays of this object
private:

  MacroCell * pCell;            // parent macrocell

  string text_dump;             // string used for dump 
  Int_t fup_countsLTT,fGTU_upLTT,frow_upLTT,fcol_upLTT,fchip_ID_upLTT,fdir_upLTT,fPdmID_LTT;
  Int_t fup_countsPTT,fGTU_upPTT,frow_upPTT,fcol_upPTT,fchip_ID_upPTT,fdir_upPTT,fPdmID_PTT;
  Int_t fup_countsCCB_LTT,fGTU_upCCB_LTT,frow_upCCB_LTT,fcol_upCCB_LTT,fchip_ID_upCCB_LTT,fdir_upCCB_LTT,fPdmID_CCB_LTT;
  Int_t ftest_triggerLTT,ftest_triggerPTT,ftest_triggerCCB_LTT;
  Int_t fGtuStart;              // first GTU in which there was activity
  Int_t fGtuEnd;                // last GTU in which there was activity
  Int_t fGtuTrigger;            // GTU in which there was trigger
  Bool_t fTriggered;            // True if macrocell was trigged
  Int_t fNumActiveGtus;         // number of GTUs in which there was activity

  // map of vectors of objects from chips (first index GTU)
  map < Int_t, vector < ChipGtuData * >*>fChipData;

  // same as before where first map key is front end chip id and second gtu
  map < Int_t, map < Int_t, ChipGtuData * >*>fChipData2;

  // map of vectors of macrocell hits (first index GTU)
  map < Int_t, vector < MacroCellHit * >*>fData;

  // true if no data are available
  Bool_t fEmpty;

  // set gtu at which trigger occurred
  inline void SetGtuTrigger (Int_t gtu)
  {
    // Save trigger time. If time was earlier than
        // a previous trigger, overwrite it.
    if ((gtu < fGtuTrigger) || !fTriggered){
      fGtuTrigger = gtu;
      fTriggered = true;
    }
  }

  ClassDef (MacroCellData, 0) friend class ChipTrackingTrgEngine;
  friend class ChipTrackingTrgEngine0;
  friend class ChipTrackingTrgEngine1;
  friend class ChipTrackingTrgEngine2;
  friend class ChipTrackingTrgEngine3;
  friend class ChipTrackingTrgEngine4;
  friend class LblChipTrackingTrgEngine;
  friend class SignalChipTrackingTrgEngine;
  friend class PTTTrigger;
  friend class LTTTrigger;
  friend class CCB_LTTTrigger;
};

#endif