[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.                  *
 **************************************************************************/

/*
$Log$
Revision 1.2  2002/10/14 14:57:44  hristov
Merging the VirtualMC branch to the main development branch (HEAD)

Revision 1.1.2.1  2002/10/11 07:26:37  hristov
Updating VirtualMC to v3-09-02

Revision 1.1  2002/09/13 14:33:52  cblume
Add conversion class to produce fake raw data

*/

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