SCC/TFndSlowCntSilRecode.cxx

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

//                                                            //
//  Class for the FINUDA Slow Control SIL Raw re-encoding     //
//                                                            //

#include "TFndSlowCntSilRecode.h"


ClassImp(TFndSlowCntSilRecode)

//_______________________________________
TFndSlowCntSilRecode::TFndSlowCntSilRecode():
  fDebugLevel(),fSilRawLen()
{
  
  Reset();
}

//_______________________________________
TFndSlowCntSilRecode::~TFndSlowCntSilRecode(){
 
  Reset();
}

//_______________________________________
void TFndSlowCntSilRecode::Reset(){

  fSilRawLen = 0;
  bzero(fSilRawBuf,sizeof(fSilRawBuf));
  fCurChar = 0;
  fCurMsgInt_ID = 0;
  fMsgBuf = "";
  fMessagePart = "";
  
}

//_______________________________________
void TFndSlowCntSilRecode::SetReceivedMessage(UInt_t *raw){
  // called whenever a single-message-string is received  
  
  fMessagePart = "";
  if(raw==0) return;
  fMessagePart = TString((const Char_t *)raw);
  fMessagePart+='\n';

  if(fDebugLevel > 1){
    Printf("\n\n+------------> SetReceivedMessage <-----------------+");
    Printf("|                                                   |");
    Int_t i=0;
    while(i<K_SLOW_SOCK_LEN){
      if(fMessagePart[i] == '\n') break;
      cout << fMessagePart[i];
      i++;
    }
    Printf("\n|                                                   |");
    Printf("+------------> SetReceivedMessage <-----------------+\n\n");
  }
  
}


//_______________________________________
void TFndSlowCntSilRecode::SetReceivedString(UInt_t *raw){
  // called whenever a complete data-string is received  
  
  Reset();
  
  TString chkstr = "";
  fReceivedString = TString((const Char_t *)raw);
  fReceivedString+='\n';
  
  if(fDebugLevel > 1){
    Printf("\n\n+------------> SetReceivedString <-----------------+");
    Printf("|                                                   |");
    Int_t i=0;
    while(i<K_SLOW_SOCK_LEN){
      if(fReceivedString[i] == '\n') break;
      cout << fReceivedString[i];
      i++;
    } 
    Printf("\n|                                                   |");
    Printf("+------------> SetReceivedString <-----------------+\n\n");
  }
}


//_______________________________________
void TFndSlowCntSilRecode::FillExampleString(){
  // This method is used in order to simulate the received string
  // (complete-data string is simulated)

  Reset();

  fReceivedString = "13:42:12 26/09/2006\nwarning  Dig IO: Watchdog switched off  DAQ/Comms: New pedestals run required\n";
  fReceivedString+="Module 0\nBI 45.2 2.3 2 (Ok)\nPH 5.99 0.21 2 (Ok) 6.39 0.47 2 (Ok) 43.4 3 (T Normal)\nZA 5.98 0.20 2 (Ok) 6.42 0.46 2 (Ok) 45.8 3 (T Normal)\nZB 6.03 0.20 2 (Ok) 6.40 0.47 2 (Ok) 37.2 3 (T Normal)\n";
  fReceivedString+="Module 1\nBI 45.1 2.9 2 (Ok)\nPH 6.00 0.20 2 (Ok) 6.41 0.45 2 (Ok) 33.3 3 (T Normal)\nZA 6.03 0.20 2 (Ok) 6.43 0.45 2 (Ok) 38.1 3 (T Normal)\nZB 6.01 0.20 2 (Ok) 6.41 0.45 2 (Ok) 36.0 3 (T Normal)\n";
  fReceivedString+= "Module 2\nBI 50.0 3.8 2 (Ok)\nPH 5.99 0.20 2 (Ok) 6.41 0.47 2 (Ok) 36.2 3 (T Normal)\nZA 6.02 0.20 2 (Ok) 6.42 0.47 2 (Ok) 46.6 3 (T Normal)\nZB 6.01 0.20 2 (Ok) 6.42 0.46 2 (Ok) 39.6 3 (T Normal)\n";
  fReceivedString+="Module 3\nBI 55.1 1.8 2 (Ok)\nPH 6.00 0.20 2 (Ok) 6.40 0.47 2 (Ok) 39.3 3 (T Normal)\nZA 6.02 0.20 2 (Ok) 6.41 0.48 2 (Ok) 45.7 3 (T Normal)\nZB 6.00 0.20 2 (Ok) 6.43 0.47 2 (Ok) 30.8 3 (T Normal)\n";
  fReceivedString+="Module 4\nBI 65.4 1.9 2 (Ok)\nPH 5.97 0.20 2 (Ok) 6.39 0.47 2 (Ok) 43.9 3 (T Normal)\nZA 5.98 0.20 2 (Ok) 6.40 0.44 2 (Ok) 42.4 3 (T Normal)\nZB 5.99 0.20 2 (Ok) 6.38 0.45 2 (Ok) 22.3 3 (T Normal)\n";
  fReceivedString+="Module 5\nBI 40.1 2.0 2 (Ok)\nPH 5.98 0.20 2 (Ok) 6.38 0.46 2 (Ok) 39.5 3 (T Normal)\nZA 5.98 0.20 2 (Ok) 6.38 0.47 2 (Ok) 34.2 3 (T Normal)\nZB 5.99 0.20 2 (Ok) 6.39 0.45 2 (Ok) 45.0 3 (T Normal)\n";
  fReceivedString+="Module 6\nBI 50.4 1.9 2 (Ok)\nPH 5.98 0.20 2 (Ok) 6.39 0.47 2 (Ok) 37.0 3 (T Normal)\nZA 5.99 0.20 2 (Ok) 5.98 0.46 2 (Ok) 35.6 3 (T Normal)\nZB 6.00 0.20 2 (Ok) 6.41 0.45 2 (Ok) 34.0 3 (T Normal)\n";
  fReceivedString+="Module 7\nBI 40.3 4.1 2 (Ok)\nPH 5.99 0.20 2 (Ok) 6.40 0.48 2 (Ok) 39.5 3 (T Normal)\nZA 6.01 0.20 2 (Ok) 6.41 0.47 2 (Ok) 35.4 3 (T Normal)\nZB 6.00 0.20 2 (Ok) 6.40 0.46 2 (Ok) 38.6 3 (T Normal)\n";
  fReceivedString+="Module 8\nBI 54.8 1.6 2 (Ok)\nPH 6.00 0.20 2 (Ok) 6.41 0.47 2 (Ok) 46.1 3 (T Normal)\nZA 6.31 0.21 2 (Ok) 6.00 0.45 2 (Ok) 35.8 3 (T Normal)\nZB 6.02 0.20 2 (Ok) 6.42 0.46 2 (Ok) 32.9 3 (T Normal)\n";
  fReceivedString+="Module 9\nBI 55.0 3.4 2 (Ok)\nPH 5.99 0.20 2 (Ok) 6.40 0.46 2 (Ok) 33.8 3 (T Normal)\nZA 5.99 0.20 2 (Ok) 6.41 0.44 2 (Ok) 43.0 3 (T Normal)\nZB 5.99 0.20 2 (Ok) 6.44 0.46 2 (Ok) 35.4 3 (T Normal)\n";
  fReceivedString+="Module 10\nBI 45.0 3.5 2 (Ok)\nPH 6.03 0.20 2 (Ok) 6.42 0.46 2 (Ok) 36.1 3 (T Normal)\nZA 5.98 0.20 2 (Ok) 6.40 0.48 2 (Ok) 35.4 3 (T Normal)\nZB 5.98 0.19 2 (Ok) 6.38 0.43 2 (Ok) 42.8 3 (T Normal)\n";
  fReceivedString+="Module 11\nBI 39.8 3.7 2 (Ok)\nPH 5.99 0.19 2 (Ok) 6.36 0.44 2 (Ok) 45.5 3 (T Normal)\nZA 5.99 0.18 2 (Ok) 6.37 0.43 2 (Ok) 35.3 3 (T Normal)\nZB 6.00 0.19 2 (Ok) 6.43 0.45 2 (Ok) 35.3 3 (T Normal)\n";
  fReceivedString+="Module 12\nBI 40.0 1.9 2 (Ok)\nPH 5.99 0.20 2 (Ok) 6.39 0.45 2 (Ok) 44.7 3 (T Normal)\nZA 5.98 0.20 2 (Ok) 6.40 0.47 2 (Ok) 53.9 3 (T Normal)\nZB 5.99 0.20 2 (Ok) 6.39 0.45 2 (Ok) 26.5 3 (T Normal)\n";
  fReceivedString+="Module 13\nBI 40.1 1.6 2 (Ok)\nPH 6.02 0.20 2 (Ok) 6.41 0.45 2 (Ok) 26.2 3 (T Normal)\nZA 5.99 0.20 2 (Ok) 6.42 0.48 2 (Ok) 27.6 3 (T Normal)\nZB 6.00 0.20 2 (Ok) 6.40 0.43 2 (Ok) 26.9 3 (T Normal)\n";
  fReceivedString+="Module 14\nBI 45.1 1.8 2 (Ok)\nPH 6.00 0.20 2 (Ok) 6.43 0.47 2 (Ok) 35.4 3 (T Normal)\nZA 5.99 0.23 2 (Ok) 6.41 0.45 2 (Ok) 34.1 3 (T Normal)\nZB 5.97 0.21 2 (Ok) 6.41 0.50 2 (Ok) 35.5 3 (T Normal)\n";
  fReceivedString+="Module 15\nBI 40.0 2.5 2 (Ok)\nPH 5.99 0.20 2 (Ok) 6.43 0.44 2 (Ok) 40.8 3 (T Normal)\nZA 5.99 0.20 2 (Ok) 6.37 0.43 2 (Ok) 33.1 3 (T Normal)\nZB 6.02 0.20 2 (Ok) 6.39 0.46 2 (Ok) 35.4 3 (T Normal)\n";
  fReceivedString+="Module 16\nBI 40.0 2.3 2 (Ok)\nPH 6.00 0.21 2 (Ok) 6.41 0.46 2 (Ok) 35.3 3 (T Normal)\nZA 6.00 0.20 2 (Ok) 6.41 0.48 2 (Ok) 35.4 3 (T Normal)\nZB 6.00 0.21 2 (Ok) 6.41 0.48 2 (Ok) 35.3 3 (T Normal)\n";
  fReceivedString+="Module 17\nBI 39.9 3.3 2 (Ok)\nPH 6.00 0.20 2 (Ok) 6.40 0.48 2 (Ok) 34.4 3 (T Normal)\nZA 6.00 0.20 2 (Ok) 6.40 0.48 2 (Ok) 54.6 3 (T Normal)\nZB 6.01 0.20 2 (Ok) 6.39 0.45 2 (Ok) 34.6 3 (T Normal)\nCooling data:\n";
  fReceivedString+="15.0 1 (Started) \'03 REMOTE START\' 0.000\n";

}

//_______________________________________
void TFndSlowCntSilRecode::ReadSilStringCompact(){

  if(fReceivedString.IsNull()){
    Warning("ReadSilStringCompact","received string is empty");
    return;
  }

  if(fDebugLevel > 0){
    Printf("\n\n =====> TFndSlowCntSilRecode::ReadSilStringCompact called <=====");
    Printf("\'fReceivedString\' content is: ");
    Printf("----------------------------------");
    Printf(fReceivedString);
    Printf("----------------------------------");
  }
  
  
  sscanf((const char*)fReceivedString, "%lf %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %d %d %d %d %d",
         &fDataCompact.timeStamp, &fDataCompact.biasV[0], &fDataCompact.biasI[0], &fDataCompact.biasV[1], &fDataCompact.biasI[1], &fDataCompact.biasV[2], &fDataCompact.biasI[2],
         &fDataCompact.biasV[3], &fDataCompact.biasI[3], &fDataCompact.biasV[4], &fDataCompact.biasI[4], &fDataCompact.biasV[5], &fDataCompact.biasI[5], &fDataCompact.biasV[6], &fDataCompact.biasI[6],
         &fDataCompact.biasV[7], &fDataCompact.biasI[7], &fDataCompact.biasV[8], &fDataCompact.biasI[8], &fDataCompact.biasV[9], &fDataCompact.biasI[9], &fDataCompact.biasV[10], &fDataCompact.biasI[10],
         &fDataCompact.biasV[11], &fDataCompact.biasI[11], &fDataCompact.biasV[12], &fDataCompact.biasI[12], &fDataCompact.biasV[13], &fDataCompact.biasI[13], &fDataCompact.biasV[14], &fDataCompact.biasI[14],
         &fDataCompact.biasV[15], &fDataCompact.biasI[15], &fDataCompact.biasV[16], &fDataCompact.biasI[16], &fDataCompact.biasV[17], &fDataCompact.biasI[17],
         &fDataCompact.crateErrorCondition, &fDataCompact.crateKill, &fDataCompact.crateStartupFailed, &fDataCompact.crateStatus, &fDataCompact.packetCounter);

  Printf("=================> \"%f\"",fDataCompact.timeStamp);
  Printf("=================> \"%f\"",fDataCompact.biasV[3]);

  if(fDebugLevel > 0) Printf("\n =====> TFndSlowCntSilRecode::ReadSilStringCompact completed <=====");
  
}

//_______________________________________
void TFndSlowCntSilRecode::PrintDataCompact(){
  // struct vsc_Data_compact
  // {
  //   double timeStamp;
  //   float biasV[18];
  //   float biasI[18];
  //   int crateErrorCondition;
  //   int crateKill;
  //   int crateStartupFailed;
  //   int crateStatus;
  //   int packetCounter;
  // };
  
  Printf("timestamp: %f",fDataCompact.timeStamp);
  for(Int_t i=0;i<18;i++) Printf("Module \"%d\" => bias_V: %f; bias_I: %f",i,fDataCompact.biasV[i],fDataCompact.biasV[i]);
  Printf("Crate_Errcondition: %d; CrateKill: %d; crateStartupFailed: %d; crateStatus: %d; packetCounter:%d",
                  fDataCompact.crateErrorCondition,
                  fDataCompact.crateKill,
                  fDataCompact.crateStartupFailed,
                  fDataCompact.crateStatus,
                  fDataCompact.packetCounter
                  );  

}


//_______________________________________
void TFndSlowCntSilRecode::ReadSilString(){

  if(fReceivedString.IsNull()){
    Warning("ReadSilString","received string is empty");
    return;
  }

  if(fDebugLevel){
    Printf("\n\n =====> TFndSlowCntSilRecode::ReadSilString called <=====");
    Printf("\'fReceivedString\' content is: ");
    Printf("----------------------------------");
    Printf(fReceivedString);
    Printf("----------------------------------");
  }

  //  char* line1 = gets((char*)fReceivedString.Data());
  Char_t line_data[95][200]; // 94 = 2 + (18 * 5) + 2

  Int_t nline=0;
  Int_t nchar=0;
  while(nline<94){
    nline++;
    Int_t nchar_line = 0;
    while(nchar_line < 200){
      //       cout << "nline:" << nline << "; " << nchar << " -> " << fReceivedString[nchar] << endl;
      line_data[nline-1][nchar_line++] = fReceivedString[nchar];
      nchar++;
      if(fReceivedString[nchar-1] == '\n') break;
      //       cout << "fReceivedString[" << nchar-1 << "] " << fReceivedString[nchar-1] << endl;
    }
    

    line_data[nline-1][nchar_line-1] = '\0';
    //    cout << "line " << nline << ": \"" << line_data[nline-1] << "\"" << endl;
  }

  sscanf((const char*)line_data[0],
         "%u:%u:%u %u/%u/%u",
         &fData.TimeStamp_hours,
         &fData.TimeStamp_minutes,
         &fData.TimeStamp_seconds,
         &fData.TimeStamp_day,
         &fData.TimeStamp_month,
         &fData.TimeStamp_year
         );

  fData.SCC_msg = line_data[1];
  // Module 14
  // BI 45.1 1.8 2 (Ok)
  // PH 6.00 0.20 2 (Ok) 6.43 0.47 2 (Ok) 35.4 3 (T Normal)
  // ZA 5.99 0.23 2 (Ok) 6.41 0.45 2 (Ok) 34.1 3 (T Normal)
  // ZB 5.97 0.21 2 (Ok) 6.41 0.50 2 (Ok) 35.5 3 (T Normal)

  Char_t dummy_str[4][100];
  Int_t mod_num = 0;
  for(Int_t mod=0;mod<18;mod++){
    // --- Module number in string: not used ( es: "Module 0")
    sscanf((const char*)line_data[(5*mod)+2],
           "%s %d",
           dummy_str[0],
           &mod_num
           );
    //    Printf("Checking: \"%s\" \"%d\"",dummy_str[0],mod_num);
    // --
    // Bias information (es: "BI 45.1 1.8 2 (Ok)")
    sscanf((const char*)line_data[(5*mod)+3],
           "%s %f %f %d", // ignoring (Ok)
           dummy_str[0],
           &fData.biasV[mod],
           &fData.biasI[mod],
           &fData.biasStatus[mod]
           );
    //    Printf("Checking: \"%s\" \"%d\"",dummy_str[0],mod_num);
    // --
    // Phi-side information (es: "PH 6.00 0.20 2 (Ok) 6.43 0.47 2 (Ok) 35.4 3 (T Normal)")
    sscanf((const char*)line_data[(5*mod)+4],
           "%s %f %f %d %s %f %f %d %s %f %f %d", // ignoring (Ok)-(T Normal)
           dummy_str[0],
           &fData.Phi_V[mod][0],
           &fData.Phi_I[mod][0],
           &fData.Phi_Status[mod][0],
           dummy_str[1], //
           &fData.Phi_V[mod][1],
           &fData.Phi_I[mod][1],
           &fData.Phi_Status[mod][1],
           dummy_str[2], //
           &fData.Phi_V[mod][2],
           &fData.Phi_I[mod][2],
           &fData.Phi_Status[mod][2]
           );
    //    Printf("Checking: \"%s\" \"%s\" \"%s\" \"%d\"",dummy_str[0],dummy_str[1],dummy_str[2],mod_num);
    // ZA-side information (es: "ZA 5.99 0.23 2 (Ok) 6.41 0.45 2 (Ok) 34.1 3 (T Normal)")
    sscanf((const char*)line_data[(5*mod)+5],
           "%s %f %f %d %s %f %f %d %s %f %f %d", // ignoring (Ok)-(T Normal)
           dummy_str[0],
           &fData.ZA_V[mod][0],
           &fData.ZA_I[mod][0],
           &fData.ZA_Status[mod][0],
           dummy_str[1], //
           &fData.ZA_V[mod][1],
           &fData.ZA_I[mod][1],
           &fData.ZA_Status[mod][1],
           dummy_str[2], //
           &fData.ZA_V[mod][2],
           &fData.ZA_I[mod][2],
           &fData.ZA_Status[mod][2]
           );
    //    Printf("Checking: \"%s\" \"%s\" \"%s\" \"%d\"",dummy_str[0],dummy_str[1],dummy_str[2],mod_num);
    // ---
    // ZB-side information (es: "ZB 5.97 0.21 2 (Ok) 6.41 0.50 2 (Ok) 35.5 3 (T Normal)")
    sscanf((const char*)line_data[(5*mod)+6],
           "%s %f %f %d %s %f %f %d %s %f %f %d", // ignoring (Ok)-(T Normal)
           dummy_str[0],
           &fData.ZB_V[mod][0],
           &fData.ZB_I[mod][0],
           &fData.ZB_Status[mod][0],
           dummy_str[1], //
           &fData.ZB_V[mod][1],
           &fData.ZB_I[mod][1],
           &fData.ZB_Status[mod][1],
           dummy_str[2], //
           &fData.ZB_V[mod][2],
           &fData.ZB_I[mod][2],
           &fData.ZB_Status[mod][2]
           );
    //    Printf("Checking: \"%s\" \"%s\" \"%s\" \"%d\"",dummy_str[0],dummy_str[1],dummy_str[2],mod_num);
  }

  // the "Cooling data:" line is dummy (check only)
  sscanf((const char*)line_data[92],
         "%s %s", // ignoring (Ok)
         dummy_str[0],
         dummy_str[1]
         );
  TString check_str_1 = "Cooling";
  TString check_str_2 = "data:";
  if(check_str_1.CompareTo(dummy_str[0]) != 0 || check_str_2.CompareTo(dummy_str[1]) != 0){
    Printf("--------> FORMAT eror detected!");
    return;
  }

  sscanf((const char*)line_data[93],
         "%f", // ignoring (Ok)
         &fData.Temperature
         );

    if(fDebugLevel > 0) Printf("\n =====> TFndSlowCntSilRecode::ReadSilStringCompact completed <=====");

}

//_______________________________________
void TFndSlowCntSilRecode::PrintData(){

  Printf("");
  Printf(" ---------------------------------");
  Printf("Printing complete data content");
  Printf("Timestamp (hours:minutes:seconds day/month/year): %u:%u:%u %u/%u/%u",
                  fData.TimeStamp_hours,
                  fData.TimeStamp_minutes,
                  fData.TimeStamp_seconds,
                  fData.TimeStamp_day,
                  fData.TimeStamp_month,
                  fData.TimeStamp_year
                  );
 
  Printf("SCC_msg: \"%s\"",(const Char_t *)fData.SCC_msg); 

  for(Int_t mod=0;mod<18;mod++){
    Printf("Module %d ===> BIAS info (V; I; Status): %f; %f; %d",
                    mod,
                    fData.biasV[mod],
                    fData.biasI[mod],
                    fData.biasStatus[mod]
                    );
    Printf("Module %d ===> PHI info (V; I; Status): (%f; %f; %d) - (%f; %f; %d) - (%f; %f; %d)",
                    mod,
                    fData.Phi_V[mod][0],
                    fData.Phi_I[mod][0],
                    fData.Phi_Status[mod][0],
                    fData.Phi_V[mod][1],
                    fData.Phi_I[mod][1],
                    fData.Phi_Status[mod][1],
                    fData.Phi_V[mod][2],
                    fData.Phi_I[mod][2],
                    fData.Phi_Status[mod][2]
                    );
    Printf("Module %d ===> ZA info (V; I; Status): (%f; %f; %d) - (%f; %f; %d) - (%f; %f; %d)",
                    mod,
                    fData.ZA_V[mod][0],
                    fData.ZA_I[mod][0],
                    fData.ZA_Status[mod][0],
                    fData.ZA_V[mod][1],
                    fData.ZA_I[mod][1],
                    fData.ZA_Status[mod][1],
                    fData.ZA_V[mod][2],
                    fData.ZA_I[mod][2],
                    fData.ZA_Status[mod][2]
                    );
    Printf("Module %d ===> ZB info (V; I; Status): (%f; %f; %d) - (%f; %f; %d) - (%f; %f; %d)",
                    mod,
                    fData.ZB_V[mod][0],
                    fData.ZB_I[mod][0],
                    fData.ZB_Status[mod][0],
                    fData.ZB_V[mod][1],
                    fData.ZB_I[mod][1],
                    fData.ZB_Status[mod][1],
                    fData.ZB_V[mod][2],
                    fData.ZB_I[mod][2],
                    fData.ZB_Status[mod][2]
                    );

  }
  Printf("Temperature: %f",fData.Temperature);    
  Printf(" ---------------------------------");
}

//_______________________________________
void TFndSlowCntSilRecode::BuildHeaderPart(Bool_t emptydata){
  // 0: Event length (bytes).
  // 1: Detector Name (TOFI/TOFO/LMD/STB/GAS/SIL/MAG)
  // 2: Current System Time (seconds)
  // 3: Number of Channels
  // 4: Data offset (bytes)
  // 5: Messages offset (bytes)
  // 6: Miscellaneous offset (bytes)
  // 7: Header length (bytes)
  // 8: Magic number
  // 9: Free space (for future development)
  // --------------------------------------
  //   enum SingleDetHdrPart_e {
  //                       HdrDet_evlen = 0,
  //                       HdrDet_detname,
  //                       HdrDet_systime,
  //                       HdrDet_nchans,
  //                       HdrDet_dataoff,
  //                       HdrDet_msgoff,
  //                       HdrDet_miscoff,
  //                       HdrDet_hdrlen,
  //                       HdrDet_magic,
  //                       HdrDet_free 
  //   };
  fSilRawBuf[HdrDet_evlen] = 0;

  UInt_t name_u32 = (UInt_t)'S';
  name_u32 = name_u32 & 0xFF;
  name_u32 = name_u32 | ( ((UInt_t)'I')<<8 );
  name_u32 = name_u32 & 0xFFFF;
  name_u32 = name_u32 | ( ((UInt_t)'L')<<16 );
  name_u32 = name_u32 & 0xFFFFFF;

  fSilRawBuf[HdrDet_detname] = name_u32;

  if(!emptydata){
    TDatime datime;
    datime.Set( (Int_t) (fData.TimeStamp_year),
                (Int_t) (fData.TimeStamp_month),
                (Int_t) (fData.TimeStamp_day),
                (Int_t) (fData.TimeStamp_hours),
                (Int_t) (fData.TimeStamp_minutes),
                (Int_t) (fData.TimeStamp_seconds)  );
    fSilRawBuf[HdrDet_systime] = datime.Convert();
  }
  
  fSilRawBuf[HdrDet_nchans] = K_SLOW_N_CHANS[SIL];
  fSilRawBuf[HdrDet_dataoff] = K_SCC_HDR_SIZE + 1;
  fSilRawBuf[HdrDet_msgoff] = fSilRawBuf[HdrDet_dataoff] + (UInt_t)(fSilRawBuf[HdrDet_nchans] * 4); // messages
  fSilRawBuf[HdrDet_miscoff] = fSilRawBuf[HdrDet_msgoff] + K_MSG_MAX_SIZE;
  fSilRawBuf[HdrDet_hdrlen] = K_SCC_HDR_SIZE; // 10 * 32bit = 40 * 8bit
  fSilRawBuf[HdrDet_magic] =K_MAGIC_NUMBER;
  fSilRawBuf[HdrDet_free] = 0x0;

  // set sil event length (up to messages, before misc)
  fSilRawLen += fSilRawBuf[HdrDet_miscoff]-1 ; // 
}

//_______________________________________
void TFndSlowCntSilRecode::UpdateHeaderPart(){
  // set event length (some check should be added)

  if(fDebugLevel > 0) Printf("TFndSlowCntSilRecode::UpdateHeaderPart ===> %u",fSilRawLen);
  fSilRawBuf[HdrDet_evlen] = fSilRawLen;
}



//_______________________________________
void TFndSlowCntSilRecode::BuildDataPart(){
  // format:
  //   Channels: 8xISI + 10 x OSI
  //       every channel: | PHI | ZA | ZB |  (64x3)bit [6 x UInt_t]
  //           every side:  | Pos | Neg |    (32x2)bit [2 x UInt_t]
  //
  // Channel status code:
  //   13 [1101]: OFF  (Hybrid unpowered)
  //   11 [1100]: TRIP (module BIAS)
  //   12 [1100]: TRIP (Killed)
  //    2 [0010]: ON   (ok)
  //
  // this method was written and tested on December 19,2006 (D. Faso)  

  enum e_sil_side { // used inside arrays
    e_ph = 0,
    e_za = 1,
    e_zb = 2,
    e_end = 3,
  };
  
  UInt_t data_off = (UInt_t) (fSilRawBuf[HdrDet_dataoff]/4) ;
  //  PrintData();  

  for(UInt_t uid = 0; uid < K_SLOW_N_CHANS[SIL] ; uid+=6){
    // uid is the U32 index
    UInt_t mod = uid/6;
    
    // --- check module status
    
    UShort_t PosSuppl_PW[e_end] = {0}; // power
    UShort_t PosSuppl_TR[e_end] = {0}; // trip
    
    UShort_t NegSuppl_PW[e_end] = {0}; // power
    UShort_t NegSuppl_TR[e_end] = {0}; // trip
    
    if(fData.Phi_Status[mod][0] == 2){
      PosSuppl_PW[e_ph] = 1;
      PosSuppl_TR[e_ph] = 0;
    }
    else if(fData.Phi_Status[mod][0] == 13){
      PosSuppl_PW[e_ph] = 0;
      PosSuppl_TR[e_ph] = 0;
    }
    else{
      PosSuppl_PW[e_ph] = 0;
      PosSuppl_TR[e_ph] = 1;
    }
    //
    if(fData.Phi_Status[mod][1] == 2){
      NegSuppl_PW[e_ph] = 1;
      NegSuppl_TR[e_ph] = 0;
    }
    else if(fData. Phi_Status[mod][1] == 13){
      NegSuppl_PW[e_ph] = 0;
      NegSuppl_TR[e_ph] = 0;
    }
    else{
      NegSuppl_PW[e_ph] = 0;
      NegSuppl_TR[e_ph] = 1;
    }
    if(fData.ZA_Status[mod][0] == 2){
      PosSuppl_PW[e_za] = 1;
      PosSuppl_TR[e_za] = 0;
    }
    else if(fData. ZA_Status[mod][0] == 13){
      PosSuppl_PW[e_za] = 0;
      PosSuppl_TR[e_za] = 0;
    }
    else{
      PosSuppl_PW[e_za] = 0;
      PosSuppl_TR[e_za] = 1;
    }
    //
    if(fData.ZA_Status[mod][1] == 2){
      NegSuppl_PW[e_za] = 1;
      NegSuppl_TR[e_za] = 0;
    }
    else if(fData.ZA_Status[mod][1] == 13){
      NegSuppl_PW[e_za] = 0;
      NegSuppl_TR[e_za] = 0;
    }
    else{
      NegSuppl_PW[e_za] = 0;
      NegSuppl_TR[e_za] = 1;
    }
    if(fData.ZB_Status[mod][0] == 2){
      PosSuppl_PW[e_zb] = 1;
      PosSuppl_TR[e_zb] = 0;
    }
    else if(fData.ZB_Status[mod][0] == 13){
      PosSuppl_PW[e_zb] = 0;
      PosSuppl_TR[e_zb]= 0;
    }
    else{
      PosSuppl_PW[e_zb] = 0;
      PosSuppl_TR[e_zb] = 1;
    }
    //
    if(fData.ZB_Status[mod][1] == 2){
      NegSuppl_PW[e_zb] = 1;
      NegSuppl_TR[e_zb] = 0;
    }
    else if(fData. ZB_Status[mod][1] == 13){
      NegSuppl_PW[e_zb] = 0;
      NegSuppl_TR[e_zb] = 0;
    }
    else{
      NegSuppl_PW[e_zb] = 0;
      NegSuppl_TR[e_zb] = 1;
    }

    // Set content
    UInt_t PosSuppl_V[e_end] = {0}; // voltage
    UInt_t PosSuppl_I[e_end] = {0}; // current
    
    UInt_t NegSuppl_V[e_end] = {0}; // voltage
    UInt_t NegSuppl_I[e_end] = {0}; // current

 
    Float_t Multiplier = 100; // used in order to keep decimals
    
    PosSuppl_V[e_ph] = (UInt_t) (0.5 + Multiplier * fData.Phi_V[mod][0]);
    PosSuppl_I[e_ph] = (UInt_t) (0.5 + Multiplier * fData.Phi_I[mod][0]);
    //
    PosSuppl_V[e_za] = (UInt_t) (0.5 + Multiplier * fData.ZA_V[mod][0]);
    PosSuppl_I[e_za] = (UInt_t) (0.5 + Multiplier * fData.ZA_I[mod][0]);
    //
    PosSuppl_V[e_zb] = (UInt_t) (0.5 + Multiplier * fData.ZB_V[mod][0]);
    PosSuppl_I[e_zb] = (UInt_t) (0.5 + Multiplier * fData.ZB_I[mod][0]);
    // ---
    NegSuppl_V[e_ph] = (UInt_t) (0.5 + Multiplier * fData.Phi_V[mod][1]);
    NegSuppl_I[e_ph] = (UInt_t) (0.5 + Multiplier * fData.Phi_I[mod][1]);
    //
    NegSuppl_V[e_za] = (UInt_t) (0.5 + Multiplier * fData.ZA_V[mod][1]);
    NegSuppl_I[e_za] = (UInt_t) (0.5 + Multiplier * fData.ZA_I[mod][1]);
    //
    NegSuppl_V[e_zb] = (UInt_t) (0.5 + Multiplier * fData.ZB_V[mod][1]);
    NegSuppl_I[e_zb] = (UInt_t) (0.5 + Multiplier * fData.ZB_I[mod][1]);
    //
    
    for(Int_t i=0;i<3;i++){
      PosSuppl_V[i] = PosSuppl_V[i] & 0x7FFF;
      NegSuppl_V[i] = NegSuppl_V[i] & 0x7FFF;
      PosSuppl_I[i] = PosSuppl_I[i] & 0x7FFF;
      NegSuppl_I[i] = NegSuppl_I[i] & 0x7FFF;
      PosSuppl_PW[i] = PosSuppl_PW[i] & 0x1;
      PosSuppl_TR[i] = PosSuppl_TR[i] & 0x1;
    }
    // ---   
    /*
    Printf("uid: %u; mod: %u",uid,mod);
    Printf("PhiPos V: %f",fData.Phi_V[mod][0] );

    Printf("PHI-Pos: V = %u; I = %u; PW = %u; TR = %u",
                    PosSuppl_V[e_ph],
                    PosSuppl_I[e_ph],
                    PosSuppl_PW[e_ph],
                    PosSuppl_TR[e_ph]
                    );

    Printf("PhiNeg V: %f",fData.Phi_V[mod][1] );
    Printf("PHI-Neg: V = %u; I = %u; PW = %u; TR = %u",
                    NegSuppl_V[e_ph],
                    NegSuppl_I[e_ph],
                    NegSuppl_PW[e_ph],
                    NegSuppl_TR[e_ph]
                    );
    Printf("");
    */

    // fill data buffer here
    UInt_t Pos_entry_Phi = 0;
    Pos_entry_Phi = (PosSuppl_V[e_ph] << 16);
    Pos_entry_Phi = Pos_entry_Phi & 0x8FFFFFFF;
    Pos_entry_Phi = Pos_entry_Phi | (PosSuppl_PW[e_ph] << 31 );
    Pos_entry_Phi = Pos_entry_Phi & 0xFFFF0000;
    Pos_entry_Phi = Pos_entry_Phi | PosSuppl_I[e_ph];
    Pos_entry_Phi = Pos_entry_Phi & 0xFFFF8FFF;
    Pos_entry_Phi = Pos_entry_Phi | ( PosSuppl_TR[e_ph] << 15);

    UInt_t Neg_entry_Phi = 0;
    Neg_entry_Phi = (NegSuppl_V[e_ph] << 16);
    Neg_entry_Phi = Neg_entry_Phi & 0x8FFFFFFF;
    Neg_entry_Phi = Neg_entry_Phi | (NegSuppl_PW[e_ph] << 31 );
    Neg_entry_Phi = Neg_entry_Phi & 0xFFFF0000;
    Neg_entry_Phi = Neg_entry_Phi | NegSuppl_I[e_ph];
    Neg_entry_Phi = Neg_entry_Phi & 0xFFFF8FFF;
    Neg_entry_Phi = Neg_entry_Phi | ( NegSuppl_TR[e_ph] << 15);
    // --- 
    UInt_t Pos_entry_ZA = 0;
    Pos_entry_ZA = (PosSuppl_V[e_za] << 16);
    Pos_entry_ZA = Pos_entry_ZA & 0x8FFFFFFF;
    Pos_entry_ZA = Pos_entry_ZA | (PosSuppl_PW[e_za] << 31 );
    Pos_entry_ZA = Pos_entry_ZA & 0xFFFF0000;
    Pos_entry_ZA = Pos_entry_ZA | PosSuppl_I[e_za];
    Pos_entry_ZA = Pos_entry_ZA & 0xFFFF8FFF;
    Pos_entry_ZA = Pos_entry_ZA | ( PosSuppl_TR[e_za] << 15);

    UInt_t Neg_entry_ZA = 0;
    Neg_entry_ZA = (NegSuppl_V[e_za] << 16);
    Neg_entry_ZA = Neg_entry_ZA & 0x8FFFFFFF;
    Neg_entry_ZA = Neg_entry_ZA | (NegSuppl_PW[e_za] << 31 );
    Neg_entry_ZA = Neg_entry_ZA & 0xFFFF0000;
    Neg_entry_ZA = Neg_entry_ZA | NegSuppl_I[e_za];
    Neg_entry_ZA = Neg_entry_ZA & 0xFFFF8FFF;
    Neg_entry_ZA = Neg_entry_ZA | ( NegSuppl_TR[e_za] << 15);
    // --- 
    UInt_t Pos_entry_ZB = 0;
    Pos_entry_ZB = (PosSuppl_V[e_zb] << 16);
    Pos_entry_ZB = Pos_entry_ZB & 0x8FFFFFFF;
    Pos_entry_ZB = Pos_entry_ZB | (PosSuppl_PW[e_zb] << 31 );
    Pos_entry_ZB = Pos_entry_ZB & 0xFFFF0000;
    Pos_entry_ZB = Pos_entry_ZB | PosSuppl_I[e_zb];
    Pos_entry_ZB = Pos_entry_ZB & 0xFFFF8FFF;
    Pos_entry_ZB = Pos_entry_ZB | ( PosSuppl_TR[e_zb] << 15);

    UInt_t Neg_entry_ZB = 0;
    Neg_entry_ZB = (NegSuppl_V[e_zb] << 16);
    Neg_entry_ZB = Neg_entry_ZB & 0x8FFFFFFF;
    Neg_entry_ZB = Neg_entry_ZB | (NegSuppl_PW[e_zb] << 31 );
    Neg_entry_ZB = Neg_entry_ZB & 0xFFFF0000;
    Neg_entry_ZB = Neg_entry_ZB | NegSuppl_I[e_zb];
    Neg_entry_ZB = Neg_entry_ZB & 0xFFFF8FFF;
    Neg_entry_ZB = Neg_entry_ZB | ( NegSuppl_TR[e_zb] << 15);


    fSilRawBuf[data_off + uid    ] = Pos_entry_Phi;
    fSilRawBuf[data_off + uid + 1] = Neg_entry_Phi;
    fSilRawBuf[data_off + uid + 2] = Pos_entry_ZA;
    fSilRawBuf[data_off + uid + 3] = Neg_entry_ZA;
    fSilRawBuf[data_off + uid + 4] = Pos_entry_ZB;
    fSilRawBuf[data_off + uid + 5] = Neg_entry_ZB;
    
  }
  




}

//_______________________________________
void TFndSlowCntSilRecode::ConvertSingleU32(){
  // convert a group of 4 char into a UInt_t element  

  UInt_t *conv = (UInt_t *)(fMsgBuf.Data());
  fSilRawBuf[(fSilRawBuf[HdrDet_msgoff]/4) + fCurMsgInt_ID] = conv[0] ;
  if(fDebugLevel > 1) Printf(" single fSilRawBuf: \"%s\"",(Char_t *) &fSilRawBuf[(fSilRawBuf[HdrDet_msgoff]/4) + fCurMsgInt_ID] );
  fCurMsgInt_ID++;
  fMsgBuf = "";
}

//_______________________________________
void TFndSlowCntSilRecode::BuildMessagesPart(){
  
  if(fDebugLevel > 0) Printf("TFndSlowCntSilRecode::BuildMessagesPart: Entering method");

  fCurChar = 0;
  fCurMsgInt_ID = 0;

  while(fCurChar<K_MSG_MAX_SIZE){ // K_MSG_MAX_SIZE bytes is the maximum space allowed

    if(fDebugLevel > 2){Printf("fCurChar: %d; fCurMsgInt_ID: %d ===> \"%c\"",
                                        fCurChar, 
                                        fCurMsgInt_ID,
                                        (Char_t)(fData.SCC_msg)[fCurChar]
                                        );
    }
    
    if(fCurChar!=0 && fCurChar%4==0){
      ConvertSingleU32();
    }
    
    fMsgBuf+=(fData.SCC_msg)[fCurChar];
    if(fDebugLevel > 1) Printf( " fMsgBuf: \"%s\"",fMsgBuf.Data() );
    fCurChar++;
    
    if((fData.SCC_msg)[fCurChar] == '\0' || (fData.SCC_msg)[fCurChar] == '\n'){
      if(fDebugLevel > 1) Printf("End of line reached");
      ConvertSingleU32();
      fSilRawBuf[(fSilRawBuf[HdrDet_msgoff]/4) + fCurMsgInt_ID] = (UInt_t)('\0');
      break;
    }
  }
  
  if(fDebugLevel > 1) Printf("fSilRawBuf conv. message: \"%s\"", (Char_t *)(&fSilRawBuf[fSilRawBuf[HdrDet_msgoff]/4]) );
  if(fDebugLevel > 0) Printf("TFndSlowCntSilRecode::BuildMessagesPart: Exiting method");
  
}

//_______________________________________
void TFndSlowCntSilRecode::UpdateMessagePart(){
// called every 6 seconds (whenever the message string only is received)
  
  if(fDebugLevel > 0) Info("UpdateSilMessage","Entering method");
  if(fSilRawBuf[HdrDet_evlen] ==0) {
    if(fDebugLevel > 0) Warning("UpdateSilMessage","Sil raw data still not available: creating an empty raw buffer");
    ReBuildSilSlowRaw(kTRUE);
  }

  if(fMessagePart.IsNull()){
    Warning("UpdateMessagePart","Null message received");
    for(Int_t i=(Int_t)(fSilRawBuf[HdrDet_msgoff]/4);i<(Int_t)(fSilRawBuf[HdrDet_miscoff]/4);i++) fSilRawBuf[i] = 0;
    return;
  }

  fCurChar = 0;
  fCurMsgInt_ID = 0;

  while(fCurChar<K_MSG_MAX_SIZE){ // K_MSG_MAX_SIZE bytes is the maximum space allowed

    if(fDebugLevel > 2){Printf("fCurChar: %d; fCurMsgInt_ID: %d ===> \"%c\"",
                                        fCurChar, 
                                        fCurMsgInt_ID,
                                        (Char_t)(fMessagePart)[fCurChar]
                                        );
    }
    
    if(fCurChar!=0 && fCurChar%4==0){
      ConvertSingleU32();
    }
    
    fMsgBuf+=(fMessagePart)[fCurChar];
    if(fDebugLevel > 1) Printf( " fMsgBuf: \"%s\"",fMsgBuf.Data() );
    fCurChar++;
    
    if((fMessagePart)[fCurChar] == '\0' || (fMessagePart)[fCurChar] == '\n'){
      if(fDebugLevel > 1) Printf("End of line reached");
      ConvertSingleU32();
      fSilRawBuf[(fSilRawBuf[HdrDet_msgoff]/4) + fCurMsgInt_ID] = (UInt_t)('\0');
      break;
    }
  }
  
  if(fDebugLevel > 1) Printf("fSilRawBuf conv. message: \"%s\"", (Char_t *)(&fSilRawBuf[fSilRawBuf[HdrDet_msgoff]/4]) );

  if(fDebugLevel > 0) Info("UpdateSilMessage","Exiting method");
}


//_______________________________________
void TFndSlowCntSilRecode::BuildMiscPart(){
  
  // --- no information needed up to now
  if(fDebugLevel > 1) Printf("TFndSlowCntSilRecode::BuildMiscPart ===> misc start at byte: %u",fSilRawBuf[HdrDet_miscoff]);
  // remember to increment "fSilRawLen (bytes!)"
}

//_______________________________________
void TFndSlowCntSilRecode::ReBuildSilSlowRaw(Bool_t empty){

  bzero(fSilRawBuf,sizeof(fSilRawBuf));
  BuildHeaderPart(empty);

  if(!empty){
    BuildDataPart();
    BuildMessagesPart();
    BuildMiscPart();
  }
  
  UpdateHeaderPart();

}

//_______________________________________
void TFndSlowCntSilRecode::PrintSilSlowRaw(Bool_t hdr,Bool_t data,Bool_t msg){

  if(!hdr && !data && !msg){
    Printf("\n\n --- TFndSlowCntSilRecode::PrintSilSlowRaw: Nothing to print (all arguments are \"false\"): \n");
    return;
  }

  Printf("\n\n --- printing SIL Slow-raw-data: \n");

  if(hdr){
    Printf(" -> HEADER: ");  
    for(Int_t i=0;i<10;i++) Printf("fSilRawBuf [%d] = 0x%x",i,fSilRawBuf[i]);
    Printf(" ---------- ");  
  }
  
  if(data){
    Printf(" -> DATA: ");  
    for(Int_t i=(Int_t)(fSilRawBuf[HdrDet_dataoff]/4);i<(Int_t)(fSilRawBuf[HdrDet_msgoff]/4);i++) Printf("fSilRawBuf [%d] = 0x%x",i,fSilRawBuf[i]);
    Printf(" ---------- ");  
  }
  
  if(msg){
    Printf(" -> MESSAGE: ");  
    for(Int_t i=(Int_t)(fSilRawBuf[HdrDet_msgoff]/4);i<(Int_t)(fSilRawBuf[HdrDet_miscoff]/4);i++) Printf("fSilRawBuf [%d] = 0x%x",i,fSilRawBuf[i]);
    for(Int_t i=(Int_t)(fSilRawBuf[HdrDet_msgoff]/4);i<(Int_t)(fSilRawBuf[HdrDet_miscoff]/4);i++) Printf("fSilRawBuf [%d] = \"%s\"",i,(Char_t*)&fSilRawBuf[i]);
    Printf(" ---------- ");  
  }
  
}

---