GeneratorInput.cxx

Go to the documentation of this file.

// $Id: GeneratorInput.cxx 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.                       *
 ************************************************************/
 
#include "mbs/GeneratorInput.h"
 
#include <cstdlib>
#include <cmath>
 
#include "mbs/Iterator.h"
 
 
double Gauss_Rnd(double mean, double sigma)
{
 
   double x, y, z;
 
//   srand(10);
 
   z = 1.* rand() / RAND_MAX;
   y = 1.* rand() / RAND_MAX;
 
   x = z * 6.28318530717958623;
   return mean + sigma*sin(x)*sqrt(-2*log(y));
}
 
 
mbs::GeneratorInput::GeneratorInput(const dabc::Url& url) :
   dabc::DataInput(),
   fEventCount(0),
   fNumSubevents(2),
   fFirstProcId(0),
   fSubeventSize(32),
   fIsGo4RandomFormat(true),
   fFullId(0),
   fTotalSize(0),
   fTotalSizeLimit(0),
   fGenerTimeout(0.)
{
   fEventCount = url.GetOptionInt("first", 0);
 
   fNumSubevents = url.GetOptionInt("numsub", 2);
   fFirstProcId = url.GetOptionInt("procid", 0);
   fSubeventSize = url.GetOptionInt("size", 32);
   fIsGo4RandomFormat = url.GetOptionBool("go4", true);
   fFullId = url.GetOptionInt("fullid", 0);
   fTotalSizeLimit = url.GetOptionInt("total", 0);
   fGenerTimeout = url.GetOptionInt("tmout", 0)*0.001;
   fTimeoutSwitch = false;
}
 
bool mbs::GeneratorInput::Read_Init(const dabc::WorkerRef& wrk, const dabc::Command& cmd)
{
   return dabc::DataInput::Read_Init(wrk,cmd);
}
 
unsigned mbs::GeneratorInput::Read_Size()
{
   if (fGenerTimeout > 0.) {
      fTimeoutSwitch = !fTimeoutSwitch;
      if (fTimeoutSwitch) return dabc::di_RepeatTimeOut;
   }
 
   if ((fTotalSizeLimit>0) && (fTotalSize / 1024. / 1024. > fTotalSizeLimit)) return dabc::di_EndOfStream;
 
   return dabc::di_DfltBufSize;
}
 
 
unsigned mbs::GeneratorInput::Read_Complete(dabc::Buffer& buf)
{
 
   mbs::WriteIterator iter(buf);
 
   while (iter.NewEvent(fEventCount)) {
 
      bool eventdone = true;
 
      for (unsigned subcnt = 0; subcnt < fNumSubevents; subcnt++)
         if (iter.NewSubevent(fSubeventSize, fFirstProcId + subcnt + 1, fFirstProcId + subcnt)) {
 
            if ((fFullId!=0) && (fNumSubevents==1))
               iter.subevnt()->fFullId = fFullId;
 
            unsigned subsz = fSubeventSize;
 
            uint32_t* value = (uint32_t*) iter.rawdata();
 
            if (fIsGo4RandomFormat) {
               unsigned numval = fSubeventSize / sizeof(uint32_t);
               for (unsigned nval=0;nval<numval;nval++)
                  *value++ = (uint32_t) Gauss_Rnd(nval*100 + 2000, 500./(nval+1));
 
               subsz = numval * sizeof(uint32_t);
            } else {
               if (subsz>0) *value++ = fEventCount;
               if (subsz>4) *value++ = fFirstProcId + subcnt;
            }
 
            iter.FinishSubEvent(subsz);
         } else {
            eventdone = false;
            break;
         }
 
      if (!eventdone) break;
 
      if (!iter.FinishEvent()) break;
 
      fEventCount++;
   }
 
   // When close iterator - take back buffer with correctly modified length field
   buf = iter.Close();
 
   fTotalSize += buf.GetTotalSize();
 
   return dabc::di_Ok;
}