[u/mrichter/AliRoot.git] / TRD / AliTRDrawData.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//  TRD raw data conversion class                                            //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include <Riostream.h>

#include "AliTRDrawData.h"
#include "AliTRDdigitsManager.h"
#include "AliTRDgeometryFull.h"
#include "AliTRDparameter.h"
#include "AliTRDdataArrayI.h"
#include "AliTRDarrayI.h"

ClassImp(AliTRDrawData)

//_____________________________________________________________________________
AliTRDrawData::AliTRDrawData():TObject()
{

  fDebug         = 0;
  fDigitsManager = NULL;

}

//_____________________________________________________________________________
AliTRDrawData::AliTRDrawData(const AliTRDrawData &r)
{
  //
  // AliTRDrawData copy constructor
  //

  ((AliTRDrawData &) r).Copy(*this);

}

//_____________________________________________________________________________
AliTRDrawData::~AliTRDrawData()
{
  //
  // Destructor
  //

  if (fDigitsManager) {
    delete fDigitsManager;
    fDigitsManager = NULL;
  }

}

//_____________________________________________________________________________
AliTRDrawData &AliTRDrawData::operator=(const AliTRDrawData &r)
{
  //
  // Assignment operator
  //

  if (this != &r) ((AliTRDrawData &) r).Copy(*this);
  return *this;

}

//_____________________________________________________________________________
void AliTRDrawData::Copy(TObject &r)
{
  //
  // Copy function
  //

  ((AliTRDrawData &) r).fDebug         = fDebug;
  ((AliTRDrawData &) r).fDigitsManager = NULL;

}

//_____________________________________________________________________________
Bool_t AliTRDrawData::OpenInput(const Char_t *name)
{
  //
  // Opens a ROOT-file with the TRD digits 
  //

  // Create the digits manager
  if (fDigitsManager) {
    delete fDigitsManager;
  }
  fDigitsManager = new AliTRDdigitsManager();
  fDigitsManager->SetDebug(fDebug);

  // Open the input file
  return fDigitsManager->Open(name);

}

//_____________________________________________________________________________
Bool_t AliTRDrawData::Digit2Raw(const Char_t *name1, const Char_t *name2)
{
  //
  // Convert the digits to raw data byte stream. The output is written
  // into the the binary files <name1> and <name2>.
  //
  // The pseudo raw data format is currently defined like this:
  //
  //          LDC header (8 bytes)
  //                  FLAG
  //                  LDC no.
  //                  Number of detectors with data (not yet implemented)
  //                  5 empty bytes
  //
  //          Subevent (= single chamber) header (8 bytes)
  //                  FLAG
  //                  Detector number (2 bytes)
  //                  Number of data bytes (2 bytes)
  //                  Number of pads with data (2 bytes)
  //                  1 empty byte
  //
  //          Data bank
  //

  const Int_t kLDCHeaderLength      = 8;
  const Int_t kSubeventHeaderLength = 8;

  const Int_t kLDCDummyFlag         = 0xAA;
  const Int_t kSubeventDummyFlag    = 0xBB;

  int headerLDC[2];
  int headerSubevent[2];

  Int_t          ntotalbyte[2] = { 0 };
  Int_t          nbyte = 0;
  Int_t          npads = 0;
  unsigned char *byte_p;
  unsigned char *header_p;

  AliTRDgeometryFull *geo = new AliTRDgeometryFull();
  AliTRDparameter    *par = new AliTRDparameter("TRDparameter"
                                               ,"TRD parameter class");
  AliTRDdataArrayI   *digits;

  if (fDebug) {
    Info("Digit2Raw","Open the LDC output files %s, %s"
        ,name1,name2);
  }
  ofstream *outputFile1 = new ofstream(name1, ios::out | ios::binary);
  ofstream *outputFile2 = new ofstream(name2, ios::out | ios::binary);
  ofstream *outputFile;

  if (!fDigitsManager) {
    Error("Digit2Raw","No input file open\n");
    return kFALSE;
  }

  // Read in the digit arrays
  if (!fDigitsManager->ReadDigits()) {
    return kFALSE;
  }

  // Count the number of chambers with data
  Int_t ndetLDC0 = 0;
  Int_t ndetLDC1 = 0;

  if (fDebug > 1) {
    Info("Digit2Raw","Write the LDC headers");
  }

  // Write the LDC header 1
  byte_p    = (unsigned char *) headerLDC;
  header_p  = byte_p;
  *byte_p++ = kLDCDummyFlag;
  *byte_p++ = 1;
  *byte_p++ = ndetLDC0;
  *byte_p++ = 0;
  *byte_p++ = 0;
  *byte_p++ = 0;
  *byte_p++ = 0;
  *byte_p++ = 0;
  outputFile1->write(header_p,kLDCHeaderLength);
  ntotalbyte[0] += kLDCHeaderLength;

  if (fDebug > 1) {
    Info("Digit2Raw","LDC header 0 = %d, %d",headerLDC[0],headerLDC[1]);
  }

  // Write the LDC header 1
  byte_p    = (unsigned char *) headerLDC;
  header_p  = byte_p;
  *byte_p++ = kLDCDummyFlag;
  *byte_p++ = 2;
  *byte_p++ = ndetLDC1;
  *byte_p++ = 0;
  *byte_p++ = 0;
  *byte_p++ = 0;
  *byte_p++ = 0;
  *byte_p++ = 0;
  outputFile2->write(header_p,kLDCHeaderLength);
  ntotalbyte[1] += kLDCHeaderLength;

  if (fDebug > 1) {
    Info("Digit2Raw","LDC header 1 = %d, %d",headerLDC[0],headerLDC[1]);
  }

  // Loop through all detectors
  for (Int_t det = 0; det < AliTRDgeometry::Ndet(); det++) {

    Int_t cham      = geo->GetChamber(det);
    Int_t plan      = geo->GetPlane(det);
    Int_t sect      = geo->GetSector(det);
    Int_t rowMax    = par->GetRowMax(plan,cham,sect);
    Int_t colMax    = par->GetColMax(plan);
    Int_t timeMax   = par->GetTimeMax();
    Int_t bufferMax = rowMax*colMax*timeMax;
    int  *buffer    = new int[bufferMax];

    npads  = 0;
    nbyte  = 0;
    byte_p = (unsigned char *) buffer;

    // Determine the LDC (resp. output file)
    Int_t ldc;
    if (sect < 9) {
      outputFile = outputFile1;
      ldc = 0;
    }
    else {
      outputFile = outputFile2;
      ldc = 1;
    }

    // Get the digits array
    digits = fDigitsManager->GetDigits(det);
    digits->Expand();

    // Loop through the detector pixel
    for (Int_t col = 0; col < colMax; col++) {
      for (Int_t row = 0; row < rowMax; row++) {

	// Check whether data exists for this pad
        Bool_t dataflag = kFALSE;
        for (Int_t time = 0; time < timeMax; time++) {
          Int_t data = digits->GetDataUnchecked(row,col,time);
          if (data) {
            dataflag = kTRUE;
            break;
	  }
	}

        if (dataflag) {

          npads++;

	  // The pad row number
          *byte_p++ = row + 1;
	  // The pad column number
          *byte_p++ = col + 1;
          nbyte += 2;

          Int_t nzero = 0;
          for (Int_t time = 0; time < timeMax; time++) {

            Int_t data = digits->GetDataUnchecked(row,col,time);

            if (!data) {
              nzero++;
              if ((nzero ==       256) || 
                  (time  == timeMax-1)) {
                *byte_p++ = 0;
                *byte_p++ = nzero-1;
                nbyte += 2;
                nzero  = 0;
      	      }
	    }
            else {
              if (nzero) {
                *byte_p++ = 0;
                *byte_p++ = nzero-1;
                nbyte += 2;
                nzero  = 0;
	      }
              // High byte (MSB always set)
              *byte_p++ = ((data >> 8) | 128);
              // Low byte
              *byte_p++ = (data & 0xff);
              nbyte += 2;
	    }

	  }

	}

      }

    }

    // Fill the end of the buffer with zeros
    while (nbyte % 4) {  
      *byte_p++ = 0;
      nbyte++;
    }

    if (fDebug > 1) {
      Info("Digit2Raw","LDC = %d, det = %d, nbyte = %d (%d)",ldc,det,nbyte,bufferMax);
    }

    // Write the subevent header
    byte_p    = (unsigned char *) headerSubevent;
    header_p  = byte_p;
    *byte_p++ = kSubeventDummyFlag;
    *byte_p++ = (det   & 0xff);
    *byte_p++ = (det   >> 8);
    *byte_p++ = (nbyte & 0xff);
    *byte_p++ = (nbyte >> 8);
    *byte_p++ = (npads & 0xff);
    *byte_p++ = (npads >> 8);
    *byte_p++ = 0;
    outputFile->write(header_p,kSubeventHeaderLength);

    // Write the buffer to the file
    byte_p = (unsigned char *) buffer;
    outputFile->write(byte_p,nbyte);

    ntotalbyte[ldc] += nbyte + kSubeventHeaderLength;

    delete buffer;

  }

  if (fDebug) {
    Info("Digit2Raw","Total size: LDC0 = %d, LDC1 = %d",ntotalbyte[0],ntotalbyte[1]);
  }

  outputFile1->close();
  outputFile2->close();

  delete geo;
  delete par;
  delete outputFile1;
  delete outputFile2;

  return kTRUE;

}

//_____________________________________________________________________________
Bool_t AliTRDrawData::Raw2Digit(const Char_t *name1, const Char_t *name2)
{

  const Int_t  kLDCHeaderLength      = 8;
  const Int_t  kSubeventHeaderLength = 8;

  const Int_t  kNldc = 2;
  const Char_t *name = 0;

  int headerLDC[2];
  int headerSubevent[2];

  Int_t             npads     = 0;
  Int_t             nbyte     = 0;
  unsigned char    *byte_p;
  ifstream         *inputFile = 0;
  AliTRDdataArrayI *digits    = 0;

  AliTRDgeometryFull *geo = new AliTRDgeometryFull();
  AliTRDparameter    *par = new AliTRDparameter("TRDparameter"
                                               ,"TRD parameter class");

  // Create the digits manager
  if (fDigitsManager) {
    delete fDigitsManager;
  }
  fDigitsManager = new AliTRDdigitsManager();
  fDigitsManager->SetDebug(fDebug);
  fDigitsManager->CreateArrays();

  for (Int_t ldc = 0; ldc < kNldc; ldc++) {

    if      (ldc == 0) {
      name = name1;
    }
    else if (ldc == 1) {
      name = name2;
    }
    if (fDebug) {
      Info("Raw2Digit","Open the LDC input file %s",name);
    }
    inputFile = new ifstream(name, ios::in | ios::binary);

    // Read the LDC header
    byte_p = (unsigned char *) headerLDC;
    inputFile->read(byte_p,kLDCHeaderLength);

    if (fDebug > 1) {
      Info("Raw2Digit","LDC header no. %d:",ldc);
      Info("Raw2Digit","\tflag   = %d",*byte_p++);
      Info("Raw2Digit","\tldc no = %d",*byte_p++);
      Info("Raw2Digit","\tndet   = %d",*byte_p++);
      Info("Raw2Digit","\tempty  = %d",*byte_p++);
      Info("Raw2Digit","\tempty  = %d",*byte_p++);
      Info("Raw2Digit","\tempty  = %d",*byte_p++);
      Info("Raw2Digit","\tempty  = %d",*byte_p++);
      Info("Raw2Digit","\tempty  = %d",*byte_p++);
    }

    // Loop through the subevents
    byte_p = (unsigned char *) headerSubevent;
    while (inputFile->read(byte_p,kSubeventHeaderLength)) {

      Int_t flag   = *byte_p++;
      Int_t detl   = *byte_p++;
      Int_t deth   = *byte_p++;
      Int_t det    = detl   + (deth   << 8);
      Int_t nbytel = *byte_p++;
      Int_t nbyteh = *byte_p++;
            nbyte  = nbytel + (nbyteh << 8);
      Int_t npadsl = *byte_p++;
      Int_t npadsh = *byte_p++;
            npads  = npadsl + (npadsh << 8);
      if (fDebug > 2) {
        Info("Raw2Digit","Subevent header:");
        Info("Raw2Digit","\tflag  = %d",flag);
        Info("Raw2Digit","\tdet   = %d",det);
        Info("Raw2Digit","\tnbyte = %d",nbyte);
        Info("Raw2Digit","\tnpads = %d",npads);
        Info("Raw2Digit","\tempty = %d",*byte_p++);
      }      

      // Create the data buffer
      Int_t cham      = geo->GetChamber(det);
      Int_t plan      = geo->GetPlane(det);
      Int_t sect      = geo->GetSector(det);
      Int_t rowMax    = par->GetRowMax(plan,cham,sect);
      Int_t colMax    = par->GetColMax(plan);
      Int_t timeMax   = par->GetTimeMax();
      Int_t bufferMax = rowMax*colMax*timeMax;
      int   *buffer   = new int[bufferMax];
      byte_p          = (unsigned char *) buffer;      
      memset(buffer,0,bufferMax*sizeof(int));

      // Add a container for the digits of this detector
      digits = fDigitsManager->GetDigits(det);
      // Allocate memory space for the digits buffer
      if (digits->GetNtime() == 0) {
        digits->Allocate(rowMax,colMax,timeMax);
      }

      // Read the data   
      inputFile->read(byte_p,nbyte);

      Int_t time;
      Int_t nzero;
      Int_t data;
      Int_t low;
      Int_t high;
      Int_t signal;

      // Decompress the data
      while (nbyte > 0) {

        // The pad row number
        Int_t row = (*byte_p++) - 1;
        // The pad column number
        Int_t col = (*byte_p++) - 1;
        nbyte -= 2;

        time = nzero = 0;

        while ((time  < timeMax) &&
               (nbyte >       0)) {

          data = *byte_p++;
          nbyte--;

          if (data) {
            if (!nzero) {
              // signal for given timebim
              low    = *byte_p++;
              high   = data & 127;
              signal = low + (high << 8);
              if ((row <       0) || (col <       0) || (time <        0) ||
                  (row >= rowMax) || (col >= colMax) || (time >= timeMax)) {
                Error("Raw2Digit"
                     ,"row=%d(%d) col=%d(%d) time=%d(%d)"
		     ,row,rowMax,col,colMax,time,timeMax);
	      }
              else {
                digits->SetDataUnchecked(row,col,time,signal);
	      }
              nbyte--;
              time++;
	    }
            else {
              time += data + 1;
              nzero = 0;
	    }
	  }
          else {
            if (!nzero) {
              nzero = 1;
	    }
            else {
              time++;
              nzero = 0;
	    }
	  }

	}

      }

      digits->Compress(1,0);

      delete buffer;

      byte_p = (unsigned char *) headerSubevent;

    } 

    inputFile->close();
    delete inputFile;
    inputFile = 0;

  }

  delete geo;
  delete par;

  return kTRUE;

}
Commit	Line	Data
5990c064	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
88cb7938	16	/* $Id$ */
5990c064	17
	18	///////////////////////////////////////////////////////////////////////////////
	19	// //
	20	// TRD raw data conversion class //
	21	// //
	22	///////////////////////////////////////////////////////////////////////////////
	23
a2cb5b3d	24	#include <Riostream.h>
5990c064	25
	26	#include "AliTRDrawData.h"
	27	#include "AliTRDdigitsManager.h"
	28	#include "AliTRDgeometryFull.h"
	29	#include "AliTRDparameter.h"
	30	#include "AliTRDdataArrayI.h"
	31	#include "AliTRDarrayI.h"
	32
	33	ClassImp(AliTRDrawData)
	34
	35	//_____________________________________________________________________________
	36	AliTRDrawData::AliTRDrawData():TObject()
	37	{
	38
	39	fDebug = 0;
	40	fDigitsManager = NULL;
	41
	42	}
	43
	44	//_____________________________________________________________________________
	45	AliTRDrawData::AliTRDrawData(const AliTRDrawData &r)
	46	{
	47	//
	48	// AliTRDrawData copy constructor
	49	//
	50
	51	((AliTRDrawData &) r).Copy(*this);
	52
	53	}
	54
	55	//_____________________________________________________________________________
	56	AliTRDrawData::~AliTRDrawData()
	57	{
	58	//
	59	// Destructor
	60	//
	61
	62	if (fDigitsManager) {
	63	delete fDigitsManager;
	64	fDigitsManager = NULL;
	65	}
	66
	67	}
	68
	69	//_____________________________________________________________________________
	70	AliTRDrawData &AliTRDrawData::operator=(const AliTRDrawData &r)
	71	{
	72	//
	73	// Assignment operator
	74	//
	75
	76	if (this != &r) ((AliTRDrawData &) r).Copy(*this);
	77	return *this;
	78
	79	}
	80
	81	//_____________________________________________________________________________
	82	void AliTRDrawData::Copy(TObject &r)
	83	{
	84	//
	85	// Copy function
	86	//
	87
	88	((AliTRDrawData &) r).fDebug = fDebug;
89	((AliTRDrawData &) r).fDigitsManager = NULL;
90
91	}
92
93	//_____________________________________________________________________________
94	Bool_t AliTRDrawData::OpenInput(const Char_t *name)
95	{
96	//
97	// Opens a ROOT-file with the TRD digits
98	//
99
100	// Create the digits manager
101	if (fDigitsManager) {
102	delete fDigitsManager;
103	}
104	fDigitsManager = new AliTRDdigitsManager();
105	fDigitsManager->SetDebug(fDebug);
106
107	// Open the input file
108	return fDigitsManager->Open(name);
109
110	}
111
112	//_____________________________________________________________________________
113	Bool_t AliTRDrawData::Digit2Raw(const Char_t name1, const Char_t name2)
114	{
115	//
116	// Convert the digits to raw data byte stream. The output is written
117	// into the the binary files <name1> and <name2>.
118	//
119	// The pseudo raw data format is currently defined like this:
120	//
121	// LDC header (8 bytes)
122	// FLAG
123	// LDC no.
124	// Number of detectors with data (not yet implemented)
125	// 5 empty bytes
126	//
127	// Subevent (= single chamber) header (8 bytes)
128	// FLAG
129	// Detector number (2 bytes)
130	// Number of data bytes (2 bytes)
131	// Number of pads with data (2 bytes)
132	// 1 empty byte
133	//
134	// Data bank
135	//
136
137	const Int_t kLDCHeaderLength = 8;
138	const Int_t kSubeventHeaderLength = 8;
139
140	const Int_t kLDCDummyFlag = 0xAA;
141	const Int_t kSubeventDummyFlag = 0xBB;
142
143	int headerLDC[2];
144	int headerSubevent[2];
145
146	Int_t ntotalbyte[2] = { 0 };
147	Int_t nbyte = 0;
148	Int_t npads = 0;
149	unsigned char *byte_p;
150	unsigned char *header_p;
151
152	AliTRDgeometryFull *geo = new AliTRDgeometryFull();
153	AliTRDparameter *par = new AliTRDparameter("TRDparameter"
154	,"TRD parameter class");
155	AliTRDdataArrayI *digits;
156
157	if (fDebug) {
158	Info("Digit2Raw","Open the LDC output files %s, %s"
159	,name1,name2);
160	}
161	ofstream *outputFile1 = new ofstream(name1, ios::out \| ios::binary);
162	ofstream *outputFile2 = new ofstream(name2, ios::out \| ios::binary);
163	ofstream *outputFile;
164
165	if (!fDigitsManager) {
166	Error("Digit2Raw","No input file open\n");
167	return kFALSE;
168	}
169
170	// Read in the digit arrays
171	if (!fDigitsManager->ReadDigits()) {
172	return kFALSE;
173	}
174
175	// Count the number of chambers with data
176	Int_t ndetLDC0 = 0;
177	Int_t ndetLDC1 = 0;
178
179	if (fDebug > 1) {
180	Info("Digit2Raw","Write the LDC headers");
181	}
182
183	// Write the LDC header 1
184	byte_p = (unsigned char *) headerLDC;
185	header_p = byte_p;
186	*byte_p++ = kLDCDummyFlag;
187	*byte_p++ = 1;
188	*byte_p++ = ndetLDC0;
189	*byte_p++ = 0;
190	*byte_p++ = 0;
191	*byte_p++ = 0;
192	*byte_p++ = 0;
193	*byte_p++ = 0;
194	outputFile1->write(header_p,kLDCHeaderLength);
195	ntotalbyte[0] += kLDCHeaderLength;
196
197	if (fDebug > 1) {
198	Info("Digit2Raw","LDC header 0 = %d, %d",headerLDC[0],headerLDC[1]);
199	}
200
201	// Write the LDC header 1
202	byte_p = (unsigned char *) headerLDC;
203	header_p = byte_p;
204	*byte_p++ = kLDCDummyFlag;
205	*byte_p++ = 2;
206	*byte_p++ = ndetLDC1;
207	*byte_p++ = 0;
208	*byte_p++ = 0;
209	*byte_p++ = 0;
210	*byte_p++ = 0;
211	*byte_p++ = 0;
212	outputFile2->write(header_p,kLDCHeaderLength);
213	ntotalbyte[1] += kLDCHeaderLength;
214
215	if (fDebug > 1) {
216	Info("Digit2Raw","LDC header 1 = %d, %d",headerLDC[0],headerLDC[1]);
217	}
218
219	// Loop through all detectors
220	for (Int_t det = 0; det < AliTRDgeometry::Ndet(); det++) {
221
222	Int_t cham = geo->GetChamber(det);
223	Int_t plan = geo->GetPlane(det);
224	Int_t sect = geo->GetSector(det);
225	Int_t rowMax = par->GetRowMax(plan,cham,sect);
226	Int_t colMax = par->GetColMax(plan);
227	Int_t timeMax = par->GetTimeMax();
228	Int_t bufferMax = rowMaxcolMaxtimeMax;
229	int *buffer = new int[bufferMax];
230
231	npads = 0;
232	nbyte = 0;
233	byte_p = (unsigned char *) buffer;
234
235	// Determine the LDC (resp. output file)
236	Int_t ldc;
237	if (sect < 9) {
238	outputFile = outputFile1;
239	ldc = 0;
240	}
241	else {
242	outputFile = outputFile2;
243	ldc = 1;
244	}
245
246	// Get the digits array
247	digits = fDigitsManager->GetDigits(det);
248	digits->Expand();
249
250	// Loop through the detector pixel
251	for (Int_t col = 0; col < colMax; col++) {
252	for (Int_t row = 0; row < rowMax; row++) {
253
254	// Check whether data exists for this pad
255	Bool_t dataflag = kFALSE;
256	for (Int_t time = 0; time < timeMax; time++) {
257	Int_t data = digits->GetDataUnchecked(row,col,time);
258	if (data) {
259	dataflag = kTRUE;
260	break;
261	}
262	}
263
264	if (dataflag) {
265
266	npads++;
267
268	// The pad row number
269	*byte_p++ = row + 1;
270	// The pad column number
271	*byte_p++ = col + 1;
272	nbyte += 2;
273
274	Int_t nzero = 0;
275	for (Int_t time = 0; time < timeMax; time++) {
276
277	Int_t data = digits->GetDataUnchecked(row,col,time);
278
279	if (!data) {
280	nzero++;
281	if ((nzero == 256) \|\|
282	(time == timeMax-1)) {
283	*byte_p++ = 0;
284	*byte_p++ = nzero-1;
285	nbyte += 2;
286	nzero = 0;
287	}
288	}
289	else {
290	if (nzero) {
291	*byte_p++ = 0;
292	*byte_p++ = nzero-1;
293	nbyte += 2;
294	nzero = 0;
295	}
296	// High byte (MSB always set)
297	*byte_p++ = ((data >> 8) \| 128);
298	// Low byte
299	*byte_p++ = (data & 0xff);
300	nbyte += 2;
301	}
302
303	}
304
305	}
306
307	}
308
309	}
310
311	// Fill the end of the buffer with zeros
312	while (nbyte % 4) {
313	*byte_p++ = 0;
314	nbyte++;
315	}
316
317	if (fDebug > 1) {
318	Info("Digit2Raw","LDC = %d, det = %d, nbyte = %d (%d)",ldc,det,nbyte,bufferMax);
319	}
320
321	// Write the subevent header
322	byte_p = (unsigned char *) headerSubevent;
323	header_p = byte_p;
324	*byte_p++ = kSubeventDummyFlag;
325	*byte_p++ = (det & 0xff);
326	*byte_p++ = (det >> 8);
327	*byte_p++ = (nbyte & 0xff);
328	*byte_p++ = (nbyte >> 8);
329	*byte_p++ = (npads & 0xff);
330	*byte_p++ = (npads >> 8);
331	*byte_p++ = 0;
332	outputFile->write(header_p,kSubeventHeaderLength);
333
334	// Write the buffer to the file
335	byte_p = (unsigned char *) buffer;
336	outputFile->write(byte_p,nbyte);
337
338	ntotalbyte[ldc] += nbyte + kSubeventHeaderLength;
339
340	delete buffer;
341
342	}
343
344	if (fDebug) {
345	Info("Digit2Raw","Total size: LDC0 = %d, LDC1 = %d",ntotalbyte[0],ntotalbyte[1]);
346	}
347
348	outputFile1->close();
349	outputFile2->close();
350
351	delete geo;
352	delete par;
353	delete outputFile1;
354	delete outputFile2;
355
356	return kTRUE;
357
358	}
359
360	//_____________________________________________________________________________
361	Bool_t AliTRDrawData::Raw2Digit(const Char_t name1, const Char_t name2)
362	{
363
364	const Int_t kLDCHeaderLength = 8;
365	const Int_t kSubeventHeaderLength = 8;
366
367	const Int_t kNldc = 2;
368	const Char_t *name = 0;
369
370	int headerLDC[2];
371	int headerSubevent[2];
372
373	Int_t npads = 0;
374	Int_t nbyte = 0;
375	unsigned char *byte_p;
376	ifstream *inputFile = 0;
377	AliTRDdataArrayI *digits = 0;
378
379	AliTRDgeometryFull *geo = new AliTRDgeometryFull();
380	AliTRDparameter *par = new AliTRDparameter("TRDparameter"
381	,"TRD parameter class");
382
383	// Create the digits manager
384	if (fDigitsManager) {
385	delete fDigitsManager;
386	}
387	fDigitsManager = new AliTRDdigitsManager();
388	fDigitsManager->SetDebug(fDebug);
389	fDigitsManager->CreateArrays();
390
391	for (Int_t ldc = 0; ldc < kNldc; ldc++) {
392
393	if (ldc == 0) {
394	name = name1;
395	}
396	else if (ldc == 1) {
397	name = name2;
398	}
399	if (fDebug) {
400	Info("Raw2Digit","Open the LDC input file %s",name);
401	}
402	inputFile = new ifstream(name, ios::in \| ios::binary);
403
404	// Read the LDC header
405	byte_p = (unsigned char *) headerLDC;
406	inputFile->read(byte_p,kLDCHeaderLength);
407
408	if (fDebug > 1) {
409	Info("Raw2Digit","LDC header no. %d:",ldc);
410	Info("Raw2Digit","\tflag = %d",*byte_p++);
411	Info("Raw2Digit","\tldc no = %d",*byte_p++);
412	Info("Raw2Digit","\tndet = %d",*byte_p++);
413	Info("Raw2Digit","\tempty = %d",*byte_p++);
414	Info("Raw2Digit","\tempty = %d",*byte_p++);
415	Info("Raw2Digit","\tempty = %d",*byte_p++);
416	Info("Raw2Digit","\tempty = %d",*byte_p++);
417	Info("Raw2Digit","\tempty = %d",*byte_p++);
418	}
419
420	// Loop through the subevents
421	byte_p = (unsigned char *) headerSubevent;
422	while (inputFile->read(byte_p,kSubeventHeaderLength)) {
423
424	Int_t flag = *byte_p++;
425	Int_t detl = *byte_p++;
426	Int_t deth = *byte_p++;
427	Int_t det = detl + (deth << 8);
428	Int_t nbytel = *byte_p++;
429	Int_t nbyteh = *byte_p++;
430	nbyte = nbytel + (nbyteh << 8);
431	Int_t npadsl = *byte_p++;
432	Int_t npadsh = *byte_p++;
433	npads = npadsl + (npadsh << 8);
434	if (fDebug > 2) {
435	Info("Raw2Digit","Subevent header:");
436	Info("Raw2Digit","\tflag = %d",flag);
437	Info("Raw2Digit","\tdet = %d",det);
438	Info("Raw2Digit","\tnbyte = %d",nbyte);
439	Info("Raw2Digit","\tnpads = %d",npads);
440	Info("Raw2Digit","\tempty = %d",*byte_p++);
441	}
442
443	// Create the data buffer
444	Int_t cham = geo->GetChamber(det);
445	Int_t plan = geo->GetPlane(det);
446	Int_t sect = geo->GetSector(det);
447	Int_t rowMax = par->GetRowMax(plan,cham,sect);
448	Int_t colMax = par->GetColMax(plan);
449	Int_t timeMax = par->GetTimeMax();
450	Int_t bufferMax = rowMaxcolMaxtimeMax;
451	int *buffer = new int[bufferMax];
452	byte_p = (unsigned char *) buffer;
453	memset(buffer,0,bufferMax*sizeof(int));
454
455	// Add a container for the digits of this detector
456	digits = fDigitsManager->GetDigits(det);
457	// Allocate memory space for the digits buffer
458	if (digits->GetNtime() == 0) {
459	digits->Allocate(rowMax,colMax,timeMax);
460	}
461
462	// Read the data
463	inputFile->read(byte_p,nbyte);
464
465	Int_t time;
466	Int_t nzero;
467	Int_t data;
468	Int_t low;
469	Int_t high;
470	Int_t signal;
471
472	// Decompress the data
473	while (nbyte > 0) {
474
475	// The pad row number
476	Int_t row = (*byte_p++) - 1;
477	// The pad column number
478	Int_t col = (*byte_p++) - 1;
479	nbyte -= 2;
480
481	time = nzero = 0;
482
483	while ((time < timeMax) &&
484	(nbyte > 0)) {
485
486	data = *byte_p++;
487	nbyte--;
488
489	if (data) {
490	if (!nzero) {
491	// signal for given timebim
492	low = *byte_p++;
493	high = data & 127;
494	signal = low + (high << 8);
495	if ((row < 0) \|\| (col < 0) \|\| (time < 0) \|\|
496	(row >= rowMax) \|\| (col >= colMax) \|\| (time >= timeMax)) {
497	Error("Raw2Digit"
498	,"row=%d(%d) col=%d(%d) time=%d(%d)"
499	,row,rowMax,col,colMax,time,timeMax);
500	}
501	else {
502	digits->SetDataUnchecked(row,col,time,signal);
503	}
504	nbyte--;
505	time++;
506	}
507	else {
508	time += data + 1;
509	nzero = 0;
510	}
511	}
512	else {
513	if (!nzero) {
514	nzero = 1;
515	}
516	else {
517	time++;
518	nzero = 0;
519	}
520	}
521
522	}
523
524	}
525
526	digits->Compress(1,0);
527
528	delete buffer;
529
530	byte_p = (unsigned char *) headerSubevent;
531
532	}
533
534	inputFile->close();
535	delete inputFile;
536	inputFile = 0;
537
538	}
539
540	delete geo;
541	delete par;
542
543	return kTRUE;
544
545	}