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

// TOF headers
#include "TofVmeDef.h"

// FAIR headers
#include "FairLogger.h"
#include "FairParamList.h" 

// ROOT headers

ClassImp(TMbsUnpackTofPar)

TMbsUnpackTofPar::TMbsUnpackTofPar() :
    FairParGenericSet("TMbsUnpackTofPar","Mbs Unpack parameters for the ToF","TestDefaultContext"),
    fiMbsSourceMode(0),
    fuCbmOutOn(0),
    fuVftxDebug(0),
    fuNbVmeBoards(0),
    fuNbNonVmeBoards(0),
    fuNbScalerB(0),
    fuNbScalerActiveB(0),
    fuNbTriglog(0),
    fuNbTriglogActive(0),
    fuNbScalOrMu(0),
    fuNbScalOrMuActive(0),
    fuNbTdc(0),
    fuNbTdcActive(0),
    fuNbV1290(0),
    fuNbVftx(0),
    fuNbTrb3(0),
    fuNbGet4(0),
    fiTriggerRejection(0)
{
}

TMbsUnpackTofPar::TMbsUnpackTofPar(const char* name,
             const char* title,
             const char* context,
             Int_t iMode ) :
    FairParGenericSet(name,title,context),
    fiMbsSourceMode(iMode),
    fuCbmOutOn(0),
    fuVftxDebug(0),
    fuNbVmeBoards(0),
    fuNbNonVmeBoards(0),
    fuNbScalerB(0),
    fuNbScalerActiveB(0),
    fuNbTriglog(0),
    fuNbTriglogActive(0),
    fuNbScalOrMu(0),
    fuNbScalOrMuActive(0),
    fuNbTdc(0),
    fuNbTdcActive(0),
    fuNbV1290(0),
    fuNbVftx(0),
    fuNbTrb3(0),
    fuNbGet4(0),
    fiTriggerRejection(0)
{
}


TMbsUnpackTofPar::~TMbsUnpackTofPar()
{
}

void TMbsUnpackTofPar::clear(void)
{
	  status = kFALSE;
	  resetInputVersions();

   fiMbsSourceMode    = 0;
   fuCbmOutOn         = 0;
   fuVftxDebug        = 0;
   fuNbVmeBoards      = 0;
   fuNbNonVmeBoards   = 0;
   fuNbScalerB        = 0;
   fuNbScalerActiveB  = 0;
   fuNbTriglog        = 0;
   fuNbTriglogActive  = 0;
   fuNbScalOrMu       = 0;
   fuNbScalOrMuActive = 0;
   fuNbTdc            = 0;
   fuNbTdcActive      = 0;
   fuNbV1290          = 0;
   fuNbVftx           = 0;
   fuNbTrb3           = 0;
   fuNbGet4           = 0;
}

void TMbsUnpackTofPar::putParams(FairParamList* l)
{
  if (!l) { return; }

  l->add("MbsSourceMode",     fiMbsSourceMode);
  l->add("WriteDataInCbmOut", (Int_t)fuCbmOutOn);
  l->add("VftxDebug",         (Int_t)fuVftxDebug);
  l->add("MbsNbVmeBoards",    (Int_t)fuNbVmeBoards);
  l->add("MbsVmeMapping",     fiMbsVmeMapping);
  l->add("NbNonVmeBoards",    (Int_t)fuNbNonVmeBoards);
  l->add("NonVmeMapping",     fiNonVmeMapping);
  l->add("TriggerRejection",  fiTriggerRejection);
}

Bool_t TMbsUnpackTofPar::getParams(FairParamList* l)
{
  if (!l) { return kFALSE; }

  LOG(DEBUG2)<<"Get the MBS unpack parameters."<<FairLogger::endl;
  
  if ( ! l->fill("MbsSourceMode",  &fiMbsSourceMode) ) return kFALSE;
  
  Int_t iTempCaster = 0;
  if ( ! l->fill("WriteDataInCbmOut",      &iTempCaster) ) return kFALSE;
  fuCbmOutOn = (UInt_t)iTempCaster;

  iTempCaster = 0;
  if ( ! l->fill("VftxDebug",      &iTempCaster) ) return kFALSE;
  fuVftxDebug = (UInt_t)iTempCaster;
  
  iTempCaster = 0;
  if ( ! l->fill("MbsNbVmeBoards", &iTempCaster) ) return kFALSE;
  fuNbVmeBoards = (UInt_t)iTempCaster;
  
  fiMbsVmeMapping.Set( fuNbVmeBoards * tofVme::kuNbFieldsMapping );
  if ( ! l->fill("MbsVmeMapping",  &fiMbsVmeMapping) ) return kFALSE;

  iTempCaster = 0;
  if ( ! l->fill("NbNonVmeBoards", &iTempCaster) ) return kFALSE;
  fuNbNonVmeBoards = (UInt_t)iTempCaster;

  if( 0 < fuNbNonVmeBoards )
  {
     fiNonVmeMapping.Set( fuNbNonVmeBoards * tofVme::kuNbFieldsMapping );
     if ( ! l->fill("NonVmeMapping",  &fiNonVmeMapping) ) return kFALSE;
  } // if( 0 < fuNbNonVmeBoards )

  if ( ! l->fill("TriggerRejection",  &fiTriggerRejection) ) return kFALSE;

  FillBoardsNbPerType();
  FillActiveBoardsNbPerType();
//  printParams();
  
  return kTRUE;
}

void TMbsUnpackTofPar::printParams()
{   
   LOG(INFO)<<"Parameter values in TMbsUnpackTofPar: "<<FairLogger::endl;
   LOG(INFO)<<"  Mbs Source Mode: \t\t"<<GetMode()<<FairLogger::endl;
   if( kTRUE == WriteDataInCbmOut() )
      LOG(INFO)<<"  Data writen in cbmroot out:  \t\tON"<<FairLogger::endl;
      else LOG(INFO)<<"  Data writen in cbmroot out:  \t\tOFF"<<FairLogger::endl;
   if( kTRUE == IsDebug() )
      LOG(INFO)<<"  VFTX Unp debug:  \t\tON"<<FairLogger::endl;
      else LOG(INFO)<<"  VFTX Unp debug:  \t\tOFF"<<FairLogger::endl;
   LOG(INFO)<<"  Mbs Nb Boards:   \t\t"<<GetBoardsNumber()<<FairLogger::endl;
   LOG(INFO)<<"  Mbs Vme Mapping: \t\t BoardIndex Active    Address AddMod     TokenA     TokenB Type"<<FairLogger::endl;
   TString sTemp = "";
   for( UInt_t uBoard = 0; uBoard < fuNbVmeBoards; uBoard++ )
   {
      sTemp = Form("                   \t\t %10d %6d 0x%08X %6x 0x%08X 0x%08X %4d",
                   GetMappingField( uBoard, tofVme::BoardIndex),
                   GetMappingField( uBoard, tofVme::Active),
                   GetMappingField( uBoard, tofVme::Address),
                   GetMappingField( uBoard, tofVme::AddMod),
                   GetMappingField( uBoard, tofVme::TokenA),
                   GetMappingField( uBoard, tofVme::TokenB),
                   GetMappingField( uBoard, tofVme::Type) );
      LOG(INFO)<<sTemp<<FairLogger::endl;
   } // for( UInt_t uBoard = 0; uBoard < fuNbVmeBoards; uBoard++ )

   LOG(INFO)<<"  Nb Non VME Boards:\t\t"<<GetNotVmeBoardsNumber()<<FairLogger::endl;
   if( 0 < GetNotVmeBoardsNumber() )
   {
      LOG(INFO)<<"  Not-Vme Mapping: \t\t BoardIndex Active    RocIndx AddMod     TokenA     TokenB Type"<<FairLogger::endl;
      sTemp = "";
      for( UInt_t uBoard = 0; uBoard < GetNotVmeBoardsNumber(); uBoard++ )
      {
         sTemp = Form("                   \t\t %10d %6d 0x%08X %6x 0x%08X 0x%08X %4d",
               GetNotVmeMappingField( uBoard, tofVme::BoardIndex),
               GetNotVmeMappingField( uBoard, tofVme::Active),
               GetNotVmeMappingField( uBoard, tofVme::Address),
               GetNotVmeMappingField( uBoard, tofVme::AddMod),
               GetNotVmeMappingField( uBoard, tofVme::TokenA),
               GetNotVmeMappingField( uBoard, tofVme::TokenB),
               GetNotVmeMappingField( uBoard, tofVme::Type) );
         LOG(INFO)<<sTemp<<FairLogger::endl;
      } // for( UInt_t uBoard = 0; uBoard < GetNotVmeBoardsNumber(); uBoard++ )
   } // if( 0 < GetNotVmeBoardsNumber() )

   if( -1 < GetTriggerToReject() )
      LOG(INFO)<<"  Trigger to reject:\t\t"<<GetTriggerToReject()<<FairLogger::endl;
      else LOG(INFO)<<"  Trigger rejection:\t\tOFF"<<FairLogger::endl;
   return;
}

//*************** VME boards ****************************************************/
Int_t TMbsUnpackTofPar::GetActiveBoardsNumber()
{
   UInt_t uNbActive = 0;
   // Count all active VME boards of all types
   for( UInt_t uBoard = 0; uBoard < fuNbVmeBoards; uBoard++ )
      if( kTRUE == IsActive( uBoard ) )
         uNbActive++;
   return uNbActive;
}
Int_t TMbsUnpackTofPar::GetMappingField( UInt_t uBoard, UInt_t uField)
{
   LOG(DEBUG3)<<"TMbsUnpackTofPar::GetMappingField: Trying to get combination ("
              <<uBoard<<"/"<<uField<<") => Index "<<uBoard*tofVme::kuNbFieldsMapping + uField<<FairLogger::endl;
   if( fuNbVmeBoards*tofVme::kuNbFieldsMapping == fiMbsVmeMapping.GetSize() )
   {
      if( uBoard < fuNbVmeBoards && uField < tofVme::kuNbFieldsMapping )
         return fiMbsVmeMapping[ uBoard*tofVme::kuNbFieldsMapping + uField ];
         else
         {
            LOG(WARNING)<<"TMbsUnpackTofPar::GetMappingField: wrong Board/field combination ("
                        <<uBoard<<"/"<<uField<<")"<<FairLogger::endl;
            return -1;
         } // else of if( uBoard < fuNbVmeBoards && uField < tofVme::kuNbFieldsMapping )
   } // if( fuNbVmeBoards*tofVme::kuNbFieldsMapping == fiMbsVmeMapping.GetSize() )
      else
      {
         LOG(ERROR)<<"TMbsUnpackTofPar::GetMappingField: wrong fiMbsVmeMapping size ("
                     <<fiMbsVmeMapping.GetSize()<<" instead of "
                     <<fuNbVmeBoards*tofVme::kuNbFieldsMapping<<"), maybe not initialized!"<<FairLogger::endl;
         return -1;
      } // else of if( fuNbVmeBoards*tofVme::kuNbFieldsMapping == fiMbsVmeMapping.GetSize() )
}
ULong64_t TMbsUnpackTofPar::GetBoardTag( UInt_t uBoard)
{
   if( fuNbVmeBoards*tofVme::kuNbFieldsMapping == fiMbsVmeMapping.GetSize() )
   {
      if( uBoard < fuNbVmeBoards )
      {
         ULong64_t uFullTag = ( ( (ULong64_t)GetMappingField( uBoard, tofVme::TokenB ) )<< 32 ) |
                                  (ULong64_t)GetMappingField( uBoard, tofVme::TokenA );
//         LOG(INFO)<<Form(" %016llX %08llX %08llX", uFullTag, (uFullTag&0xFFFFFFFF00000000)>>32, (uFullTag&0xFFFFFFFF) )<<FairLogger::endl;
         return uFullTag;
      } // if( uBoard < fuNbVmeBoards )
         else
         {
            LOG(WARNING)<<"TMbsUnpackTofPar::GetBoardTag: wrong Board ("
                        <<uBoard<<")"<<FairLogger::endl;
            return 0;
         } // else of if( uBoard < fuNbVmeBoards && uField < tofVme::kuNbFieldsMapping )
   } // if( fuNbVmeBoards*tofVme::kuNbFieldsMapping == fiMbsVmeMapping.GetSize() )
      else
      {
         LOG(ERROR)<<"TMbsUnpackTofPar::GetBoardTag: wrong fiMbsVmeMapping size ("
                     <<fiMbsVmeMapping.GetSize()<<" instead of "
                     <<fuNbVmeBoards*tofVme::kuNbFieldsMapping<<"), maybe not initialized!"<<FairLogger::endl;
         return 0;
      } // else of if( fuNbVmeBoards*tofVme::kuNbFieldsMapping == fiMbsVmeMapping.GetSize() )
}
Bool_t TMbsUnpackTofPar::IsActive( UInt_t uBoard)
{
   if( fuNbVmeBoards*tofVme::kuNbFieldsMapping == fiMbsVmeMapping.GetSize() )
   {
      if( uBoard < fuNbVmeBoards )
         return (1 == GetMappingField( uBoard, tofVme::Active ) )? kTRUE: kFALSE;
         else
         {
            LOG(WARNING)<<"TMbsUnpackTofPar::IsActive: wrong Board ("
                        <<uBoard<<")"<<FairLogger::endl;
            return kFALSE;
         } // else of if( uBoard < fuNbVmeBoards && uField < tofVme::kuNbFieldsMapping )
   } // if( fuNbVmeBoards*tofVme::kuNbFieldsMapping == fiMbsVmeMapping.GetSize() )
      else
      {
         LOG(ERROR)<<"TMbsUnpackTofPar::IsActive: wrong fiMbsVmeMapping size ("
                     <<fiMbsVmeMapping.GetSize()<<" instead of "
                     <<fuNbVmeBoards*tofVme::kuNbFieldsMapping<<"), maybe not initialized!"<<FairLogger::endl;
         return kFALSE;
      } // else of if( fuNbVmeBoards*tofVme::kuNbFieldsMapping == fiMbsVmeMapping.GetSize() )
}
Int_t TMbsUnpackTofPar::GetBoardType( UInt_t uBoard)
{ 
   return GetMappingField( uBoard, tofVme::Type); 
};
UInt_t TMbsUnpackTofPar::GetGlobalToTypeInd( UInt_t uBoardToFind )
{
   UInt_t uIndBoardSameType = 0;
   for( UInt_t uBoard = 0; uBoard < fuNbVmeBoards; uBoard++)
   {
      // When find target return its index among boards
      // of same type
      if( uBoardToFind == uBoard )
         return uIndBoardSameType;
      // Count active boards of same type as target
      if( GetBoardType( uBoardToFind ) == GetBoardType( uBoard ) )
         uIndBoardSameType++;
   } // for( UInt_t uBoard = 0; uBoard < fuNbVmeBoards; uBoard++)
   // If the board was not found:
   // return total number of boards as it will be rejected by other functions!
   return fuNbVmeBoards;
}
UInt_t TMbsUnpackTofPar::GetGlobalToActiveInd( UInt_t uBoardToFind )
{
   UInt_t uIndActiveSameBoard = 0;
   for( UInt_t uBoard = 0; uBoard < fuNbVmeBoards; uBoard++)
   {
      // When find target return its index among active boards
      // of same type
      if( uBoardToFind == uBoard )
         return uIndActiveSameBoard;
      // Count active boards of same type as target
      if( GetBoardType( uBoardToFind ) == GetBoardType( uBoard ) &&
          kTRUE == IsActive( uBoard ) )
          uIndActiveSameBoard++;
   } // for( UInt_t uBoard = 0; uBoard < fuNbVmeBoards; uBoard++)
   // If the board was not found:
   // return total number of boards as it will be rejected by other functions!
   return fuNbVmeBoards;
}
UInt_t TMbsUnpackTofPar::GetActiveToAllTypeInd( UInt_t uBoardToFind, UInt_t uType )
{
   UInt_t uIndBoardSameType = 0;
   UInt_t uIndActiveSameBoard = 0;
   for( UInt_t uBoard = 0; uBoard < fuNbVmeBoards; uBoard++)
   {
      // When find target return its index among boards
      // of same type
      if( uBoardToFind == uIndActiveSameBoard &&
           kTRUE == IsActive( uBoard ))
         return uIndBoardSameType;
      // Count all boards of same type as target
      if( uType == GetBoardType( uBoard ) )
      {
         uIndBoardSameType++;
         // Count active boards of same type as target
         if( kTRUE == IsActive( uBoard ) )
            uIndActiveSameBoard++;
       }
   } // for( UInt_t uBoard = 0; uBoard < fuNbVmeBoards; uBoard++)
   // If the boad was not found:
   // return total number of boards as it will be rejected by other functions!
   return fuNbVmeBoards;
}
//*******************************************************************************/
//*********** Not VME boards ****************************************************/
Int_t TMbsUnpackTofPar::GetActiveNotVmeBoardsNumber()
{
   UInt_t uNbActive = 0;
   // Count all active Non-VME boards of all types
   for( UInt_t uBoard = 0; uBoard < fuNbNonVmeBoards; uBoard++ )
      if( kTRUE == IsActiveNotVme( uBoard ) )
         uNbActive++;
   return uNbActive;
}
Int_t TMbsUnpackTofPar::GetNotVmeMappingField( UInt_t uBoard, UInt_t uField)
{
   LOG(DEBUG2)<<"TMbsUnpackTofPar::GetNotVmeMappingField: Trying to get combination ("
              <<uBoard<<"/"<<uField<<") => Index "<<uBoard*tofVme::kuNbFieldsMapping + uField<<FairLogger::endl;
   if( fuNbNonVmeBoards*tofVme::kuNbFieldsMapping == fiNonVmeMapping.GetSize() )
   {
      if( uBoard < fuNbNonVmeBoards && uField < tofVme::kuNbFieldsMapping )
         return fiNonVmeMapping[ uBoard*tofVme::kuNbFieldsMapping + uField ];
         else
         {
            LOG(WARNING)<<"TMbsUnpackTofPar::GetMappingField: wrong Board/field combination ("
                        <<uBoard<<"/"<<uField<<")"<<FairLogger::endl;
            return -1;
         } // else of if( uBoard < fuNbNonVmeBoards && uField < tofVme::kuNbFieldsMapping )
   } // if( fuNbNonVmeBoards*tofVme::kuNbFieldsMapping == fiMbsVmeMapping.GetSize() )
      else
      {
         LOG(ERROR)<<"TMbsUnpackTofPar::GetMappingField: wrong fiNonVmeMapping size ("
                     <<fiNonVmeMapping.GetSize()<<" instead of "
                     <<fuNbNonVmeBoards*tofVme::kuNbFieldsMapping<<"), maybe not initialized!"<<FairLogger::endl;
         return -1;
      } // else of if( fuNbNonVmeBoards*tofVme::kuNbFieldsMapping == fiNonVmeMapping.GetSize() )
}
ULong64_t TMbsUnpackTofPar::GetNotVmeBoardTag( UInt_t uBoard)
{
   if( fuNbNonVmeBoards*tofVme::kuNbFieldsMapping == fiNonVmeMapping.GetSize() )
   {
      if( uBoard < fuNbNonVmeBoards )
      {
         ULong64_t uFullTag = ( ( (ULong64_t)GetNotVmeMappingField( uBoard, tofVme::TokenB ) )<< 32 ) |
                                  (ULong64_t)GetNotVmeMappingField( uBoard, tofVme::TokenA );
         return uFullTag;
      } // if( uBoard < fuNbVmeBoards )
         else
         {
            LOG(WARNING)<<"TMbsUnpackTofPar::GetNotVmeBoardTag: wrong Board ("
                        <<uBoard<<")"<<FairLogger::endl;
            return 0;
         } // else of if( uBoard < fuNbNonVmeBoards && uField < tofVme::kuNbFieldsMapping )
   } // if( fuNbNonVmeBoards*tofVme::kuNbFieldsMapping == fiNonVmeMapping.GetSize() )
      else
      {
         LOG(ERROR)<<"TMbsUnpackTofPar::GetNotVmeBoardTag: wrong fiNonVmeMapping size ("
                     <<fiNonVmeMapping.GetSize()<<" instead of "
                     <<fuNbNonVmeBoards*tofVme::kuNbFieldsMapping<<"), maybe not initialized!"<<FairLogger::endl;
         return 0;
      } // else of if( fuNbNonVmeBoards*tofVme::kuNbFieldsMapping == fiNonVmeMapping.GetSize() )
}
Bool_t TMbsUnpackTofPar::IsActiveNotVme( UInt_t uBoard)
{
   if( fuNbNonVmeBoards*tofVme::kuNbFieldsMapping == fiNonVmeMapping.GetSize() )
   {
      if( uBoard < fuNbNonVmeBoards )
         return (1 == GetNotVmeMappingField( uBoard, tofVme::Active ) )? kTRUE: kFALSE;
         else
         {
            LOG(WARNING)<<"TMbsUnpackTofPar::IsActiveNotVme: wrong Board ("
                        <<uBoard<<")"<<FairLogger::endl;
            return kFALSE;
         } // else of if( uBoard < fuNbNonVmeBoards && uField < tofVme::kuNbFieldsMapping )
   } // if( fuNbNonVmeBoards*tofVme::kuNbFieldsMapping == fiNonVmeMapping.GetSize() )
      else
      {
         LOG(ERROR)<<"TMbsUnpackTofPar::IsActiveNotVme: wrong fiNonVmeMapping size ("
                     <<fiNonVmeMapping.GetSize()<<" instead of "
                     <<fuNbNonVmeBoards*tofVme::kuNbFieldsMapping<<"), maybe not initialized!"<<FairLogger::endl;
         return kFALSE;
      } // else of if( fuNbNonVmeBoards*tofVme::kuNbFieldsMapping == fiNonVmeMapping.GetSize() )
}
Int_t TMbsUnpackTofPar::GetNotVmeBoardType( UInt_t uBoard)
{
   return GetNotVmeMappingField( uBoard, tofVme::Type);
};
UInt_t TMbsUnpackTofPar::GetGlobToTypeIndNoVme( UInt_t uBoardToFind )
{
   UInt_t uIndBoardSameType = 0;
   for( UInt_t uBoard = 0; uBoard < fuNbNonVmeBoards; uBoard++)
   {
      // When find target return its index among boards
      // of same type
      if( uBoardToFind == uBoard )
         return uIndBoardSameType;
      // Count active boards of same type as target
      if( GetNotVmeBoardType( uBoardToFind ) == GetNotVmeBoardType( uBoard ) )
         uIndBoardSameType++;
   } // for( UInt_t uBoard = 0; uBoard < fuNbNonVmeBoards; uBoard++)
   // If the board was not found:
   // return total number of boards as it will be rejected by other functions!
   return fuNbNonVmeBoards;
}
UInt_t TMbsUnpackTofPar::GetGlobToActiveIndNoVme( UInt_t uBoardToFind )
{
   UInt_t uIndActiveSameBoard = 0;
   for( UInt_t uBoard = 0; uBoard < fuNbNonVmeBoards; uBoard++)
   {
      // When find target return its index among active boards
      // of same type
      if( uBoardToFind == uBoard )
         return uIndActiveSameBoard;
      // Count active boards of same type as target
      if( GetNotVmeBoardType( uBoardToFind ) == GetNotVmeBoardType( uBoard ) &&
          kTRUE == IsActiveNotVme( uBoard ) )
          uIndActiveSameBoard++;
   } // for( UInt_t uBoard = 0; uBoard < fuNbNonVmeBoards; uBoard++)
   // If the board was not found:
   // return total number of boards as it will be rejected by other functions!
   return fuNbNonVmeBoards;
}
UInt_t TMbsUnpackTofPar::GetActivToAllTypeIndNoVme( UInt_t uBoardToFind, UInt_t uType )
{
   UInt_t uIndBoardSameType = 0;
   UInt_t uIndActiveSameBoard = 0;
   for( UInt_t uBoard = 0; uBoard < fuNbNonVmeBoards; uBoard++)
   {
      // When find target return its index among boards
      // of same type
      if( uBoardToFind == uIndActiveSameBoard && 
           kTRUE == IsActiveNotVme( uBoard ))
         return uIndBoardSameType;
      // Count all boards of same type as target
      if( uType == GetNotVmeBoardType( uBoard ) )
      {
         uIndBoardSameType++;
         // Count active boards of same type as target
         if( kTRUE == IsActiveNotVme( uBoard ) )
            uIndActiveSameBoard++;
       }
   } // for( UInt_t uBoard = 0; uBoard < fuNbNonVmeBoards; uBoard++)
   // If the boad was not found: 
   // return total number of boards as it will be rejected by other functions!
   return fuNbNonVmeBoards;
}
//*******************************************************************************/
//*************** All boards ****************************************************/
UInt_t TMbsUnpackTofPar::GetNbActiveBoards()
{
   UInt_t uNbActiveBoards = 0;

   uNbActiveBoards += GetActiveBoardsNumber();
   uNbActiveBoards += GetActiveNotVmeBoardsNumber();

   return uNbActiveBoards;
}
UInt_t TMbsUnpackTofPar::GetNbActiveBoards( UInt_t uType )
{
   UInt_t uNbActiveSameBoard = 0;

   // Count active boards of asked type
   for( UInt_t uBoard = 0; uBoard < fuNbVmeBoards; uBoard++)
      if( uType == GetBoardType( uBoard ) &&
          kTRUE == IsActive( uBoard ) )
          uNbActiveSameBoard++;

   // Count active boards of asked type
   for( UInt_t uBoard = 0; uBoard < fuNbNonVmeBoards; uBoard++)
      if( uType == GetNotVmeBoardType( uBoard ) &&
          kTRUE == IsActiveNotVme( uBoard ) )
          uNbActiveSameBoard++;

   return uNbActiveSameBoard;
}
UInt_t TMbsUnpackTofPar::GetNbTdcs( )
{
   // If 0 recheck if it was simply not filled from params
   if( 0 == fuNbTdc )
      FillBoardsNbPerType();
      
   return fuNbTdc;
}
UInt_t TMbsUnpackTofPar::GetNbActiveTdcs( )
{
   // If 0 recheck if it was simply not filled from params
   if( 0 == fuNbTdcActive )
      FillActiveBoardsNbPerType();
      
   return fuNbTdcActive;
}
UInt_t TMbsUnpackTofPar::GetNbScalersB( )
{
   // If 0 recheck if it was simply not filled from params
   if( 0 == fuNbScalerB )
      FillBoardsNbPerType();
      
   return fuNbScalerB;
}
UInt_t TMbsUnpackTofPar::GetNbActiveScalersB( )
{
   // If 0 recheck if it was simply not filled from params
   if( 0 == fuNbScalerActiveB )
      FillActiveBoardsNbPerType();
      
   return fuNbScalerActiveB;
}
Bool_t TMbsUnpackTofPar::WithActiveTriglog( )
{
   if( 0 == fuNbTriglogActive )
      FillActiveBoardsNbPerType();
   
   if( 0 == fuNbTriglogActive )
      return kFALSE;
      else return kTRUE;
}
   
void TMbsUnpackTofPar::FillBoardsNbPerType()
{
   // Scaler boards
   fuNbScalerB  = 0;
   fuNbTriglog  = 0;
   fuNbScalOrMu = 0;
      // TDC boards
   fuNbTdc      = 0;
   fuNbV1290    = 0;
   fuNbVftx     = 0;
   fuNbTrb3     = 0;
   fuNbGet4     = 0;
   for( UInt_t uBoard = 0; uBoard < fuNbVmeBoards; uBoard++)
      switch( GetBoardType( uBoard ) )
      {
         case tofVme::caenV1290:
            fuNbTdc++;
            fuNbV1290++;
            break;
         case tofVme::vftx:
            fuNbTdc++;
            fuNbVftx++;
            break;
         case tofVme::trb3:
            fuNbTdc++;
            fuNbTrb3++;
            break;
         case tofVme::get4:
            fuNbTdc++;
            fuNbGet4++;
            break;
         case tofVme::triglog:
            fuNbScalerB++;
            fuNbTriglog++;
            break;
         case tofVme::scalormu:
            fuNbScalerB++;
            fuNbScalOrMu++;
            break;
         case tofVme::caenv965:
         case tofVme::lecroy1182:
         case tofVme::vulqfwread:
            break;
         case tofVme::undef:
         default:
            LOG(WARNING)<<"TMbsUnpackTofPar::FillBoardsNbPerType => Unknown board type "
                        <<GetBoardType( uBoard )
                        <<"!!!!" <<FairLogger::endl;
      } // switch( GetBoardType( uBoard ) )
   for( UInt_t uBoard = 0; uBoard < GetNotVmeBoardsNumber(); uBoard++)
      switch( GetNotVmeBoardType( uBoard ) )
      {
         case tofVme::caenV1290:
            fuNbTdc++;
            fuNbV1290++;
            break;
         case tofVme::vftx:
            fuNbTdc++;
            fuNbVftx++;
            break;
         case tofVme::trb3:
            fuNbTdc++;
            fuNbTrb3++;
            break;
         case tofVme::get4:
            fuNbTdc++;
            fuNbGet4++;
            break;
         case tofVme::triglog:
            fuNbScalerB++;
            fuNbTriglog++;
            break;
         case tofVme::scalormu:
            fuNbScalerB++;
            fuNbScalOrMu++;
            break;
         case tofVme::caenv965:
         case tofVme::lecroy1182:
         case tofVme::vulqfwread:
            break;
         case tofVme::undef:
         default:
            LOG(WARNING)<<"TMbsUnpackTofPar::FillBoardsNbPerType => Unknown board type "
                        <<GetNotVmeBoardType( uBoard )
                        <<"!!!!" <<FairLogger::endl;
      } // switch( GetNotVmeBoardType( uBoard ) )
}    
void TMbsUnpackTofPar::FillActiveBoardsNbPerType()
{
   // Scaler boards
   fuNbScalerActiveB = 0;
   fuNbTriglogActive = 0;
   fuNbScalOrMuActive = 0;
      // TDC boards
   fuNbTdcActive     = 0;
   for( UInt_t uBoard = 0; uBoard < fuNbVmeBoards; uBoard++)
      if( kTRUE == IsActive( uBoard ) )
         switch( GetBoardType( uBoard ) )
         {
            case tofVme::caenV1290:
            case tofVme::vftx:
            case tofVme::trb3:
            case tofVme::get4:
               fuNbTdcActive++;
               break;
            case tofVme::triglog:
               fuNbTriglogActive++;
               fuNbScalerActiveB++;
               break;
            case tofVme::scalormu:
               fuNbScalOrMuActive++;
               fuNbScalerActiveB++;
               break;
            case tofVme::caenv965:
            case tofVme::lecroy1182:
            case tofVme::vulqfwread:
               break;
            case tofVme::undef:
            default:
               LOG(WARNING)<<"TMbsUnpackTofPar::FillBoardsNbPerType => Unknown board type "
                           <<GetBoardType( uBoard )
                           <<"!!!!" <<FairLogger::endl;
         } // switch( GetBoardType( uBoard ) )
   for( UInt_t uBoard = 0; uBoard < GetNotVmeBoardsNumber(); uBoard++)
      if( kTRUE == IsActiveNotVme( uBoard ) )
         switch( GetNotVmeBoardType( uBoard ) )
         {
            case tofVme::caenV1290:
            case tofVme::vftx:
            case tofVme::trb3:
            case tofVme::get4:
               fuNbTdcActive++;
               break;
            case tofVme::triglog:
               fuNbTriglogActive++;
               fuNbScalerActiveB++;
               break;
            case tofVme::scalormu:
               fuNbScalOrMuActive++;
               fuNbScalerActiveB++;
               break;
            case tofVme::caenv965:
            case tofVme::lecroy1182:
            case tofVme::vulqfwread:
               break;
            case tofVme::undef:
            default:
               LOG(WARNING)<<"TMbsUnpackTofPar::FillBoardsNbPerType => Unknown board type "
                           <<GetBoardType( uBoard )
                           <<"!!!!" <<FairLogger::endl;
         } // switch( GetNotVmeBoardType( uBoard ) )
}    

Bool_t TMbsUnpackTofPar::OnlyOneTriglog()
{
   return ( 1 == GetNbActiveBoards( tofVme::triglog ) ? kTRUE: kFALSE);
}