spadicplugin/src/ReadoutApplication.cxx (r4864/r4016)

Go to the documentation of this file.

/********************************************************************
 * 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.
 ********************************************************************/
/*
 * Simple Readout application for Susibo /Spadic readout
 * V-0.8 22-Oct-2010 J.Adamczewski-Musch. GSI
 */


#include "spadic/ReadoutApplication.h"

#include "dabc/Manager.h"


spadic::ReadoutApplication::ReadoutApplication() :
   dabc::Application(spadic::nameReadoutAppClass)
{
   CreatePar(spadic::xmlNumSusibo).DfltInt(1);
   for (int n = 0; n < NumSusibo(); n++)
      CreatePar(FORMAT(("%s%d", spadic::xmlSusiboDevID, n))).DfltInt(n+1);

   CreatePar(dabc::xmlBufferSize).DfltInt(65536);
   CreatePar(dabc::xmlNumBuffers).DfltInt(20);
   CreatePar(spadic::xmlEventsPerBuffer).DfltInt(1);
   CreatePar(spadic::xmlHitDelay).DfltInt(35);
   CreatePar(spadic::xmlTimeout).DfltDouble(0.1);
   CreatePar(spadic::xmlUseInternalTrigger).DfltBool(false);
   CreatePar(spadic::xmlInternalTriggerFreq).DfltDouble(15);

   CreatePar(dabc::xmlPoolName).DfltStr("SusiboPool");
   CreatePar(spadic::xmlModuleName).DfltStr("SusiboComb");
   CreatePar(spadic::xmlModuleThread).DfltStr("SusiboThread");

   CreatePar(mbs::xmlServerKind).DfltStr(mbs::ServerKindToStr(mbs::StreamServer));
   CreatePar(mbs::xmlFileName).DfltStr("");
   CreatePar(mbs::xmlSizeLimit).DfltInt(0);

   CreatePar("EpicsStreamNode").DfltStr("");


   DOUT1(("!!!! Data server plugin created %s !!!!", GetName()));
}

int spadic::ReadoutApplication::DataServerKind() const
{
   return mbs::StrToServerKind(Par(mbs::xmlServerKind).AsStr());
}

int spadic::ReadoutApplication::SusiboID(int index) const
{
   if ((index < 0) || (index >= NumSusibo())) return 0;
   return Par(FORMAT(("%s%d", spadic::xmlSusiboDevID, index))).AsInt();
}

bool spadic::ReadoutApplication::CreateAppModules()
{
   DOUT1(("CreateAppModules starts..."));
   bool res = false;

   std::string modname = Par(spadic::xmlModuleName).AsStdStr();
   std::string poolname = Par(dabc::xmlPoolName).AsStr("Dummy");

   bool isepics = !EpicsStreamNode().empty();

   dabc::lgr()->SetLogLimit(10000000);

   dabc::mgr.CreateMemoryPool(poolname.c_str(),
         Par(dabc::xmlBufferSize).AsInt(8192),
         Par(dabc::xmlNumBuffers).AsInt(100));

   // Readout module with memory pool:
   dabc::CmdCreateModule cmd1("mbs::CombinerModule",
         modname.c_str(), Par(spadic::xmlModuleThread).AsStr());

   cmd1.SetStr(dabc::xmlPoolName, poolname);
   cmd1.SetInt(dabc::xmlNumInputs, NumSusibo() + (isepics ? 1 : 0));
   cmd1.SetBool(mbs::xmlFileOutput, true);
   cmd1.SetBool(mbs::xmlServerOutput, true);

   res = dabc::mgr.Execute(cmd1);
   DOUT1(("Create Susibo Readout module = %s", DBOOL(res)));
   if (!res) return false;

   for (int n = 0; n < NumSusibo(); n++) {
      dabc::CmdCreateTransport cmd2(FORMAT(("%s/Input%d", modname.c_str(), n)), spadic::typeSusiboInput);
      cmd2.SetInt(spadic::xmlSusiboDevID, SusiboID(n));
      cmd2.SetInt(spadic::xmlEventsPerBuffer, Par(spadic::xmlEventsPerBuffer).AsInt(1));
      cmd2.SetInt(spadic::xmlHitDelay, Par(spadic::xmlHitDelay).AsInt(35));
      cmd2.SetDouble(spadic::xmlTimeout, Par(spadic::xmlTimeout).AsDouble(0.1));
      cmd2.SetBool(spadic::xmlUseInternalTrigger, Par(xmlUseInternalTrigger).AsBool(false));
      cmd2.SetDouble(spadic::xmlInternalTriggerFreq, Par(xmlInternalTriggerFreq).AsDouble(10));
      cmd2.SetBool(spadic::xmlFormatMbs, true);
      res = dabc::mgr.Execute(cmd2);
      if (!res) {
         EOUT(("!!!! Cannot connect susibo%d !!!!", SusiboID(n)));
         return false;
      }
   }

   if (isepics) {
      dabc::CmdCreateTransport cmd8(
            FORMAT(("%s/Input%d", modname.c_str(), NumSusibo())),
            mbs::typeClientTransport, "MbsReadoutThrd");
      cmd8.SetStr(mbs::xmlServerName, EpicsStreamNode());
      cmd8.SetStr(mbs::xmlServerKind, mbs::ServerKindToStr(mbs::StreamServer));

      cmd8.SetDouble(dabc::xmlConnTimeout, 5.);
      res = dabc::mgr.Execute(cmd8);
      DOUT0(("Created EPICS client transport result is %s", DBOOL(res)));
      if (!res) return false;

      dabc::Command cmd9("ConfigureInput");
      cmd9.SetInt("Port", NumSusibo());
      cmd9.SetBool("RealMbs", false);
      cmd9.SetBool("RealEvntNum", false);
      cmd9.SetBool("NoEvntNum", true);

      cmd9.SetReceiver(modname);
      res = dabc::mgr.Execute(cmd9);
      DOUT1(("Configure special EPICS case as input %d : result is %s", NumSusibo(), DBOOL(res)));
      if (!res) return false;
   }


   // connect file and mbs server outputs:
   if (OutputFileName().length() > 0) {
      dabc::CmdCreateTransport cmd3(FORMAT(("%s/%s", modname.c_str(), mbs::portFileOutput)),
                                    mbs::typeLmdOutput);
      cmd3.SetStr(mbs::xmlFileName, OutputFileName());
      res = dabc::mgr.Execute(cmd3);
      DOUT1(("Create raw lmd output file %s , result = %s", OutputFileName().c_str(), DBOOL(res)));
      if (!res) return false;
   }

   if (DataServerKind() != mbs::NoServer) {
      dabc::CmdCreateTransport cmd4(FORMAT(("%s/%s", modname.c_str(), mbs::portServerOutput)),
                                     mbs::typeServerTransport, "MbsServerThrd");

      // no need to set extra parameters - they will be taken from application !!!
      //      cmd->SetStr(mbs::xmlServerKind, mbs::ServerKindToStr(DataServerKind())); //mbs::StreamServer ,mbs::TransportServer
      //      cmd->SetInt(dabc::xmlBufferSize, GetParInt(dabc::xmlBufferSize, 8192));

      res = dabc::mgr.Execute(cmd4);
      DOUT1(("Connected readout module output to Mbs server = %s", DBOOL(res)));
      if (!res) return false;
   }

   return true;
}

int spadic::ReadoutApplication::ExecuteCommand(dabc::Command cmd)
{
   return dabc::Application::ExecuteCommand(cmd);
}