CombinerModule.h

Go to the documentation of this file.

// $Id: CombinerModule.h 4479 2020-04-15 14:30:52Z linev $
 
/************************************************************
 * The Data Acquisition Backbone Core (DABC)                *
 ************************************************************
 * Copyright (C) 2009 -                                     *
 * GSI Helmholtzzentrum fuer Schwerionenforschung GmbH      *
 * Planckstr. 1, 64291 Darmstadt, Germany                   *
 * Contact:  http://dabc.gsi.de                             *
 ************************************************************
 * This software can be used under the GPL license          *
 * agreements as stated in LICENSE.txt file                 *
 * which is part of the distribution.                       *
 ************************************************************/
 
#ifndef MBS_CombinerModule
#define MBS_CombinerModule
 
#ifndef DABC_ModuleAsync
#include "dabc/ModuleAsync.h"
#endif
 
#ifndef MBS_Iterator
#include "mbs/Iterator.h"
#endif
 
namespace mbs {
 
   class CombinerModule : public dabc::ModuleAsync {
      protected:
 
         struct InputCfg {
            bool real_mbs;
 
            mbs::EventNumType curr_evnt_num;
 
            bool curr_evnt_special;
 
            bool real_evnt_num;
 
            bool no_evnt_num;
 
            bool optional_input;
 
            uint32_t evntsrc_fullid;
 
            uint32_t evntsrc_shift;
 
            bool selected;
 
            bool valid;
 
            double last_valid_tm;
 
            InputCfg() :
               real_mbs(true),
               curr_evnt_num(0),
               curr_evnt_special(false),
               real_evnt_num(true),
               no_evnt_num(false),
               optional_input(false),
               evntsrc_fullid(0),
               evntsrc_shift(0),
               selected(false),
               valid(false),
               last_valid_tm(0){}
 
            InputCfg(const InputCfg& src) :
               real_mbs(src.real_mbs),
               curr_evnt_num(src.curr_evnt_num),
               curr_evnt_special(src.curr_evnt_special),
               real_evnt_num(src.real_evnt_num),
               no_evnt_num(src.no_evnt_num),
               optional_input(src.optional_input),
               evntsrc_fullid(src.evntsrc_fullid),
               evntsrc_shift(src.evntsrc_shift),
               selected(src.selected),
               valid(src.valid),
               last_valid_tm(src.last_valid_tm) {}
 
            void Reset()
            {
               real_mbs = true;
               curr_evnt_num = 0;
               curr_evnt_special = false;
               real_evnt_num = true;
               no_evnt_num = false;
               optional_input = false;
               evntsrc_fullid = 0;
               evntsrc_shift = 0;
               selected = false;
               valid = false;
               last_valid_tm = 0.;
            }
         };
 
         std::vector<ReadIterator>  fInp;
         std::vector<InputCfg>      fCfg;
         WriteIterator              fOut;
         bool                       fFlushFlag;
 
         /* switch between partial combining of smallest event ids (false)
          * and building of complete events only (true)*/
         bool                       fBuildCompleteEvents;
 
         /*switch on checking duplicate subevent ids in merged events -> indicate setup error*/
         bool                       fCheckSubIds;
 
         mbs::EventNumType          fEventIdMask;
 
         /* defines maximum difference allowed between event id in merged data streams.
          * if id difference is larger, combiner may stop with error message*/
         mbs::EventNumType          fEventIdTolerance;
 
         int                        fSpecialTriggerLimit;
 
         unsigned                   fNumObligatoryInputs;
 
         double                     fExcludeTime;
 
         std::string                fEventRateName;
         std::string                fDataRateName;
         std::string                fInfoName;
         std::string                fFileStateName;
 
         bool BuildEvent();
         bool FlushBuffer();
 
         virtual void BeforeModuleStart();
 
         virtual void AfterModuleStop();
 
         bool ShiftToNextEvent(unsigned ninp);
 
         bool ShiftToNextBuffer(unsigned ninp);
 
         mbs::EventNumType CurrEventId(unsigned int ninp) const { return fCfg[ninp].curr_evnt_num; }
 
         void SetInfo(const std::string &info, bool forceinfo = false);
 
         bool IsOptionalInput(unsigned ninp) { return ninp<fCfg.size() ? (fCfg[ninp].optional_input || fCfg[ninp].no_evnt_num) : true; }
 
 
         void ChangeFileState(bool on);
 
      public:
 
         CombinerModule(const std::string &name, dabc::Command cmd = nullptr);
         virtual ~CombinerModule();
 
         virtual void ModuleCleanup();
 
         virtual bool ProcessRecv(unsigned port) { return BuildEvent(); }
         virtual bool ProcessSend(unsigned port) { return BuildEvent(); }
 
         virtual void ProcessTimerEvent(unsigned timer);
 
         unsigned NumObligatoryInputs() const { return fNumObligatoryInputs; }
 
         /* returns maximum possible eventnumber for overflow checking*/
         virtual unsigned int GetOverflowEventNumber() const;
 
         virtual int ExecuteCommand(dabc::Command cmd);
   };
}
 
 
#endif