SCC/TFndSCCRaw.cxx

// @(#)fROOT/SCC:$Name:  $:$Id: TFndSCCRaw.cxx,v 1.28 2007/09/24 07:32:41 Diego_Faso Exp $
// Author: Diego Faso <mailto:faso@to.infn.it>, 2006/03/03

//                                                                 //
//  Class for the FINUDA Slow Control Raw events decoding/encoding //
//                                                                 //
// This class is used in order to:                                 //
//                                                                 //
//  - Build the header for the complete raw event (separate array) //
//  - Read the raw event for every detector                        //
//  - Get DataValues (Volts-Currents-Trips) from every detector    //
//  - Get message part (string) from every detector                //
//  - Get miscellaneous part (string) from every detector          //
//                                                                 //
//  - Read the complete raw event                                  //
//                                                                 //

#include "TFndSCCRaw.h"
#include "TROOT.h"

ClassImp(TFndSCCRaw) // Manager of the Slow-Control-Manager

//______________________
TFndSCCRaw::TFndSCCRaw():
  fEvCounter(),fGlobalHdr(),fGlobalEvent(),
  fSingleRawData(),fDataReady(),
  fMsgPart(),fMiscArray(),fDatime(),
  fSilRecode()
{
  
  /*
    for(Int_t i=0;i<(K_SCC_HDR_SIZE/4);i++) fGlobalHdr[i] = 0;
    for(Int_t slow_det=0;slow_det<K_N_SLOWS;slow_det++){
    for(Int_t i=0;i<K_SLOW_SOCK_LEN;i++){
    fSingleRawData[slow_det][i] = 0;
    }
    }
  */

  fSilRecode = new TFndSlowCntSilRecode();
  fEvCounter = 0;
}

//______________________
TFndSCCRaw::~TFndSCCRaw(){
  
  delete fSilRecode;
}

//_________________________
void TFndSCCRaw::SetSingleRawData(Int_t slow_det,UInt_t *DataArray,Int_t part){
  // "part" is used by SIL only (messages and data are asynchronous):
  //                            1: Message (or complete data)
  //                            2: Data
  //
  // If a SIL raw-data is received:
  //   - Check if header was already built
  //   - Write new information in header
  //   - Add the received part
  //
  
  /*
  if(slow_det == SIL && part ==2){ // need to re-encode SIL report string
    fSilRecode->SetReceivedString(DataArray);
    fSilRecode->ReadSilString();
    
    Printf("+++++++ SIL COMPLETE REPORT ++++++++");
    Printf("%s",(Char_t *) &DataArray[0]);
    Printf("+++++++++++++++++++++++++++++++");
  }
  */
  
  
  if(K_DEBUG_LEV > 0) Printf("TFndSCCRaw::SetSingleRawData called for %s (part = %d)",fSlowDetNames[slow_det].Data(),part);
  
  if(part != 1 && DataArray[0] > (UInt_t)(K_SLOW_SOCK_LEN)){
    Printf("TFndSCCRaw::SetSingleRawData ===> The received event is not valid (lengt = %u)",DataArray[0]);
    return;
  }
  
  
  if(K_DEBUG_LEV > 1) Printf("TFndSCCRaw::SetSingleRawData ===> event size = %u",DataArray[0]);
  
  
  if(part ==2) part = 0; // "part" is kept for backwards compatibility, but not used here

  UInt_t totsize = 0; // bytes
  UInt_t totbuf = 0; // number of U32

  switch(part){
  case 0: // all but SIL messages
    for(UInt_t i=0;i<DataArray[0];i++){
      fSingleRawData[slow_det][i] = DataArray[i];
      //      Printf("Checking received raw-data [%i]: %x",i,fSingleRawData[slow_det][i] = DataArray[i]);
    }
    // Check magic number
    if(fSingleRawData[slow_det][HdrDet_magic] != K_MAGIC_NUMBER){
      Printf("TFndSCCRaw::SetSingleRawData ===> Wrong magic number received (0x%x)",fSingleRawData[slow_det][HdrDet_magic]);
      return;
      if(K_DEBUG_LEV > 1) Printf("TFndSCCRaw::SetSingleRawData ===> event size = %u",fSingleRawData[slow_det][HdrDet_evlen]);
      for(Int_t i=0;i<K_SLOW_SOCK_LEN;i++) fSingleRawData[slow_det][i] = DataArray[i];
    }
    
    // Now Store Date/Time
    fDatime[slow_det] = TDatime(fSingleRawData[slow_det][HdrDet_systime]);
    StoreMessagePart(slow_det);
    StoreMiscPart(slow_det);
    fDataReady[slow_det]++;
    if(K_DEBUG_LEV > 0) Printf("DataReady[%d]: %d",slow_det,fDataReady[slow_det]);
    break;
  case 1: // SIL Message
    if(slow_det != SIL){
      Printf("TFndSCCRaw::SetSingleRawData (BUG) ===> case %d called, but not for \"SIL\"",part);    
      return;
    }
    //     if(fSingleRawData[slow_det][0] == 0){
    //       Info("SetSingleRawData","Leaving unchanged local raw-data ( length = 0 )");
    //       return;
    //     }
    

    //    fSilRecode->SetReceivedMessage(0); // this operation will reset any message 
    fSilRecode->SetReceivedMessage(DataArray);
    fSilRecode->UpdateMessagePart();
    
    //    Printf("===================================> ==> ===> ====> %u <====",fSingleRawData[slow_det][0]);

    // --- update message in local SIL-raw (the whole data is updated)
    totsize = (UInt_t) (*(fSilRecode->GetRawBuf()) );
    //    totbuf = (UInt_t) ( totsize / 4 );
    //     Printf(" =============================> totbuf: \"%u\"",totbuf);
    //     cout << "0: "; for(UInt_t is = 0; is < totbuf; is++) cout << fSingleRawData[slow_det][is] << " " ; cout << endl;
    
    memcpy(fSingleRawData[slow_det], fSilRecode->GetRawBuf() ,totsize);
    
    //     cout << "1: "; for(UInt_t is = 0; is < totbuf; is++) cout << fSingleRawData[slow_det][is] << " " ; cout << endl;
    
    
    //     Printf("TFndSCCRaw::SetSingleRawData ===> Message Received from \"SIL\"");
    //     Printf("+++++++ SIL RECEIVED MESSAGE ++++++++");
    //     Printf("%s",(Char_t *) &DataArray[0]);
    //     Printf("+++++++++++++++++++++++++++++++");
    
    // Check magic number
    if(fSingleRawData[slow_det][HdrDet_magic] != K_MAGIC_NUMBER){
      Printf("TFndSCCRaw::SetSingleRawData ===> Wrong magic number received (0x%x)",fSingleRawData[slow_det][HdrDet_magic]);
      return;
      if(K_DEBUG_LEV > 1) Printf("TFndSCCRaw::SetSingleRawData ===> event size = %u",fSingleRawData[slow_det][HdrDet_evlen]);
      for(Int_t i=0;i<K_SLOW_SOCK_LEN;i++) fSingleRawData[slow_det][i] = DataArray[i];
    }
    
    // Now Store Date/Time
    fDatime[slow_det] = TDatime(fSingleRawData[slow_det][HdrDet_systime]);
    StoreMessagePart(slow_det);
    StoreMiscPart(slow_det);
    //     fDataReady[slow_det]++;
    //     if(K_DEBUG_LEV > 0) Printf("DataReady[%d]: %d",slow_det,fDataReady[slow_det]);
    
    break;
  case 2: // SIL Data
    if(slow_det != SIL){
      Printf("TFndSCCRaw::SetSingleRawData (BUG) ===> case %d called, but not for \"SIL\"",part);    
      return;
    }
    Printf("TFndSCCRaw::SetSingleRawData ===> Data Received from \"SIL\"");

    break;
  default: // SIL Message
    Printf("TFndSCCRaw::SetSingleRawData (BUG) ===> part = %d not accepted!",part);    
    return;
  }
}

//_________________________
void TFndSCCRaw::StoreMessagePart(Int_t slow_det){

  if(slow_det <0 || slow_det>HdrDet_free){
    Printf("TFndSCCRaw::StoreMessagePart (BUG) ===> slow_det = %d not accepted!",slow_det);
    return;
  }
  fMsgPart[slow_det] = "";
  TString TmpStr = "";
  //  Int_t nchars = 0;
  Int_t msgStart = (Int_t)((Float_t)(fSingleRawData[slow_det][HdrDet_msgoff])  / 4.);
  Int_t msgStop =  (Int_t)((Float_t)((fSingleRawData[slow_det][HdrDet_miscoff])-1) / 4.);
  if(K_DEBUG_LEV > 2) Printf("TFndSCCRaw::StoreMessagePart ===> %d - %d",msgStart,msgStop);
  for(Int_t i=msgStart;i<=msgStop;i++){
    TmpStr = (Char_t *)(&fSingleRawData[slow_det][i]);
    if(TmpStr.Sizeof()>4) TmpStr.Resize(4); // very important to preserve from errors due to missing end-of-line
    fMsgPart[slow_det]+=TmpStr;
    //nchars+=4;
    if(K_DEBUG_LEV > 2) Printf("TFndSCCRaw::StoreMessagePart ===> \"%s\" ---> \"%s\"",TmpStr.Data(),fMsgPart[slow_det].Data());
  } 
}

//_________________________
void TFndSCCRaw::StoreMiscPart(Int_t slow_det){

  if(slow_det <0 || slow_det>HdrDet_free){
    Printf("TFndSCCRaw::StoreMiscPart (BUG) ===> slow_det = %d not accepted!",slow_det);
    return;
  }
  Int_t miscStart =  (Int_t)((Float_t)(fSingleRawData[slow_det][HdrDet_miscoff]) / 4.);
  Int_t N_info = (Int_t)((Float_t)(K_MISC_MAX_SIZE)/4.);
  for(Int_t i=0;i<N_info;i++){
    fMiscArray[slow_det][i] = fSingleRawData[slow_det][miscStart+i];
  }
}

//_________________________
Bool_t TFndSCCRaw::IsDataReady(const Int_t &slow_det){

  if(slow_det <0 || slow_det>HdrDet_free){
    Printf("TFndSCCRaw::IsDataReady ===> slow_det = %d not accepted!",slow_det);
    return kFALSE;
  }
  if(!fDataReady[slow_det]){
    Printf("TFndSCCRaw::IsDataReady ===> Raw data still not ready for %s.",fSlowDetNames[slow_det].Data());
    return kFALSE;
  }
  
  return kTRUE;
}

//_________________________
TString TFndSCCRaw::GetMessagePart(Int_t slow_det){
  // slow_det = -1  not accepted
  
  if( !IsDataReady(slow_det) && slow_det != SIL ) return 0;

  return fMsgPart[slow_det];
}

//_________________________
UInt_t TFndSCCRaw::GetMiscInfo(Int_t slow_det,Int_t num){
  // num starts from zero

  if( !IsDataReady(slow_det) ) return 0;

  return fMiscArray[slow_det][num];
}

//_________________________
Int_t TFndSCCRaw::GetChannelData(Int_t slow_det,Int_t ch,Bool_t &power,UInt_t &voltage,UInt_t &current,Bool_t &trip){
  // (one UInt_t for every channel in the data part)
  // The "ch" argument is the number of the selected channel (starting from 1)
  // return value (error code):
  //                            0: no error
  //                           -1: selected detector not supported (or data not ready)
  //                           -2: channel (ch) out of range

  if( !IsDataReady(slow_det) ) return -1;

  if(ch < 1 || ch > K_SLOW_N_CHANS[slow_det]){
    Printf("TFndSCCRaw::GetChannelData ===> channel = %d out of range (for \"%s\")!",ch,fSlowDetNames[slow_det].Data());
    return -2;
  }
    
  Int_t ch_off = (Int_t)((Float_t)(fSingleRawData[slow_det][HdrDet_dataoff]-1)/4); // end of header in units of 32 bits
  ch_off += ch; // add the offset to the selected channel (remember that ch starts from 1!)
  
  Printf("TFndSCCRaw::GetChannelData ===> Offset for the selected channel (units of U32): %d",ch_off);
  DecodeDataElement(fSingleRawData[slow_det][ch_off-1],power,voltage,current,trip);
  return 0;
}

//_________________________
TString TFndSCCRaw::GetChannelName(Int_t slow_det,Int_t ch){
  // get channel name depending on the raw-data structure

  TString result = "";
  
  Bool_t second_half = kFALSE;
  if( ch > (UInt_t)( (K_SLOW_N_CHANS[slow_det] / 2) -1) ) second_half = kTRUE;

  Int_t which_quarter = 0; // 1,2,3,4
  UInt_t div[3] = {0};
  
  div[0] = (UInt_t)( (K_SLOW_N_CHANS[slow_det] / 4) );
  div[1] = (UInt_t)( (K_SLOW_N_CHANS[slow_det] / 2) );
  div[2] = (UInt_t)( K_SLOW_N_CHANS[slow_det] - (K_SLOW_N_CHANS[slow_det] / 4) );
  
  if( ch < div[0] ) which_quarter = 1;
  else if   ( ch >= div[0] && ch < div[1] ) which_quarter = 2;
  else if   ( ch >= div[1] && ch < div[2] ) which_quarter = 3;
  else which_quarter = 4;

  TString side = ""; 
  UInt_t det_ch = 0; // numbering: 1,2,3,...

  TString lay = ""; // needed by LMD and SIL

  TString sign = "";
  Int_t modch = 0; // needed by SIL
  Int_t modnum = 0; // needed by SIL
  
  switch(slow_det){
  case TOFI:
    side = (second_half) ? "P" : "E";
    det_ch = (UInt_t) ( ch +1 );
    if(second_half) det_ch -=  ( (K_SLOW_N_CHANS[slow_det] / 2 ) );
    result.Form("TOFI %u %s",det_ch,side.Data());
    break;
  case TOFO:
    side = (second_half) ? "P" : "E";
    det_ch = (UInt_t) ( ch +1 );
    if(second_half) det_ch -=  ( (K_SLOW_N_CHANS[slow_det] / 2 ) );
    result.Form("TOFO %u %s",det_ch,side.Data());
    break;
  case LMD:
    switch(which_quarter){
    case 1:
      lay = "INN";
      sign = "POS";
      break;
    case 2:
      lay = "INN";
      sign = "NEG";
      break;
    case 3:
      lay = "OUT";
      sign = "POS";
      break;
    case 4:
      lay = "OUT";
      sign = "NEG";
      break;
    default: 
      gROOT->Error("TFndSCCRaw::GetChannelName","BUG detected");
      gApplication->Terminate();
      return 0;
    }
    det_ch = (UInt_t) ( (ch + 1) -  ( (which_quarter -1) *8 ) );
    result.Form("LMD-%s-%s %u",lay.Data(),sign.Data(),det_ch);
    break;
  case STB:
    result.Form("STB Group %u",ch+1);
    break;
  case GAS:
    // no data part from Slow-Control
    break;
  case SIL:
    if(ch< 8 *6){
      lay = "ISIM";
      modnum = (ch / 6) +1;
    }
    else{
      lay = "OSIM";
      modnum = ( (ch - (7 *6) ) / 6) ;
    }
    
    modch = ch%6;
    if(modch == 0 || modch ==1) side = "PHI";
    else if(modch == 2 || modch ==3)  side = "ZA ";
    else if(modch == 4 || modch ==5)  side = "ZB ";
    
    if(ch%2 ==0) sign = "POS";
    else sign = "NEG";

    result.Form("%s %s %s %u",lay.Data(),side.Data(),sign.Data(),modnum);
    if(modnum < 10) result += " "; // tabbing
    break;
  case MAG:
    // still not supported
    break;
  default:
    Printf("GetChannelName","Slow control ID \"%d\" not available",slow_det);
    return 0;
  }
  
  return result;
}

//_________________________
void TFndSCCRaw::DecodeDataElement(UInt_t entry,Bool_t &power,UInt_t &voltage,UInt_t &current,Bool_t &trip){
  // The "entry" binary code is splitted according to the
  // SlowRaw data structure:
  //   [MSB] ---> ---> ---> ---> ---> ---> ---> ---> ---> ---> [LSB]
  //          Voltage(16 bit) + Trip(1 bit) + Current(15 bit)

  UInt_t p = entry & 0x80000000; // select the MSB (power)
  power = (Bool_t)(p>>31);
  UInt_t v = entry & 0x7FFF0000; // select the voltage part
  voltage = v>>16;
  UInt_t t = entry & 0x8000; // select 16th bit
  trip = (Bool_t)(t>>15);
  current = entry & 0x7FFF; // select less significative 15 bit (no need to shift)

}

//_________________________
void TFndSCCRaw::PrintHeader(Int_t slow_det){
  // slow_det = -1  means "Global Header"
  
  if( !IsDataReady(slow_det) ) return;

  TString DetName = "";
  TDatime SysTime;
  UInt_t HdrEntries =  (UInt_t)((Float_t)(K_SCC_HDR_SIZE) / (Float_t)(4.));
  
  if(slow_det != -1){ // Single detector header
    if(!fSingleRawData[slow_det][0]){
      Printf("TFndSCCMan::PrintHeader ===> Raw data buffer for \"%s\" is empty.",fSlowDetNames[slow_det].Data());
      return;
    }
    for(UInt_t i=0;i<HdrEntries;i++){
      switch(i){
      case HdrDet_evlen:
        Printf("Event length  (Data[%u]) (%d bytes) ",i,fSingleRawData[slow_det][i]);
        break;
      case HdrDet_detname: // detector name
        DetName = (Char_t *)(&fSingleRawData[slow_det][i]);
        if(DetName.Sizeof()>4) DetName.Resize(4); // very important to preserve from errors due to missing end-of-line
        Printf("Detector name (Data[%u]) = %x",i,fSingleRawData[slow_det][i]);      
        Printf("Detector name (Data[%u]) = %s",i,DetName.Data());      
        break;
      case HdrDet_systime: // system time
        SysTime = TDatime(fSingleRawData[slow_det][i]);
        Printf("System time   (Data[%u]) = %u (%s)",i,fSingleRawData[slow_det][i],SysTime.AsString());
        //SysTime.Set();      
        //Printf("Check ==> %u (%s) ",SysTime.Convert(),SysTime.AsString());
        break;
      case HdrDet_magic: // Magic number: should be printed as Hexadecomal
        Printf("Magic number  (Data[%u]) = 0x%x",i,fSingleRawData[slow_det][i]);
        break;
      case HdrDet_free: // last 4 bytes are free
        Printf("Free space    (Data[%u]) = %u",i,fSingleRawData[slow_det][i]);
        break;
      default: Printf("Data[%u] = %u",i,fSingleRawData[slow_det][i]);
      }    
    }
  } // (Single detector header)
  // -----
  else{ // Global header
    if(!fGlobalHdr[0]){
      Printf("TFndSCCMan::PrintHeader ===> Global Raw data buffer for is empty.");
      return;
    }
    for(UInt_t i=0;i<HdrEntries;i++){
      switch(i){
      case HdrTot_EvLen:
        Printf("Global Event length (Data[%u]): %d bytes",i,fGlobalHdr[i]);
        break;
      case HdrTot_SysTime:
        SysTime = TDatime(fGlobalHdr[i]);
        Printf("Data[%u] = %u (%s)",i,fGlobalHdr[i],SysTime.AsString());
        SysTime.Set();      
        Printf("Check ==> %u (%s) ",SysTime.Convert(),SysTime.AsString());
        break;
      default:
        Printf("%s offset (Data[%u]): %d bytes",i,fGlobalHdr[i]);
      }
    }        
  } // (Global header)
  
  Printf("------------------------------------------");
}

//_________________________
void TFndSCCRaw::PrintBuffer(Int_t slow_det){
  // slow_det = -1  not accepted
  
  if( !IsDataReady(slow_det) ) return;
  
  TString ReceivedString = "";
  TString CompleteString = "";
  UInt_t n_elements = (UInt_t)((Float_t)(fSingleRawData[slow_det][0])/4.);
  Printf("TFndSCCRaw::PrintBuffer ===-------------> n_elements  = %d.",n_elements);
  
  for(UInt_t i=0;i<n_elements;i++) {
    TThread::CancelPoint();
    //      cout << "fSingleRawData[slow_det][" << i << "] = " << fSingleRawData[slow_det][i] << endl;
    ReceivedString  = (char*)(&fSingleRawData[slow_det][i]);
    if(ReceivedString.Sizeof()>4) ReceivedString.Resize(4);
    CompleteString+=ReceivedString;
  }
  for(UInt_t i=0;i<n_elements;i++) {
    TThread::CancelPoint();
      ReceivedString  = (char*)(&fSingleRawData[slow_det][i]);
      if(ReceivedString.Sizeof()>4) ReceivedString.Resize(4); // limit to one byte
      if(K_DEBUG_LEV > 2){
        Printf("fSingleRawData[slow_det][%d] = %u  (\"%s\")",i,fSingleRawData[slow_det][i],ReceivedString.Data());
        print_binary(fSingleRawData[slow_det][i]);
      }
  }
  if(K_DEBUG_LEV > 2){
    Printf(" Complete string: \"%s\"",CompleteString.Data());
    Printf("   ---   ---   ---");
    Printf("");
  }
  
}


// GLOBAL EVENT MANAGEMENT
//_________________________
Int_t TFndSCCRaw::BuildGlobalHeader(TString &message){
  // return value:
  //              0: ok
  //             -1: error
  

  if(K_DEBUG_LEV > 0){
    Printf(" ------> Building global header");  
    for(Int_t slow_det = (Int_t)TOFI ; slow_det <= (Int_t)MAG ; slow_det++){ 
      TString d_ready = (fDataReady[slow_det]) ? "ready" : "not ready";
      Printf("            - Data %s for %s",d_ready.Data(),fSlowDetNames[slow_det].Data());
    }
  }

  TString tmp_str;
  // --- Following check disabled (check global header for missing detectors) 
  /* 
     Bool_t can_build = kTRUE;
     for(Int_t slow_det = (Int_t)TOFI ; slow_det <= (Int_t)MAG ; slow_det++){ 
     if( slow_det != (Int_t)MAG && !fDataReady[slow_det] )  can_build = kFALSE;    
     }
     if(!can_build){
     Warning("BuildGlobalHeader","some data still missing");
     return -1;
     }
  */
  // ---
  
  bzero(fGlobalHdr,sizeof(fGlobalHdr));
  TDatime dattim; dattim.Set();

  UInt_t tofi_offset = K_SCC_HDR_SIZE + 1;
  UInt_t tofo_offset = tofi_offset + fSingleRawData[TOFI][HdrDet_evlen];
  UInt_t lmd_offset  = (fDataReady[TOFO]) ?  tofo_offset + fSingleRawData[TOFO][HdrDet_evlen] : tofo_offset ;
  UInt_t stb_offset  = (fDataReady[LMD] ) ?  lmd_offset  + fSingleRawData[LMD][HdrDet_evlen]  : lmd_offset  ;
  UInt_t gas_offset  = (fDataReady[STB] ) ?  stb_offset  + fSingleRawData[STB][HdrDet_evlen]  : stb_offset  ;
  UInt_t sil_offset  = (fDataReady[GAS] ) ?  gas_offset  + fSingleRawData[GAS][HdrDet_evlen]  : gas_offset  ;
  UInt_t mag_offset  = (fDataReady[SIL] ) ?  sil_offset  + fSingleRawData[SIL][HdrDet_evlen]  : sil_offset  ;
  

  UInt_t tot_size =   (fDataReady[MAG] ) ?  mag_offset + fSingleRawData[MAG][HdrDet_evlen]  : mag_offset;
  if( tot_size < 2  || tot_size > K_TOT_SCC_MAX_SIZE){
    Error("BuildGlobalHeader","size not accepted (%u)",tot_size);
    tmp_str.Form("size not accepted (%u)\n",tot_size);
    message+=tmp_str;
    return -1;
  }

  tot_size -= 1; // very important: this is not an offset!!!

  TString sum_chk_msg ="\n ------------------------- \n";
  
  Float_t div_by_four = ((Float_t)tot_size)  / 4.;
  Float_t rem_by_four = div_by_four - TMath::Floor(div_by_four);  
  if(rem_by_four !=0 ){
    Error("BuildGlobalHeader","tot_size not multiple of four (%u)",tot_size);
    tmp_str.Form("tot_size not multiple of four (%u)\n",tot_size);
    message+=tmp_str;
    return -1; // to be enabled    
  }


  // --- DEBUG CHECK
  UInt_t sum_chk = K_SCC_HDR_SIZE;
  for(Int_t slow_det = (Int_t)TOFI ; slow_det <= (Int_t)MAG ; slow_det++){ 
    if(fDataReady[slow_det]) sum_chk += fSingleRawData[slow_det][HdrDet_evlen];
  }

  
  
  //  Printf("Sumcheck (Global header):");
  //  Printf("  - K_SCC_HDR_SIZE: %u",K_SCC_HDR_SIZE);
  //  Printf("  - offsets (tofi;tofo;lmd;stb;gas;sil,mag): (%u\t%u\t%u\t%u\t%u\t%u\t%u)",
  //              tofi_offset,tofo_offset,lmd_offset,stb_offset,gas_offset,sil_offset,mag_offset);
  //   Printf("  - size    (tofi;tofo;lmd;stb;gas;sil,mag): (%u\t%u\t%u\t%u\t%u\t%u\t%u)",
  //              fSingleRawData[TOFI][HdrDet_evlen],
  //              fSingleRawData[TOFO][HdrDet_evlen],
  //              fSingleRawData[LMD][HdrDet_evlen],
  //              fSingleRawData[STB][HdrDet_evlen],
  //              fSingleRawData[GAS][HdrDet_evlen],
  //              fSingleRawData[SIL][HdrDet_evlen],
  //              fSingleRawData[MAG][HdrDet_evlen]
  //              );
  //   Printf("  ===> tot_size: %u",tot_size);
  //   Printf("  ===> sum_chk: %u\n",sum_chk);
  //   Printf("  ===> tot_size / 4: %2f",div_by_four);
  //   Printf("  ===> tot_size R_4: %2f",rem_by_four);
  // ---
  
  sum_chk_msg += "Sumcheck (Global header):\n";
  tmp_str.Form("  - K_SCC_HDR_SIZE: %u\n",K_SCC_HDR_SIZE);
  sum_chk_msg+=tmp_str;
  tmp_str.Form("  - offsets (tofi;tofo;lmd;stb;gas;sil,mag): (%u\t%u\t%u\t%u\t%u\t%u\t%u)\n",
               tofi_offset,tofo_offset,lmd_offset,stb_offset,gas_offset,sil_offset,mag_offset);
  sum_chk_msg+=tmp_str;
  tmp_str.Form("  - size    (tofi;tofo;lmd;stb;gas;sil,mag): (%u\t%u\t%u\t%u\t%u\t%u\t%u)\n",
               fSingleRawData[TOFI][HdrDet_evlen],
               fSingleRawData[TOFO][HdrDet_evlen],
               fSingleRawData[LMD][HdrDet_evlen],
               fSingleRawData[STB][HdrDet_evlen],
               fSingleRawData[GAS][HdrDet_evlen],
               fSingleRawData[SIL][HdrDet_evlen],
               fSingleRawData[MAG][HdrDet_evlen]);
  sum_chk_msg+=tmp_str;
  tmp_str.Form("  ===> tot_size: %u\n",tot_size);
  sum_chk_msg+=tmp_str;
  tmp_str.Form("  ===> sum_chk: %u\n",sum_chk);
  sum_chk_msg+=tmp_str;
  tmp_str.Form("  ===> tot_size / 4: %2f\n",div_by_four);
  sum_chk_msg+=tmp_str;
  tmp_str.Form("  ===> tot_size R_4: %2f\n",rem_by_four);
  sum_chk_msg+=tmp_str;
  sum_chk_msg+="------------------------- \n\n ";
  if(K_DEBUG_LEV > 0)  Printf(sum_chk_msg);
  message+=sum_chk_msg;


  if(tot_size != sum_chk){
    Error("BuildGlobalHeader","wrong checksum: tot_size = %u; sum_chk = %u",tot_size,sum_chk);
    tmp_str.Form("wrong checksum: tot_size = %u; sum_chk = %u\n",tot_size,sum_chk);
    message+=tmp_str;
    return -1;
  }
 

  // --- check for data to be ready  
  if(! fDataReady[TOFI]) tofi_offset = 0;  
  if(! fDataReady[TOFO]) tofo_offset = 0;  
  if(! fDataReady[LMD]) lmd_offset = 0;  
  if(! fDataReady[STB]) stb_offset = 0;  
  if(! fDataReady[GAS]) gas_offset = 0;  
  if(! fDataReady[SIL]) sil_offset = 0;  
  if(! fDataReady[MAG]) mag_offset = 0;  
  //

  fGlobalHdr[HdrTot_EvLen] = tot_size;
  fGlobalHdr[HdrTot_SysTime] = (UInt_t) ( dattim.Convert() );
  fGlobalHdr[HdrTot_TofiOff] = tofi_offset;
  fGlobalHdr[HdrTot_TofoOff] = tofo_offset;
  fGlobalHdr[HdrTot_LmdOff] = lmd_offset;
  fGlobalHdr[HdrTot_StbOff] = stb_offset;
  fGlobalHdr[HdrTot_GasOff] = gas_offset;
  fGlobalHdr[HdrTot_SilOff] = sil_offset;
  fGlobalHdr[HdrTot_MagOff] = mag_offset; // not used
  fGlobalHdr[HdrTot_Magic] = 0xBABA; // filled lately
    
  message+=" ------> Global header built\n";
  return 0; 

}

//_________________________
void TFndSCCRaw::PrintGlobalHeader(){

  if( !fGlobalHdr[HdrTot_EvLen] ){
    Warning("PrintGlobalHeader","NULL event size: nothing to print");
    return;
  }

  TString descr;
  for(Int_t i=HdrTot_EvLen; i<=HdrTot_Magic ; i++){
    switch(i){
    case HdrTot_EvLen  : descr = "Glob.ev length (bytes)"; break;
    case HdrTot_SysTime: descr = "SCC system time (unix)"; break;
    case HdrTot_TofiOff: descr = "TOFINO offset (bytes)"; break;
    case HdrTot_TofoOff: descr = "TOFONE offset (bytes)"; break;
    case HdrTot_LmdOff : descr = "LMD    offset (bytes)"; break;
    case HdrTot_StbOff : descr = "STB    offset (bytes)"; break;
    case HdrTot_GasOff : descr = "GAS    offset (bytes)"; break;
    case HdrTot_SilOff : descr = "SIL    offset (bytes)"; break;
    case HdrTot_MagOff : descr = "MAG    offset (bytes)"; break;
    case HdrTot_Magic  : descr = "Magic number [0xBABA]"; break;
    default:
      Error("PrintGlobalHeader","BUG!");
      gApplication->Terminate();
      return;
    }
    
    if(i == (Int_t)HdrTot_SysTime){
      TDatime datime;
      datime.Set(fGlobalHdr[i]);
      Printf("Glob.Hdr pos[%i] (%s): %u (%s)",i,descr.Data(), fGlobalHdr[i], datime.AsSQLString());
    } 
    else if(i == (Int_t)HdrTot_Magic) Printf("Glob.Hdr pos[%i] (%s): 0x%X",i,descr.Data(),fGlobalHdr[i]);
    else Printf("Glob.Hdr pos[%i] (%s): %u",i,descr.Data(),fGlobalHdr[i]);
    
  }
  
}

//_________________________
Int_t TFndSCCRaw::BuildGlobalEvent(TString &message){
  // return value:
  //              0: ok
  //             -1: error

  fEvCounter++;

  TString tmp_str;
  message.Form("Building Global Event (ev %u)\n",fEvCounter);

  Printf(" ---> Building global event");

  // ---
  bzero(fGlobalEvent,sizeof(fGlobalEvent));
  Int_t h_res = BuildGlobalHeader(message);
  if(h_res != 0) return h_res;
  for(Int_t i=(Int_t)HdrTot_EvLen; i<=(Int_t)HdrTot_Magic; i++){
    fGlobalEvent[i] = fGlobalHdr[i];
    // debug line follows
    if(0) Printf(" *************************** i = %i; fGlobalEvent: %u ; fGlobalHdr = %u",i , fGlobalEvent[i] , fGlobalHdr[i]);
  }
  //  memcpy(&fGlobalEvent[0], fGlobalHdr, (UInt_t)(K_SCC_HDR_SIZE/4) );
  //
  if(K_DEBUG_LEV > 0) PrintGlobalHeader();
  // ---
  
  
  UInt_t tot_size    = (UInt_t) ( (Float_t)fGlobalHdr[HdrTot_EvLen] ); // bytes

  UInt_t tofi_offset = (UInt_t) ( (Float_t)fGlobalHdr[HdrTot_TofiOff] / 4. ) ;  // number of U32
  UInt_t tofo_offset = (UInt_t) ( (Float_t)fGlobalHdr[HdrTot_TofoOff] / 4. ) ;  // number of U32
  UInt_t lmd_offset  = (UInt_t) ( (Float_t)fGlobalHdr[HdrTot_LmdOff]  / 4. ) ;  // number of U32
  UInt_t stb_offset  = (UInt_t) ( (Float_t)fGlobalHdr[HdrTot_StbOff]  / 4. ) ;  // number of U32
  UInt_t gas_offset  = (UInt_t) ( (Float_t)fGlobalHdr[HdrTot_GasOff]  / 4. ) ;  // number of U32
  UInt_t sil_offset  = (UInt_t) ( (Float_t)fGlobalHdr[HdrTot_SilOff]  / 4. ) ;  // number of U32
  UInt_t mag_offset  = (UInt_t) ( (Float_t)fGlobalHdr[HdrTot_MagOff]  / 4. ) ;  // not used

  //  
  if(tofi_offset){
    if( (UInt_t) ( fGlobalHdr[HdrTot_TofiOff] + fSingleRawData[TOFI][HdrDet_evlen] )  > (tot_size+1)){
      Error("BuildGlobalEvent","Buffer size mismatch (%s)",fSlowDetNames[TOFI].Data());
      tmp_str.Form("Buffer size mismatch (%s)\n",fSlowDetNames[TOFI].Data());
      message+=tmp_str;
      return -1;
    }
    for(Int_t i=0; i<(Int_t)(fSingleRawData[TOFI][HdrDet_evlen]/4); i++)
      fGlobalEvent[tofi_offset+i] = fSingleRawData[TOFI][i];
  }
  else Warning("BuildGlobalEvent","%s data not available",fSlowDetNames[TOFI].Data());
  //
  if(tofo_offset){
    if( (UInt_t) ( fGlobalHdr[HdrTot_TofoOff] + fSingleRawData[TOFO][HdrDet_evlen] )  > (tot_size+1)){
      Error("BuildGlobalEvent","Buffer size mismatch (%s)",fSlowDetNames[TOFO].Data());
      tmp_str.Form("Buffer size mismatch (%s)\n",fSlowDetNames[TOFO].Data());
      message+=tmp_str;
      return -1;
    }
    for(Int_t i=0; i<(Int_t)(fSingleRawData[TOFO][HdrDet_evlen]/4); i++)
      fGlobalEvent[tofo_offset+i] = fSingleRawData[TOFO][i];
  }
  else Warning("BuildGlobalEvent","%s data not available",fSlowDetNames[TOFO].Data());
  //
  if(lmd_offset){
    if( (UInt_t) ( fGlobalHdr[HdrTot_LmdOff] + fSingleRawData[LMD][HdrDet_evlen] )  > (tot_size+1)){
      Error("BuildGlobalEvent","Buffer size mismatch (%s)",fSlowDetNames[LMD].Data());
      tmp_str.Form("Buffer size mismatch (%s)\n",fSlowDetNames[LMD].Data());
      message+=tmp_str;
      return -1;
    }
    for(Int_t i=0; i<(Int_t)(fSingleRawData[LMD][HdrDet_evlen]/4); i++){
      fGlobalEvent[lmd_offset+i] = fSingleRawData[LMD][i];
      //      Printf("************************** %i ; %i ===> %u  ===> %u",i,lmd_offset+i,fSingleRawData[LMD][i],fGlobalEvent[lmd_offset+i]);
    }
  }
  else Warning("BuildGlobalEvent","%s data not available",fSlowDetNames[LMD].Data());
  //
  if(stb_offset){
    if( (UInt_t) ( fGlobalHdr[HdrTot_StbOff] + fSingleRawData[STB][HdrDet_evlen] )  > (tot_size+1)){
      Error("BuildGlobalEvent","Buffer size mismatch (%s)",fSlowDetNames[STB].Data());
      tmp_str.Form("Buffer size mismatch (%s)\n",fSlowDetNames[STB].Data());
      message+=tmp_str;
      return -1;
    }
    for(Int_t i=0; i<(Int_t)(fSingleRawData[STB][HdrDet_evlen]/4); i++){
      fGlobalEvent[stb_offset+i] = fSingleRawData[STB][i];
      //      Printf("************************** %i ; %i ===> %u  ===> %u",i,stb_offset+i,fSingleRawData[STB][i],fGlobalEvent[stb_offset+i]);
    }
  }
  else Warning("BuildGlobalEvent","%s data not available",fSlowDetNames[STB].Data());
  //
  if(gas_offset){
    if( (UInt_t) ( fGlobalHdr[HdrTot_GasOff] + fSingleRawData[GAS][HdrDet_evlen] )  > (tot_size+1)){
      Error("BuildGlobalEvent","Buffer size mismatch (%s)",fSlowDetNames[GAS].Data());
      tmp_str.Form("Buffer size mismatch (%s)\n",fSlowDetNames[GAS].Data());
      message+=tmp_str;
      return -1;
    }
    for(Int_t i=0; i<(Int_t)(fSingleRawData[GAS][HdrDet_evlen]/4); i++)
      fGlobalEvent[gas_offset+i] = fSingleRawData[GAS][i];
  }
  else Warning("BuildGlobalEvent","%s data not available",fSlowDetNames[GAS].Data());
  //
  if(sil_offset){
    if( (UInt_t) ( fGlobalHdr[HdrTot_SilOff] + fSingleRawData[SIL][HdrDet_evlen] )  > (tot_size+1)){
      Error("BuildGlobalEvent","Buffer size mismatch (%s)",fSlowDetNames[SIL].Data());
      tmp_str.Form("Buffer size mismatch (%s)\n",fSlowDetNames[SIL].Data());
      message+=tmp_str;
      return -1;
    }
    for(Int_t i=0; i<(Int_t)(fSingleRawData[SIL][HdrDet_evlen]/4); i++)
      fGlobalEvent[sil_offset+i] = fSingleRawData[SIL][i];
  }
  else Warning("BuildGlobalEvent","%s data not available",fSlowDetNames[SIL].Data());
  //
  if(mag_offset){
    if( (UInt_t) ( fGlobalHdr[HdrTot_MagOff] + fSingleRawData[MAG][HdrDet_evlen] )  > (tot_size+1)){
      Error("BuildGlobalEvent","Buffer size mismatch (%s)",fSlowDetNames[MAG].Data());
      tmp_str.Form("Buffer size mismatch (%s)\n",fSlowDetNames[MAG].Data());
      message+=tmp_str;
      return -1;
    }
    for(Int_t i=0; i<(Int_t)(fSingleRawData[MAG][HdrDet_evlen]/4); i++)
      fGlobalEvent[mag_offset+i] = fSingleRawData[MAG][i];
  }
  else Warning("BuildGlobalEvent","%s data not available",fSlowDetNames[MAG].Data());
  
  // ---
  message+=" ---> Global event built\n";

  if(0){ // debug  lines
    for(Int_t i=(Int_t)HdrTot_EvLen; i<=(Int_t)HdrTot_Magic; i++){
      Printf(" **** i = %i; fGlobalEvent: %u ; fGlobalHdr = %u",i , fGlobalEvent[i] , fGlobalHdr[i]);
    }
  }

  return 0; 

}

---