framework/fun4allraw/SingleTriggeredInput.h

0001 #ifndef FUN4ALLRAW_SINGLETRIGGEREDINPUT_H
0002 #define FUN4ALLRAW_SINGLETRIGGEREDINPUT_H
0003
0004 #include <fun4all/Fun4AllBase.h>
0005 #include <fun4all/InputFileHandler.h>
0006
0007 #include <Event/EventTypes.h>
0008 #include <Event/Eventiterator.h>
0009 #include <Event/fileEventiterator.h>
0010 #include <Event/packet.h>
0011
0012 #include <array>
0013 #include <cstdint>  // for uint64_t
0014 #include <deque>
0015 #include <fstream>
0016 #include <limits>
0017 #include <map>
0018 #include <set>
0019 #include <string>
0020 #include <vector>
0021
0022 class Event;
0023 class Eventiterator;
0024 class OfflinePacket;
0025 class PHCompositeNode;
0026
0027 class SingleTriggeredInput : public Fun4AllBase, public InputFileHandler
0028 {
0029  public:
0030   static constexpr size_t pooldepth{10};  // number of events which are read in in one go
0031   explicit SingleTriggeredInput(const std::string &name);
0032   ~SingleTriggeredInput() override;
0033   virtual Eventiterator *GetEventIterator() { return m_EventIterator; }
0034   virtual void FillPool();
0035   virtual void RunNumber(const int runno) { m_RunNumber = runno; }
0036   virtual int RunNumber() const { return m_RunNumber; }
0037   virtual void EventNumber(const int i) { m_EventNumber = i; }
0038   virtual int EventNumber() const { return m_EventNumber; }
0039   virtual int EventsInThisFile() const { return m_EventsThisFile; }
0040   virtual int fileopen(const std::string &filename) override;
0041   virtual int fileclose() override;
0042   virtual int AllDone() const { return m_AllDone; }
0043   virtual void AllDone(const int i) { m_AllDone = i; }
0044   virtual int FilesDone() const { return m_FilesDone; }
0045   virtual void FilesDone(const int i) { m_FilesDone = i; }
0046   virtual void EventAlignmentProblem(const int i) { m_EventAlignmentProblem = i; }
0047   virtual int EventAlignmentProblem() const { return m_EventAlignmentProblem; }
0048   virtual void CreateDSTNodes(Event *evt);
0049   // these ones are used directly by the derived classes, maybe later
0050   // move to cleaner accessors
0051   virtual int FillEventVector();
0052   virtual void FillPacketClock(Event *evt, Packet *pkt, size_t event_index);
0053   virtual int ReadEvent();
0054   virtual SingleTriggeredInput *Gl1Input() { return m_Gl1Input; }
0055   virtual void Gl1Input(SingleTriggeredInput *input) { m_Gl1Input = input; }
0056   virtual uint64_t GetClock(Event *evt, int pid);
0057   virtual std::array<uint64_t, pooldepth>::const_iterator clkdiffbegin() { return m_bclkdiffarray.begin(); }
0058   virtual std::array<uint64_t, pooldepth>::const_iterator clkdiffend() { return m_bclkdiffarray.end(); }
0059   virtual std::array<uint64_t, pooldepth>::const_iterator beginclock() { return m_bclkarray.begin(); }
0060   virtual void KeepPackets() { m_KeepPacketsFlag = true; }
0061   virtual bool KeepMyPackets() const { return m_KeepPacketsFlag; }
0062   void topNode(PHCompositeNode *topNode) { m_topNode = topNode; }
0063   PHCompositeNode *topNode() { return m_topNode; }
0064   virtual void FakeProblemEvent(const int ievent) { m_ProblemEvent = ievent; }
0065   virtual int FemEventNrClockCheck(OfflinePacket *calopkt);
0066   void dumpdeque();
0067   int checkfirstsebevent();
0068   virtual bool CheckFemDiffIdx(int pid, size_t index, const std::deque<Event*>& events, uint64_t gl1diffidx);
0069   virtual bool CheckPoolAlignment(int pid, const std::array<uint64_t, pooldepth>& sebdiff, const std::array<uint64_t, pooldepth>& gl1diff, std::vector<int>& bad_indices, int& shift, bool& CurrentPoolLastDiffBad, bool PrevPoolLastDiffBad);
0070   virtual bool FemClockAlignment(int pid, const std::deque<Event*>& events, const std::array<uint64_t, pooldepth>& gl1diff);
0071
0072  protected:
0073   PHCompositeNode *m_topNode{nullptr};
0074   // lined up like this:
0075   // Event * | previous event beam clock | clock diff to previous event
0076   // keeping previous beam clock just eases the looping, we want to be able to have
0077   // the accompanying diff to the previous beam clock with this event, so any mismatch
0078   // gives us the event index in the deque which is off
0079   std::deque<Event *> m_EventDeque;
0080   std::map<int, std::deque<Event*>> m_PacketEventDeque;
0081   std::map<int, Event*> m_PacketEventBackup;
0082   std::map<int, int> m_PacketShiftOffset;
0083   std::array<uint64_t, pooldepth + 1> m_bclkarray{};  // keep the last bco from previous loop
0084   std::array<uint64_t, pooldepth> m_bclkdiffarray{};
0085   std::map<int, std::array<uint64_t, pooldepth + 1>> m_bclkarray_map;
0086   std::map<int, std::array<uint64_t, pooldepth>>     m_bclkdiffarray_map;
0087   std::set<int> m_PacketSet;
0088   static uint64_t ComputeClockDiff(uint64_t curr, uint64_t prev) { return (curr - prev) & 0xFFFFFFFF; }
0089
0090
0091  private:
0092   Eventiterator *m_EventIterator{nullptr};
0093   SingleTriggeredInput *m_Gl1Input{nullptr};
0094   int m_AllDone{0};
0095   uint64_t m_Event{0};
0096   uint64_t m_Gl1PacketNumberOneSkip{0};
0097   int m_EventNumber{0};
0098   int m_EventsThisFile{0};
0099   int m_EventAlignmentProblem{0};
0100   int m_FilesDone{0};
0101   int m_Gl1PacketOneSkipCount{5};
0102   int m_LastEvent{std::numeric_limits<int>::max()};
0103   int m_ProblemEvent{-1};
0104   int m_RepresPacket{-1};
0105   int m_RunNumber{0};
0106   int m_max_alignment_retries{3};
0107   bool firstcall{true};
0108   bool firstclockcheck{true};
0109   bool m_Gl1PacketOneSkipActiveTrace{false};
0110   bool m_KeepPacketsFlag{false};
0111   bool m_packetclk_copy_runs{false};
0112   std::set<int> m_CorrectCopiedClockPackets;
0113   std::map<int, std::set<int>> m_DitchPackets;
0114   std::set<int> m_FEMEventNrSet;
0115   std::set<int> m_OverrideWithRepClock;
0116   std::map<int, int> m_PacketAlignmentFailCount;
0117   std::map<int, bool> m_PacketAlignmentProblem;
0118   std::map<int, bool> m_PrevPoolLastDiffBad;
0119   std::map<int, uint64_t> m_PreviousValidBCOMap;
0120 };
0121
0122 #endif