/[PAMELA software]/PamelaDigitizer/Digitizer.cxx

Diff of /PamelaDigitizer/Digitizer.cxx

Parent Directory | Revision Log | View Patch Patch

-revision 1.2 by orsi,
Fri Sep 28 10:46:23 2007 UTC
+revision 1.5 by silvio,
Wed Nov 28 18:54:31 2007 UTC
 Line 1
  //               ------ PAMELA Digitizer ------
  //
  // Date, release and how-to: see file Pamelagp2Digits.cxx
  //
  // NB: Check length physics packet [packet type (0x10 = physics data)]
  //
  #include <sstream>
  #include <fstream>
  #include <stdlib.h>
  #include <stdio.h>
  #include <string.h>
  #include <ctype.h>
  #include <time.h>
  #include "Riostream.h"
  #include "TFile.h"
  #include "TDirectory.h"
  #include "TTree.h"
  #include "TLeafI.h"
  #include "TH1.h"
  #include "TH2.h"
  #include "TMath.h"
  #include "TRandom.h"
  #include "TSQLServer.h"
  #include "TSystem.h"
  //
  #include "Digitizer.h"
  #include "CRC.h"
  //
  #include <PamelaRun.h>
  #include <physics/calorimeter/CalorimeterEvent.h>
  #include <CalibCalPedEvent.h>
  #include "GLTables.h"
  //
  extern "C"{
    short crc(short, short);
  };
  //
  Digitizer::Digitizer(TTree* tree, char* &file_raw){
    fhBookTree = tree;
    fFilename =  file_raw;
    fCounter = 0;
    fOBT = 0;
    //
    // DB connections
    //
    TString host = "mysql://localhost/pamelaprod";
    TString user = "anonymous";
    TString psw = "";
    //
    const char *pamdbhost=gSystem->Getenv("PAM_DBHOST");
    const char *pamdbuser=gSystem->Getenv("PAM_DBUSER");
    const char *pamdbpsw=gSystem->Getenv("PAM_DBPSW");
    if ( !pamdbhost ) pamdbhost = "";
    if ( !pamdbuser ) pamdbuser = "";
    if ( !pamdbpsw ) pamdbpsw = "";
    if ( strcmp(pamdbhost,"") ) host = pamdbhost;
    if ( strcmp(pamdbuser,"") ) user = pamdbuser;
    if ( strcmp(pamdbpsw,"") ) psw = pamdbpsw;
    fDbc = TSQLServer::Connect(host.Data(),user.Data(),psw.Data());
    //
    GL_TABLES *glt = new GL_TABLES(host,user,psw);
    if ( glt->IsConnected(fDbc) ) printf("\n DB INFORMATION:\n SQL: %s Version: %s Host %s Port %i \n\n",fDbc->GetDBMS(),fDbc->ServerInfo(),fDbc->GetHost(),fDbc->GetPort());
    //
    // Use UTC in the DB and make timeout bigger
    //
    stringstream myquery;
    myquery.str("");
    myquery << "SET time_zone='+0:00'";
    fDbc->Query(myquery.str().c_str());
    myquery.str("");
    myquery << "SET wait_timeout=173000;";
    fDbc->Query(myquery.str().c_str());
    //
    std:: cout << "preparing tree" << endl;
    // prepare tree
    fhBookTree->SetBranchAddress("Irun",&Irun);
    fhBookTree->SetBranchAddress("Ievnt",&Ievnt);
    fhBookTree->SetBranchAddress("Ipa",&Ipa);
    fhBookTree->SetBranchAddress("X0",&X0);
    fhBookTree->SetBranchAddress("Y0",&Y0);
    fhBookTree->SetBranchAddress("Z0",&Z0);
    fhBookTree->SetBranchAddress("Theta",&Theta);
    fhBookTree->SetBranchAddress("Phi",&Phi);
    fhBookTree->SetBranchAddress("P0",&P0);
    fhBookTree->SetBranchAddress("Nthtof",&Nthtof);
    fhBookTree->SetBranchAddress("Ipltof",Ipltof);
    fhBookTree->SetBranchAddress("Ipaddle",Ipaddle);
    fhBookTree->SetBranchAddress("Ipartof",Ipartof);
    fhBookTree->SetBranchAddress("Xintof",Xintof);
    fhBookTree->SetBranchAddress("Yintof",Yintof);
    fhBookTree->SetBranchAddress("Zintof",Zintof);
    fhBookTree->SetBranchAddress("Xouttof",Xouttof);
    fhBookTree->SetBranchAddress("Youttof",Youttof);
    fhBookTree->SetBranchAddress("Zouttof",Zouttof);
    fhBookTree->SetBranchAddress("Ereltof",Ereltof);
    fhBookTree->SetBranchAddress("Timetof",Timetof);
    fhBookTree->SetBranchAddress("Pathtof",Pathtof);
    fhBookTree->SetBranchAddress("P0tof",P0tof);
    fhBookTree->SetBranchAddress("Nthcat",&Nthcat);
    fhBookTree->SetBranchAddress("Iparcat",Iparcat);
    fhBookTree->SetBranchAddress("Icat",Icat);
    fhBookTree->SetBranchAddress("Xincat",Xincat);
    fhBookTree->SetBranchAddress("Yincat",Yincat);
    fhBookTree->SetBranchAddress("Zincat",Zincat);
    fhBookTree->SetBranchAddress("Xoutcat",Xoutcat);
    fhBookTree->SetBranchAddress("Youtcat",Youtcat);
    fhBookTree->SetBranchAddress("Zoutcat",Zoutcat);
    fhBookTree->SetBranchAddress("Erelcat",Erelcat);
    fhBookTree->SetBranchAddress("Timecat",Timecat);
    fhBookTree->SetBranchAddress("Pathcat",Pathcat);
    fhBookTree->SetBranchAddress("P0cat",P0cat);
    fhBookTree->SetBranchAddress("Nthcas",&Nthcas);
    fhBookTree->SetBranchAddress("Iparcas",Iparcas);
    fhBookTree->SetBranchAddress("Icas",Icas);
    fhBookTree->SetBranchAddress("Xincas",Xincas);
    fhBookTree->SetBranchAddress("Yincas",Yincas);
    fhBookTree->SetBranchAddress("Zincas",Zincas);
    fhBookTree->SetBranchAddress("Xoutcas",Xoutcas);
    fhBookTree->SetBranchAddress("Youtcas",Youtcas);
    fhBookTree->SetBranchAddress("Zoutcas",Zoutcas);
    fhBookTree->SetBranchAddress("Erelcas",Erelcas);
    fhBookTree->SetBranchAddress("Timecas",Timecas);
    fhBookTree->SetBranchAddress("Pathcas",Pathcas);
    fhBookTree->SetBranchAddress("P0cas",P0cas);
    fhBookTree->SetBranchAddress("Nthspe",&Nthspe);
    fhBookTree->SetBranchAddress("Iparspe",Iparspe);
    fhBookTree->SetBranchAddress("Itrpb",Itrpb);
    fhBookTree->SetBranchAddress("Itrsl",Itrsl);
    fhBookTree->SetBranchAddress("Itspa",Itspa);
    fhBookTree->SetBranchAddress("Xinspe",Xinspe);
    fhBookTree->SetBranchAddress("Yinspe",Yinspe);
    fhBookTree->SetBranchAddress("Zinspe",Zinspe);
    fhBookTree->SetBranchAddress("Xoutspe",Xoutspe);
    fhBookTree->SetBranchAddress("Youtspe",Youtspe);
    fhBookTree->SetBranchAddress("Zoutspe",Zoutspe);
    fhBookTree->SetBranchAddress("Xavspe",Xavspe);
    fhBookTree->SetBranchAddress("Yavspe",Yavspe);
    fhBookTree->SetBranchAddress("Zavspe",Zavspe);
    fhBookTree->SetBranchAddress("Erelspe",Erelspe);
    fhBookTree->SetBranchAddress("Pathspe",Pathspe);
    fhBookTree->SetBranchAddress("P0spe",P0spe);
    fhBookTree->SetBranchAddress("Nxmult",Nxmult);
    fhBookTree->SetBranchAddress("Nymult",Nymult);
    fhBookTree->SetBranchAddress("Nstrpx",&Nstrpx);
    fhBookTree->SetBranchAddress("Npstripx",Npstripx);
    fhBookTree->SetBranchAddress("Ntstripx",Ntstripx);
    fhBookTree->SetBranchAddress("Istripx",Istripx);
    fhBookTree->SetBranchAddress("Qstripx",Qstripx);
    fhBookTree->SetBranchAddress("Xstripx",Xstripx);
    fhBookTree->SetBranchAddress("Nstrpy",&Nstrpy);
    fhBookTree->SetBranchAddress("Npstripy",Npstripy);
    fhBookTree->SetBranchAddress("Ntstripy",Ntstripy);
    fhBookTree->SetBranchAddress("Istripy",Istripy);
    fhBookTree->SetBranchAddress("Qstripy",Qstripy);
    fhBookTree->SetBranchAddress("Ystripy",Ystripy);
    fhBookTree->SetBranchAddress("Nthcali",&Nthcali);
    fhBookTree->SetBranchAddress("Icaplane",Icaplane);
    fhBookTree->SetBranchAddress("Icastrip",Icastrip);
    fhBookTree->SetBranchAddress("Icamod",Icamod);
    fhBookTree->SetBranchAddress("Enestrip",Enestrip);
    fhBookTree->SetBranchAddress("Nthcal",&Nthcal);
    fhBookTree->SetBranchAddress("Icapl",Icapl);
    fhBookTree->SetBranchAddress("Icasi",Icasi);
    fhBookTree->SetBranchAddress("Icast",Icast);
    fhBookTree->SetBranchAddress("Xincal",Xincal);
    fhBookTree->SetBranchAddress("Yincal",Yincal);
    fhBookTree->SetBranchAddress("Zincal",Zincal);
    fhBookTree->SetBranchAddress("Erelcal",Erelcal);
    fhBookTree->SetBranchAddress("Nthnd",&Nthnd);
    fhBookTree->SetBranchAddress("Itubend",Itubend);
    fhBookTree->SetBranchAddress("Iparnd",Iparnd);
    fhBookTree->SetBranchAddress("Xinnd",Xinnd);
    fhBookTree->SetBranchAddress("Yinnd",Yinnd);
    fhBookTree->SetBranchAddress("Zinnd",Zinnd);
    fhBookTree->SetBranchAddress("Xoutnd",Xoutnd);
    fhBookTree->SetBranchAddress("Youtnd",Youtnd);
    fhBookTree->SetBranchAddress("Zoutnd",Zoutnd);
    fhBookTree->SetBranchAddress("Erelnd",Erelnd);
    fhBookTree->SetBranchAddress("Timend",Timend);
    fhBookTree->SetBranchAddress("Pathnd",Pathnd);
    fhBookTree->SetBranchAddress("P0nd",P0nd);
    fhBookTree->SetBranchAddress("Nthcard",&Nthcard);
    fhBookTree->SetBranchAddress("Iparcard",Iparcard);
    fhBookTree->SetBranchAddress("Icard",Icard);
    fhBookTree->SetBranchAddress("Xincard",Xincard);
    fhBookTree->SetBranchAddress("Yincard",Yincard);
    fhBookTree->SetBranchAddress("Zincard",Zincard);
    fhBookTree->SetBranchAddress("Xoutcard",Xoutcard);
    fhBookTree->SetBranchAddress("Youtcard",Youtcard);
    fhBookTree->SetBranchAddress("Zoutcard",Zoutcard);
    fhBookTree->SetBranchAddress("Erelcard",Erelcard);
    fhBookTree->SetBranchAddress("Timecard",Timecard);
    fhBookTree->SetBranchAddress("Pathcard",Pathcard);
    fhBookTree->SetBranchAddress("P0card",P0card);
    fhBookTree->SetBranchStatus("*",0);
  };
  void Digitizer::Close(){
    delete fhBookTree;
  };
  void Digitizer::Loop() {
    //
    // opens the raw output file and loops over the events
    //
    fOutputfile.open(fFilename, ios::out | ios::binary);
    //fOutputfile.open(Form("Output%s",fFilename), ios::out | ios::binary);
    //
    // Load in memory and save at the beginning of file the calorimeter calibration
    //
    CaloLoadCalib();
    DigitizeCALOCALIB();
    //  load, digitize and write tracker calibration
    LoadTrackCalib();
    DigitizeTrackCalib(1);
    UInt_t length=fTracklength*2;
    DigitizePSCU(length,0x12);
    AddPadding();
    WriteTrackCalib();
    DigitizeTrackCalib(2);
    length=fTracklength*2;
    DigitizePSCU(length,0x13);
    AddPadding();
    WriteTrackCalib();
    LoadMipCor();  // some initialization of parameters -not used now-
    //  end loading, digitizing and writing tracker calibration
    //
    // loops over the events
    //
    Int_t nentries = fhBookTree->GetEntriesFast();
    Long64_t nbytes = 0;
    for (Int_t i=0; i<nentries;i++) {
      //
      nbytes += fhBookTree->GetEntry(i);
      // read detectors sequentially:
      // http://www.ts.infn.it/fileadmin/documents/physics/experiments/wizard/cpu/gen_arch/RM_Acquisition.pdf
      // on pamelatov:
      // /cvs/yoda/techmodel/physics/NeutronDetectorReader.cpp
      DigitizeTRIGGER();
      DigitizeTOF();
      DigitizeAC();
      DigitizeCALO();
      DigitizeTrack();
-     //DigitizeS4();
+     DigitizeS4();
      DigitizeND();
        //
      // Add padding to 64 bits
      //
      AddPadding();
  //
      // Create CPU header, we need packet type (0x10 = physics data) and packet length.
      //
-     //UInt_t length=2*(fCALOlength+fACbuffer+fTracklength+fNDbuffer+fS4buffer)+fPadding+fTOFbuffer+fTRIGGERbuffer;
+     UInt_t length=2*(fCALOlength+fACbuffer+fTracklength+fNDbuffer+fS4buffer)+fPadding+fTOFbuffer+fTRIGGERbuffer;
-     UInt_t length=2*(fCALOlength+fACbuffer+fTracklength+fNDbuffer)+fPadding+fTOFbuffer+fTRIGGERbuffer;
+     //UInt_t length=2*(fCALOlength+fACbuffer+fTracklength+fNDbuffer)+fPadding+fTOFbuffer+fTRIGGERbuffer;
      DigitizePSCU(length,0x10);
      if ( !i%100 ) std::cout << "writing event " << i << endl;
      WriteData();
    };
    fOutputfile.close();
    std::cout << "files closed" << endl << flush;
  };
  void Digitizer::AddPadding(){
    //
    Float_t pd0 = (fLen+16)/64.;
    Float_t pd1 = pd0 - (Float_t)int(pd0);
    Float_t padfrac = 64. - pd1 * 64.;
    //
    UInt_t padbytes = (UInt_t)padfrac;
    if ( padbytes > 0 && padbytes < 64 ){
      //
      // here the padding length
      //
      fPadding = padbytes+64;
      //
      // random padding bytes
      //
      for (Int_t ur=0; ur<32; ur++){
        fDataPadding[ur] = (UShort_t)rand();
      };
    };
  };
  void Digitizer::DigitizePSCU(UInt_t length, UChar_t type) {
    //
    UChar_t buff[16];
    //
    // CPU signature
    //
    buff[0] = 0xFA;
    buff[1] = 0xFE;
    buff[2] = 0xDE;
    //
    // packet type (twice)
    //
    buff[3] = type;
    buff[4] = type;
    //
    // counter
    //
    fCounter++;
    while ( fCounter > 16777215 ){
      fCounter -= 16777215;
    };
    //
    buff[5] = (UChar_t)(fCounter >> 16);
    buff[6] = (UChar_t)(fCounter >> 8);
    buff[7] = (UChar_t)fCounter;
    //
    // on board time
    //
    ULong64_t obt = fOBT + 30LL;
    //
    while ( obt > 4294967295LL ){
      obt -= 4294967295LL;
    };
    fOBT = (UInt_t)obt;
    //
    buff[8] = (UChar_t)(fOBT >> 24);
    buff[9] = (UChar_t)(fOBT >> 16);
    buff[10] = (UChar_t)(fOBT >> 8);
    buff[11] = (UChar_t)fOBT;
    //
    // Packet length
    //
    fLen = length;
    //
    buff[12] = (UChar_t)(fLen >> 16);
    buff[13] = (UChar_t)(fLen >> 8);
    buff[14] = (UChar_t)fLen;
    //
    // CPU header CRC
    //
    buff[15] = (BYTE)CM_Compute_CRC16((UINT16)0, (BYTE*)&buff, (UINT32)15);
    //
    memcpy(fDataPSCU,buff,16*sizeof(UChar_t));
    //
  };
  void Digitizer::ClearCaloCalib(Int_t s){
    //
    fcstwerr[s] = 0;
    fcperror[s] = 0.;
    for ( Int_t d=0 ; d<11 ;d++  ){
      Int_t pre = -1;
      for ( Int_t j=0; j<96 ;j++){
        if ( j%16 == 0 ) pre++;
        fcalped[s][d][j] = 0.;
        fcstwerr[s] = 0.;
        fcperror[s] = 0.;
        fcalgood[s][d][j] = 0.;
        fcalthr[s][d][pre] = 0.;
        fcalrms[s][d][j] = 0.;
        fcalbase[s][d][pre] = 0.;
        fcalvar[s][d][pre] = 0.;
      };
    };
    return;
  }
  Int_t Digitizer::CaloLoadCalib(Int_t s,TString fcalname, UInt_t calibno){
    //
    //
    UInt_t e = 0;
    if ( s == 0 ) e = 0;
    if ( s == 1 ) e = 2;
    if ( s == 2 ) e = 3;
    if ( s == 3 ) e = 1;
    //
    ifstream myfile;
    myfile.open(fcalname.Data());
    if ( !myfile ){
      return(-107);
    };
    myfile.close();
    //
    TFile *File = new TFile(fcalname.Data());
    if ( !File ) return(-108);
    TTree *tr = (TTree*)File->Get("CalibCalPed");
    if ( !tr ) return(-109);
    //
    TBranch *calo = tr->GetBranch("CalibCalPed");
    //
    pamela::CalibCalPedEvent *ce = 0;
    tr->SetBranchAddress("CalibCalPed", &ce);
    //
    Long64_t ncalibs = calo->GetEntries();
    //
    if ( !ncalibs ) return(-110);
    //
    calo->GetEntry(calibno);
    //
    if (ce->cstwerr[s] != 0 && ce->cperror[s] == 0 ) {
      fcstwerr[s] = ce->cstwerr[s];
      fcperror[s] = ce->cperror[s];
      for ( Int_t d=0 ; d<11 ;d++  ){
        Int_t pre = -1;
        for ( Int_t j=0; j<96 ;j++){
          if ( j%16 == 0 ) pre++;
          fcalped[s][d][j] = ce->calped[e][d][j];
          fcalgood[s][d][j] = ce->calgood[e][d][j];
          fcalthr[s][d][pre] = ce->calthr[e][d][pre];
          fcalrms[s][d][j] = ce->calrms[e][d][j];
          fcalbase[s][d][pre] = ce->calbase[e][d][pre];
          fcalvar[s][d][pre] = ce->calvar[e][d][pre];
        };
      };
    } else {
      printf(" CALORIMETER - ERROR: problems finding a good calibration in this file! \n\n ");
      File->Close();
      return(-111);
    };
    File->Close();
    return(0);
  }
  void Digitizer::DigitizeCALOCALIB() {
    //
    // Header of the four sections
    //
    fSecCalo[0] = 0xAA00; // XE
    fSecCalo[1] = 0xB100; // XO
    fSecCalo[2] = 0xB600; // YE
    fSecCalo[3] = 0xAD00; // YO
    //
    // length of the data is 0x1215
    //
    fSecCALOLength[0] = 0x1215; // XE
    fSecCALOLength[1] = 0x1215; // XO
    fSecCALOLength[2] = 0x1215; // YE
    fSecCALOLength[3] = 0x1215; // YO
    //
    Int_t chksum = 0;
    UInt_t tstrip = 0;
    UInt_t fSecPointer = 0;
    //
    for (Int_t sec=0; sec < 4; sec++){
      //
      // sec =    0 -> XE      1 -> XO        2-> YE         3 -> YO
      //
      fCALOlength = 0;
      memset(fDataCALO,0,sizeof(UShort_t)*fCALObuffer);
      fSecPointer = fCALOlength;
      //
      // First of all we have section header and packet length
      //
      fDataCALO[fCALOlength] = fSecCalo[sec];
      fCALOlength++;
      fDataCALO[fCALOlength] = fSecCALOLength[sec];
      fCALOlength++;
      //
      // Section XO is read in the opposite direction respect to the others
      //
      chksum = 0;
      //
      for (Int_t plane=0; plane < 11; plane++){
        //
        if ( sec == 1 ) tstrip = fCALOlength + 96*2;
        //
        for (Int_t strip=0; strip < 96; strip++){
          //
          chksum += (Int_t)fcalped[sec][plane][strip];
          //
          // save value
          //
          if ( sec == 1 ){
            tstrip -= 2;
            fDataCALO[tstrip] = (Int_t)fcalped[sec][plane][strip];
            fDataCALO[tstrip+1] = (Int_t)fcalgood[sec][plane][strip];
          } else {
            fDataCALO[fCALOlength] = (Int_t)fcalped[sec][plane][strip];
            fDataCALO[fCALOlength+1] = (Int_t)fcalgood[sec][plane][strip];
          };
          fCALOlength +=2;
        };
        //
      };
      //
      fDataCALO[fCALOlength] = (UShort_t)chksum;
      fCALOlength++;
      fDataCALO[fCALOlength] = 0;
      fCALOlength++;
      fDataCALO[fCALOlength] = (UShort_t)((Int_t)(chksum >> 16));
      fCALOlength++;
      //
      // Section XO is read in the opposite direction respect to the others
      //
      chksum = 0;
      //
      for (Int_t plane=0; plane < 11; plane++){
        //
        if ( sec == 1 ) tstrip = fCALOlength+6*2;
        //
        for (Int_t strip=0; strip < 6; strip++){
          //
          chksum += (Int_t)fcalthr[sec][plane][strip];
          //
          // save value
          //
          if ( sec == 1 ){
            tstrip -= 2;
            fDataCALO[tstrip] = 0;
            fDataCALO[tstrip+1] = (Int_t)fcalthr[sec][plane][strip];
          } else {
            fDataCALO[fCALOlength] = 0;
            fDataCALO[fCALOlength+1] = (Int_t)fcalthr[sec][plane][strip];
          };
          fCALOlength +=2;
        };
        //
      };
      //
      fDataCALO[fCALOlength] = 0;
      fCALOlength++;
      fDataCALO[fCALOlength] = (UShort_t)chksum;
      fCALOlength++;
      fDataCALO[fCALOlength] = 0;
      fCALOlength++;
      fDataCALO[fCALOlength] = (UShort_t)((Int_t)(chksum >> 16));
      fCALOlength++;
      //
      // Section XO is read in the opposite direction respect to the others
      //
      for (Int_t plane=0; plane < 11; plane++){
        //
        if ( sec == 1 ) tstrip = fCALOlength+96*2;
        //
        for (Int_t strip=0; strip < 96; strip++){
          //
          // save value
          //
          if ( sec == 1 ){
            tstrip -= 2;
            fDataCALO[tstrip] = 0;
            fDataCALO[tstrip+1] = (Int_t)fcalrms[sec][plane][strip];
          } else {
            fDataCALO[fCALOlength] = 0;
            fDataCALO[fCALOlength+1] = (Int_t)fcalrms[sec][plane][strip];
          };
          fCALOlength += 2;
        };
        //
      };
      //
      // Section XO is read in the opposite direction respect to the others
      //
      for (Int_t plane=0; plane < 11; plane++){
        //
        if ( sec == 1 ) tstrip = fCALOlength+6*4;
        //
        for (Int_t strip=0; strip < 6; strip++){
          //
          // save value
          //
          if ( sec == 1 ){
            tstrip -= 4;
            fDataCALO[tstrip] = 0;
            fDataCALO[tstrip+1] = (Int_t)fcalbase[sec][plane][strip];
            fDataCALO[tstrip+2] = 0;
            fDataCALO[tstrip+3] = (Int_t)fcalvar[sec][plane][strip];
          } else {
            fDataCALO[fCALOlength] = 0;
            fDataCALO[fCALOlength+1] = (Int_t)fcalbase[sec][plane][strip];
            fDataCALO[fCALOlength+2] = 0;
            fDataCALO[fCALOlength+3] = (Int_t)fcalvar[sec][plane][strip];
          };
          fCALOlength +=4;
        };
        //
      };
      //
      //
      // here we calculate and save the CRC
      //
      fDataCALO[fCALOlength] = 0;
      fCALOlength++;
      Short_t CRC = 0;
      for (UInt_t i=0; i<(fCALOlength-fSecPointer); i++){
        CRC=crc(CRC,fDataCALO[i+fSecPointer]);
      };
      fDataCALO[fCALOlength] = (UShort_t)CRC;
      fCALOlength++;
      //
      UInt_t length=fCALOlength*2;
      DigitizePSCU(length,0x18);
      //
      // Add padding to 64 bits
      //
      AddPadding();
      //
      fOutputfile.write(reinterpret_cast<char*>(fDataPSCU),sizeof(UShort_t)*fPSCUbuffer);
      UShort_t temp[1000000];
      memset(temp,0,sizeof(UShort_t)*1000000);
      swab(fDataCALO,temp,sizeof(UShort_t)*fCALOlength);  // WE MUST SWAP THE BYTES!!!
      fOutputfile.write(reinterpret_cast<char*>(temp),sizeof(UShort_t)*fCALOlength);
      //
      // padding to 64 bytes
      //
      if ( fPadding ){
        fOutputfile.write(reinterpret_cast<char*>(fDataPadding),sizeof(UChar_t)*fPadding);
      };
      //
      //
    };
    //
  };
  void Digitizer::CaloLoadCalib() {
    //
    fGivenCaloCalib = 0; //                                  ####@@@@ should be given as input par @@@@####
    //
    // first of all load the MIP to ADC conversion values
    //
    stringstream calfile;
    Int_t error = 0;
    GL_PARAM *glparam = new GL_PARAM();
    //
    // determine where I can find calorimeter ADC to MIP conversion file
    //
    error = 0;
    error = glparam->Query_GL_PARAM(3,101,fDbc);
    //
    calfile.str("");
    calfile << glparam->PATH.Data() << "/";
    calfile << glparam->NAME.Data();
    //
    printf("\n Using Calorimeter ADC to MIP conversion file: \n %s \n",calfile.str().c_str());
    FILE *f;
    f = fopen(calfile.str().c_str(),"rb");
    //
    memset(fCalomip,0,4224*sizeof(fCalomip[0][0][0]));
    //
    for (Int_t m = 0; m < 2 ; m++ ){
      for (Int_t k = 0; k < 22; k++ ){
        for (Int_t l = 0; l < 96; l++ ){
          fread(&fCalomip[m][k][l],sizeof(fCalomip[m][k][l]),1,f);
        };
      };
    };
    fclose(f);
    //
    // determine which calibration has to be used and load it for each section
    //
    GL_CALO_CALIB *glcalo = new GL_CALO_CALIB();
    GL_ROOT *glroot = new GL_ROOT();
    TString fcalname;
    UInt_t idcalib;
    UInt_t calibno;
    UInt_t utime = 0;
    //
    for (UInt_t s=0; s<4; s++){
      //
      // clear calo calib variables for section s
      //
      ClearCaloCalib(s);
      //
      if ( fGivenCaloCalib ){
        //
        // a time has been given as input on the command line so retrieve the calibration that preceed that time
        //
        glcalo->Query_GL_CALO_CALIB(fGivenCaloCalib,utime,s,fDbc);
        //
        calibno = glcalo->EV_ROOT;
        idcalib = glcalo->ID_ROOT_L0;
        //
        // determine path and name and entry of the calibration file
        //
        printf("\n");
        printf(" ** SECTION %i **\n",s);
        //
        glroot->Query_GL_ROOT(idcalib,fDbc);
        //
        stringstream name;
        name.str("");
        name << glroot->PATH.Data() << "/";
        name << glroot->NAME.Data();
        //
        fcalname = (TString)name.str().c_str();
        //
        printf("\n Section %i : using  file %s calibration at entry %i: \n",s,fcalname.Data(),calibno);
        //
      } else {
        error = 0;
        error = glparam->Query_GL_PARAM(1,104,fDbc);
        //
        calfile.str("");
        calfile << glparam->PATH.Data() << "/";
        calfile << glparam->NAME.Data();
        //
        printf("\n Section %i : using default calorimeter calibration: \n %s \n",s,calfile.str().c_str());
        //
        fcalname = (TString)calfile.str().c_str();
        calibno = s;
        //
      };
      //
      // load calibration variables in memory
      //
      CaloLoadCalib(s,fcalname,calibno);
      //
    };
    //
    // at this point we have in memory the calorimeter calibration and we can save it to disk in the correct format and use it to digitize the data
    //
    delete glparam;
    delete glcalo;
    delete glroot;
  };
  void Digitizer::DigitizeCALO() {
    //
    fModCalo = 0; // 0 is RAW, 1 is COMPRESS, 2 is FULL     ####@@@@ should be given as input par @@@@####
    //
    //
    //
    fCALOlength = 0;  // reset total dimension of calo data
    //
    // gpamela variables to be used
    //
    fhBookTree->SetBranchStatus("Nthcali",1);
    fhBookTree->SetBranchStatus("Icaplane",1);
    fhBookTree->SetBranchStatus("Icastrip",1);
    fhBookTree->SetBranchStatus("Icamod",1);
    fhBookTree->SetBranchStatus("Enestrip",1);
    //
    // call different routines depending on the acq mode you want to simulate
    //
    switch ( fModCalo ){
    case 0:
      this->DigitizeCALORAW();
      break;
    case 1:
      this->DigitizeCALOCOMPRESS();
      break;
    case 2:
      this->DigitizeCALOFULL();
      break;
    };
    //
  };
  Float_t Digitizer::GetCALOen(Int_t sec, Int_t plane, Int_t strip){
    //
    // determine plane and strip
    //
    Int_t mplane = 0;
    //
    // wrong!
    //
    //  if ( sec == 0 || sec == 3 ) mplane = (plane * 4) + sec + 1;
    //  if ( sec == 1 ) mplane = (plane * 4) + 2 + 1;
    //  if ( sec == 2 ) mplane = (plane * 4) + 1 + 1;
    //
    if ( sec == 0 ) mplane = plane * 4 + 1; // it must be 0, 4, 8, ... (+1)  from plane = 0, 11
    if ( sec == 1 ) mplane = plane * 4 + 2 + 1; // it must be 2, 6, 10, ... (+1)  from plane = 0, 11
    if ( sec == 2 ) mplane = plane * 4 + 3 + 1; // it must be 3, 7, 11, ... (+1)  from plane = 0, 11
    if ( sec == 3 ) mplane = plane * 4 + 1 + 1; // it must be 1, 5, 9, ... (+1)  from plane = 0, 11
    //
    Int_t mstrip = strip + 1;
    //
    // search energy release in gpamela output
    //
    for (Int_t i=0; i<Nthcali;i++){
      if ( Icaplane[i] == mplane && Icastrip[i] == mstrip ){
        return (Enestrip[i]);
      };
    };
    //
    // if not found it means no energy release so return 0.
    //
    return(0.);
  };
  void Digitizer::DigitizeCALORAW() {
    //
    // some variables
    //
    Float_t ens = 0.;
    UInt_t adcsig = 0;
    UInt_t adcbase = 0;
    UInt_t adc = 0;
    Int_t pre = 0;
    UInt_t l = 0;
    UInt_t lpl = 0;
    UInt_t tstrip = 0;
    UInt_t fSecPointer = 0;
    Double_t pedenoise;
    Float_t rms = 0.;
    Float_t pedestal = 0.;
    //
    // clean the data structure
    //
    memset(fDataCALO,0,sizeof(UShort_t)*fCALObuffer);
    //
    // Header of the four sections
    //
    fSecCalo[0] = 0xEA08; // XE
    fSecCalo[1] = 0xF108; // XO
    fSecCalo[2] = 0xF608; // YE
    fSecCalo[3] = 0xED08; // YO
    //
    // length of the data is 0x0428 in RAW mode
    //
    fSecCALOLength[0] = 0x0428; // XE
    fSecCALOLength[1] = 0x0428; // XO
    fSecCALOLength[2] = 0x0428; // YE
    fSecCALOLength[3] = 0x0428; // YO
    //
    // let's start
    //
    fCALOlength = 0;
    //
    for (Int_t sec=0; sec < 4; sec++){
      //
      // sec =    0 -> XE      1 -> XO        2-> YE         3 -> YO
      //
      l = 0;                 // XE and XO are Y planes
      if ( sec < 2 ) l = 1;  // while YE and  YO are X planes
      //
      fSecPointer = fCALOlength;
      //
      // First of all we have section header and packet length
      //
      fDataCALO[fCALOlength] = fSecCalo[sec];
      fCALOlength++;
      fDataCALO[fCALOlength] = fSecCALOLength[sec];
      fCALOlength++;
      //
      // selftrigger coincidences - in the future we should add here some code to simulate timing response of pre-amplifiers
      //
      for (Int_t autoplane=0; autoplane < 7; autoplane++){
        fDataCALO[fCALOlength] = 0x0000;
        fCALOlength++;
      };
      //
      //
      // here comes data
      //
      //
      // Section XO is read in the opposite direction respect to the others
      //
      if ( sec == 1 ){
        tstrip = 96*11 + fCALOlength;
      } else {
        tstrip = 0;
      };
      //
      pre = -1;
      //
      for (Int_t strip=0; strip < 96; strip++){
        //
        // which is the pre for this strip?
        //
        if (strip%16 == 0) {
          pre++;
        };
        //
        if ( sec == 1 ) tstrip -= 11;
        //
        for (Int_t plane=0; plane < 11; plane++){
          //
          // here is wrong!!!!
          //
          //
          //      if ( plane%2 == 0 && sec%2 != 0){
          //        lpl = plane*2;
          //      } else {
          //        lpl = (plane*2) + 1;
          //      };
          //
          if ( sec == 0 || sec == 3 ) lpl = plane * 2;
          if ( sec == 1 || sec == 2 ) lpl = (plane * 2) + 1;
          //
          // get the energy in GeV from the simulation for that strip
          //
          ens = this->GetCALOen(sec,plane,strip);
          //
          // convert it into ADC channels
          //
          adcsig = int(ens*fCalomip[l][lpl][strip]/fCALOGeV2MIPratio);
          //
          // sum baselines
          //
          adcbase = (UInt_t)fcalbase[sec][plane][pre];
          //
          // add noise and pedestals
          //
          pedestal = fcalped[sec][plane][strip];
          rms = fcalrms[sec][plane][strip]/4.;
          //
          // Add random gaussian noise of RMS rms and Centered in the pedestal
          //
          pedenoise = gRandom->Gaus((Double_t)pedestal,(Double_t)rms);
          //
          // Sum all contribution
          //
          adc = adcsig + adcbase + (Int_t)round(pedenoise);
          //
          // Signal saturation
          //
          if ( adc > 0x7FFF ) adc = 0x7FFF;
          //
          // save value
          //
          if ( sec == 1 ){
            fDataCALO[tstrip] = adc;
            tstrip++;
          } else {
            fDataCALO[fCALOlength] = adc;
          };
          fCALOlength++;
          //
        };
        //
        if ( sec == 1 ) tstrip -= 11;
        //
      };
      //
      // here we calculate and save the CRC
      //
      Short_t CRC = 0;
      for (UInt_t i=0; i<(fCALOlength-fSecPointer); i++){
        CRC=crc(CRC,fDataCALO[i+fSecPointer]);
      };
      fDataCALO[fCALOlength] = (UShort_t)CRC;
      fCALOlength++;
      //
    };
    //
    //   for (Int_t i=0; i<fCALOlength; i++){
    //     printf(" WORD %i       DIGIT %0x   \n",i,fDataCALO[i]);
    //   };
    //
  };
  void Digitizer::DigitizeCALOCOMPRESS() {
    //
    printf(" COMPRESS MODE STILL NOT IMPLEMENTED! \n");
    //
    this->DigitizeCALORAW();
    return;
    //
    //
    //
    fSecCalo[0] = 0xEA00;
    fSecCalo[1] = 0xF100;
    fSecCalo[2] = 0xF600;
    fSecCalo[3] = 0xED00;
    //
    // length of the data in DSP mode must be calculated on fly during digitization
    //
    memset(fSecCALOLength,0x0,4*sizeof(UShort_t));
    //
    // here comes raw data
    //
    Int_t en = 0;
    //
    for (Int_t sec=0; sec < 4; sec++){
      fDataCALO[en] = fSecCalo[sec];
      en++;
      fDataCALO[en] = fSecCALOLength[sec];
      en++;
      for (Int_t plane=0; plane < 11; plane++){
        for (Int_t strip=0; strip < 11; strip++){
          fDataCALO[en] = 0x0;
          en++;
        };
      };
    };
    //
  };
  void Digitizer::DigitizeCALOFULL() {
    //
    printf(" FULL MODE STILL NOT IMPLEMENTED! \n");
    //
    this->DigitizeCALORAW();
    return;
    //
    fSecCalo[0] = 0xEA00;
    fSecCalo[1] = 0xF100;
    fSecCalo[2] = 0xF600;
    fSecCalo[3] = 0xED00;
    //
    // length of the data in DSP mode must be calculated on fly during digitization
    //
    memset(fSecCALOLength,0x0,4*sizeof(UShort_t));
    //
    // here comes raw data
    //
    Int_t  en = 0;
    //
    for (Int_t sec=0; sec < 4; sec++){
      fDataCALO[en] = fSecCalo[sec];
      en++;
      fDataCALO[en] = fSecCALOLength[sec];
      en++;
      for (Int_t plane=0; plane < 11; plane++){
        for (Int_t strip=0; strip < 11; strip++){
          fDataCALO[en] = 0x0;
          en++;
        };
      };
    };
    //
  };
  void Digitizer::DigitizeTRIGGER() {
    //fDataTrigger: 153 bytes
    for (Int_t j=0; j < 153; j++)
-     fDataTrigger[0]=0x00;
+     fDataTrigger[j]=0x00;
  };
  Int_t Digitizer::DigitizeTOF() {
    //fDataTof: 12 x 23 bytes (=276 bytes)
    UChar_t *pTof=fDataTof;
+   Bool_t DEBUG=false;
-   // --- activate branches:
-   fhBookTree->SetBranchStatus("Nthtof",1);
+   // --- activate branches:
-   fhBookTree->SetBranchStatus("Ipltof",1);
+   fhBookTree->SetBranchStatus("Nthtof",1);
-   fhBookTree->SetBranchStatus("Ipaddle",1);
+   fhBookTree->SetBranchStatus("Ipltof",1);
-   fhBookTree->SetBranchStatus("Xintof",1);
+   fhBookTree->SetBranchStatus("Ipaddle",1);
-   fhBookTree->SetBranchStatus("Yintof",1);
+   fhBookTree->SetBranchStatus("Xintof",1);
-   fhBookTree->SetBranchStatus("Xouttof",1);
+   fhBookTree->SetBranchStatus("Yintof",1);
-   fhBookTree->SetBranchStatus("Youttof",1);
+   fhBookTree->SetBranchStatus("Xouttof",1);
-   fhBookTree->SetBranchStatus("Ereltof",1);
+   fhBookTree->SetBranchStatus("Youttof",1);
-   fhBookTree->SetBranchStatus("Timetof",1);
+   fhBookTree->SetBranchStatus("Ereltof",1);
-   // not yet used: Zintof, Xouttof, Youttof, Zouttof
+   fhBookTree->SetBranchStatus("Timetof",1);
+   // not yet used: Zintof, Xouttof, Youttof, Zouttof
-   // ------ evaluate energy in each pmt: ------
-   // strip geometry (lenght/width)
+   // ------ evaluate energy in each pmt: ------
-   Float_t dimel[6] = {33.0, 40.8 ,18.0, 15.0, 15.0, 18.0};
+   // strip geometry (lenght/width)
-   //Float_t dimes[6] = {5.1, 5.5, 7.5, 9.0, 6.0, 5.0};
+   Float_t dimel[6] = {33.0, 40.8 ,18.0, 15.0, 15.0, 18.0};
+   //Float_t dimes[6] = {5.1, 5.5, 7.5, 9.0, 6.0, 5.0};
-   //  S11 8 paddles  33.0 x 5.1 cm
-   //  S12 6 paddles  40.8 x 5.5 cm
+   //  S11 8 paddles  33.0 x 5.1 cm
-   //  S21 2 paddles  18.0 x 7.5 cm
+   //  S12 6 paddles  40.8 x 5.5 cm
-   //  S22 2 paddles  15.0 x 9.0 cm
+   //  S21 2 paddles  18.0 x 7.5 cm
-   //  S31 3 paddles  15.0 x 6.0 cm
+   //  S22 2 paddles  15.0 x 9.0 cm
-   //  S32 3 paddles  18.0 x 5.0 cm
+   //  S31 3 paddles  15.0 x 6.0 cm
+   //  S32 3 paddles  18.0 x 5.0 cm
-   // distance from the interaction point to the pmts (right,left)
-   Float_t xpath[2]={0., 0.}; /*path(cm) in X per S12,S21,S32 verso il pmt DX o SX*/
+   Float_t FGeo[2]={0., 0.}; /* geometrical factor */
-   Float_t ypath[2]={0., 0.}; /*path(cm) in Y per S11,S22,S31 verso il pmt DX o SX*/
-   Float_t FGeo[2]={0., 0.}; /* fattore geometrico */
+   const Float_t Pho_keV = 10.;     // photons per keV in scintillator
+   const Float_t echarge = 1.6e-19; // electron charge
-   const Float_t Pho_keV = 10.;     // photons per keV in scintillator
+   Float_t Npho=0.;
-   const Float_t echarge = 1.6e-19; // carica dell'elettrone
+   Float_t QevePmt_pC[48];
-   Float_t Npho=0.;
+   Float_t QhitPad_pC[2]={0., 0.};
-   Float_t QevePmt_pC[48];
+   Float_t QhitPmt_pC[2]={0., 0.};
-   Float_t QhitPad_pC[2]={0., 0.};
+   Float_t pmGain = 3.5e6;  /* PMT Gain: the same for all PMTs */
-   Float_t QhitPmt_pC[2]={0., 0.};
+   Float_t effi=0.21;       /* Efficienza di fotocatodo */
-   Float_t pmGain = 3.5e6;  /* Gain: per il momento uguale per tutti */
-   Float_t effi=0.21;       /* Efficienza di fotocatodo */
+   //   Float_t ADC_pC0=-58.1;      //  ADC/pC conversion coefficient 0
-   Float_t ADC_pC=1.666667; // ADC_ch/pC conversion = 0.6 pC/channel (+30 di offset)
+   //   Float_t ADC_pC1=1.728;      //  ADC/pC conversion coefficient 1
-   Float_t ADCoffset=30.;
+   //   Float_t ADC_pC2=-4.063e-05; //  ADC/pC conversion coefficient 2
-   Int_t ADClast=4095;      // no signal --> ADC ch=4095
+   //   Float_t ADC_pC3=-5.763e-08; //  ADC/pC conversion coefficient 3
-   Int_t ADCtof[48];
-   //Float_t ADCsat=3100;  ci pensiamo in futuro !
+   // pC < 800
-   //Float_t pCsat=2500;
+   Float_t ADC_pC0A =   -4.437616e+01   ;
-   for(Int_t i=0; i<48; i++){
+   Float_t ADC_pC1A =   1.573329e+00    ;
-     QevePmt_pC[i] = 0;
+   Float_t ADC_pC2A =   2.780518e-04  ;
-     ADCtof[i]=0;
+   Float_t ADC_pC3A =  -2.302160e-07 ;
-   }
+   // pC   > 800:
-   // ------ read calibration file (get A1, A2, lambda1, lambda2)
+   Float_t ADC_pC0B =    -2.245756e+02  ;
-   ifstream fileTriggerCalib;
+   Float_t ADC_pC1B =     2.184156e+00  ;
-   TString ftrigname="TrigCalibParam.txt";
+   Float_t ADC_pC2B =     -4.171825e-04  ;
-   fileTriggerCalib.open(ftrigname.Data());
+   Float_t ADC_pC3B =     3.789715e-08  ;
-   if ( !fileTriggerCalib ) {
-     printf("debug: no trigger calib file!\n");
+   Float_t pCthres=40.;     // threshold in charge
-     return(-117); //check output!
+   Int_t ADClast=4095;      // no signal --> ADC ch=4095
-   };
+   Int_t ADCsat=3100;       // saturation value for the ADCs
-   Float_t atte1[48],atte2[48],lambda1[48],lambda2[48];
+   Int_t ADCtof[48];
-   Int_t temp=0;
-   for(Int_t i=0; i<48; i++){
-     fileTriggerCalib >> temp;
+   // ---- introduce scale factors to tune simul ADC to real data   24-oct DC
-     fileTriggerCalib >> atte1[i];
+   //   Float_t ScaleFact[48]={0.18,0.22,0.35,0.26,0.47,0.35,0.31,0.37,
-     fileTriggerCalib >> atte2[i];
+   //                     0.44,0.23,0.38,0.60,0.39,0.29,0.40,0.23,
-     fileTriggerCalib >> lambda1[i];
+   //                     0.30,0.66,0.22,1.53,0.17,0.55,
-     fileTriggerCalib >> lambda2[i];
+   //                     0.84,0.19,0.21,1.64,0.62,0.13,
-     fileTriggerCalib >> temp;
+   //                     0.18,0.15,0.10,0.14,0.14,0.14,0.14,0.12,
-   }
+   //                     0.26,0.18,0.25,0.23,0.20,0.40,0.19,0.23,0.25,0.23,0.25,0.20};
-   fileTriggerCalib.close();
+   // new scale factors: WM 30-Oct-07
-   //  Read from file the 48*4 values of the attenuation fit function
+   //   Float_t ScaleFact[48]={0.35,0.41,0.32,0.34,0.58,0.47,0.42,0.44,
-   //  NB: lambda<0; x,y defined in gpamela (=0 in the centre of the cavity)
+   //                     0.50,0.34,0.50,0.50,0.51,0.42,0.46,0.25,
-   //    Qhitpmt_pC =  atte1 * exp(x/lambda1) + atte2 * exp(x/lambda2)
+   //                     0.20,0.38,0.29,0.49,0.24,0.68,
+   //                     0.30,0.26,0.28,0.79,0.31,0.12,
-   //    fine lettura dal file */
+   //                     0.25,0.21,0.14,0.20,
+   //                     0.16,0.17,0.19,0.18,
-   //const Int_t nmax=??; = Nthtof
+   //                     0.34,0.27,0.34,0.31,0.25,0.57,
-   Int_t ip, ipad;
+   //                     0.24,0.34,0.34,0.32,0.31,0.30};
-   //Int_t ipmt;
-   Int_t pmtleft=0, pmtright=0;
+   Float_t ScaleFact[48]={0.39, 0.49, 0.38, 0.40, 0.65, 0.51, 0.43,
-   Int_t *pl, *pr;
+.49, 0.58, 0.38, 0.53, 0.57, 0.53, 0.45, 0.49, 0.16,
-   pl = &pmtleft;
+.15, 0.44, 0.28, 0.57, 0.26, 0.72, 0.37, 0.29, 0.30, 0.89,
-   pr = &pmtright;
+.37, 0.08,  0.27, 0.23, 0.12, 0.22, 0.15, 0.16, 0.21,
+.19, 0.41, 0.32, 0.39, 0.38, 0.28, 0.66, 0.28, 0.40, 0.39, 0.40, 0.37, 0.35 };
-   // TDC variables:
-   Int_t TDClast=4095;      // no signal --> ADC ch=4095
+   for(Int_t i=0; i<48; i++){
-   Int_t TDCint[48];
+     QevePmt_pC[i] = 0;
-   Float_t  tdc[48],tdc1[48],tdcpmt[48];
+     ADCtof[i]=0;
-   for(Int_t i=0; i<48; i++)
+   }
-     tdcpmt[i] = 1000.;
-   Float_t thresh=1.; // to be defined better... (Wolfgang)
+   // ------ read calibration file (get A1, A2, lambda1, lambda2)
+   ifstream fileTriggerCalib;
-     // === TDC: simulate timing for each paddle
+   TString ftrigname="TrigCalibParam.txt";
-     Float_t dt1 = 285.e-12 ;   // single PMT resolution
+   fileTriggerCalib.open(ftrigname.Data());
-     Float_t tdcres[50],c1_S[50],c2_S[50],c3_S[50];
+   if ( !fileTriggerCalib ) {
-     for(Int_t j=0;j<48;j++)  tdcres[j] = 50.E-12;   // TDC resolution 50 picosec
+     printf("debug: no trigger calib file!\n");
-     for(Int_t j=0;j<48;j++)  c1_S[j] = 500.;  // cable length in channels
+     return(-117); //check output!
-     for(Int_t j=0;j<48;j++)  c2_S[j] = 0.;
+   };
-     for(Int_t j=0;j<48;j++)  c3_S[j] = 1000.;
+   Float_t atte1[48],atte2[48],lambda1[48],lambda2[48];
-     for(Int_t j=0;j<48;j++)  c1_S[j] = c1_S[j]*tdcres[j];   // cable length in sec
+   Int_t temp=0;
-     for(Int_t j=0;j<48;j++)  c2_S[j] = c2_S[j]*tdcres[j];
+   // correct readout WM Oct '07
-      // ih = 0 + i1;  // not used?? (Silvio)
+   for(Int_t i=0; i<48; i++){
+     fileTriggerCalib >> temp;
-   /* **********************************  inizio loop sugli hit */
+     fileTriggerCalib >> atte1[i];
+     fileTriggerCalib >> lambda1[i];
-   for(Int_t nh=0; nh<Nthtof; nh++){
+     fileTriggerCalib >> atte2[i];
+     fileTriggerCalib >> lambda2[i];
-     for(Int_t j=0; j<2; j++) { // already done!! remove???
+     fileTriggerCalib >> temp;
-       xpath[j]=0.;
+   }
-       ypath[j]=0.;
+   fileTriggerCalib.close();
-       FGeo[j]=0.;
-     }
+   Int_t ip, ipad;
+   //Int_t ipmt;
-     Float_t s_l_g[6] = {8.0, 8.0, 20.9, 22.0, 9.8, 8.3 };  // length of the lightguide
+   Int_t pmtleft=0, pmtright=0;
-     Float_t t1,t2,veff,veff1,veff0 ;
+   Int_t *pl, *pr;
-     veff0 = 100.*1.0e8 ; // light velocity in the scintillator in m/sec
+   pl = &pmtleft;
-     veff1 = 100.*1.5e8; // light velocity in the lightguide in m/sec
+   pr = &pmtright;
-     veff=veff0;         // signal velocity in the paddle
+   // TDC variables:
-     t1 = Timetof[nh] ;  // Start
+   Int_t TDClast=4095;      // no signal --> TDC ch=4095
-     t2 = Timetof[nh] ;
+   Int_t TDCint[48];
+   Float_t  tdc[48],tdc1[48],tdcpmt[48];
-     // Donatella
+   for(Int_t i=0; i<48; i++) {
-     // ridefiniz. piano e pad per i vettori in C
+     tdcpmt[i] = 1000.;
-     ip = Ipltof[nh]-1;
+     tdc[i]  = 0.;            // 18-oct WM
-     ipad = Ipaddle[nh]-1;
+     tdc1[i] = 0.;            // 18-oct WM
-     pmtleft=0;
+   }
-     pmtright=0;
+   Float_t thresh=10.; // to be defined better... (Wolfgang)
-     //Paddle2Pmt((Int_t)ip, (Int_t) ipad, (Int_t*) &pmtleft, (Int_t*) &pmtright);
-     Paddle2Pmt(ip, ipad, &pmtleft, &pmtright);
+   // === TDC: simulate timing for each paddle
-     //Paddle2Pmt(ip, ipad, pl, pr);
+   //Float_t dt1 = 285.e-12 ;   // single PMT resolution
+   Float_t dt1 = 425.e-12 ;   // single PMT resolution (WM, Nov'07)
-     // per avere anche la corrispondenza pmt --> half board e canale
+   Float_t tdcres[50],c1_S[50],c2_S[50],c3_S[50];
-     // metodo GetPMTIndex(Int_t ipmt, Int_t &hb, Int_t &ch) // non lo usiamo x ora
+   for(Int_t j=0;j<48;j++)  tdcres[j] = 50.E-12;   // TDC resolution 50 picosec
+   for(Int_t j=0;j<48;j++)  c1_S[j] = 500.;  // cable length in channels
-     /*calcola la pos media e il path all'interno della paddle */
+   for(Int_t j=0;j<48;j++)  c2_S[j] = 0.;
+   for(Int_t j=0;j<48;j++)  c3_S[j] = 1000.;
-     Float_t tpos=0.;
+   for(Int_t j=0;j<48;j++)  c1_S[j] = c1_S[j]*tdcres[j];   // cable length in sec
-     Float_t path[2] = {0., 0.};
+   for(Int_t j=0;j<48;j++)  c2_S[j] = c2_S[j]*tdcres[j];
-     //--- Strip in Y = S11,S22,S31 ------
+   // ih = 0 + i1;  // not used?? (Silvio)
-     if(ip==0 || ip==3 || ip==4)
-       tpos = (Yintof[nh]+Youttof[nh])/2.;
+   /* **********************************  start loop over hits */
-     else
-       if(ip==1 || ip==2 || ip==5)   //--- Strip in X per S12,S21,S32
+   for(Int_t nh=0; nh<Nthtof; nh++){
-         tpos = (Xintof[nh]+Xouttof[nh])/2.;
-       else if (ip!=6)
+     Float_t s_l_g[6] = {8.0, 8.0, 20.9, 22.0, 9.8, 8.3 };  // length of the lightguide
-         printf("*** Warning: this option should never occur! (ip=%2i, nh=%2i)\n",ip,nh);
+     Float_t t1,t2,veff,veff1,veff0 ;
-     path[0]= tpos + dimel[ip]/2.;
+     veff0 = 100.*1.0e8 ; // light velocity in the scintillator in m/sec
-     path[1]= dimel[ip]/2.- tpos;
+     veff1 = 100.*1.5e8; // light velocity in the lightguide in m/sec
+     veff=veff0;         // signal velocity in the paddle
-     //  cout <<"Strip N. ="<< ipaddle <<" piano n.= "<< iplane <<" POSIZ = "<< tpos <<"\n";
+     t1 = Timetof[nh] ;  // Start
-     /* per il momento metto un fattore geometrico costante*/
+     t2 = Timetof[nh] ;
-     FGeo[0] =0.5;
-     FGeo[1] =0.5;
+     // Donatella: redefinition plane and pad for vectors in C
-     //  FGeo[1] = atan(path[1]/dimes[ip])/6.28318; // frazione fotoni verso SX
+     ip = Ipltof[nh]-1;
-     //  FGeo[2] = atan(path[2]/dimes[ip])/6.28318; // e verso DX
+     ipad = Ipaddle[nh]-1;
+     pmtleft=0;
-     /*  rimando la fluttuazione poissoniana sui fotoni prodotti
+     pmtright=0;
-         sto studiando come funziona la funzione:
-         long int i = sto.Poisson(double x);  */
+     // WM: S12 paddles are "reversed" (Nov'07)
-     //  Npho = Poisson(ERELTOF[nh])*Pho_keV*1e6   Eloss in GeV ?
+     if (ip==2)
-     Npho = Ereltof[nh]*Pho_keV*10.0e6;  // Eloss in GeV ?
+       if (ipad==0)
+         ipad=1;
-     Float_t knorm[2]={0., 0.}; // Donatella
+       else
-     Float_t Atten[2]={0., 0.}; // Donatella
+         ipad=0;
-     for(Int_t j=0; j<2; j++){
-       QhitPad_pC[j]= Npho*FGeo[j]*effi*pmGain*echarge;
+    if (ip<6) {
-       knorm[j]=QhitPad_pC[j]/(atte1[pmtleft+j]*exp((dimel[ip]/2.*pow(-1,j+1))/lambda1[pmtleft+j]) +
+       Paddle2Pmt(ip, ipad, &pmtleft, &pmtright);
-                               atte2[pmtleft+j]*exp((dimel[ip]/2.*pow(-1,j+1))/lambda2[pmtleft+j]));
+       // DC: evaluates mean position and path inside the paddle
-       Atten[j]=knorm[j]*(atte1[pmtleft+j]*exp(tpos/lambda1[pmtleft+j]) +
-                          atte2[pmtleft+j]*exp(tpos/lambda2[pmtleft+j]));
+       Float_t tpos=0.;
+       Float_t path[2] = {0., 0.};
-       QhitPmt_pC[j]= QhitPad_pC[j]*Atten[j];
+       //--- Strip in Y = S11,S22,S31 ------
-     }
+       if(ip==0 || ip==3 || ip==4)
+         tpos = (Yintof[nh]+Youttof[nh])/2.;
-     QevePmt_pC[pmtleft]  += QhitPmt_pC[0];
+       else
-     QevePmt_pC[pmtright] += QhitPmt_pC[1];
+         if(ip==1 || ip==2 || ip==5)   //--- Strip in X for S12,S21,S32
+           tpos = (Xintof[nh]+Xouttof[nh])/2.;
-     // TDC
+         else //if (ip!=6)
-     t2 = t2 + fabs(path[0]/veff) + s_l_g[ip]/veff1 ;  // Signal reaches PMT
+           printf("*** WARNING TOF: this option should never occur! (ip=%2i, nh=%2i)\n",ip,nh);
-     t1 = t1 + fabs(path[1]/veff) + s_l_g[ip]/veff1;
+       path[0]= tpos + dimel[ip]/2.;   // path to left PMT
-     TRandom r;
+       path[1]= dimel[ip]/2.- tpos;    // path to right PMT
-     t1 = r.Gaus(t1,dt1);  //apply gaussian error  dt
-     t2 = r.Gaus(t2,dt1);  //apply gaussian error  dt
+       //  cout <<"Strip N. ="<< ipaddle <<" piano n.= "<< iplane <<" POSIZ = "<< tpos <<"\n";
-     t1 = t1 + c1_S[pmtleft] ;  // Signal reaches Discriminator ,TDC starts  to run
+       if (DEBUG) {
-     t2 = t2 + c1_S[pmtright] ;
+         cout <<" plane "<<ip<<" strip # ="<< ipad <<" tpos  "<< tpos <<"\n";
+         cout <<"pmtleft, pmtright "<<pmtleft<<" "<<pmtright<<endl;
-     // check if signal is above threshold
+       }
-     // then check if tdcpmt is already filled by another hit...
-     // only re-fill if time is smaller
+       // constant geometric factor, the rest is handled by the scaling factor
+       FGeo[0] =0.5;
-     if (QhitPmt_pC[0] > thresh)
+       FGeo[1] =0.5;
-       if (tdcpmt[pmtleft] < 1000.) // is already filled!
+       //  FGeo[1] = atan(path[1]/dimes[ip])/6.28318; // fraction of photons toward left
-         if (t1 <  tdcpmt[pmtleft]) {
+       //  FGeo[2] = atan(path[2]/dimes[ip])/6.28318; // toward right
-           tdcpmt[pmtleft] = t1;
-           t1 = t1 + c2_S[pmtleft] ;  // Signal reaches Coincidence
-           tdc[pmtleft] = t1;
+       //  Npho = Poisson(ERELTOF[nh])*Pho_keV*1e6  Poissonian fluctuations to be inserted-DC
-         }
+       Npho = Ereltof[nh]*Pho_keV*1.0e6;  // Eloss in GeV
-     if (QhitPmt_pC[1] > thresh)
+       Float_t knorm[2]={0., 0.}; // Donatella
-         if (tdcpmt[pmtright] < 1000.)  // is already filled!
+       Float_t Atten[2]={0., 0.}; // Donatella
-           if (t2 <  tdcpmt[pmtright]) {
+       for(Int_t j=0; j<2; j++){
-             tdcpmt[pmtright] = t2;
+         QhitPad_pC[j]= Npho*FGeo[j]*effi*pmGain*echarge*1.E12*ScaleFact[pmtleft+j];
-             t2 = t2 + c2_S[pmtright] ;
+         // WM
-             tdc[pmtright] = t2;
+         knorm[j]=atte1[pmtleft+j]*exp(lambda1[pmtleft+j]*dimel[ip]/2.*pow(-1,j+1)) +
-           }
+           atte2[pmtleft+j]*exp(lambda2[pmtleft+j]*dimel[ip]/2.*pow(-1,j+1));
+         Atten[j]=atte1[pmtleft+j]*exp(tpos*lambda1[pmtleft+j]) +
-   } // ****************************************       end loop over hits
+           atte2[pmtleft+j]*exp(tpos*lambda2[pmtleft+j]) ;
+         QhitPmt_pC[j]= QhitPad_pC[j]*Atten[j]/knorm[j];
-   // ======  ADC ======
+         //              QhitPmt_pC[j]= QhitPad_pC[j]; //no attenuation
-   for(Int_t i=0; i<48; i++){
-     if(QevePmt_pC[i] != 0.){
-       ADCtof[i]= (Int_t)(ADC_pC*QevePmt_pC[i] + ADCoffset);
+         if (DEBUG) {
-       if(ADCtof[i]> ADClast) ADCtof[i]=ADClast;
+           cout<<"pmtleft "<<pmtleft<<" j "<<j<<endl;
-     } else
+           cout<<" atte1 "<<atte1[pmtleft+j]<<"lambda1 "<<lambda1[pmtleft+j]<<" atte2 "<<atte2[pmtleft+j]<<"lambda2 "<<lambda2[pmtleft+j] <<endl;
-       ADCtof[i]= ADClast;
+           cout<<j<<" tpos "<<tpos<<" knorm "<<knorm[j]<<" "<<Atten[j]<<" "<<"QhitPmt_pC "<<QhitPmt_pC[j]<<endl;
-   };
+         }
+       }
-   // ======  build  TDC coincidence  ======
+       if (DEBUG)
+         cout<<"Npho "<<Npho<<" QhitPmt_pC "<<QhitPmt_pC[0]<<" "<<QhitPmt_pC[1]<<endl;
-   Float_t t_coinc = 0;
-   Int_t ilast = 100;
+       QevePmt_pC[pmtleft]  += QhitPmt_pC[0];
-   for (Int_t ii=0; ii<48;ii++)
+       QevePmt_pC[pmtright] += QhitPmt_pC[1];
-     if (tdc[ii] > t_coinc) {
-       t_coinc = tdc[ii];
+       // TDC
-       ilast = ii;
+       // WM right and left <->
-     }
+       //      t2 = t2 + fabs(path[0]/veff) + s_l_g[ip]/veff1 ;  // Signal reaches PMT
+       //      t1 = t1 + fabs(path[1]/veff) + s_l_g[ip]/veff1;
-   //     cout<<ilast<<" "<<t_coinc<<endl;
-   //     At t_coinc  trigger condition is fulfilled
+       t1 = t1 + fabs(path[0]/veff) + s_l_g[ip]/veff1;
+       t2 = t2 + fabs(path[1]/veff) + s_l_g[ip]/veff1 ;  // Signal reaches PMT
-   for (Int_t ii=0; ii<48;ii++){
-     //      if (tdc[ii] != 0) tdc1[ii] = t_coinc - tdc[ii];   // test 1
+       t1 = gRandom->Gaus(t1,dt1); //apply gaussian error  dt
-     if (tdc[ii] != 0) tdc1[ii] = t_coinc - tdcpmt[ii];  // test 2
+       t2 = gRandom->Gaus(t2,dt1); //apply gaussian error  dt
-     tdc1[ii] = tdc1[ii]/tdcres[ii];                     // divide by TDC resolution
-     if (tdc[ii] != 0) tdc1[ii] = tdc1[ii] + c3_S[ii];  // add cable length c3
+       t1 = t1 + c1_S[pmtleft] ;  // Signal reaches Discriminator ,TDC starts  to run
+       t2 = t2 + c1_S[pmtright] ;
-   } // missing parenthesis inserted! (Silvio)
+       // check if signal is above threshold
-   for(Int_t i=0; i<48; i++){
+       // then check if tdcpmt is already filled by another hit...
-     if(tdc1[i] != 0.){
+       // only re-fill if time is smaller
-       TDCint[i]=(Int_t)tdc1[i];
-       //ADC[i]= ADC_pC * QevePmt_pC[i] + ADCoffset;
+       if (QhitPmt_pC[0] > thresh) {
-       //if(ADC[i]> ADClast) ADC[i]=ADClast;
+         if (tdcpmt[pmtleft] == 1000.) {  // fill for the first time
-     } else
+           tdcpmt[pmtleft] = t1;
-       TDCint[i]= TDClast;
+           tdc[pmtleft] = t1 + c2_S[pmtleft] ;  // Signal reaches Coincidence
-   }
+         }
+         if (tdcpmt[pmtleft] < 1000.) // is already filled!
- // ======  write fDataTof  =======
+           if (t1 <  tdcpmt[pmtleft]) {
-   UChar_t tofBin;
+             tdcpmt[pmtleft] = t1;
-   for (Int_t j=0; j < 12; j++){
+             t1 = t1 + c2_S[pmtleft] ;  // Signal reaches Coincidence
-     Int_t j12=j*12;
+             tdc[pmtleft] = t1;
-     fDataTof[j12+0]=0x00;   // TDC_ID
+           }
-     fDataTof[j12+1]=0x00;   // EV_COUNT
+       }
-     fDataTof[j12+2]=0x00;   // TDC_MASK (1)
+       if (QhitPmt_pC[1] > thresh) {
-     fDataTof[j12+3]=0x00;   // TDC_MASK (2)
+         if (tdcpmt[pmtright] == 1000.) {  // fill for the first time
-     for (Int_t k=0; k < 4; k++){
+           tdcpmt[pmtright] = t2;
-       Int_t jk12=j12+k;
+           tdc[pmtright] = t2 + c2_S[pmtright] ;  // Signal reaches Coincidence
-       tofBin=(UChar_t)(ADCtof[k+4*j]/256);   // ADC# (msb) (#=1+k+4*j)
+         }
-       fDataTof[jk12+4] = Bin2GrayTof(tofBin,fDataTof[jk12+4]);
+         if (tdcpmt[pmtright] < 1000.)  // is already filled!
-       tofBin=(UChar_t)(ADCtof[k+4*j]%256);   // ADC# (lsb)
+           if (t2 <  tdcpmt[pmtright]) {
-       fDataTof[jk12+5] = Bin2GrayTof(tofBin,fDataTof[jk12+5]);
+             tdcpmt[pmtright] = t2;
-       tofBin=(UChar_t)(TDCint[k+4*j]/256);   // TDC# (msb)
+             t2 = t2 + c2_S[pmtright] ;
-       fDataTof[jk12+6]=Bin2GrayTof(tofBin,fDataTof[jk12+6]);
+             tdc[pmtright] = t2;
-       tofBin=(UChar_t)(TDCint[k+4*j]%256);   // TDC# (lsb)
+           }
-       fDataTof[jk12+7]=Bin2GrayTof(tofBin,fDataTof[jk12+7]);
+       }
-     };
-     fDataTof[j12+20]=0x00;   // TEMP1
+       if (DEBUG)
-     fDataTof[j12+21]=0x00;   // TEMP2
+         cout<<nh<<" "<<Timetof[nh]<<" "<<t1<<" "<<t2<<endl;
-     fDataTof[j12+22]= EvaluateCrcTof(pTof);   // CRC
-     pTof+=23;
+     } // ip < 6
-   };
-   return(0);
+   }; // ****************************************       end loop over hits
- };
+   // ======  ADC ======
- UChar_t Digitizer::Bin2GrayTof(UChar_t binaTOF,UChar_t grayTOF){
-   union graytof_data {
+   for(Int_t i=0; i<48; i++){
-     UChar_t word;
+     if (QevePmt_pC[i] < 800.)  ADCtof[i]= (Int_t)(ADC_pC0A + ADC_pC1A*QevePmt_pC[i] + ADC_pC2A*pow(QevePmt_pC[i],2) + ADC_pC3A*pow(QevePmt_pC[i],3));
-     struct bit_field {
+     if (QevePmt_pC[i] > 800.)  ADCtof[i]= (Int_t)(ADC_pC0B + ADC_pC1B*QevePmt_pC[i] + ADC_pC2B*pow(QevePmt_pC[i],2) + ADC_pC3B*pow(QevePmt_pC[i],3));
-       unsigned b0:1;
+     if (QevePmt_pC[i] > 2485.) ADCtof[i]= (Int_t)(1758. + 0.54*QevePmt_pC[i]);  //assuming a fictional 0.54 ch/pC above ADCsat
-       unsigned b1:1;
+     if (ADCtof[i]>ADCsat) ADCtof[i]=ADCsat;
-       unsigned b2:1;
+     if (QevePmt_pC[i] < pCthres)  ADCtof[i]= ADClast;
-       unsigned b3:1;
+     if (ADCtof[i] < 0) ADCtof[i]=ADClast;
-       unsigned b4:1;
+     if (ADCtof[i] > ADClast) ADCtof[i]=ADClast;
-       unsigned b5:1;
+   }
-       unsigned b6:1;
-       unsigned b7:1;
+ //   for(Int_t i=0; i<48; i++){
-     } bit;
+ //     if(QevePmt_pC[i] >= pCthres){
-   } bi,gr;
+ //       ADCtof[i]= (Int_t)(ADC_pC0 + ADC_pC1*QevePmt_pC[i] + ADC_pC2*pow(QevePmt_pC[i],2) + ADC_pC3*pow(QevePmt_pC[i],3));
-   //
+ //   } else
-   bi.word = binaTOF;
+ //       ADCtof[i]= ADClast;
-   gr.word = grayTOF;
+ // }
-   //
-   gr.bit.b0 = bi.bit.b1 ^ bi.bit.b0;
+ // // ---- introduce scale factors to tune simul ADC to real data   24-oct DC
-   gr.bit.b1 = bi.bit.b2 ^ bi.bit.b1;
-   gr.bit.b2 = bi.bit.b3 ^ bi.bit.b2;
+ //   for(Int_t i=0; i<48; i++){
-   gr.bit.b3 = bi.bit.b3;
+ //     if(ADCtof[i] != ADClast){
-   //
+ //                              //      printf("%3d, %4d, %4.2f\n",i, ADCtof[i],ScaleFact[i]);
-   /* bin to gray conversion 4 bit per time*/
+ //       ADCtof[i]= Int_t (ADCtof[i]*ScaleFact[i]);
-   //
+ //                              //      printf("%3d, %4d,\n",i, ADCtof[i]);
-   gr.bit.b4 = bi.bit.b5 ^ bi.bit.b4;
+ //     }
-   gr.bit.b5 = bi.bit.b6 ^ bi.bit.b5;
+ //   }
-   gr.bit.b6 = bi.bit.b7 ^ bi.bit.b6;
-   gr.bit.b7 = bi.bit.b7;
+ //   for(Int_t i=0; i<48; i++){
-   //
+ //     if(ADCtof[i] != ADClast){
-   return(gr.word);
+ //       if(ADCtof[i]> ADCsat) ADCtof[i]=ADCsat;
- }
+ //       else if(ADCtof[i]< 0) ADCtof[i]=ADClast;
+ //   }
- UChar_t Digitizer::EvaluateCrcTof(UChar_t *pTof) {
+ //   }
-   // UChar_t crcTof=0x00;
-   //   for (Int_t jp=0; jp < 23; jp++){
-   //     crcTof = crc8(...)
+ // ======  build  TDC coincidence  ======
-   //   }
-   return(0x00);
+   Float_t t_coinc = 0;
- };
+   Int_t ilast = 100;
+   for (Int_t ii=0; ii<48;ii++)
- //void Digitizer::Paddle2Pmt(Int_t plane, Int_t paddle, Int_t* &pmtleft, Int_t* &pmtright){
+     if (tdc[ii] > t_coinc) {
- void Digitizer::Paddle2Pmt(Int_t plane, Int_t paddle, Int_t *pl, Int_t *pr){
+       t_coinc = tdc[ii];
-   //* @param plane    (0 - 5)
+       ilast = ii;
-   //* @param paddle   (plane=0, paddle = 0,...5)
+     }
-   //* @param padid    (0 - 23)
-   //
+   //     cout<<ilast<<" "<<t_coinc<<endl;
-   Int_t padid=-1;
+   //     At t_coinc  trigger condition is fulfilled
-   Int_t pads[6]={8,6,2,2,3,3};
-   //
+   for (Int_t ii=0; ii<48;ii++){
-   Int_t somma=0;
+     //      if (tdc[ii] != 0) tdc1[ii] = t_coinc - tdc[ii];   // test 1
-   Int_t np=plane;
+     if (tdc[ii] != 0) tdc1[ii] = t_coinc - tdcpmt[ii];  // test 2
-   for(Int_t j=0; j<np; j++)
+     tdc1[ii] = tdc1[ii]/tdcres[ii];                     // divide by TDC resolution
-     somma+=pads[j];
+     if (tdc[ii] != 0) tdc1[ii] = tdc1[ii] + c3_S[ii];  // add cable length c3
-   padid=paddle+somma;
+   } // missing parenthesis inserted! (Silvio)
-   *pl = padid*2;
-   *pr = *pr + 1;
+   for(Int_t i=0; i<48; i++){
- };
+     if(tdc1[i] != 0.){
+       TDCint[i]=(Int_t)tdc1[i];
- void Digitizer::DigitizeAC() {
+       if (TDCint[i]>4093) TDCint[i]=TDClast;  // 18-oct WM
-   // created:  J. Conrad, KTH
+       if (DEBUG)
-   // modified: S. Orsi, INFN Roma2
+         cout<<i<<" "<<TDCint[i]<<endl;
+       //ADC[i]= ADC_pC * QevePmt_pC[i] + ADCoffset;
-   fDataAC[0] = 0xACAC;
+       //if(ADC[i]> ADClast) ADC[i]=ADClast;
-   fDataAC[64]= 0xACAC;
+     } else
-   fDataAC[1] = 0xAC11;   // main card
+       TDCint[i]= TDClast;
-   fDataAC[65] = 0xAC22;   // extra card
+   }
-   // the third word is a status word (dummy)
+   if (DEBUG)
-   fDataAC[2] = 0xFFFF; //FFEF?
+     cout<<"-----------"<<endl;
-   fDataAC[66] = 0xFFFF;
-   const UInt_t nReg = 6;
+ //------ use channelmap  18-oct WM
-   // Registers (dummy)
+   Int_t  channelmap[] =  {3,21,11,29,19,45,27,37,36,28,44,20,5,12,13,4,
-   for (UInt_t i=0; i<=nReg; i++){
+,47,14,39,22,31,30,23,38,15,46,7,0,33,16,24,
-     fDataAC[i+4] = 0xFFFF;
+,41,32,40,25,17,34,9,42,1,2,10,18,26,35,43};
-     fDataAC[i+68] = 0xFFFF;
-   }
+   Int_t ADChelp[48];
+   Int_t TDChelp[48];
-   // the last word is a CRC
-   // Dummy for the time being, but it might need to be calculated in the end
+   for(Int_t i=0; i<48; i++){
-   fDataAC[63] = 0xABCD;
+     Int_t ii=channelmap[i];
-   fDataAC[127] = 0xABCD;
+     ADChelp[ii]= ADCtof[i];
+     TDChelp[ii]= TDCint[i];
-   // shift registers, which one is with respect to PMT, where in
+   }
-   // shift registers is a question of time relative trigger
-   // In level2: hitmap, hitmap-status (synchronised with a trigger),
+   for(Int_t i=0; i<48; i++){
-   // status
+     ADCtof[i]= ADChelp[i];
+     TDCint[i]= TDChelp[i];
-   for (UInt_t i=0; i<=15; i++){
+   }
-     fDataAC[i+11] = 0x0000;
-     fDataAC[i+75] = 0x0000;
-   }
+ // ======  write fDataTof  =======
-   // singles counters are dummy
+ //  UChar_t tdcadd[8]={1,0,3,2,5,4,7,6};  (coded in 3 bit)
-   for (UInt_t i=0; i<=16; i++){
+   UChar_t Ctrl3bit[8]={32,0,96,64,160,128,224,192};  // DC (msb in 8 bit word )
-     fDataAC[i+26] = 0x0000;
-     fDataAC[i+90] = 0x0000;
+   UChar_t tofBin;
-   }
+   for (Int_t j=0; j < 12; j++){   // loop on TDC #12
+     Int_t j12=j*23;               // for each TDC 23 bytes (8 bits)
-   // coincidences are dummy
+     fDataTof[j12+0]=0x00;   // TDC_ID
+     fDataTof[j12+1]=0x00;   // EV_COUNT
-   for (UInt_t i=0; i<=7; i++){
+     fDataTof[j12+2]=0x00;   // TDC_MASK (1)
-     fDataAC[i+42] = 0x0000;
+     fDataTof[j12+3]=0x00;   // TDC_MASK (2)
-     fDataAC[i+106] = 0x0000;
+     for (Int_t k=0; k < 4; k++){   // for each TDC 4 channels (ADC+TDC)
-   }
+       Int_t jk12=j12+4*k;         // ADC,TDC channel (0-47)
-   // increments for every trigger might be needed at some point.
-   // dummy for now
+       tofBin =(UChar_t)(ADCtof[k+4*j]/256);   // ADC# (msb)
-   fDataAC[50]  = 0x0000;
+       fDataTof[jk12+4] = Bin2GrayTof(tofBin,fDataTof[jk12+4]);
-   fDataAC[114] = 0x0000;
+       /* control bits inserted here, after the bin to gray conv - DC*/
+       fDataTof[jk12+4] = Ctrl3bit[2*k] | fDataTof[jk12+4];
-   // dummy FPGA clock
+       tofBin=(UChar_t)(ADCtof[k+4*j]%256);   // ADC# (lsb)
+       fDataTof[jk12+5] = Bin2GrayTof(tofBin,fDataTof[jk12+5]);
-   fDataAC[51] = 0x006C;
+       tofBin=(UChar_t)(TDCint[k+4*j]/256);   // TDC# (msb)
-   fDataAC[52] = 0x6C6C;
+       fDataTof[jk12+6]=Bin2GrayTof(tofBin,fDataTof[jk12+6]);
-   fDataAC[115] = 0x006C;
+       /* control bits inserted here, after the bin to gray conv - DC*/
-   fDataAC[116] = 0x6C6C;
+       fDataTof[jk12+6] = Ctrl3bit[2*k+1] | fDataTof[jk12+6];
+       tofBin=(UChar_t)(TDCint[k+4*j]%256);   // TDC# (lsb)
+       fDataTof[jk12+7]=Bin2GrayTof(tofBin,fDataTof[jk12+7]);
-   // dummy temperatures
+     };
-   fDataAC[53] = 0x0000;
+     fDataTof[j12+20]=0x00;   // TEMP1
-   fDataAC[54] = 0x0000;
+     fDataTof[j12+21]=0x00;   // TEMP2
-   fDataAC[117] = 0x0000;
+     fDataTof[j12+22]= EvaluateCrcTof(pTof);   // CRC
-   fDataAC[118] = 0x0000;
+     pTof+=23;
+   };
+   return(0);
-   // dummy DAC thresholds
+ };
-   for (UInt_t i=0; i<=7; i++){
-     fDataAC[i+55] = 0x1A13;
-     fDataAC[i+119] = 0x1A13;
+ UChar_t Digitizer::Bin2GrayTof(UChar_t binaTOF,UChar_t grayTOF){
-   }
+   union graytof_data {
+     UChar_t word;
-   // We activate all branches. Once the digitization algorithm
+     struct bit_field {
-   // is determined only the branches need to activated which involve needed
+       unsigned b0:1;
-   // information
+       unsigned b1:1;
+       unsigned b2:1;
-   fhBookTree->SetBranchStatus("Nthcat",1);
+       unsigned b3:1;
-   fhBookTree->SetBranchStatus("Iparcat",1);
+       unsigned b4:1;
-   fhBookTree->SetBranchStatus("Icat",1);
+       unsigned b5:1;
-   fhBookTree->SetBranchStatus("Xincat",1);
+       unsigned b6:1;
-   fhBookTree->SetBranchStatus("Yincat",1);
+       unsigned b7:1;
-   fhBookTree->SetBranchStatus("Zincat",1);
+     } bit;
-   fhBookTree->SetBranchStatus("Xoutcat",1);
+   } bi,gr;
-   fhBookTree->SetBranchStatus("Youtcat",1);
+   //
-   fhBookTree->SetBranchStatus("Zoutcat",1);
+   bi.word = binaTOF;
-   fhBookTree->SetBranchStatus("Erelcat",1);
+   gr.word = grayTOF;
-   fhBookTree->SetBranchStatus("Timecat",1);
+   //
-   fhBookTree->SetBranchStatus("Pathcat",1);
+   gr.bit.b0 = bi.bit.b1 ^ bi.bit.b0;
-   fhBookTree->SetBranchStatus("P0cat",1);
+   gr.bit.b1 = bi.bit.b2 ^ bi.bit.b1;
-   fhBookTree->SetBranchStatus("Nthcas",1);
+   gr.bit.b2 = bi.bit.b3 ^ bi.bit.b2;
-   fhBookTree->SetBranchStatus("Iparcas",1);
+   gr.bit.b3 = bi.bit.b3;
-   fhBookTree->SetBranchStatus("Icas",1);
+   //
-   fhBookTree->SetBranchStatus("Xincas",1);
+   /* bin to gray conversion 4 bit per time*/
-   fhBookTree->SetBranchStatus("Yincas",1);
+   //
-   fhBookTree->SetBranchStatus("Zincas",1);
+   gr.bit.b4 = bi.bit.b5 ^ bi.bit.b4;
-   fhBookTree->SetBranchStatus("Xoutcas",1);
+   gr.bit.b5 = bi.bit.b6 ^ bi.bit.b5;
-   fhBookTree->SetBranchStatus("Youtcas",1);
+   gr.bit.b6 = bi.bit.b7 ^ bi.bit.b6;
-   fhBookTree->SetBranchStatus("Zoutcas",1);
+   gr.bit.b7 = bi.bit.b7;
-   fhBookTree->SetBranchStatus("Erelcas",1);
+   //
-   fhBookTree->SetBranchStatus("Timecas",1);
+   return(gr.word);
-   fhBookTree->SetBranchStatus("Pathcas",1);
+ }
-   fhBookTree->SetBranchStatus("P0cas",1);
-   fhBookTree->SetBranchStatus("Nthcard",1);
+ UChar_t Digitizer::EvaluateCrcTof(UChar_t *pTof) {
-   fhBookTree->SetBranchStatus("Iparcard",1);
+   Bool_t DEBUG=false;
-   fhBookTree->SetBranchStatus("Icard",1);
+   if (DEBUG)
-   fhBookTree->SetBranchStatus("Xincard",1);
+     return(0x00);
-   fhBookTree->SetBranchStatus("Yincard",1);
-   fhBookTree->SetBranchStatus("Zincard",1);
+   UChar_t crcTof=0x00;
-   fhBookTree->SetBranchStatus("Xoutcard",1);
+   UChar_t *pc=&crcTof, *pc2;
-   fhBookTree->SetBranchStatus("Youtcard",1);
+   pc2=pTof;
-   fhBookTree->SetBranchStatus("Zoutcard",1);
+   for (Int_t jp=0; jp < 23; jp++){
-   fhBookTree->SetBranchStatus("Erelcard",1);
+     //crcTof = crc8(...)
-   fhBookTree->SetBranchStatus("Timecard",1);
+     Crc8Tof(pc2++,pc);
-   fhBookTree->SetBranchStatus("Pathcard",1);
+     //    printf("%2i --- %x\n",jp,crcTof);
-   fhBookTree->SetBranchStatus("P0card",1);
+   }
+   return(crcTof);
-   // In this simpliefied approach we will assume that once
+ }
-   // a particle releases > 0.5 mip in one of the 12 AC detectors it
-   // will fire. We will furthermore assume that both cards read out
+ void Digitizer::Crc8Tof(UChar_t *oldCRC, UChar_t *crcTof){
-   // identical data.
+   union crctof_data {
+     UChar_t word;
-   // If you develop you digitization algorithm, you should start by
+     struct bit_field {
-   // identifying the information present in level2 (post-darth-vader)
+       unsigned b0:1;
-   // data.
+       unsigned b1:1;
+       unsigned b2:1;
-   Float_t SumEcat[5];
+       unsigned b3:1;
-   Float_t SumEcas[5];
+       unsigned b4:1;
-   Float_t SumEcard[5];
+       unsigned b5:1;
-   for (Int_t k= 0;k<5;k++){
+       unsigned b6:1;
-     SumEcat[k]=0.;
+       unsigned b7:1;
-     SumEcas[k]=0.;
+     } bit;
-     SumEcard[k]=0.;
+   } c,d,r;
-   };
+   c.word = *oldCRC;
-   if (Nthcat>50 || Nthcas>50 || Nthcard>50)
+   //d.word = *newCRC;
-     printf("Error! NthAC out of range!\n\n");
+   d.word = *crcTof;
+   r.word = 0;
-   // look in CAT
-   //  for (UInt_t k= 0;k<50;k++){
+   r.bit.b0 = c.bit.b7 ^ c.bit.b6 ^ c.bit.b0 ^
-   for (Int_t k= 0;k<Nthcat;k++){
+              d.bit.b0 ^ d.bit.b6 ^ d.bit.b7;
-     if (Erelcat[k] > 0)
-       SumEcat[Icat[k]] += Erelcat[k];
+   r.bit.b1 = c.bit.b6 ^ c.bit.b1 ^ c.bit.b0 ^
-   };
+              d.bit.b0 ^ d.bit.b1 ^ d.bit.b6;
-   // look in CAS
+   r.bit.b2 = c.bit.b6 ^ c.bit.b2 ^ c.bit.b1 ^ c.bit.b0 ^
-   for (Int_t k= 0;k<Nthcas;k++){
+              d.bit.b0 ^ d.bit.b1 ^ d.bit.b2 ^ d.bit.b6;
-     if (Erelcas[k] >0)
-       SumEcas[Icas[k]] += Erelcas[k];
+   r.bit.b3 = c.bit.b7 ^ c.bit.b3 ^ c.bit.b2 ^ c.bit.b1 ^
-   };
+              d.bit.b1 ^ d.bit.b2 ^ d.bit.b3 ^ d.bit.b7;
-   // look in CARD
+   r.bit.b4 = c.bit.b4 ^ c.bit.b3 ^ c.bit.b2 ^
-   for (Int_t k= 0;k<Nthcard;k++){
+              d.bit.b2 ^ d.bit.b3 ^ d.bit.b4;
-     if (Erelcard[k] >0)
-       SumEcard[Icard[k]] += Erelcard[k];
+   r.bit.b5 = c.bit.b5 ^ c.bit.b4 ^ c.bit.b3 ^
-   };
+              d.bit.b3 ^ d.bit.b4 ^ d.bit.b5;
-   // channel mapping              Hit Map
+   r.bit.b6 = c.bit.b6 ^ c.bit.b5 ^ c.bit.b4 ^
-   // 1 CARD4                      0          LSB
+              d.bit.b4 ^ d.bit.b5 ^ d.bit.b6;
-   // 2 CAT2                       0
-   // 3 CAS1                       0
+   r.bit.b7 = c.bit.b7 ^ c.bit.b6 ^ c.bit.b5 ^
-   // 4 NC                         0
+              d.bit.b5 ^ d.bit.b6 ^ d.bit.b7 ;
-   // 5 CARD2                      0
-   // 6 CAT4                       1
+   *crcTof=r.word;
-   // 7 CAS4                       0
+   //return r.word;
-   // 8 NC                         0
+ };
-   // 9 CARD3                      0
-   // 10 CAT3                      0
+ //void Digitizer::Paddle2Pmt(Int_t plane, Int_t paddle, Int_t* &pmtleft, Int_t* &pmtright){
-   // 11 CAS3                      0
+ void Digitizer::Paddle2Pmt(Int_t plane, Int_t paddle, Int_t *pl, Int_t *pr){
-   // 12 NC                        0
+   //* @param plane    (0 - 5)
-   // 13 CARD1                     0
+   //* @param paddle   (plane=0, paddle = 0,...5)
-   // 14 CAT1                      0
+   //* @param padid    (0 - 23)
-   // 15 CAS2                      0
+   //
-   // 16 NC                        0          MSB
+   Int_t padid=-1;
+   Int_t pads[6]={8,6,2,2,3,3};
-   // In the first version only the hit-map is filled, not the SR.
+   //
+   Int_t somma=0;
-   // Threshold: 0.8 MeV.
+   Int_t np=plane;
+   for(Int_t j=0; j<np; j++)
-   Float_t thr = 8e-4;
+     somma+=pads[j];
+   padid=paddle+somma;
-   fDataAC[3] = 0x0000;
+   *pl = padid*2;
+   //  *pr = *pr + 1;
-   if (SumEcas[0] > thr)  fDataAC[3]  = 0x0004;
+   *pr = *pl + 1; // WM
-   if (SumEcas[1] > thr)  fDataAC[3] += 0x4000;
+ };
-   if (SumEcas[2] > thr)  fDataAC[3] += 0x0400;
-   if (SumEcas[3] > thr)  fDataAC[3] += 0x0040;
+ void Digitizer::DigitizeAC() {
+   // created:  J. Conrad, KTH
-   if (SumEcat[0] > thr)  fDataAC[3] += 0x2000;
+   // modified: S. Orsi, INFN Roma2
-   if (SumEcat[1] > thr)  fDataAC[3] += 0x0002;
+   // fDataAC[0-63]:   main AC board
-   if (SumEcat[2] > thr)  fDataAC[3] += 0x0200;
+   // fDataAC[64-127]: extra AC board
-   if (SumEcat[3] > thr)  fDataAC[3] += 0x0020;
+   fDataAC[0] = 0xACAC;
-   if (SumEcard[0] > thr)  fDataAC[3] += 0x1000;
+   fDataAC[64]= 0xACAC;
-   if (SumEcard[1] > thr)  fDataAC[3] += 0x0010;
+   fDataAC[1] = 0xAC11;
-   if (SumEcard[2] > thr)  fDataAC[3] += 0x0100;
+   fDataAC[65] = 0xAC22;
-   if (SumEcard[3] > thr)  fDataAC[3] += 0x0001;
+   // the third word is a status word (dummy: "no errors are present in the AC boards")
-   fDataAC[67] = fDataAC[3];
+   fDataAC[2] = 0xFFFF; //FFEF?
+   fDataAC[66] = 0xFFFF;
-   //    for (Int_t i=0; i<fACbuffer; i++){
-   //    printf("%0x  ",fDataAC[i]);
+   const UInt_t nReg = 6;
-   //    if ((i+1)%8 ==0) cout << endl;
-   //   }
+   // FPGA Registers (dummy)
- };
+   for (UInt_t i=0; i<=nReg; i++){
+     fDataAC[i+4] = 0xFFFF;
+     fDataAC[i+68] = 0xFFFF;
+   }
- void Digitizer::DigitizeS4(){
-   // creato:  S. Borisov, INFN Roma2 e MEPHI, Sett 2007
+   // the last word is a CRC
-   TString ciao,modo="ns";
+   // Dummy for the time being, but it might need to be calculated in the end
-   Int_t i,j,t,NdF,pmt,NdFT,S4,S4v=0,S4p=32;
+   fDataAC[63] = 0xABCD;
-   Float_t E0,E1=1e-6,Ert,X,Y,Z,x,y,z,V[3],Xs[2],Ys[2],Zs[2],Yp[6],q,w,p=0.1,l,l0=500.;
+   fDataAC[127] = 0xABCD;
-   Xs[0]=-24.1;
-   Xs[1]=24.1;
+   // shift registers (moved to the end of the routine)
-   Ys[0]=-24.1;
-   Ys[1]=24.1;
+   Int_t evntLSB=Ievnt%65536;
-   Zs[0]=-0.5;
+   Int_t evntMSB=(Int_t)(Ievnt/65536);
-   Zs[1]=0.5;
-   Yp[0]=-20.;
+   // singles counters are dummy
-   Yp[2]=-1.;
+   for (UInt_t i=0; i<=15; i++){  //SO Oct '07: // for (UInt_t i=0; i<=16; i++){
-   Yp[4]=17.;
+     //     fDataAC[i+26] = 0x0000;
-   for(i=0;i<3;i++)
+     //     fDataAC[i+90] = 0x0000;
-     Yp[2*i+1]=Yp[2*i]+3;
+     fDataAC[i+26] = evntLSB;
-   srand(time(NULL));
+     fDataAC[i+90] = evntLSB;
-   // --- activate branches:
+   };
-   fhBookTree->SetBranchStatus("Nthtof",1);
-   fhBookTree->SetBranchStatus("Ipltof",1);
+   // coincidences are dummy (increment by 1 at each event)
-   fhBookTree->SetBranchStatus("Ipaddle",1);
+   // for (UInt_t i=0; i<=7; i++){
+   //    fDataAC[i+42] = 0x0000;
-   fhBookTree->SetBranchStatus("Xintof",1);
+   //    fDataAC[i+106] = 0x0000;
-   fhBookTree->SetBranchStatus("Yintof",1);
+   //   }
-   fhBookTree->SetBranchStatus("Xouttof",1);
+   for (UInt_t i=0; i<=7; i++){
-   fhBookTree->SetBranchStatus("Youttof",1);
+     fDataAC[i+42] = evntLSB;
+     fDataAC[i+106] = evntLSB;
-   fhBookTree->SetBranchStatus("Ereltof",1);
+   };
-   fhBookTree->SetBranchStatus("Timetof",1);
-   NdFT=0;
+   // increments for every trigger might be needed at some point.
-   Ert=0;
+   // dummy for now
-   for(i=0;i<Nthtof;i++){
+   fDataAC[50]  = 0x0000;
-     if(Ipltof[i]!=6) continue;
+   fDataAC[114] = 0x0000;
-     Ert+=Ereltof[i];
+   // dummy FPGA clock (increment by 1 at each event)
+   /*
-     if(modo=="ns") continue;
+     fDataAC[51] = 0x006C;
-     NdF=Int_t(Ereltof[i]/E1);
+     fDataAC[52] = 0x6C6C;
-     NdFT=0;
+     fDataAC[115] = 0x006C;
-     X=Xintof[i];
+     fDataAC[116] = 0x6C6C;
-     Y=Yintof[i];
+   */
-     Z=((Float_t)random()/(Float_t)0x7fffffff)-0.5;
+   if (Ievnt<=0xFFFF) {
-     //cout<<"XYZ "<<X<<"  "<<Y<<"  "<<Z<<endl;
+     fDataAC[51] = 0x0000;
-     for(j=0;j<NdF;j++){
+     fDataAC[52] = Ievnt;
-       q=(Float_t)random()/(Float_t)0x7fffffff;
+     fDataAC[115] = 0x0000;
-       w=(Float_t)random()/(Float_t)0x7fffffff;
+     fDataAC[116] = Ievnt;
-       // cout<<"qw "<<q<<" "<<w<<endl;
+   } else {
-       V[0]=p*cos(6.28318*q);
+     fDataAC[51] = evntMSB;
-       V[1]=p*sin(6.28318*q);
+     fDataAC[52] = evntLSB;
-       V[2]=p*(2.*w-1.);
+     fDataAC[115] = fDataAC[51];
-       pmt=0;
+     fDataAC[116] = fDataAC[52];
-       x=X;
+   }
-       y=Y;
-       z=Z;
+   // dummy temperatures
-       while(pmt==0 && (x>Xs[0] && x<Xs[1])&&(y>Ys[0] && y<Ys[1])&&(z>Zs[0] && z<Zs[1])){
+   fDataAC[53] = 0x0000;
-         l=0;
+   fDataAC[54] = 0x0000;
-         while(pmt==0 && (x>Xs[0] && x<Xs[1])&&(y>Ys[0] && y<Ys[1])&&(z>Zs[0] && z<Zs[1])){
+   fDataAC[117] = 0x0000;
-           x+=V[0];
+   fDataAC[118] = 0x0000;
-           y+=V[1];
-           z+=V[2];
-           l+=p;
+   // dummy DAC thresholds
-           //cout<<x<<"  "<<y<<"  "<<z<<"  "<<l<<endl;
+   for (UInt_t i=0; i<=7; i++){
-           //cin>>ciao;
+     fDataAC[i+55] = 0x1A13;
-         }
+     fDataAC[i+119] = 0x1A13;
-         if((x<Xs[0]+p || x>Xs[1]-p)&&(y>Ys[0]+p && y<Ys[1]-p)&&(z>Zs[0]+p && z<Zs[1]-p)){
+   }
-           for(t=0;t<3;t++){
-             if(y>=Yp[2*t] && y<Yp[2*t+1]){
+   // We activate all branches. Once the digitization algorithm is determined
-               if(pmt==0)NdFT++;
+   // only the branches that involve needed information will be activated
-               pmt=1;
-               //cout<<NdFT<<endl;
+   fhBookTree->SetBranchAddress("Ievnt",&Ievnt);
-               break;
+   fhBookTree->SetBranchStatus("Nthcat",1);
-             }
+   fhBookTree->SetBranchStatus("Iparcat",1);
-           }
+   fhBookTree->SetBranchStatus("Icat",1);
-           if(pmt==1)break;
+   fhBookTree->SetBranchStatus("Xincat",1);
-           V[0]=-V[0];
+   fhBookTree->SetBranchStatus("Yincat",1);
-         }
+   fhBookTree->SetBranchStatus("Zincat",1);
-         q=(Float_t)random()/(Float_t)0x7fffffff;
+   fhBookTree->SetBranchStatus("Xoutcat",1);
-         w=1-exp(-l/l0);
+   fhBookTree->SetBranchStatus("Youtcat",1);
-         if(q<w)break;
+   fhBookTree->SetBranchStatus("Zoutcat",1);
-         q=(Float_t)random()/(Float_t)0x7fffffff;
+   fhBookTree->SetBranchStatus("Erelcat",1);
-         w=0.5;
+   fhBookTree->SetBranchStatus("Timecat",1);
-         if(q<w)break;
+   fhBookTree->SetBranchStatus("Pathcat",1);
-         if((x>Xs[0]+p && x<Xs[1]-p)&&(y<Ys[0]+p || y>Ys[1]-p)&&(z>Zs[0]+p && z<Zs[1]-p))V[1]=-V[1];
+   fhBookTree->SetBranchStatus("P0cat",1);
-         if((x>Xs[0]+p && x<Xs[1]-p)&&(y>Ys[0]+p && y<Ys[1]-p)&&(z<Zs[0]+p || z>Zs[1]-p))V[2]=-V[2];
+   fhBookTree->SetBranchStatus("Nthcas",1);
-         x+=V[0];
+   fhBookTree->SetBranchStatus("Iparcas",1);
-         y+=V[1];
+   fhBookTree->SetBranchStatus("Icas",1);
-         z+=V[2];
+   fhBookTree->SetBranchStatus("Xincas",1);
-         l=0;
+   fhBookTree->SetBranchStatus("Yincas",1);
-         //cout<<x<<"  "<<y<<"  "<<z<<"  "<<l<<endl;
+   fhBookTree->SetBranchStatus("Zincas",1);
-                 //cin>>ciao;
+   fhBookTree->SetBranchStatus("Xoutcas",1);
-       }
+   fhBookTree->SetBranchStatus("Youtcas",1);
-     }
+   fhBookTree->SetBranchStatus("Zoutcas",1);
-   }
+   fhBookTree->SetBranchStatus("Erelcas",1);
-   Ert=Ert/0.002;
+   fhBookTree->SetBranchStatus("Timecas",1);
-   q=(Float_t)(random())/(Float_t)(0x7fffffff);
+   fhBookTree->SetBranchStatus("Pathcas",1);
-   w=0.7;
+   fhBookTree->SetBranchStatus("P0cas",1);
-   //E0=Float_t(4064)/7;
+   fhBookTree->SetBranchStatus("Nthcard",1);
-   E0=4064./7.;
+   fhBookTree->SetBranchStatus("Iparcard",1);
-   S4=(Int_t)(4064.*(1.-exp(-int(Ert)/E0)));
+   fhBookTree->SetBranchStatus("Icard",1);
-   //S4=Ert*7;
+   fhBookTree->SetBranchStatus("Xincard",1);
-   i=S4/4;
+   fhBookTree->SetBranchStatus("Yincard",1);
-   if(S4%4==0)
+   fhBookTree->SetBranchStatus("Zincard",1);
-     S4v=S4+S4p;
+   fhBookTree->SetBranchStatus("Xoutcard",1);
-   else if(S4%4==1) {
+   fhBookTree->SetBranchStatus("Youtcard",1);
-     if(q<w) S4v=S4-1+S4p;
+   fhBookTree->SetBranchStatus("Zoutcard",1);
-     else S4v=S4+1+S4p;
+   fhBookTree->SetBranchStatus("Erelcard",1);
-   } else if(S4%4==2)
+   fhBookTree->SetBranchStatus("Timecard",1);
-     S4v=S4+S4p;
+   fhBookTree->SetBranchStatus("Pathcard",1);
-   else if(S4%4==3){
+   fhBookTree->SetBranchStatus("P0card",1);
-     if(q<w) S4v=S4+1+S4p;
-     else S4v=S4-1+S4p;
+   // In this simpliefied approach we will assume that once
-   }
+   // a particle releases > 0.5 mip in one of the 12 AC detectors it
+   // will fire. We will furthermore assume that both cards read out
-   cout << "Ert= " <<Ert<<"; S4v= "<<S4v<<"; S4= "<<S4<<endl;
+   // identical data.
-   fDataS4[0]=S4v;//0xf028;
-   fDataS4[1]=0xd800;
+   // If you develop your digitization algorithm, you should start by
-   fDataS4[2]=0x0300;
+   // identifying the information present in level2 (post-darth-vader)
-   //  cout<<"  PMT  "<<NdFT<<"  "<<NdF<<endl;
+   // data.
-   //cin>>ciao;
- }
+   Float_t SumEcat[5];
+   Float_t SumEcas[5];
+   Float_t SumEcard[5];
+   for (Int_t k= 0;k<5;k++){
- void Digitizer::DigitizeND(){
+     SumEcat[k]=0.;
-   // creato:  S. Borisov, INFN Roma2 e MEPHI, Sett 2007
+     SumEcas[k]=0.;
-   Int_t i=0;
+     SumEcard[k]=0.;
-   UShort_t NdN=0;
+   };
-   fhBookTree->SetBranchStatus("Nthnd",1);
-   fhBookTree->SetBranchStatus("Itubend",1);
+   if (Nthcat>50 || Nthcas>50 || Nthcard>50)
-   fhBookTree->SetBranchStatus("Iparnd",1);
+     printf("*** ERROR AC! NthAC out of range!\n\n");
-   fhBookTree->SetBranchStatus("Xinnd",1);
-   fhBookTree->SetBranchStatus("Yinnd",1);
+   // energy dependence on position (see file AcFitOutputDistancePmt.C by S.Orsi)
-   fhBookTree->SetBranchStatus("Zinnd",1);
+   // based on J.Lundquist's calculations (PhD thesis, page 94)
-   fhBookTree->SetBranchStatus("Xoutnd",1);
+   // function: [0]+[1]*atan([2]/(x+1)), where the 3 parameters are:
-   fhBookTree->SetBranchStatus("Youtnd",1);
+   //   8.25470e-01   +- 1.79489e-02
-   fhBookTree->SetBranchStatus("Zoutnd",1);
+   //   6.41609e-01   +- 2.65846e-02
-   fhBookTree->SetBranchStatus("Erelnd",1);
+   //   9.81177e+00   +- 1.21284e+00
-   fhBookTree->SetBranchStatus("Timend",1);
+   // hp: 1 minimum ionising particle at 35cm from the PMT releases 1mip
-   fhBookTree->SetBranchStatus("Pathnd",1);
+   //
-   fhBookTree->SetBranchStatus("P0nd",1);
+   // NB: the PMT positions are needed!
-   //cout<<"n="<<Nthnd<<"  "<<NdN<<"\n";
-   for(i=0;i<Nthnd;i++){
+   // look in CAT
-     if(Iparnd[i]==13){
+   //  for (UInt_t k= 0;k<50;k++){
-       NdN++;
+   for (Int_t k= 0;k<Nthcat;k++){
-     }
+     if (Erelcat[k] > 0)
-   }
+       SumEcat[Icat[k]] += Erelcat[k];
-   NdN=100;
+   };
-   for(i=0;i<3;i++){
-     fDataND[2*i]=0x0000;
+   // look in CAS
-     fDataND[2*i+1]=0x010F;
+   for (Int_t k= 0;k<Nthcas;k++){
-   }
+     if (Erelcas[k] >0)
-   fDataND[0]=0xFF00 & (256*NdN);
+       SumEcas[Icas[k]] += Erelcas[k];
- }
+   };
+   // look in CARD
- void Digitizer::DigitizeDummy() {
+   for (Int_t k= 0;k<Nthcard;k++){
+     if (Erelcard[k] >0)
-   fhBookTree->SetBranchStatus("Enestrip",1);
+       SumEcard[Icard[k]] += Erelcard[k];
+   };
-   // dumy header
-   fDataDummy[0] = 0xCAAA;
+   // channel mapping              Hit Map
+   // 1 CARD4                      0          LSB
-   for (Int_t i=1; i<fDummybuffer; i++){
+   // 2 CAT2                       0
-     fDataDummy[i] = 0xFFFF;
+   // 3 CAS1                       0
-     //   printf("%0x  ",fDataDummy[i]);
+   // 4 NC                         0
-     //if ((i+1)%8 ==0) cout << endl;
+   // 5 CARD2                      0
-   }
+   // 6 CAT4                       1
- };
+   // 7 CAS4                       0
+   // 8 NC                         0
+   // 9 CARD3                      0
- void Digitizer::WriteData(){
+   // 10 CAT3                      0
+   // 11 CAS3                      0
-   // Routine that writes the data to a binary file
+   // 12 NC                        0
-   // PSCU data are already swapped
+   // 13 CARD1                     0
-   fOutputfile.write(reinterpret_cast<char*>(fDataPSCU),sizeof(UShort_t)*fPSCUbuffer);
+   // 14 CAT1                      0
-   // TRG
+   // 15 CAS2                      0
-   fOutputfile.write(reinterpret_cast<char*>(fDataTrigger),sizeof(UChar_t)*153);
+   // 16 NC                        0          MSB
-   // TOF
-   fOutputfile.write(reinterpret_cast<char*>(fDataTof),sizeof(UChar_t)*276);
+   // In the first version only the hit-map is filled, not the SR.
-   // AC
-   UShort_t temp[1000000];
+   // Threshold: 0.8 MeV.
-   memset(temp,0,sizeof(UShort_t)*1000000);
-   swab(fDataAC,temp,sizeof(UShort_t)*fACbuffer);  // WE MUST SWAP THE BYTES!!!
+   Float_t thr = 8e-4;
-   fOutputfile.write(reinterpret_cast<char*>(temp),sizeof(UShort_t)*fACbuffer);
-   // CALO
+   fDataAC[3] = 0x0000;
-   memset(temp,0,sizeof(UShort_t)*1000000);
-   swab(fDataCALO,temp,sizeof(UShort_t)*fCALOlength); // WE MUST SWAP THE BYTES!!!
+   if (SumEcas[0] > thr)  fDataAC[3]  = 0x0004;
-   fOutputfile.write(reinterpret_cast<char*>(temp),sizeof(UShort_t)*fCALOlength);
+   if (SumEcas[1] > thr)  fDataAC[3] += 0x4000;
-   // TRK
+   if (SumEcas[2] > thr)  fDataAC[3] += 0x0400;
-   memset(temp,0,sizeof(UShort_t)*1000000);
+   if (SumEcas[3] > thr)  fDataAC[3] += 0x0040;
-   swab(fDataTrack,temp,sizeof(UShort_t)*fTracklength);  // WE MUST SWAP THE BYTES!!!
-   fOutputfile.write(reinterpret_cast<char*>(temp),sizeof(UShort_t)*fTracklength);
+   if (SumEcat[0] > thr)  fDataAC[3] += 0x2000;
-   fTracklength=0;
+   if (SumEcat[1] > thr)  fDataAC[3] += 0x0002;
-    // padding to 64 bytes
+   if (SumEcat[2] > thr)  fDataAC[3] += 0x0200;
-   //
+   if (SumEcat[3] > thr)  fDataAC[3] += 0x0020;
-   if ( fPadding ){
-     fOutputfile.write(reinterpret_cast<char*>(fDataPadding),sizeof(UChar_t)*fPadding);
+   if (SumEcard[0] > thr)  fDataAC[3] += 0x1000;
-   };
+   if (SumEcard[1] > thr)  fDataAC[3] += 0x0010;
-   // S4
+   if (SumEcard[2] > thr)  fDataAC[3] += 0x0100;
-   memset(temp,0,sizeof(UShort_t)*1000000);
+   if (SumEcard[3] > thr)  fDataAC[3] += 0x0001;
-   swab(fDataS4,temp,sizeof(UShort_t)*fS4buffer);  // WE MUST SWAP THE BYTES!!!
-   fOutputfile.write(reinterpret_cast<char*>(temp),sizeof(UShort_t)*fS4buffer);
+   fDataAC[67] = fDataAC[3];
-   // ND
-   memset(temp,0,sizeof(UShort_t)*1000000);
+   // shift registers
-   swab(fDataND,temp,sizeof(UShort_t)*fNDbuffer);  // WE MUST SWAP THE BYTES!!!
+   // the central bin is equal to the hitmap, all other bins in the shift register are 0
-   fOutputfile.write(reinterpret_cast<char*>(temp),sizeof(UShort_t)*fNDbuffer);
+   for (UInt_t i=0; i<=15; i++){
- };
+     fDataAC[i+11] = 0x0000;
+     fDataAC[i+75] = 0x0000;
+   }
- void Digitizer::ReadData(){
+   fDataAC[18] = fDataAC[3];
+   fDataAC[82] = fDataAC[3];
-   UShort_t InData[64];
+   //    for (Int_t i=0; i<fACbuffer; i++){
-   // for debuggigng purposes only, write your own routine if you like (many
+   //    printf("%0x  ",fDataAC[i]);
-   // hardwired things.
+   //    if ((i+1)%8 ==0) cout << endl;
+   //   }
-   ifstream InputFile;
+ };
-   // if (!InputFile) {
+ void Digitizer::DigitizeS4(){
-   //     std::cout << "ERROR" << endl;
+   Int_t DEBUG=0;
-   //     // An error occurred!
+   // creato:  S. Borisov, INFN Roma2 e MEPHI, Sett 2007
-   //     // myFile.gcount() returns the number of bytes read.
+   TString ciao,modo="ns";
-   //     // calling myFile.clear() will reset the stream state
+   Int_t i,j,t,NdF,pmt,NdFT,S4,S4v=0,S4p=32;
-   //     // so it is usable again.
+   Float_t E0,E1=1e-6,Ert,X,Y,Z,x,y,z,V[3],Xs[2],Ys[2],Zs[2],Yp[6],q,w,p=0.1,l,l0=500;
-   //   };
+   Xs[0]=-24.1;
+   Xs[1]=24.1;
+   Ys[0]=-24.1;
+   Ys[1]=24.1;
-   //InputFile.seekg(0);
+   Zs[0]=-0.5;
+   Zs[1]=0.5;
-   InputFile.open(fFilename, ios::in | ios::binary);
+   Yp[0]=-20.;
-   //    fOutputfile.seekg(0);
+   Yp[2]=-1.;
-   if (!InputFile.is_open()) std::cout << "ERROR" << endl;
+   Yp[4]=17.;
+   for(i=0;i<3;i++)
-   InputFile.seekg(0);
+     Yp[2*i+1]=Yp[2*i]+3;
+   srand(time(NULL));
-   for (Int_t k=0; k<=1000; k++){
+   // --- activate branches:
-     InputFile.read(reinterpret_cast<char*>(InData),384*sizeof(UShort_t));
+   fhBookTree->SetBranchStatus("Nthtof",1);
+   fhBookTree->SetBranchStatus("Ipltof",1);
-     std::cout << "Read back: " << endl << endl;
+   fhBookTree->SetBranchStatus("Ipaddle",1);
-     for (Int_t i=0; i<=384; i++){
+   fhBookTree->SetBranchStatus("Xintof",1);
-       printf("%4x ", InData[i]);
+   fhBookTree->SetBranchStatus("Yintof",1);
-       if ((i+1)%8 ==0) cout << endl;
+   fhBookTree->SetBranchStatus("Xouttof",1);
-     }
+   fhBookTree->SetBranchStatus("Youttof",1);
-   }
+   fhBookTree->SetBranchStatus("Ereltof",1);
-   cout << endl;
+   fhBookTree->SetBranchStatus("Timetof",1);
-   InputFile.close();
+   NdFT=0;
+   Ert=0;
- };
+   for(i=0;i<Nthtof;i++){
+     if(Ipltof[i]!=6) continue;
+     Ert+=Ereltof[i];
- void Digitizer::DigitizeTrack() {
+     if(modo=="ns") continue;
- //std:: cout << "Entering DigitizeTrack " << endl;
+     NdF=Int_t(Ereltof[i]/E1);
- Float_t  AdcTrack[fNviews][fNstrips_view];  //  Vector of strips to be compressed
+     NdFT=0;
+     X=Xintof[i];
- Int_t Iview;
+     Y=Yintof[i];
- Int_t Nstrip;
+     Z=(Float_t)(random())/(Float_t)(0x7fffffff)-0.5;
+     //cout<<"XYZ "<<X<<"  "<<Y<<"  "<<Z<<endl;
-   for (Int_t j=0; j<fNviews;j++) {
+     for(j=0;j<NdF;j++){
+       q=(Float_t)random()/(Float_t)0x7fffffff;
-     for (Int_t i=0; i<fNladder;i++) {
+       w=(Float_t)random()/(Float_t)0x7fffffff;
+       // cout<<"qw "<<q<<" "<<w<<endl;
-       Float_t commonN1=gRandom->Gaus(0.,fSigmaCommon);
+       V[0]=p*cos(6.28318*q);
-       Float_t commonN2=gRandom->Gaus(0.,fSigmaCommon);
+       V[1]=p*sin(6.28318*q);
-       for (Int_t k=0; k<fNstrips_ladder;k++) {
+       V[2]=p*(2.*w-1.);
-       Nstrip=i*fNstrips_ladder+k;
+       pmt=0;
-       AdcTrack[j][Nstrip]=gRandom->Gaus(fPedeTrack[j][Nstrip],fSigmaTrack[j][Nstrip]);
+       x=X;
-       if(k<4*128) {AdcTrack[j][Nstrip] += commonN1;}  // full correlation of 4 VA1 Com. Noise
+       y=Y;
-       else {AdcTrack[j][Nstrip] += commonN2;}   // full correlation of 4 VA1 Com. Noise
+       z=Z;
+       while(pmt==0 && (x>Xs[0] && x<Xs[1])&&(y>Ys[0] && y<Ys[1])&&(z>Zs[0] && z<Zs[1])){
-       };
+         l=0;
+         while(pmt==0 && (x>Xs[0] && x<Xs[1])&&(y>Ys[0] && y<Ys[1])&&(z>Zs[0] && z<Zs[1])){
+           x+=V[0];
-     };
+           y+=V[1];
+           z+=V[2];
+           l+=p;
-   };
+           //cout<<x<<"  "<<y<<"  "<<z<<"  "<<l<<endl;
+           //cin>>ciao;
+         }
-   fhBookTree->SetBranchStatus("Nstrpx",1);
+         if((x<Xs[0]+p || x>Xs[1]-p)&&(y>Ys[0]+p && y<Ys[1]-p)&&(z>Zs[0]+p && z<Zs[1]-p)){
-   fhBookTree->SetBranchStatus("Npstripx",1);
+           for(t=0;t<3;t++){
-   fhBookTree->SetBranchStatus("Ntstripx",1);
+             if(y>=Yp[2*t] && y<Yp[2*t+1]){
-   fhBookTree->SetBranchStatus("Istripx",1);
+               if(pmt==0)NdFT++;
-   fhBookTree->SetBranchStatus("Qstripx",1);
+               pmt=1;
-   fhBookTree->SetBranchStatus("Xstripx",1);
+               //cout<<NdFT<<endl;
-   fhBookTree->SetBranchStatus("Nstrpy",1);
+               break;
-   fhBookTree->SetBranchStatus("Npstripy",1);
+             }
-   fhBookTree->SetBranchStatus("Ntstripy",1);
+           }
-   fhBookTree->SetBranchStatus("Istripy",1);
+           if(pmt==1)break;
-   fhBookTree->SetBranchStatus("Qstripy",1);
+           V[0]=-V[0];
-   fhBookTree->SetBranchStatus("Ystripy",1);
+         }
+         q=(Float_t)random()/(Float_t)0x7fffffff;
+         w=1-exp(-l/l0);
+         if(q<w)break;
-   Float_t ADCfull;
+         q=(Float_t)random()/(Float_t)0x7fffffff;
-   Int_t iladd=0;
+         w=0.5;
-   for (Int_t ix=0; ix<Nstrpx;ix++) {
+         if(q<w)break;
-   Iview=Npstripx[ix]*2-1;
+         if((x>Xs[0]+p && x<Xs[1]-p)&&(y<Ys[0]+p || y>Ys[1]-p)&&(z>Zs[0]+p && z<Zs[1]-p))V[1]=-V[1];
-   Nstrip=(Int_t)Istripx[ix]-1;
+         if((x>Xs[0]+p && x<Xs[1]-p)&&(y>Ys[0]+p && y<Ys[1]-p)&&(z<Zs[0]+p || z>Zs[1]-p))V[2]=-V[2];
-   if(Nstrip<fNstrips_ladder) iladd=0;
+         x+=V[0];
-   if((Nstrip>=fNstrips_ladder)&&(Nstrip<2*fNstrips_ladder)) iladd=1;
+         y+=V[1];
-   if((Nstrip>=2*fNstrips_ladder)&&(Nstrip<3*fNstrips_ladder)) iladd=2;
+         z+=V[2];
-   ADCfull=AdcTrack[Iview][Nstrip] += Qstripx[ix]*fMipCor[iladd][Iview];
+         l=0;
-   AdcTrack[Iview][Nstrip] *= SaturationTrack(ADCfull);
+         //cout<<x<<"  "<<y<<"  "<<z<<"  "<<l<<endl;
+                 //cin>>ciao;
-   };
+       }
+     }
+   }
-   for (Int_t iy=0; iy<Nstrpy;iy++) {
+   Ert=Ert/0.002;
-   Iview=Npstripy[iy]*2-2;
+   q=(Float_t)(random())/(Float_t)0x7fffffff;
-   Nstrip=(Int_t)Istripy[iy]-1;
+   w=0.7;
-   if(Nstrip<fNstrips_ladder) iladd=0;
+   //E0=(Float_t)(4064./7.);
-   if((Nstrip>=fNstrips_ladder)&&(Nstrip<2*fNstrips_ladder)) iladd=1;
+   E0=4064./7.;
-   if((Nstrip>=2*fNstrips_ladder)&&(Nstrip<3*fNstrips_ladder)) iladd=2;
+   if(Ert<1) S4=0;
-   ADCfull=AdcTrack[Iview][Nstrip] -= Qstripy[iy]*fMipCor[iladd][Iview];
+   else S4=(Int_t)(4064.*(1.-exp(-(Ert-1.)/E0)));
-   AdcTrack[Iview][Nstrip] *= SaturationTrack(ADCfull);
+   i=S4/4;
+   if(S4%4==0)
-   };
+     S4v=S4+S4p;
+   else if(S4%4==1){
- CompressTrackData(AdcTrack);  // Compress and Digitize data of one Ladder  in turn for all ladders
+     if(q<w) S4v=S4-1+S4p;
+     else S4v=S4+1+S4p;
- };
+   } else if(S4%4==2) S4v=S4+S4p;
+   else if(S4%4==3){
+     if(q<w) S4v=S4+1+S4p;
+     else S4v=S4-1+S4p;
- void Digitizer::DigitizeTrackCalib(Int_t ii) {
+   }
+   if (DEBUG)
- std:: cout << "Entering DigitizeTrackCalib " << ii << endl;
+     cout<<"Ert_S4 = " << Ert << " --- S4v = " << S4v << endl;
- if( (ii!=1)&&(ii!=2) ) {
+   fDataS4[0]=S4v;//0xf028;
-  std:: cout << "error wrong DigitizeTrackCalib argument" << endl;
+   fDataS4[1]=0xd800;
-  return;
+   fDataS4[2]=0x0300;
- };
+   //cout<<"  PMT  "<<NdFT<<"  "<<NdF<<endl;
+   //cin>>ciao;
- memset(fDataTrack,0,sizeof(UShort_t)*fTRACKbuffer);
+ }
- fTracklength=0;
- UShort_t Dato;
+ void Digitizer::DigitizeND(){
- Float_t dato1;
+   // creato:  S. Borisov, INFN Roma2 e MEPHI, Sett 2007
- Float_t dato2;
+   Int_t i=0;
- Float_t dato3;
+   UShort_t NdN=0;
- Float_t dato4;
+   fhBookTree->SetBranchStatus("Nthnd",1);
+   fhBookTree->SetBranchStatus("Itubend",1);
- UShort_t DatoDec;
+   fhBookTree->SetBranchStatus("Iparnd",1);
- UShort_t DatoDec1;
+   fhBookTree->SetBranchStatus("Xinnd",1);
- UShort_t DatoDec2;
+   fhBookTree->SetBranchStatus("Yinnd",1);
- UShort_t DatoDec3;
+   fhBookTree->SetBranchStatus("Zinnd",1);
- UShort_t DatoDec4;
+   fhBookTree->SetBranchStatus("Xoutnd",1);
+   fhBookTree->SetBranchStatus("Youtnd",1);
- UShort_t EVENT_CAL;
+   fhBookTree->SetBranchStatus("Zoutnd",1);
- UShort_t PED_L1;
+   fhBookTree->SetBranchStatus("Erelnd",1);
- UShort_t ReLength;
+   fhBookTree->SetBranchStatus("Timend",1);
- UShort_t OveCheckCode;
+   fhBookTree->SetBranchStatus("Pathnd",1);
- //UShort_t PED_L2;
+   fhBookTree->SetBranchStatus("P0nd",1);
- //UShort_t PED_L3HI;
+   //cout<<"n="<<Nthnd<<"  "<<NdN<<"\n";
- //UShort_t PED_L3LO;
+   for(i=0;i<Nthnd;i++){
- //UShort_t SIG_L1HI;
+     if(Iparnd[i]==13){
- //UShort_t SIG_L1LO;
+       NdN++;
- //UShort_t SIG_L2HI;
+     }
- //UShort_t SIG_L2LO;
+   }
- //UShort_t SIG_L3;
+   //NdN=100; //only for debug
- //UShort_t BAD_L1;
- //UShort_t BAD_L2LO;
+   for(i=0;i<3;i++){
- //UShort_t BAD_L3HI;
+     fDataND[2*i]=0x0000;
- //UShort_t BAD_L3LO;
+     fDataND[2*i+1]=0x010F;
- //UShort_t FLAG;
+   }
+   fDataND[0]=0xFF00 & (256*NdN);
+ }
-   Int_t DSPpos;
-   for (Int_t j=ii-1; j<fNviews;j+=2) {
-   UShort_t CkSum=0;
+ void Digitizer::DigitizeDummy() {
-   // here skip the dsp header and his trailer , to be written later
-   DSPpos=fTracklength;
+   fhBookTree->SetBranchStatus("Enestrip",1);
-   fTracklength=fTracklength+13+3;
+   // dumy header
+   fDataDummy[0] = 0xCAAA;
-     for (Int_t i=0; i<fNladder;i++) {
-       for (Int_t k=0; k<fNstrips_ladder;k++) {
+   for (Int_t i=1; i<fDummybuffer; i++){
-       // write in buffer the current LADDER
+     fDataDummy[i] = 0xFFFF;
-       Dato=(UShort_t)fPedeTrack[j][i*fNstrips_ladder+k];
+     //   printf("%0x  ",fDataDummy[i]);
-       dato1=fPedeTrack[j][i*fNstrips_ladder+k]-Dato;
+     //if ((i+1)%8 ==0) cout << endl;
+   }
-       DatoDec1=(UShort_t)(dato1*2);
+ };
-       dato2=dato1*2-DatoDec1;
-       DatoDec2=(UShort_t)(dato2*2);
+ void Digitizer::WriteData(){
-       dato3=dato2*2-DatoDec2;
+   // Routine that writes the data to a binary file
-       DatoDec3=(UShort_t)(dato3*2);
+   // PSCU data are already swapped
-       dato4=dato3*2-DatoDec3;
+   fOutputfile.write(reinterpret_cast<char*>(fDataPSCU),sizeof(UShort_t)*fPSCUbuffer);
+   // TRG
-       DatoDec4=(UShort_t)(dato4*2);
+   fOutputfile.write(reinterpret_cast<char*>(fDataTrigger),sizeof(UChar_t)*153);
+   // TOF
-       DatoDec=DatoDec1*0x0008+DatoDec2*0x0004+DatoDec3*0x0002+DatoDec4*0x0001;
+   fOutputfile.write(reinterpret_cast<char*>(fDataTof),sizeof(UChar_t)*276);
-       fDataTrack[fTracklength]=( (Dato << 4) | (DatoDec & 0x000F) );
+   // AC
-       CkSum=CkSum^fDataTrack[fTracklength];
+   UShort_t temp[1000000];
-       fTracklength++;
+   memset(temp,0,sizeof(UShort_t)*1000000);
-       };
+   swab(fDataAC,temp,sizeof(UShort_t)*fACbuffer);  // WE MUST SWAP THE BYTES!!!
+   fOutputfile.write(reinterpret_cast<char*>(temp),sizeof(UShort_t)*fACbuffer);
-       for (Int_t k=0; k<fNstrips_ladder;k++) {
+   // CALO
-       // write in buffer the current LADDER
+   memset(temp,0,sizeof(UShort_t)*1000000);
-       Dato=(UShort_t)fSigmaTrack[j][i*fNstrips_ladder+k];
+   swab(fDataCALO,temp,sizeof(UShort_t)*fCALOlength); // WE MUST SWAP THE BYTES!!!
-       dato1=fSigmaTrack[j][i*fNstrips_ladder+k]-Dato;
+   fOutputfile.write(reinterpret_cast<char*>(temp),sizeof(UShort_t)*fCALOlength);
+   // TRK
-       DatoDec1=(UShort_t)(dato1*2);
+   memset(temp,0,sizeof(UShort_t)*1000000);
-       dato2=dato1*2-DatoDec1;
+   swab(fDataTrack,temp,sizeof(UShort_t)*fTracklength);  // WE MUST SWAP THE BYTES!!!
+   fOutputfile.write(reinterpret_cast<char*>(temp),sizeof(UShort_t)*fTracklength);
-       DatoDec2=(UShort_t)(dato2*2);
+   fTracklength=0;
-       dato3=dato2*2-DatoDec2;
+    // padding to 64 bytes
+   //
-       DatoDec3=(UShort_t)(dato3*2);
+   if ( fPadding ){
-       dato4=dato3*2-DatoDec3;
+     fOutputfile.write(reinterpret_cast<char*>(fDataPadding),sizeof(UChar_t)*fPadding);
+   };
-       DatoDec4=(UShort_t)(dato4*2);
+   // S4
+   memset(temp,0,sizeof(UShort_t)*1000000);
-       DatoDec=DatoDec1*0x0008+DatoDec2*0x0004+DatoDec3*0x0002+DatoDec4*0x0001;
+   swab(fDataS4,temp,sizeof(UShort_t)*fS4buffer);  // WE MUST SWAP THE BYTES!!!
+   fOutputfile.write(reinterpret_cast<char*>(temp),sizeof(UShort_t)*fS4buffer);
-       fDataTrack[fTracklength]=( (Dato << 4) | (DatoDec & 0x000F) );
+   // ND
-       CkSum=CkSum^fDataTrack[fTracklength];
+   memset(temp,0,sizeof(UShort_t)*1000000);
-       fTracklength++;
+   swab(fDataND,temp,sizeof(UShort_t)*fNDbuffer);  // WE MUST SWAP THE BYTES!!!
-       };
+   fOutputfile.write(reinterpret_cast<char*>(temp),sizeof(UShort_t)*fNDbuffer);
+ };
-       for (Int_t k=0; k<64;k++) {
-       fDataTrack[fTracklength]=0x0000;
-       CkSum=CkSum^fDataTrack[fTracklength];
+ void Digitizer::ReadData(){
-       fTracklength++;
+   UShort_t InData[64];
-       };
-       // end ladder
+   // for debuggigng purposes only, write your own routine if you like (many
+   // hardwired things.
-     // write in buffer the end ladder word
-     if(i==0) fDataTrack[fTracklength]=0x1807;
+   ifstream InputFile;
-     if(i==1) fDataTrack[fTracklength]=0x1808;
-     if(i==2) fDataTrack[fTracklength]=0x1809;
+   // if (!InputFile) {
-     CkSum=CkSum^fDataTrack[fTracklength];
-     fTracklength++;
+   //     std::cout << "ERROR" << endl;
+   //     // An error occurred!
-     // write in buffer the TRAILER
+   //     // myFile.gcount() returns the number of bytes read.
-     ReLength=(UShort_t)((fNstrips_ladder*2+64+1)*2+3);
+   //     // calling myFile.clear() will reset the stream state
-     OveCheckCode=0x0000;
+   //     // so it is usable again.
+   //   };
-     fDataTrack[fTracklength]=0x0000;
-     fTracklength++;
-     fDataTrack[fTracklength]=(ReLength >> 8);
+   //InputFile.seekg(0);
-     fTracklength++;
+   InputFile.open(fFilename, ios::in | ios::binary);
-     fDataTrack[fTracklength]=( (ReLength << 8) | (OveCheckCode & 0x00FF) );
+   //    fOutputfile.seekg(0);
-     fTracklength++;
+   if (!InputFile.is_open()) std::cout << "ERROR" << endl;
-     // end TRAILER
+   InputFile.seekg(0);
-     };
+   for (Int_t k=0; k<=1000; k++){
-   // write in buffer the DSP header
+     InputFile.read(reinterpret_cast<char*>(InData),384*sizeof(UShort_t));
-   fDataTrack[DSPpos]=(0xE800 | ( ((j+1) << 3) | 0x0005) );
+     std::cout << "Read back: " << endl << endl;
-   fDataTrack[DSPpos+1]=0x01A9;
+     for (Int_t i=0; i<=384; i++){
+       printf("%4x ", InData[i]);
-   fDataTrack[DSPpos+2]=0x8740;
+       if ((i+1)%8 ==0) cout << endl;
+     }
-   EVENT_CAL=0;
-   fDataTrack[DSPpos+3]=(0x1A00 | ( (0x03FF & EVENT_CAL)>> 1) );
+   }
+   cout << endl;
-   PED_L1=0;
+   InputFile.close();
-   fDataTrack[DSPpos+4]=( ((EVENT_CAL << 15) | 0x5002 ) | ((0x03FF & PED_L1) << 2) );
+ };
-   // FROM HERE WE WRITE AS ALL VARIABLE apart CkSum are =0
-   fDataTrack[DSPpos+5]=0x8014;
+ void Digitizer::DigitizeTrack() {
-   fDataTrack[DSPpos+6]=0x00A0;
+ //std:: cout << "Entering DigitizeTrack " << endl;
+ Float_t  AdcTrack[fNviews][fNstrips_view];  //  Vector of strips to be compressed
-   fDataTrack[DSPpos+7]=0x0500;
+ Int_t Iview;
-   fDataTrack[DSPpos+8]=0x2801;
+ Int_t Nstrip;
-   fDataTrack[DSPpos+9]=0x400A;
+   for (Int_t j=0; j<fNviews;j++) {
-   fDataTrack[DSPpos+10]=0x0050;
+     for (Int_t i=0; i<fNladder;i++) {
-   CkSum=(CkSum >> 8)^(CkSum&0x00FF);
+       Float_t commonN1=gRandom->Gaus(0.,fSigmaCommon);
-   fDataTrack[DSPpos+11]=(0x0280 | (CkSum >> 3));
+       Float_t commonN2=gRandom->Gaus(0.,fSigmaCommon);
+       for (Int_t k=0; k<fNstrips_ladder;k++) {
-   fDataTrack[DSPpos+12]=(0x1FFF | (CkSum << 13) );
+       Nstrip=i*fNstrips_ladder+k;
+       AdcTrack[j][Nstrip]=gRandom->Gaus(fPedeTrack[j][Nstrip],fSigmaTrack[j][Nstrip]);
-   // end dsp header
+       if(k<4*128) {AdcTrack[j][Nstrip] += commonN1;}  // full correlation of 4 VA1 Com. Noise
+       else {AdcTrack[j][Nstrip] += commonN2;}   // full correlation of 4 VA1 Com. Noise
-   // write in buffer the TRAILER
+       };
-   ReLength=(UShort_t)((13*2)+3);
-   OveCheckCode=0x0000;
-   fDataTrack[DSPpos+13]=0x0000;
+     };
-   fDataTrack[DSPpos+14]=(ReLength >> 8);
+   };
-   fDataTrack[DSPpos+15]=( (ReLength << 8) | (OveCheckCode & 0x00FF) );
-   // end TRAILER
+   fhBookTree->SetBranchStatus("Nstrpx",1);
+   fhBookTree->SetBranchStatus("Npstripx",1);
+   fhBookTree->SetBranchStatus("Ntstripx",1);
+   fhBookTree->SetBranchStatus("Istripx",1);
+   fhBookTree->SetBranchStatus("Qstripx",1);
-   // end DSP
+   fhBookTree->SetBranchStatus("Xstripx",1);
-   };
+   fhBookTree->SetBranchStatus("Nstrpy",1);
+   fhBookTree->SetBranchStatus("Npstripy",1);
+   fhBookTree->SetBranchStatus("Ntstripy",1);
+   fhBookTree->SetBranchStatus("Istripy",1);
- };
+   fhBookTree->SetBranchStatus("Qstripy",1);
+   fhBookTree->SetBranchStatus("Ystripy",1);
- void Digitizer::WriteTrackCalib() {
- std:: cout << " Entering WriteTrackCalib " << endl;
+   Float_t ADCfull;
+   Int_t iladd=0;
- fOutputfile.write(reinterpret_cast<char*>(fDataPSCU),sizeof(UShort_t)*fPSCUbuffer);
+   for (Int_t ix=0; ix<Nstrpx;ix++) {
+   Iview=Npstripx[ix]*2-1;
- UShort_t temp[1000000];
+   Nstrip=(Int_t)Istripx[ix]-1;
- memset(temp,0,sizeof(UShort_t)*1000000);
+   if(Nstrip<fNstrips_ladder) iladd=0;
- swab(fDataTrack,temp,sizeof(UShort_t)*fTracklength);  // WE MUST SWAP THE BYTES!!!
+   if((Nstrip>=fNstrips_ladder)&&(Nstrip<2*fNstrips_ladder)) iladd=1;
- fOutputfile.write(reinterpret_cast<char*>(temp),sizeof(UShort_t)*fTracklength);
+   if((Nstrip>=2*fNstrips_ladder)&&(Nstrip<3*fNstrips_ladder)) iladd=2;
- fTracklength=0;
+   ADCfull=AdcTrack[Iview][Nstrip] += Qstripx[ix]*fMipCor[iladd][Iview];
- if ( fPadding ){
+   AdcTrack[Iview][Nstrip] *= SaturationTrack(ADCfull);
-       fOutputfile.write(reinterpret_cast<char*>(fDataPadding),sizeof(UChar_t)*fPadding);
- };
+   };
- };
+   for (Int_t iy=0; iy<Nstrpy;iy++) {
+   Iview=Npstripy[iy]*2-2;
- void Digitizer::ClearTrackCalib() {
+   Nstrip=(Int_t)Istripy[iy]-1;
+   if(Nstrip<fNstrips_ladder) iladd=0;
- std:: cout << "Entering ClearTrackCalib " << endl;
+   if((Nstrip>=fNstrips_ladder)&&(Nstrip<2*fNstrips_ladder)) iladd=1;
+   if((Nstrip>=2*fNstrips_ladder)&&(Nstrip<3*fNstrips_ladder)) iladd=2;
+   ADCfull=AdcTrack[Iview][Nstrip] -= Qstripy[iy]*fMipCor[iladd][Iview];
- };
+   AdcTrack[Iview][Nstrip] *= SaturationTrack(ADCfull);
+   };
- void Digitizer::LoadTrackCalib() {
- std:: cout << "Entering LoadTrackCalib " << endl;
+ CompressTrackData(AdcTrack);  // Compress and Digitize data of one Ladder  in turn for all ladders
- // Generate the pedestals and sigmas according to parametrization
+ };
-   for (Int_t j=0; j<fNviews;j++) {
-     for (Int_t i=0; i<fNstrips_view;i++) {
-     if((j+1)%2==0) {
+ void Digitizer::DigitizeTrackCalib(Int_t ii) {
-     fPedeTrack[j][i]=gRandom->Gaus(fAvePedex,fSigmaPedex);
-     fSigmaTrack[j][i]=gRandom->Gaus(fAveSigmax,fSigmaSigmax);
+ std:: cout << "Entering DigitizeTrackCalib " << ii << endl;
-     };
+ if( (ii!=1)&&(ii!=2) ) {
-     if((j+1)%2==1) {
+  std:: cout << "error wrong DigitizeTrackCalib argument" << endl;
-     fPedeTrack[j][i]=gRandom->Gaus(fAvePedey,fSigmaPedey);
+  return;
-     fSigmaTrack[j][i]=gRandom->Gaus(fAveSigmay,fSigmaSigmay);
+ };
-     };
+ memset(fDataTrack,0,sizeof(UShort_t)*fTRACKbuffer);
-     };
+ fTracklength=0;
-   };
+ UShort_t Dato;
+ Float_t dato1;
- };
+ Float_t dato2;
+ Float_t dato3;
- void Digitizer::LoadMipCor() {
+ Float_t dato4;
- std:: cout << "Entering LoadMipCor" << endl;
-   Float_t xfactor=1./151.6*1.04;
+ UShort_t DatoDec;
-   Float_t yfactor=1./152.1;
+ UShort_t DatoDec1;
+ UShort_t DatoDec2;
-   fMipCor[0][0]=140.02*yfactor;
+ UShort_t DatoDec3;
-   fMipCor[0][1]=140.99*xfactor;
+ UShort_t DatoDec4;
-   fMipCor[0][2]=134.48*yfactor;
-   fMipCor[0][3]=144.41*xfactor;
+ UShort_t EVENT_CAL;
-   fMipCor[0][4]=140.74*yfactor;
+ UShort_t PED_L1;
-   fMipCor[0][5]=142.28*xfactor;
+ UShort_t ReLength;
-   fMipCor[0][6]=134.53*yfactor;
+ UShort_t OveCheckCode;
-   fMipCor[0][7]=140.63*xfactor;
+ //UShort_t PED_L2;
-   fMipCor[0][8]=135.55*yfactor;
+ //UShort_t PED_L3HI;
-   fMipCor[0][9]=138.00*xfactor;
+ //UShort_t PED_L3LO;
-   fMipCor[0][10]=154.95*yfactor;
+ //UShort_t SIG_L1HI;
-   fMipCor[0][11]=158.44*xfactor;
+ //UShort_t SIG_L1LO;
+ //UShort_t SIG_L2HI;
+ //UShort_t SIG_L2LO;
-   fMipCor[1][0]=136.07*yfactor;
+ //UShort_t SIG_L3;
-   fMipCor[1][1]=135.59*xfactor;
+ //UShort_t BAD_L1;
-   fMipCor[1][2]=142.69*yfactor;
+ //UShort_t BAD_L2LO;
-   fMipCor[1][3]=138.19*xfactor;
+ //UShort_t BAD_L3HI;
-   fMipCor[1][4]=137.35*yfactor;
+ //UShort_t BAD_L3LO;
-   fMipCor[1][5]=140.23*xfactor;
+ //UShort_t FLAG;
-   fMipCor[1][6]=153.15*yfactor;
-   fMipCor[1][7]=151.42*xfactor;
-   fMipCor[1][8]=129.76*yfactor;
+   Int_t DSPpos;
-   fMipCor[1][9]=140.63*xfactor;
+   for (Int_t j=ii-1; j<fNviews;j+=2) {
-   fMipCor[1][10]=157.87*yfactor;
+   UShort_t CkSum=0;
-   fMipCor[1][11]=153.64*xfactor;
+   // here skip the dsp header and his trailer , to be written later
+   DSPpos=fTracklength;
-   fMipCor[2][0]=134.98*yfactor;
+   fTracklength=fTracklength+13+3;
-   fMipCor[2][1]=143.95*xfactor;
-   fMipCor[2][2]=140.23*yfactor;
-   fMipCor[2][3]=138.88*xfactor;
+     for (Int_t i=0; i<fNladder;i++) {
-   fMipCor[2][4]=137.95*yfactor;
+       for (Int_t k=0; k<fNstrips_ladder;k++) {
-   fMipCor[2][5]=134.87*xfactor;
+       // write in buffer the current LADDER
-   fMipCor[2][6]=157.56*yfactor;
+       Dato=(UShort_t)fPedeTrack[j][i*fNstrips_ladder+k];
-   fMipCor[2][7]=157.31*xfactor;
+       dato1=fPedeTrack[j][i*fNstrips_ladder+k]-Dato;
-   fMipCor[2][8]=141.37*yfactor;
-   fMipCor[2][9]=143.39*xfactor;
+       DatoDec1=(UShort_t)(dato1*2);
-   fMipCor[2][10]=156.15*yfactor;
+       dato2=dato1*2-DatoDec1;
-   fMipCor[2][11]=158.79*xfactor;
+       DatoDec2=(UShort_t)(dato2*2);
- /*
+       dato3=dato2*2-DatoDec2;
-   for (Int_t j=0; j<fNviews;j++) {
-     for (Int_t i=0; i<fNstrips_view;i++) {
+       DatoDec3=(UShort_t)(dato3*2);
-     fMipCor[j][i]=1.;
+       dato4=dato3*2-DatoDec3;
-     };
-   };
+       DatoDec4=(UShort_t)(dato4*2);
+       DatoDec=DatoDec1*0x0008+DatoDec2*0x0004+DatoDec3*0x0002+DatoDec4*0x0001;
- */
+       fDataTrack[fTracklength]=( (Dato << 4) | (DatoDec & 0x000F) );
- };
+       CkSum=CkSum^fDataTrack[fTracklength];
+       fTracklength++;
- void Digitizer::CompressTrackData(Float_t AdcTrack[fNviews][fNstrips_view]) {
+       };
- // copy of the corresponding compression fortran routine + new digitization
- // std:: cout << "Entering CompressTrackData " << endl;
+       for (Int_t k=0; k<fNstrips_ladder;k++) {
- Int_t oldval=0;
+       // write in buffer the current LADDER
- Int_t newval=0;
+       Dato=(UShort_t)fSigmaTrack[j][i*fNstrips_ladder+k];
- Int_t trasmesso=0;
+       dato1=fSigmaTrack[j][i*fNstrips_ladder+k]-Dato;
- Int_t ntrastot=0;
- Float_t real;
+       DatoDec1=(UShort_t)(dato1*2);
- Float_t inte;
+       dato2=dato1*2-DatoDec1;
- Int_t cercacluster=0;
- Int_t kt=0;
+       DatoDec2=(UShort_t)(dato2*2);
- static const int DSPbufferSize = 4000; // 13 bit buffer to be rearranged in 16 bit Track buffer
+       dato3=dato2*2-DatoDec2;
- UShort_t DataDSP[DSPbufferSize];  // 13 bit  buffer to be rearranged in 16 bit Track buffer
- UShort_t DSPlength;  // 13 bit buffer to be rearranged in 16 bit Track buffer
+       DatoDec3=(UShort_t)(dato3*2);
+       dato4=dato3*2-DatoDec3;
- memset(fDataTrack,0,sizeof(UShort_t)*fTRACKbuffer); // probably not necessary becouse already done ?
- fTracklength=0;
+       DatoDec4=(UShort_t)(dato4*2);
-   for (Int_t iv=0; iv<fNviews;iv++) {
+       DatoDec=DatoDec1*0x0008+DatoDec2*0x0004+DatoDec3*0x0002+DatoDec4*0x0001;
-   memset(DataDSP,0,sizeof(UShort_t)*DSPbufferSize);
-   DSPlength=16; // skip the header, to be written later
+       fDataTrack[fTracklength]=( (Dato << 4) | (DatoDec & 0x000F) );
-   UShort_t CheckSum=0;
+       CkSum=CkSum^fDataTrack[fTracklength];
- // write dsp header on buffer
+       fTracklength++;
+       };
- //    fDataTrack[fTracklength]=0xE805;
- //    fTracklength++;
+       for (Int_t k=0; k<64;k++) {
+       fDataTrack[fTracklength]=0x0000;
- //    fDataTrack[fTracklength]=0x01A9;
+       CkSum=CkSum^fDataTrack[fTracklength];
- //    fTracklength++;
+       fTracklength++;
- // end dsp header
+       };
+       // end ladder
-    //
-    // INIZIO VISTA IV - TAKE PROPER ACTION
+     // write in buffer the end ladder word
-    //
+     if(i==0) fDataTrack[fTracklength]=0x1807;
+     if(i==1) fDataTrack[fTracklength]=0x1808;
+     if(i==2) fDataTrack[fTracklength]=0x1809;
+     CkSum=CkSum^fDataTrack[fTracklength];
-     for (Int_t ladder=0; ladder<fNladder;ladder++) {
+     fTracklength++;
-       Int_t k=0;
-       while (k<fNstrips_ladder) {
+     // write in buffer the TRAILER
-         // compress write in buffer the current LADDER
+     ReLength=(UShort_t)((fNstrips_ladder*2+64+1)*2+3);
-         if ( k == 0)  {
+     OveCheckCode=0x0000;
-           real=modff(AdcTrack[iv][ladder*fNstrips_ladder+k],&inte);
-           if (real > 0.5) inte=inte+1;
+     fDataTrack[fTracklength]=0x0000;
-           newval=(Int_t)inte -(Int_t)fPedeTrack[iv][ladder*fNstrips_ladder+k];
+     fTracklength++;
-           // first strip of ladder is transmitted
-           // DC_TOT first " << AdcTrack[iv][ladder*fNstrips_ladder+k] << endl;
+     fDataTrack[fTracklength]=(ReLength >> 8);
-           DataDSP[DSPlength]=( ((UShort_t)inte) & 0x0FFF);
+     fTracklength++;
-           DSPlength++;
-           ntrastot++;
+     fDataTrack[fTracklength]=( (ReLength << 8) | (OveCheckCode & 0x00FF) );
-           trasmesso=1;
+     fTracklength++;
-           oldval=newval;
-           kt=k;
+     // end TRAILER
-           k++;
+     };
-           continue;
-         };
+   // write in buffer the DSP header
-         real=modff(AdcTrack[iv][ladder*fNstrips_ladder+k],&inte);
-         if (real > 0.5) inte=inte+1;
+   fDataTrack[DSPpos]=(0xE800 | ( ((j+1) << 3) | 0x0005) );
-         newval=(Int_t)inte -(Int_t)(fPedeTrack[iv][ladder*fNstrips_ladder+k]);
-         cercacluster=1; // ?????????
+   fDataTrack[DSPpos+1]=0x01A9;
-         if (cercacluster==1) {
+   fDataTrack[DSPpos+2]=0x8740;
-  // controlla l'ordine di tutti queste strip ladder e DSP !!!!!!!
-           Int_t diff=0;
+   EVENT_CAL=0;
+   fDataTrack[DSPpos+3]=(0x1A00 | ( (0x03FF & EVENT_CAL)>> 1) );
-           switch ((iv+1)%2) {
+   PED_L1=0;
-           case 0: diff=newval-oldval;
+   fDataTrack[DSPpos+4]=( ((EVENT_CAL << 15) | 0x5002 ) | ((0x03FF & PED_L1) << 2) );
-           break;
-           case 1: diff=oldval-newval;
+   // FROM HERE WE WRITE AS ALL VARIABLE apart CkSum are =0
-           break;
-           };
+   fDataTrack[DSPpos+5]=0x8014;
-           if (diff>fCutclu*(Int_t)fSigmaTrack[iv][ladder*fNstrips_ladder+k]) {
+   fDataTrack[DSPpos+6]=0x00A0;
-             Int_t clval=newval;
-             Int_t klp=k;        // go on to search for maximum
+   fDataTrack[DSPpos+7]=0x0500;
-             klp++;
+   fDataTrack[DSPpos+8]=0x2801;
-             while(klp<fNstrips_ladder) {
-               real=modff(AdcTrack[iv][ladder*fNstrips_ladder+klp],&inte);
+   fDataTrack[DSPpos+9]=0x400A;
-               if (real > 0.5) inte=inte+1;
-               Int_t clvalp=(Int_t)inte -(Int_t)fPedeTrack[iv][ladder*fNstrips_ladder+klp];
+   fDataTrack[DSPpos+10]=0x0050;
-               if((iv+1)%2==0) {
+   CkSum=(CkSum >> 8)^(CkSum&0x00FF);
-                 if(clvalp>clval) {
+   fDataTrack[DSPpos+11]=(0x0280 | (CkSum >> 3));
-                    clval=clvalp;
-                    k=klp;}
+   fDataTrack[DSPpos+12]=(0x1FFF | (CkSum << 13) );
-                 else break; // max of cluster found
+   // end dsp header
-               } else {
+   // write in buffer the TRAILER
-                 if(clvalp<clval) {
-                    clval=clvalp;
+   ReLength=(UShort_t)((13*2)+3);
-                    k=klp;}
+   OveCheckCode=0x0000;
-                 else break; // max of cluster found
+   fDataTrack[DSPpos+13]=0x0000;
-               };
+   fDataTrack[DSPpos+14]=(ReLength >> 8);
-               klp++;
+   fDataTrack[DSPpos+15]=( (ReLength << 8) | (OveCheckCode & 0x00FF) );
-             };
+   // end TRAILER
-             Int_t kl1=k-fNclst; // max of cluster (or end of ladder ?)
-             trasmesso=0;
-             if(kl1<0)  kl1=0;
-             if(kt>=kl1) kl1=kt+1;
+   // end DSP
-             if( (kt+1)==kl1 ) trasmesso=1;
+   };
-             Int_t kl2=k+fNclst;
+ };
-             if(kl2>=fNstrips_ladder) kl2=fNstrips_ladder-1;
+ void Digitizer::WriteTrackCalib() {
-             for(Int_t klt=kl1 ; klt<=kl2 ; klt++) {
-               if(trasmesso==0) {
-               //  std:: cout << "STRIP " << klt << endl;
+ std:: cout << " Entering WriteTrackCalib " << endl;
-               //  std:: cout << "ADC_TOT " <<AdcTrack[iv][ladder*fNstrips_ladder+klt] << endl;
+ fOutputfile.write(reinterpret_cast<char*>(fDataPSCU),sizeof(UShort_t)*fPSCUbuffer);
-                 DataDSP[DSPlength]=( ((UShort_t)klt) | 0x1000);
-                 DSPlength++;
+ UShort_t temp[1000000];
-                 ntrastot++;
+ memset(temp,0,sizeof(UShort_t)*1000000);
+ swab(fDataTrack,temp,sizeof(UShort_t)*fTracklength);  // WE MUST SWAP THE BYTES!!!
+ fOutputfile.write(reinterpret_cast<char*>(temp),sizeof(UShort_t)*fTracklength);
-                 real=modff(AdcTrack[iv][ladder*fNstrips_ladder+klt],&inte);
+ fTracklength=0;
-                 if (real > 0.5) inte=inte+1;
+ if ( fPadding ){
-                 DataDSP[DSPlength]=( ((UShort_t)inte) & 0x0FFF);
+       fOutputfile.write(reinterpret_cast<char*>(fDataPadding),sizeof(UChar_t)*fPadding);
-                 DSPlength++;
+ };
-                 ntrastot++;
+ };
-                }
-                else {
-                //   std:: cout << "ADC_TOT " <<AdcTrack[iv][ladder*fNstrips_ladder+klt] << endl;
+ void Digitizer::ClearTrackCalib() {
-                 real=modff(AdcTrack[iv][ladder*fNstrips_ladder+klt],&inte);
-                 if (real > 0.5) inte=inte+1;
+ std:: cout << "Entering ClearTrackCalib " << endl;
-                 DataDSP[DSPlength]=( ((UShort_t)inte) & 0x0FFF);
-                 DSPlength++;
-                 ntrastot++;
+ };
-                 };
-                 trasmesso=1;
-             };  // end trasmission
+ void Digitizer::LoadTrackCalib() {
-             kt=kl2;
+ std:: cout << "Entering LoadTrackCalib " << endl;
-             k=kl2;
-             real=modff(AdcTrack[iv][ladder*fNstrips_ladder+kt],&inte);
+ // Generate the pedestals and sigmas according to parametrization
-             if (real > 0.5) inte=inte+1;
+   for (Int_t j=0; j<fNviews;j++) {
-             oldval=(Int_t)inte -(Int_t)fPedeTrack[iv][ladder*fNstrips_ladder+kt];
+     for (Int_t i=0; i<fNstrips_view;i++) {
-             k++;
-             continue;
+     if((j+1)%2==0) {
+     fPedeTrack[j][i]=gRandom->Gaus(fAvePedex,fSigmaPedex);
+     fSigmaTrack[j][i]=gRandom->Gaus(fAveSigmax,fSigmaSigmax);
-           }; // end cercacluster
+     };
-         }; // end cercacluster
+     if((j+1)%2==1) {
+     fPedeTrack[j][i]=gRandom->Gaus(fAvePedey,fSigmaPedey);
- // start ZOP check for strips no
+     fSigmaTrack[j][i]=gRandom->Gaus(fAveSigmay,fSigmaSigmay);
+     };
-       if(abs(newval-oldval)>=fCutzop*(Int_t)fSigmaTrack[iv][ladder*fNstrips_ladder+k]) {
+     };
-        if(trasmesso==0) {
+   };
-        // std:: cout << "STRIP " << k << endl;
-        // std:: cout << "ADC_TOT " << AdcTrack[iv][ladder*fNstrips_ladder+k] << endl;
-          DataDSP[DSPlength]=( ((UShort_t)k) | 0x1000);
+ };
-          DSPlength++;
-          ntrastot++;
+ void Digitizer::LoadMipCor() {
+ std:: cout << "Entering LoadMipCor" << endl;
+   Float_t xfactor=1./151.6*1.04;
-          real=modff(AdcTrack[iv][ladder*fNstrips_ladder+k],&inte);
+   Float_t yfactor=1./152.1;
-          if (real > 0.5) inte=inte+1;
-          DataDSP[DSPlength]=( ((UShort_t)inte) & 0x0FFF);
+   fMipCor[0][0]=140.02*yfactor;
-          DSPlength++;
+   fMipCor[0][1]=140.99*xfactor;
-          ntrastot++;
+   fMipCor[0][2]=134.48*yfactor;
+   fMipCor[0][3]=144.41*xfactor;
-        }
+   fMipCor[0][4]=140.74*yfactor;
-        else {
+   fMipCor[0][5]=142.28*xfactor;
-        //  std:: cout << "ADC_TOT " << AdcTrack[iv][ladder*fNstrips_ladder+k] << endl;
+   fMipCor[0][6]=134.53*yfactor;
-          real=modff(AdcTrack[iv][ladder*fNstrips_ladder+k],&inte);
+   fMipCor[0][7]=140.63*xfactor;
-          if (real > 0.5) inte=inte+1;
+   fMipCor[0][8]=135.55*yfactor;
-          DataDSP[DSPlength]=(  ((UShort_t)inte) & 0x0FFF);
+   fMipCor[0][9]=138.00*xfactor;
-          DSPlength++;
+   fMipCor[0][10]=154.95*yfactor;
-          ntrastot++;
+   fMipCor[0][11]=158.44*xfactor;
-        };
-        trasmesso=1;
-        oldval=newval;
+   fMipCor[1][0]=136.07*yfactor;
-        kt=k;
+   fMipCor[1][1]=135.59*xfactor;
+   fMipCor[1][2]=142.69*yfactor;
-       }
+   fMipCor[1][3]=138.19*xfactor;
-       else trasmesso=0;
+   fMipCor[1][4]=137.35*yfactor;
-       // end zop
+   fMipCor[1][5]=140.23*xfactor;
+   fMipCor[1][6]=153.15*yfactor;
-       k++;
+   fMipCor[1][7]=151.42*xfactor;
-       };  // end cycle inside ladder
+   fMipCor[1][8]=129.76*yfactor;
- // write here the end ladder bytes
+   fMipCor[1][9]=140.63*xfactor;
- //            std:: cout << "FINE LADDER " << ladder+1 << endl;
+   fMipCor[1][10]=157.87*yfactor;
+   fMipCor[1][11]=153.64*xfactor;
-       DataDSP[DSPlength]=( ((UShort_t)(ladder+1))  | 0x1800);
-       DSPlength++;
+   fMipCor[2][0]=134.98*yfactor;
-       ntrastot++;
+   fMipCor[2][1]=143.95*xfactor;
-       trasmesso=0;
+   fMipCor[2][2]=140.23*yfactor;
+   fMipCor[2][3]=138.88*xfactor;
-     };  //end cycle inside dsp
+   fMipCor[2][4]=137.95*yfactor;
- //  std:: cout << "FINE DSP " << iv+1 << endl;
+   fMipCor[2][5]=134.87*xfactor;
- // here put DSP header
+   fMipCor[2][6]=157.56*yfactor;
-     DataDSP[0]=(0x1CA0 | ((UShort_t)(iv+1)) );
+   fMipCor[2][7]=157.31*xfactor;
-     UShort_t Nword=(DSPlength*13)/16;
+   fMipCor[2][8]=141.37*yfactor;
-     if( ((DSPlength*13)%16)!=0) Nword++;
+   fMipCor[2][9]=143.39*xfactor;
-     DataDSP[1]=(0x1400 | ( Nword >> 10));
+   fMipCor[2][10]=156.15*yfactor;
-     DataDSP[2]=(0x1400 | ( Nword & 0x03FF) );
+   fMipCor[2][11]=158.79*xfactor;
-     DataDSP[3]=(0x1400 | (( (UShort_t)(fCounter >> 10) ) & 0x03FF) );
-     DataDSP[4]=(0x1400 | (( (UShort_t)(fCounter) )  & 0x03FF) );
+ /*
-     DataDSP[5]=(0x1400 | ( (UShort_t)(fNclst << 7) ) | ( (UShort_t)(fCutzop << 4) )
+   for (Int_t j=0; j<fNviews;j++) {
-      | ( (UShort_t)fCutzop  ) );
+     for (Int_t i=0; i<fNstrips_view;i++) {
-     DataDSP[6]=0x1400;
+     fMipCor[j][i]=1.;
-     DataDSP[7]=0x1400;
+     };
-     DataDSP[8]=0x1400;
+   };
-     DataDSP[9]=0x1400;
-     DataDSP[10]=0x1400;
-     DataDSP[11]=0x1400;
+ */
-     DataDSP[12]=0x1400;
+ };
-     DataDSP[13]=0x1400;
-     DataDSP[14]=(0x1400 | (CheckSum & 0x00FF) );
+ void Digitizer::CompressTrackData(Float_t AdcTrack[fNviews][fNstrips_view]) {
-     DataDSP[15]=0x1C00;
+ // copy of the corresponding compression fortran routine + new digitization
- // end DSP header
+ // std:: cout << "Entering CompressTrackData " << endl;
+ Int_t oldval=0;
+ Int_t newval=0;
- // write 13 bit DataDSP bufer inside 16 bit fDataTrack buffer
+ Int_t trasmesso=0;
-     Int_t Bit16free=16;
+ Int_t ntrastot=0;
-     UShort_t Dato;
+ Float_t real;
-     for (Int_t NDSP=0; NDSP<DSPlength;NDSP++) {
+ Float_t inte;
-       Int_t Bit13ToWrite=13;
+ Int_t cercacluster=0;
-       while(Bit13ToWrite>0) {
+ Int_t kt=0;
-         if(Bit13ToWrite<=Bit16free) {
+ static const int DSPbufferSize = 4000; // 13 bit buffer to be rearranged in 16 bit Track buffer
-           Dato=((DataDSP[NDSP]&(0xFFFF >> (16-Bit13ToWrite)))<<(Bit16free-Bit13ToWrite));
+ UShort_t DataDSP[DSPbufferSize];  // 13 bit  buffer to be rearranged in 16 bit Track buffer
-           fDataTrack[fTracklength]=fDataTrack[fTracklength] | Dato ;
+ UShort_t DSPlength;  // 13 bit buffer to be rearranged in 16 bit Track buffer
-           Bit16free=Bit16free-Bit13ToWrite;
-           Bit13ToWrite=0;
+ memset(fDataTrack,0,sizeof(UShort_t)*fTRACKbuffer); // probably not necessary becouse already done ?
-           if(Bit16free==0) {
+ fTracklength=0;
-             if(NDSP>15) CheckSum=CheckSum^fDataTrack[fTracklength];
-             fTracklength++;
+   for (Int_t iv=0; iv<fNviews;iv++) {
-             Bit16free=16;
+   memset(DataDSP,0,sizeof(UShort_t)*DSPbufferSize);
-           };
+   DSPlength=16; // skip the header, to be written later
-         }
+   UShort_t CheckSum=0;
-         else if(Bit13ToWrite>Bit16free) {
+ // write dsp header on buffer
-           Dato=( (DataDSP[NDSP]&(0xFFFF >> (16-Bit13ToWrite) ) ) >> (Bit13ToWrite-Bit16free) );
-           fDataTrack[fTracklength]=fDataTrack[fTracklength] | Dato ;
+ //    fDataTrack[fTracklength]=0xE805;
-           if(NDSP>15) CheckSum=CheckSum^fDataTrack[fTracklength];
+ //    fTracklength++;
-           fTracklength++;
-           Bit13ToWrite=Bit13ToWrite-Bit16free;
+ //    fDataTrack[fTracklength]=0x01A9;
-           Bit16free=16;
+ //    fTracklength++;
-         };
+ // end dsp header
-       }; // end cycle while(Bit13ToWrite>0)
+    //
-     }; // end cycle DataDSP
+    // INIZIO VISTA IV - TAKE PROPER ACTION
-     if(Bit16free!=16) { fTracklength++; CheckSum=CheckSum^fDataTrack[fTracklength]; };
+    //
-     CheckSum=(CheckSum >> 8)^(CheckSum&0x00FF);
-     fDataTrack[fTracklength-Nword+11]=(0x0280 | (CheckSum >> 3));
-     fDataTrack[fTracklength-Nword+12]=(0x1C00 | (CheckSum << 13) );
+     for (Int_t ladder=0; ladder<fNladder;ladder++) {
- // end write 13 bit DataDSP bufer inside 16 bit fDataTrack buffer
+       Int_t k=0;
+       while (k<fNstrips_ladder) {
- //write trailer on buffer
+         // compress write in buffer the current LADDER
-     UShort_t ReLength=(UShort_t)((Nword+13)*2+3);
+         if ( k == 0)  {
-     UShort_t OveCheckCode=0x0000;
+           real=modff(AdcTrack[iv][ladder*fNstrips_ladder+k],&inte);
+           if (real > 0.5) inte=inte+1;
-     fDataTrack[fTracklength]=0x0000;
+           newval=(Int_t)inte -(Int_t)fPedeTrack[iv][ladder*fNstrips_ladder+k];
-     fTracklength++;
+           // first strip of ladder is transmitted
+           // DC_TOT first " << AdcTrack[iv][ladder*fNstrips_ladder+k] << endl;
-     fDataTrack[fTracklength]=(ReLength >> 8);
+           DataDSP[DSPlength]=( ((UShort_t)inte) & 0x0FFF);
-     fTracklength++;
+           DSPlength++;
+           ntrastot++;
-     fDataTrack[fTracklength]=( (ReLength << 8) | (OveCheckCode & 0x00FF) );
+           trasmesso=1;
-     fTracklength++;
+           oldval=newval;
- // end trailer
+           kt=k;
- //    std:: cout  << "DSPlength  " <<DSPlength << endl;
+           k++;
- //    std:: cout << "Nword " << Nword  << endl;
+           continue;
- //    std:: cout <<  "ReLength " << ReLength << endl;
+         };
-   };
+         real=modff(AdcTrack[iv][ladder*fNstrips_ladder+k],&inte);
- //    std:: cout << "ntrastot " << ntrastot << endl;
+         if (real > 0.5) inte=inte+1;
+         newval=(Int_t)inte -(Int_t)(fPedeTrack[iv][ladder*fNstrips_ladder+k]);
- };
+         cercacluster=1; // ?????????
+         if (cercacluster==1) {
- Float_t Digitizer::SaturationTrack(Float_t ADC) {
+  // controlla l'ordine di tutti queste strip ladder e DSP !!!!!!!
-   Float_t SatFact=1.;
+           Int_t diff=0;
-   if(ADC<70.) { SatFact=80./ADC; };
-   if(ADC>3000.) { SatFact=3000./ADC; };
-   return SatFact;
+           switch ((iv+1)%2) {
- };
+           case 0: diff=newval-oldval;
+           break;
+           case 1: diff=oldval-newval;
+           break;
+           };
+           if (diff>fCutclu*(Int_t)fSigmaTrack[iv][ladder*fNstrips_ladder+k]) {
+             Int_t clval=newval;
+             Int_t klp=k;        // go on to search for maximum
+             klp++;
+             while(klp<fNstrips_ladder) {
+               real=modff(AdcTrack[iv][ladder*fNstrips_ladder+klp],&inte);
+               if (real > 0.5) inte=inte+1;
+               Int_t clvalp=(Int_t)inte -(Int_t)fPedeTrack[iv][ladder*fNstrips_ladder+klp];
+               if((iv+1)%2==0) {
+                 if(clvalp>clval) {
+                    clval=clvalp;
+                    k=klp;}
+                 else break; // max of cluster found
+               } else {
+                 if(clvalp<clval) {
+                    clval=clvalp;
+                    k=klp;}
+                 else break; // max of cluster found
+               };
+               klp++;
+             };
+             Int_t kl1=k-fNclst; // max of cluster (or end of ladder ?)
+             trasmesso=0;
+             if(kl1<0)  kl1=0;
+             if(kt>=kl1) kl1=kt+1;
+             if( (kt+1)==kl1 ) trasmesso=1;
+             Int_t kl2=k+fNclst;
+             if(kl2>=fNstrips_ladder) kl2=fNstrips_ladder-1;
+             for(Int_t klt=kl1 ; klt<=kl2 ; klt++) {
+               if(trasmesso==0) {
+               //  std:: cout << "STRIP " << klt << endl;
+               //  std:: cout << "ADC_TOT " <<AdcTrack[iv][ladder*fNstrips_ladder+klt] << endl;
+                 DataDSP[DSPlength]=( ((UShort_t)klt) | 0x1000);
+                 DSPlength++;
+                 ntrastot++;
+                 real=modff(AdcTrack[iv][ladder*fNstrips_ladder+klt],&inte);
+                 if (real > 0.5) inte=inte+1;
+                 DataDSP[DSPlength]=( ((UShort_t)inte) & 0x0FFF);
+                 DSPlength++;
+                 ntrastot++;
+                }
+                else {
+                //   std:: cout << "ADC_TOT " <<AdcTrack[iv][ladder*fNstrips_ladder+klt] << endl;
+                 real=modff(AdcTrack[iv][ladder*fNstrips_ladder+klt],&inte);
+                 if (real > 0.5) inte=inte+1;
+                 DataDSP[DSPlength]=( ((UShort_t)inte) & 0x0FFF);
+                 DSPlength++;
+                 ntrastot++;
+                 };
+                 trasmesso=1;
+             };  // end trasmission
+             kt=kl2;
+             k=kl2;
+             real=modff(AdcTrack[iv][ladder*fNstrips_ladder+kt],&inte);
+             if (real > 0.5) inte=inte+1;
+             oldval=(Int_t)inte -(Int_t)fPedeTrack[iv][ladder*fNstrips_ladder+kt];
+             k++;
+             continue;
+           }; // end cercacluster
+         }; // end cercacluster
+ // start ZOP check for strips no
+       if(abs(newval-oldval)>=fCutzop*(Int_t)fSigmaTrack[iv][ladder*fNstrips_ladder+k]) {
+        if(trasmesso==0) {
+        // std:: cout << "STRIP " << k << endl;
+        // std:: cout << "ADC_TOT " << AdcTrack[iv][ladder*fNstrips_ladder+k] << endl;
+          DataDSP[DSPlength]=( ((UShort_t)k) | 0x1000);
+          DSPlength++;
+          ntrastot++;
+          real=modff(AdcTrack[iv][ladder*fNstrips_ladder+k],&inte);
+          if (real > 0.5) inte=inte+1;
+          DataDSP[DSPlength]=( ((UShort_t)inte) & 0x0FFF);
+          DSPlength++;
+          ntrastot++;
+        }
+        else {
+        //  std:: cout << "ADC_TOT " << AdcTrack[iv][ladder*fNstrips_ladder+k] << endl;
+          real=modff(AdcTrack[iv][ladder*fNstrips_ladder+k],&inte);
+          if (real > 0.5) inte=inte+1;
+          DataDSP[DSPlength]=(  ((UShort_t)inte) & 0x0FFF);
+          DSPlength++;
+          ntrastot++;
+        };
+        trasmesso=1;
+        oldval=newval;
+        kt=k;
+       }
+       else trasmesso=0;
+       // end zop
+       k++;
+       };  // end cycle inside ladder
+ // write here the end ladder bytes
+ //            std:: cout << "FINE LADDER " << ladder+1 << endl;
+       DataDSP[DSPlength]=( ((UShort_t)(ladder+1))  | 0x1800);
+       DSPlength++;
+       ntrastot++;
+       trasmesso=0;
+     };  //end cycle inside dsp
+ //  std:: cout << "FINE DSP " << iv+1 << endl;
+ // here put DSP header
+     DataDSP[0]=(0x1CA0 | ((UShort_t)(iv+1)) );
+     UShort_t Nword=(DSPlength*13)/16;
+     if( ((DSPlength*13)%16)!=0) Nword++;
+     DataDSP[1]=(0x1400 | ( Nword >> 10));
+     DataDSP[2]=(0x1400 | ( Nword & 0x03FF) );
+     DataDSP[3]=(0x1400 | (( (UShort_t)(fCounter >> 10) ) & 0x03FF) );
+     DataDSP[4]=(0x1400 | (( (UShort_t)(fCounter) )  & 0x03FF) );
+     DataDSP[5]=(0x1400 | ( (UShort_t)(fNclst << 7) ) | ( (UShort_t)(fCutzop << 4) )
+      | ( (UShort_t)fCutzop  ) );
+     DataDSP[6]=0x1400;
+     DataDSP[7]=0x1400;
+     DataDSP[8]=0x1400;
+     DataDSP[9]=0x1400;
+     DataDSP[10]=0x1400;
+     DataDSP[11]=0x1400;
+     DataDSP[12]=0x1400;
+     DataDSP[13]=0x1400;
+     DataDSP[14]=(0x1400 | (CheckSum & 0x00FF) );
+     DataDSP[15]=0x1C00;
+ // end DSP header
+ // write 13 bit DataDSP bufer inside 16 bit fDataTrack buffer
+     Int_t Bit16free=16;
+     UShort_t Dato;
+     for (Int_t NDSP=0; NDSP<DSPlength;NDSP++) {
+       Int_t Bit13ToWrite=13;
+       while(Bit13ToWrite>0) {
+         if(Bit13ToWrite<=Bit16free) {
+           Dato=((DataDSP[NDSP]&(0xFFFF >> (16-Bit13ToWrite)))<<(Bit16free-Bit13ToWrite));
+           fDataTrack[fTracklength]=fDataTrack[fTracklength] | Dato ;
+           Bit16free=Bit16free-Bit13ToWrite;
+           Bit13ToWrite=0;
+           if(Bit16free==0) {
+             if(NDSP>15) CheckSum=CheckSum^fDataTrack[fTracklength];
+             fTracklength++;
+             Bit16free=16;
+           };
+         }
+         else if(Bit13ToWrite>Bit16free) {
+           Dato=( (DataDSP[NDSP]&(0xFFFF >> (16-Bit13ToWrite) ) ) >> (Bit13ToWrite-Bit16free) );
+           fDataTrack[fTracklength]=fDataTrack[fTracklength] | Dato ;
+           if(NDSP>15) CheckSum=CheckSum^fDataTrack[fTracklength];
+           fTracklength++;
+           Bit13ToWrite=Bit13ToWrite-Bit16free;
+           Bit16free=16;
+         };
+       }; // end cycle while(Bit13ToWrite>0)
+     }; // end cycle DataDSP
+     if(Bit16free!=16) { fTracklength++; CheckSum=CheckSum^fDataTrack[fTracklength]; };
+     CheckSum=(CheckSum >> 8)^(CheckSum&0x00FF);
+     fDataTrack[fTracklength-Nword+11]=(0x0280 | (CheckSum >> 3));
+     fDataTrack[fTracklength-Nword+12]=(0x1C00 | (CheckSum << 13) );
+ // end write 13 bit DataDSP bufer inside 16 bit fDataTrack buffer
+ //write trailer on buffer
+     UShort_t ReLength=(UShort_t)((Nword+13)*2+3);
+     UShort_t OveCheckCode=0x0000;
+     fDataTrack[fTracklength]=0x0000;
+     fTracklength++;
+     fDataTrack[fTracklength]=(ReLength >> 8);
+     fTracklength++;
+     fDataTrack[fTracklength]=( (ReLength << 8) | (OveCheckCode & 0x00FF) );
+     fTracklength++;
+ // end trailer
+ //    std:: cout  << "DSPlength  " <<DSPlength << endl;
+ //    std:: cout << "Nword " << Nword  << endl;
+ //    std:: cout <<  "ReLength " << ReLength << endl;
+   };
+ //    std:: cout << "ntrastot " << ntrastot << endl;
+ };
+ Float_t Digitizer::SaturationTrack(Float_t ADC) {
+   Float_t SatFact=1.;
+   if(ADC<70.) { SatFact=80./ADC; };
+   if(ADC>3000.) { SatFact=3000./ADC; };
+   return SatFact;
+ };

 Legend:



Removed from v.1.2
 


changed lines


 
Added in v.1.5
 Legend:



Removed from v.1.2
 


changed lines


 
Added in v.1.5
-Removed from v.1.2
+Added in v.1.5

	ViewVC Help
Powered by ViewVC 1.1.23