// ------------------------------------------------------------------
// -----                    TMbsUnpackTofCustom                 -----
// -----              Created 08/05/2013 by P.-A. Loizeau       -----
// ------------------------------------------------------------------
#include "TMbsUnpackTofCustom.h"

// SubEvent ProcId from ROC library
#include "commons.h"

// General MBS headers
#include "TGo4EventEndException.h"
#include "TofVmeDef.h"
#include "TMbsUnpackTofPar.h"
#include "TMbsSourceParameter.h"
#include "TMbsFileParameter.h"
#include "TMbsClient.h"
#include "TMbsFile.h"
#include "TMbsEvent.h"
#include "TMbsSubEvent.h"

// ToF specific headers
#include "TTofTriglogUnpacker.h"
#include "TTofTriglogBoard.h"
#include "TTofScomUnpacker.h"
#include "TTofScalerBoard.h"
#include "TTofVftxUnpacker.h"
#include "TTofVftxBoard.h"
#include "TTofTdcBoard.h"
#include "TTofGet4Unpacker.h"
#include "TTofGet4Board.h"
#include "TTofGet4Data.h"

// ROOT headers
#include "Riostream.h" // for cout, endl, etc...
#include "TClonesArray.h"
#include "TFile.h"
#include "TDatime.h"

// FAIR headers
#include "FairLogger.h"
#include "FairRunAna.h"
#include "FairRuntimeDb.h"
#include "FairRootManager.h"

const Int_t fgiDEFAULT_PORT__TRANSPORT   =   6000;
const Int_t fgiDEFAULT_PORT__STREAM_SERV =   6002;
const Int_t fgiDEFAULT_PORT__EVENT_SERV  =   6003;

TMbsUnpackTofCustom::TMbsUnpackTofCustom() : 
   FairTask("MbsUnpackTofCustom"),
   fMbsUnpackPar(0),
   fMbsSourcePar(0),
   fMbsFilePar(0),
   fMbsClient(0),
   fMbsFile(0),
   fMbsEvent(0),
   fiNbEvents(0),
   fiFirstEventNumber(0),
   fiLastEventNumber(0)
{
}

TMbsUnpackTofCustom::TMbsUnpackTofCustom(const char* name, Int_t mode, Int_t verbose) :
   FairTask(name, verbose),
   fMbsUnpackPar(0),
   fMbsSourcePar(0),
   fMbsFilePar(0),
   fMbsClient(0),
   fMbsFile(0),
   fMbsEvent(0),
   fiNbEvents(0),
   fiFirstEventNumber(0),
   fiLastEventNumber(0)
{
}
      
TMbsUnpackTofCustom::~TMbsUnpackTofCustom()
{      
   LOG(INFO)<<"**** TMbsUnpackTofCustom: Delete instance "<<FairLogger::endl;
   if( 0 < fMbsFile )
      delete fMbsFile;
   if( 0 < fMbsClient )
      delete fMbsClient;
   if( 0 < fMbsEvent )
      delete fMbsEvent;
   
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::triglog ) )
      delete fTriglogUnp;
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::scalormu ) )
      delete fScomUnp;
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::vftx ) )
      delete fVftxUnp;
   if( 0 <  fMbsUnpackPar->GetNbActiveBoards( tofVme::get4 ) )
      delete fGet4Unp;
}

// --------------------------------------------------
// Fairtask specific functions
void TMbsUnpackTofCustom::SetParContainers()
{
   cout << " MbsUnpackTofCustom: Get the unpack parameters for tof"<<endl;
   InitParameters();
}

InitStatus TMbsUnpackTofCustom::ReInit()
{
   cout << " MbsUnpackTofCustom: Reinitialize the unpack parameters for tof"<<endl;
   InitParameters();
}

InitStatus TMbsUnpackTofCustom::Init()
{
   if( kFALSE == InitParameters() )
      return kFATAL;
      
   // now create the proper MBS source
   fMbsEvent = new TMbsEvent(0, 0, 0, 0, 0);
   switch( fMbsUnpackPar->GetMode() )
   {
      case GETEVT__FILE:
      {
         // LMD file
         fMbsFile = new TMbsFile( fMbsFilePar );
         
         // For Debug purpose, printout the first 3 events
         if( kTRUE == fMbsUnpackPar->IsDebug() )
            fMbsFile->SetPrintEvent(3);
         break;
      } // case GETEVT__FILE:
      case GETEVT__STREAM:
      case GETEVT__TRANS:
      case GETEVT__EVENT:
      case GETEVT__REVSERV:
      {
         if( 0 == fMbsSourcePar->GetPort() )
            if( GETEVT__TRANS == fMbsUnpackPar->GetMode() )
               fMbsSourcePar->SetPort(    fgiDEFAULT_PORT__TRANSPORT );
            else if( GETEVT__STREAM == fMbsUnpackPar->GetMode() )
               fMbsSourcePar->SetPort(    fgiDEFAULT_PORT__STREAM_SERV );
            else fMbsSourcePar->SetPort( fgiDEFAULT_PORT__EVENT_SERV );
         // MBS event client
         fMbsClient = new TMbsClient(  fMbsSourcePar, fMbsUnpackPar->GetMode()  );
            
         // For Debug purpose, printout the first 3 events
         if( kTRUE == fMbsUnpackPar->IsDebug() )
            fMbsClient->SetPrintEvent(3);
         break;
      } // case MBS client
      default:
         return kFATAL;
   } // switch( fMbsUnpackPar->GetMode() )      
   
   // Create the proper Unpackers and number of output objects for each boards type
   if( kFALSE == RegisterOutput() )
      return kFATAL;
   if( kFALSE == CreateUnpackers() )
      return kFATAL;
   if( kFALSE == CreateHistogramms() )
      return kFATAL;
   
   fFirstCheck.Set();
   fLastCheck.Set();
   
   return kSUCCESS;
}
void TMbsUnpackTofCustom::Exec(Option_t* option)
{
   ClearOutput();
   if( 0 == fiNbEvents%10000 )
   {
      fCheck.Set();
      TString sFormat = Form("Event: %8d is MBS event %8d dt %5us Since start %5us",
                              fiNbEvents, fiLastEventNumber, fCheck.Get() - fLastCheck.Get(),
                              fCheck.Get() - fFirstCheck.Get() );
      LOG(INFO)<<sFormat<<FairLogger::endl;
      fLastCheck.Set();
   }
      
   LOG(DEBUG)<<"Event: "<<fiNbEvents<<" is MBS event "<<fiLastEventNumber<<FairLogger::endl;

   // GO4 like way
      // First clear the event container
   fMbsEvent->Clear(); 
      // Then get the next event
   switch( fMbsUnpackPar->GetMode() )
   {
      case GETEVT__FILE:
      {
         try
         {
            fMbsFile->BuildEvent( fMbsEvent );
         } // try
         catch(TGo4EventEndException& ex)
         {
            LOG(INFO)<<"Last event in file reached"<<FairLogger::endl;
            
            FairRunAna* ana = FairRunAna::Instance();
            ana->StopProcessingLMD();
            return;
         } // catch(TGo4EventEndException& ex)
         
         break;
      } // case GETEVT__FILE:
      case GETEVT__STREAM:
      case GETEVT__TRANS:
      case GETEVT__EVENT:
      case GETEVT__REVSERV:
      {
         fMbsClient->BuildEvent( fMbsEvent );
         break;
      }
      default:
         return;
   } // switch( fMbsUnpackPar->GetMode() )
   if( 0 == fiNbEvents )
   {
      fiFirstEventNumber = fMbsEvent->GetCount();
      LOG(INFO)<<"First Event: "<<fiLastEventNumber<<FairLogger::endl;
   }
   fiLastEventNumber = fMbsEvent->GetCount();
   
   // Get next filled sub event
   fMbsSubEvent = 0;
   fMbsEvent->ResetIterator();
   fMbsSubEvent = fMbsEvent->NextSubEvent();
   while( 0 != fMbsSubEvent )
   {
      // Process current sub event
      ProcessSubevent( fMbsSubEvent );
      // Get next filled sub event
      fMbsSubEvent = fMbsEvent->NextSubEvent();
   } // while( 0 != fMbsSubEvent )
      
   // Need to understand the fairroot like way!!!!
   /*
    *  TODO
    */
   
   FillHistograms();
   fiNbEvents++;
}
void TMbsUnpackTofCustom::Finish()
{
   LOG(INFO)<<"Last Event: "<<fiNbEvents<<" with MBS event nb "<<fiLastEventNumber<<FairLogger::endl;
   WriteHistogramms();
   
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::triglog ) )
      fTriglogUnp->FinishTriglog();
//   fScomUnp->FinishScom();
}

// ------------------------------------------------------------------
Bool_t TMbsUnpackTofCustom::InitParameters()
{
   // Get Base Container
   FairRunAna* ana = FairRunAna::Instance();
   FairRuntimeDb* rtdb=ana->GetRuntimeDb();

   // Unpacker parameter
   fMbsUnpackPar = (TMbsUnpackTofPar*) (rtdb->getContainer("TMbsUnpackTofPar"));
   if( 0 == fMbsUnpackPar )
      return kFALSE;
   fMbsUnpackPar->printParams();
    
   // Load the proper parameter file for the source we choose
   switch( fMbsUnpackPar->GetMode() )
   {
      case GETEVT__FILE:
      {
         LOG(DEBUG)<<"TMbsUnpackTofCustom::InitParameters: get TMbsFileParameter "<<FairLogger::endl;
         // LMD file
         fMbsFilePar = (TMbsFileParameter*) (rtdb->getContainer("TMbsFileParameter"));
         if( 0 == fMbsFilePar )
            return kFALSE;
         // Force a new initialisation of all available parameters
         rtdb->initContainers( ana->GetRunId() );
         fMbsFilePar->printParams();
         break;
      } // case GETEVT__FILE:
      case GETEVT__STREAM:
      case GETEVT__TRANS:
      case GETEVT__EVENT:
      case GETEVT__REVSERV:
      {
         LOG(DEBUG)<<"TMbsUnpackTofCustom::InitParameters: get TMbsSourceParameter "<<FairLogger::endl;
         // MBS event client
         fMbsSourcePar = (TMbsSourceParameter*) (rtdb->getContainer("TMbsSourceParameter"));
         if( 0 == fMbsSourcePar )
            return kFALSE;
         // Force a new initialisation of all available parameters
         rtdb->initContainers( ana->GetRunId() );
         fMbsSourcePar->printParams();
         break;
      } // case MBS client
      default:
         LOG(WARNING)<<"Mbs Source Mode = 0 in TMbsUnpackTofCustom::InitParameters "<<FairLogger::endl;
         return kFALSE;
   } // switch( fMbsUnpackPar->GetMode() )
     
   return kTRUE;
} 
// ------------------------------------------------------------------
Bool_t TMbsUnpackTofCustom::CreateHistogramms()
{

   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::triglog ) )
      fTriglogUnp->CreateHistos();
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::scalormu ) )
      fScomUnp->CreateHistos();
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::vftx ) )
      fVftxUnp->CreateHistos();

   // Get4 histos initialized on creation of unpacker!!!
//   if( 0 <  fMbsUnpackPar->GetNbActiveBoards( tofVme::get4 ) )
//      fGet4Unp->CreateHistos();

}
Bool_t TMbsUnpackTofCustom::FillHistograms()
{
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::triglog ) )
      fTriglogUnp->FillHistos();
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::scalormu ) )
      fScomUnp->FillHistos();
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::vftx ) )
      fVftxUnp->FillHistos();

   // Get4 histos initialized on creation of unpacker!!!
   if( 0 <  fMbsUnpackPar->GetNbActiveBoards( tofVme::get4 ) )
      fGet4Unp->FillHistos();
   
   return kTRUE;
}
void TMbsUnpackTofCustom::WriteHistogramms()
{
   TDirectory * oldir = gDirectory;
   TFile *fHist = new TFile("./tofMbsUnp.hst.root","RECREATE");
   
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::triglog ) )
      fTriglogUnp->WriteHistos( fHist );
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::scalormu ) )
      fScomUnp->WriteHistos( fHist );
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::vftx ) )
      fVftxUnp->WriteHistos( fHist );
      
   gDirectory->cd( oldir->GetPath() );
   fHist->Close();

   TFile *fHist2 = new TFile("./tofRocUnp.hst.root","RECREATE");

   fGet4Unp->WriteHistos( fHist2 );

   gDirectory->cd( oldir->GetPath() );
   fHist2->Close();
}
void TMbsUnpackTofCustom::DeleteHistograms()
{
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::triglog ) )
      fTriglogUnp->DeleteHistos();
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::scalormu ) )
      fScomUnp->DeleteHistos();
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::vftx ) )
      fVftxUnp->DeleteHistos();

   if( 0 <  fMbsUnpackPar->GetNbActiveBoards( tofVme::get4 ) )
      fGet4Unp->DeleteHistos();
}
// ------------------------------------------------------------------
Bool_t TMbsUnpackTofCustom::CreateUnpackers()
{
   if( 0 == fMbsUnpackPar->GetNbActiveBoards() )
   {
      LOG(ERROR)<<"TMbsUnpackTofCustom::CreateUnpackers => No active boards => No unpacker !?!?! "<<FairLogger::endl;
      return kFALSE;
   }
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::triglog ) )
      fTriglogUnp = new TTofTriglogUnpacker( fMbsUnpackPar );
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::scalormu ) )
      fScomUnp    = new TTofScomUnpacker( fMbsUnpackPar );
/*
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::caenV1290 ) )
      fV1290Unp = new TTofV1290Unpacker( fMbsUnpackPar );
*/
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::vftx ) )
      fVftxUnp = new TTofVftxUnpacker( fMbsUnpackPar );

   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::get4 ) )
   {
      fGet4Unp = new TTofGet4Unpacker( fMbsUnpackPar );
      fGet4Unp->Init();
   }

   return kTRUE;
}
Bool_t TMbsUnpackTofCustom::RegisterOutput()
{
   if( 0 == fMbsUnpackPar->GetNbActiveBoards() )
   {
      LOG(ERROR)<<"TMbsUnpackTofCustom::RegisterOutput => No active boards => No output objects !?!?! "<<FairLogger::endl;
      return kFALSE;
   }
   // Not sure here what is the best way to group the TDC objects......
   // The vector of data in the board objects kill probably the TClonesArray purpose?
   // Maybe better to have big fixed size array and TTofVftxData::Clear calls in TTofVftxBoard combined
   // with ConstructedAt access in TTofVftxUnpacker
   FairRootManager *fManager = FairRootManager::Instance();
      // Scalers
         // Triglog
   if( 1 == fMbsUnpackPar->GetNbActiveBoards( tofVme::triglog ) )
   {
      // There should always be maximum one trigger board active at a time!!!
      fTriglogBoardCollection = new TClonesArray( "TTofTriglogBoard", 1 );
//      fManager->Register("TofTriglog","TofUnpack",fTriglogBoardCollection, kTRUE);
      fManager->Register( "TofTriglog","TofUnpack",fTriglogBoardCollection,
                          fMbsUnpackPar->WriteDataInCbmOut());
   } // if( 1 == fMbsUnpackPar->GetNbActiveBoards( tofVme::triglog ) )
      else if( 1 < fMbsUnpackPar->GetNbActiveBoards( tofVme::triglog ) )
      {
         LOG(ERROR)<<"TMbsUnpackTofCustom::RegisterOutput => More than 1 TRIGLOG board active!!!!! recheck your VME address matrix "<<FairLogger::endl;
         return kFALSE;
      } // else if( 1 < fMbsUnpackPar->GetNbActiveBoards( tofVme::triglog ) )
         // TRIGLOG + Scalormu
   if( 0 < fMbsUnpackPar->GetNbActiveScalersB() )
   {
      fScalerBoardCollection = new TClonesArray( "TTofScalerBoard", 
                                                  fMbsUnpackPar->GetNbActiveScalersB());
//      fManager->Register("TofRawScalers","TofUnpack",fScalerBoardCollection, kTRUE);
      fManager->Register( "TofRawScalers","TofUnpack",fScalerBoardCollection,
                          fMbsUnpackPar->WriteDataInCbmOut());
   } // if( 0 < fMbsUnpackPar->GetNbActiveScalersB() )
      //TDC
         // VFTX
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::vftx ) )
   {
      fVftxBoardCollection = new TClonesArray( "TTofVftxBoard", 
                                               fMbsUnpackPar->GetNbActiveBoards( tofVme::vftx ));
//      fManager->Register("TofVftxTdc","TofUnpack",fVftxBoardCollection, kTRUE);
      fManager->Register( "TofVftxTdc","TofUnpack",fVftxBoardCollection,
                          fMbsUnpackPar->WriteDataInCbmOut());
   } // if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::vftx ) )
         // Caen v1290 TDC
         // TRB3
         // GET4
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::get4 ) )
   {
      fGet4BoardCollection = new TClonesArray( "TTofGet4Board",
                                                fMbsUnpackPar->GetNbActiveBoards( tofVme::get4 ));
//      fManager->Register("TofGet4Tdc","TofUnpack",fGet4BoardCollection, kTRUE);
      fManager->Register( "TofGet4Tdc","TofUnpack",fGet4BoardCollection,
                          fMbsUnpackPar->WriteDataInCbmOut());
   } // if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::get4 ) )

   return kTRUE;
}
Bool_t TMbsUnpackTofCustom::ClearOutput()
{
   if( 1 == fMbsUnpackPar->GetNbActiveBoards( tofVme::triglog ) )
      fTriglogBoardCollection->Clear("C");
   if( 0 < fMbsUnpackPar->GetNbActiveScalersB() )
      fScalerBoardCollection->Clear("C");
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::vftx ) ) 
      fVftxBoardCollection->Clear("C");
   if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::get4 ) )
      fGet4BoardCollection->Clear("C");
   return kTRUE;
}
// ------------------------------------------------------------------
void TMbsUnpackTofCustom::ProcessSubevent(TMbsSubEvent* subevt)
{
   LOG(DEBUG)<<"TMbsUnpackTofCustom::ProcessSubevent => Found subevent with type "
            <<subevt->GetType()<<" subtype "
            <<subevt->GetSubtype()<<" procid "
            <<subevt->GetProcid()<<" subcrate "
            <<(Int_t)subevt->GetSubcrate()<<" control "
            <<(Int_t)subevt->GetControl()
            <<FairLogger::endl;

   // Triglog board always has its own subevent
   if( subevt->GetProcid() == roc::proc_Triglog ) 
   {
      if( 0 < fMbsUnpackPar->GetNbActiveBoards( tofVme::triglog ) )
         fTriglogUnp->ProcessTriglog( (UInt_t*)(subevt->GetDataField() ), subevt->GetIntLen() ); 
      LOG(DEBUG)<<"TMbsUnpackTofCustom::ProcessSubevent => Found TRIGLOG subevent! LEN"
               <<subevt->GetIntLen()<<FairLogger::endl;
   } 
       
   // all other boards are in a common subevent
   if( subevt->GetProcid() == roc::proc_COSY_Nov11 ) 
   {
      // MBS data from GSI beamtime, August-October-November 11
//      if( 400 < fiNbEvents )
//         LOG(ERROR)<<"TMbsUnpackTof::ProcessSubevent => Event "<<fiNbEvents<< "nbWords "<<subevt->GetIntLen()<<FairLogger::endl;

      Int_t  * pData   = subevt->GetDataField();
      UInt_t  uNbWords = subevt->GetIntLen();

      Int_t* iTagPos[ fMbsUnpackPar->GetBoardsNumber() ];
      Int_t  iTagLen[ fMbsUnpackPar->GetBoardsNumber() ];

      for(Int_t iBoard = 0; iBoard < fMbsUnpackPar->GetBoardsNumber(); iBoard++) 
      {
         iTagPos[iBoard] = 0;
         iTagLen[iBoard] = 0;
      } // for(Int_t iBoard = 0; iBoard < fMbsUnpackPar->GetBoardsNumber(); iBoard++) 

      Int_t iLastTag = -1;

      for (UInt_t uCurrWord = 0; uCurrWord < uNbWords; ++uCurrWord) 
      {
         ULong64_t* plTag = (ULong64_t*) pData;
         Bool_t bFound = kFALSE;

         // loop over boards until finding a matching one0
         for( Int_t iBoard=0;iBoard< fMbsUnpackPar->GetBoardsNumber(); iBoard++ )
            if( kTRUE == fMbsUnpackPar->IsActive( iBoard ) )
               if ((*plTag == fMbsUnpackPar->GetBoardTag( iBoard )) && (fMbsUnpackPar->GetBoardTag( iBoard )!=0)) 
               {
                  if (iLastTag>=0) 
                  {
                     // If a tag was already found:
                     // length of corresponding data is nb words since it was found
                     iTagLen[iLastTag] = pData - iTagPos[iLastTag];
                     iLastTag = -1;
                  } // if (iLastTag>=0) 

                  if (iTagPos[iBoard]==0) 
                  {
                     // if Tag of this board was never found
                     pData+=2; 
                     uCurrWord+=1;
                     iTagPos[iBoard] = pData;
                     iLastTag = iBoard;
                  } // if (iTagPos[iBoard]==0) 
                     else 
                     {
                        LOG(ERROR)<<"TMbsUnpackTofCustom::ProcessSubevent => FORMAT ERROR found tag "
                                  <<fMbsUnpackPar->GetBoardTag( iBoard )<<" twice"<<FairLogger::endl;
                        // jump this tag
                        pData+=2; 
                        uCurrWord+=1;
                     } // else of if (iTagPos[iBoard]==0) 

                  bFound = kTRUE;
                  break;
               } // if ((*plTag == fMbsUnpackPar->GetBoardTag( iBoard )) && (fMbsUnpackPar->GetBoardTag( iBoard )!=0))

         if( kFALSE == bFound ) 
            pData++;
      } // for (UInt_t uCurrWord = 0; uCurrWord < uNbWords; ++uCurrWord) 

      // if t east one TAG found: end of corresponding data is end of subevent
      if (iLastTag>=0)
         iTagLen[iLastTag] = pData - iTagPos[iLastTag];

      // Actually process data in different Unpackers:
      
      for( UInt_t uBoard=0; uBoard < fMbsUnpackPar->GetBoardsNumber(); uBoard++ )
         if( 0 < iTagPos[uBoard] )
         {
            LOG(DEBUG)<<"TMbsUnpackTofCustom::ProcessSubevent => TAG "<<uBoard
                      <<" POS "<<iTagPos[uBoard] - subevt->GetDataField()
                      <<" LEN "<<iTagLen[uBoard]
                      <<" TYP "<<fMbsUnpackPar->GetBoardType( uBoard )<<FairLogger::endl;
            if( 0 < iTagLen[uBoard])
               switch( fMbsUnpackPar->GetBoardType( uBoard ) )
               {
                  case tofVme::caenV1290:
                     break;
                  case tofVme::vftx:
                     fVftxUnp->ProcessVFTX( fMbsUnpackPar->GetGlobalToActiveInd( uBoard ), 
                                            (UInt_t*) iTagPos[uBoard], iTagLen[uBoard]); 
                     break;
                  case tofVme::trb3:
                     break;
                  case tofVme::get4:
                     break;
                  case tofVme::triglog:
                     break;
                  case tofVme::scalormu:
                     fScomUnp->ProcessScom( fMbsUnpackPar->GetGlobalToActiveInd( uBoard ), 
                                            (UInt_t*) iTagPos[uBoard], iTagLen[uBoard]);  // Scaler Or Multiplicity
                     break;
                  case tofVme::undef:
                  default:
                     LOG(WARNING)<<"TMbsUnpackTofCustom::ProcessSubevent => Unknown board type "
                                 <<fMbsUnpackPar->GetBoardType( uBoard )
                                 <<"!!!!" <<FairLogger::endl;
               } // switch( fMbsUnpackPar->GetBoardType( uBoard ) )
         } // if (iTagPos[iBoard])
/*
      if (iTagPos[VME__ID_1182] && iTagLen[VME__ID_1182])
         Process1182(0, iTagPos[VME__ID_1182], iTagLen[VME__ID_1182]);  // 1182
      if (iTagPos[VME__ID_1183] && iTagLen[VME__ID_1183])
         Process1182(1, iTagPos[VME__ID_1183], iTagLen[VME__ID_1183]);  // 1183
      for (int tdc=VME__ID_TDC1;tdc<=VME__ID_TDC8;tdc++)
         if (iTagPos[tdc] && iTagLen[tdc])
            Process1290(tdc-VME__ID_TDC1, iTagPos[tdc], iTagLen[tdc]);  // all TDCs
      for (int qdc=VME__ID_QDC1;qdc<=VME__ID_QDC2;qdc++)
         if (iTagPos[qdc] && iTagLen[qdc])
            Process965(qdc-VME__ID_QDC1, iTagPos[qdc], iTagLen[qdc]);  // all QDCs
      if (iTagPos[VME__ID_QFW] && iTagLen[VME__ID_QFW])
         ProcessQFW((uint32_t*)iTagPos[VME__ID_QFW], iTagLen[VME__ID_QFW]);  // QFW
*/
   
      
   } // if( subevt->GetProcid() == roc::proc_COSY_Nov11 ) 

   if( subevt->GetProcid() == roc::proc_RocEvent ||
        subevt->GetProcid() == roc::proc_RawData )
   {
      if( 0 <  fMbsUnpackPar->GetNbActiveBoards( tofVme::get4 ) )
         fGet4Unp->ProcessGet4( (UInt_t*)(subevt->GetDataField() ), subevt->GetDlen(),
                                subevt->GetSubcrate(), subevt->GetControl() );
   }
}