[u/mrichter/AliRoot.git] / FMD / AliFMDRawReader.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$ */
/** @file    AliFMDRawReader.cxx
    @author  Christian Holm Christensen <cholm@nbi.dk>
    @date    Mon Mar 27 12:45:23 2006
    @brief   Class to read raw data 
*/
//____________________________________________________________________
//
// Class to read ADC values from a AliRawReader object. 
//
// This class uses the AliFMDRawStreamer class to read the ALTRO
// formatted data. 
// 
//          +-------+
//          | TTask |
//          +-------+
//              ^
//              |
//      +-----------------+  <<references>>  +--------------+
//      | AliFMDRawReader |<>----------------| AliRawReader |
//      +-----------------+                  +--------------+
//              |                                  ^
//              | <<uses>>                         |
//              V                                  |
//      +-----------------+      <<uses>>          |
//      | AliFMDRawStream |------------------------+
//      +-----------------+
//              |
//              V
//      +----------------+
//      | AliAltroStream |
//      +----------------+
//
#include <AliLog.h>		// ALILOG_H
#include "AliFMDParameters.h"	// ALIFMDPARAMETERS_H
#include "AliFMDDigit.h"	// ALIFMDDIGIT_H
#include "AliFMDRawStream.h"	// ALIFMDRAWSTREAM_H 
#include "AliRawReader.h"	// ALIRAWREADER_H 
#include "AliFMDRawReader.h"	// ALIFMDRAWREADER_H 
// #include "AliFMDAltroIO.h"	// ALIFMDALTROIO_H 
#include <TArrayI.h>		// ROOT_TArrayI
#include <TTree.h>		// ROOT_TTree
#include <TClonesArray.h>	// ROOT_TClonesArray
#include <iostream>
#include <iomanip>
#include <sstream>
#define PRETTY_HEX(N,X) \
  "  0x" << std::setfill('0') << std::setw(N) << std::hex << X \
         << std::setfill(' ') << std::dec

//____________________________________________________________________
ClassImp(AliFMDRawReader)
#if 0
  ; // This is here to keep Emacs for indenting the next line
#endif

//____________________________________________________________________
AliFMDRawReader::AliFMDRawReader(AliRawReader* reader, TTree* tree) 
  : TTask("FMDRawReader", "Reader of Raw ADC values from the FMD"),
    fTree(tree),
    fReader(reader), 
    fSampleRate(1)
{
  // Default CTOR
}

//____________________________________________________________________
void
AliFMDRawReader::Exec(Option_t*) 
{
  TClonesArray* array = new TClonesArray("AliFMDDigit");
  if (!fTree) {
    AliError("No tree");
    return;
  }
  fTree->Branch("FMD", &array);
  ReadAdcs(array);
  Int_t nWrite = fTree->Fill();
  AliDebug(1, Form("Got a grand total of %d digits, wrote %d bytes to tree", 
		   array->GetEntries(), nWrite));
}


#if 1
//____________________________________________________________________
Bool_t
AliFMDRawReader::ReadAdcs(TClonesArray* array) 
{
  // Read raw data into the digits array, using AliFMDAltroReader. 
  if (!array) {
    AliError("No TClonesArray passed");
    return kFALSE;
  }
  if (!fReader->ReadHeader()) {
    AliError("Couldn't read header");
    return kFALSE;
  }
  // Get sample rate 
  AliFMDParameters* pars = AliFMDParameters::Instance();
  AliFMDRawStream input(fReader);
  // Select FMD DDL's 
  fReader->Select(AliFMDParameters::kBaseDDL>>8);

  UShort_t stripMin = 0;
  UShort_t stripMax = 127;
  UShort_t preSamp  = 0;
  
  UInt_t ddl    = 0;
  UInt_t rate   = 0;
  UInt_t last   = 0;
  UInt_t hwaddr = 0;
  // Data array is approx twice the size needed. 
  UShort_t data[2048];
  while (input.ReadChannel(ddl, hwaddr, last, data)) {
    AliDebug(5, Form("Read channel 0x%x of size %d", hwaddr, last));
    UShort_t det, sec, str;
    Char_t   ring;
    if (!pars->Hardware2Detector(ddl, hwaddr, det, ring, sec, str)) {
      AliError(Form("Failed to get detector id from DDL %d "
		    "and hardware address 0x%x", ddl, hwaddr));
      continue;
    }
    rate     = pars->GetSampleRate(det, ring, sec, str);
    stripMin = pars->GetMinStrip(det, ring, sec, str);
    stripMax = pars->GetMaxStrip(det, ring, sec, str);
    AliDebug(5, Form("DDL 0x%04x, address 0x%03x maps to FMD%d%c[%2d,%3d]", 
		       ddl, hwaddr, det, ring, sec, str));
    
    // Loop over the `timebins', and make the digits
    for (size_t i = 0; i < last; i++) {
      if (i < preSamp) continue;
      Int_t    n      = array->GetEntries();
      UShort_t curStr = str + stripMin + i / rate;
      if ((curStr-str) > stripMax) {
	AliError(Form("Current strip is %d but DB says max is %d", 
		      curStr, stripMax));
      }
      AliDebug(5, Form("making digit for FMD%d%c[%2d,%3d] from sample %4d", 
		       det, ring, sec, curStr, i));
      new ((*array)[n]) AliFMDDigit(det, ring, sec, curStr, data[i], 
				    (rate >= 2 ? data[i+1] : 0),
				    (rate >= 3 ? data[i+2] : 0));
      if (rate >= 2) i++;
      if (rate >= 3) i++;
    }
  }
  return kTRUE;
}
#else
//____________________________________________________________________
Bool_t
AliFMDRawReader::ReadAdcs(TClonesArray* array) 
{
  // Read raw data into the digits array, using AliFMDAltroReader. 
  if (!array) {
    AliError("No TClonesArray passed");
    return kFALSE;
  }
  if (!fReader->ReadHeader()) {
    AliError("Couldn't read header");
    return kFALSE;
  }
  // Get sample rate 
  AliFMDParameters* pars = AliFMDParameters::Instance();

  // Select FMD DDL's 
  fReader->Select(AliFMDParameters::kBaseDDL>>8);

  UShort_t stripMin = 0;
  UShort_t stripMax = 127;
  UShort_t preSamp  = 0;
  
  do {
    UChar_t* cdata;
    if (!fReader->ReadNextData(cdata)) break;
    size_t   nchar = fReader->GetDataSize();
    UShort_t ddl   = AliFMDParameters::kBaseDDL + fReader->GetDDLID();
    UShort_t rate  = 0;
    AliDebug(1, Form("Reading %d bytes (%d 10bit words) from %d", 
		     nchar, nchar * 8 / 10, ddl));
    // Make a stream to read from 
    std::string str((char*)(cdata), nchar);
    std::istringstream s(str);
    // Prep the reader class.
    AliFMDAltroReader r(s);
    // Data array is approx twice the size needed. 
    UShort_t data[2048], hwaddr, last;
    while (r.ReadChannel(hwaddr, last, data) > 0) {
      AliDebug(5, Form("Read channel 0x%x of size %d", hwaddr, last));
      UShort_t det, sec, str;
      Char_t   ring;
      if (!pars->Hardware2Detector(ddl, hwaddr, det, ring, sec, str)) {
	AliError(Form("Failed to detector id from DDL %d "
		      "and hardware address 0x%x", ddl, hwaddr));
	continue;
      }
      rate     = pars->GetSampleRate(det, ring, sec, str);
      stripMin = pars->GetMinStrip(det, ring, sec, str);
      stripMax = pars->GetMaxStrip(det, ring, sec, str);
      AliDebug(5, Form("DDL 0x%04x, address 0x%03x maps to FMD%d%c[%2d,%3d]", 
		       ddl, hwaddr, det, ring, sec, str));

      // Loop over the `timebins', and make the digits
      for (size_t i = 0; i < last; i++) {
	if (i < preSamp) continue;
	Int_t    n      = array->GetEntries();
	UShort_t curStr = str + stripMin + i / rate;
	if ((curStr-str) > stripMax) {
	  AliError(Form("Current strip is %d but DB says max is %d", 
			curStr, stripMax));
	}
	AliDebug(5, Form("making digit for FMD%d%c[%2d,%3d] from sample %4d", 
			 det, ring, sec, curStr, i));
	new ((*array)[n]) AliFMDDigit(det, ring, sec, curStr, data[i], 
				      (rate >= 2 ? data[i+1] : 0),
				      (rate >= 3 ? data[i+2] : 0));
	if (rate >= 2) i++;
	if (rate >= 3) i++;
	}
	if (r.IsBof()) break;
    }
  } while (true);
  return kTRUE;
}

  
// This is the old method, for comparison.   It's really ugly, and far
// too convoluted. 
//____________________________________________________________________
void
AliFMDRawReader::Exec(Option_t*) 
{
  // Read raw data into the digits array
  if (!fReader->ReadHeader()) {
    Error("ReadAdcs", "Couldn't read header");
    return;
  }

  Int_t n = 0;
  TClonesArray* array = new TClonesArray("AliFMDDigit");
  fTree->Branch("FMD", &array);

  // Get sample rate 
  AliFMDParameters* pars = AliFMDParameters::Instance();
  fSampleRate = pars->GetSampleRate(AliFMDParameters::kBaseDDL);

  // Use AliAltroRawStream to read the ALTRO format.  No need to
  // reinvent the wheel :-) 
  AliFMDRawStream input(fReader, fSampleRate);
  // Select FMD DDL's 
  fReader->Select(AliFMDParameters::kBaseDDL);
  
  Int_t    oldDDL      = -1;
  Int_t    count       = 0;
  UShort_t detector    = 1; // Must be one here
  UShort_t oldDetector = 0;
  Bool_t   next        = kTRUE;

  // local Cache 
  TArrayI counts(10);
  counts.Reset(-1);
  
  // Loop over data in file 
  while (next) {
    next = input.Next();

    count++; 
    Int_t ddl = fReader->GetDDLID();
    AliDebug(10, Form("Current DDL is %d", ddl));
    if (ddl != oldDDL || input.IsNewStrip() || !next) {
      // Make a new digit, if we have some data (oldDetector == 0,
      // means that we haven't really read anything yet - that is,
      // it's the first time we get here). 
      if (oldDetector > 0) {
	// Got a new strip. 
	AliDebug(10, Form("Add a new strip: FMD%d%c[%2d,%3d] "
			  "(current: FMD%d%c[%2d,%3d])", 
			  oldDetector, input.PrevRing(), 
			  input.PrevSector() , input.PrevStrip(),
			  detector , input.Ring(), input.Sector(), 
			  input.Strip()));
	new ((*array)[n]) AliFMDDigit(oldDetector, 
				      input.PrevRing(), 
				      input.PrevSector(), 
				      input.PrevStrip(), 
				      counts[0], counts[1], counts[2]);
	n++;
#if 0
	AliFMDDigit* digit = 
	  static_cast<AliFMDDigit*>(fFMD->Digits()->
				    UncheckedAt(fFMD->GetNdigits()-1));
#endif 
      }
	
      if (!next) { 
	AliDebug(10, Form("Read %d channels for FMD%d", 
			  count + 1, detector));
	break;
      }
    
    
      // If we got a new DDL, it means we have a new detector. 
      if (ddl != oldDDL) {
	if (detector != 0) 
	  AliDebug(10, Form("Read %d channels for FMD%d", count + 1, detector));
	// Reset counts, and update the DDL cache 
	count       = 0;
	oldDDL      = ddl;
	// Check that we're processing a FMD detector 
	Int_t detId = fReader->GetDetectorID();
	if (detId != (AliFMDParameters::kBaseDDL >> 8)) {
	  AliError(Form("Detector ID %d != %d",
			detId, (AliFMDParameters::kBaseDDL >> 8)));
	  break;
	}
	// Figure out what detector we're deling with 
	oldDetector = detector;
	switch (ddl) {
	case 0: detector = 1; break;
	case 1: detector = 2; break;
	case 2: detector = 3; break;
	default:
	  AliError(Form("Unknown DDL 0x%x for FMD", ddl));
	  return;
	}
	AliDebug(10, Form("Reading ADCs for 0x%x  - That is FMD%d",
			  fReader->GetEquipmentId(), detector));
      }
      counts.Reset(-1);
    }
    
    counts[input.Sample()] = input.Count();
    
    AliDebug(10, Form("ADC of FMD%d%c[%2d,%3d] += %d",
		      detector, input.Ring(), input.Sector(), 
		      input.Strip(), input.Count()));
    oldDetector = detector;
  }
  fTree->Fill();
  return;

}
#endif

//____________________________________________________________________
// 
// EOF
//
Commit	Line	Data
e802be3e	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	**************************************************************************/
e802be3e	15	/* $Id$ */
c2fc1258	16	/** @file AliFMDRawReader.cxx
	17	@author Christian Holm Christensen <cholm@nbi.dk>
	18	@date Mon Mar 27 12:45:23 2006
	19	@brief Class to read raw data
	20	*/
e802be3e	21	//____________________________________________________________________
	22	//
	23	// Class to read ADC values from a AliRawReader object.
	24	//
7684b53c	25	// This class uses the AliFMDRawStreamer class to read the ALTRO
	26	// formatted data.
	27	//
	28	// +-------+
	29	// \| TTask \|
	30	// +-------+
	31	// ^
	32	// \|
	33	// +-----------------+ <<references>> +--------------+
	34	// \| AliFMDRawReader \|<>----------------\| AliRawReader \|
	35	// +-----------------+ +--------------+
	36	// \| ^
	37	// \| <<uses>> \|
	38	// V \|
	39	// +-----------------+ <<uses>> \|
	40	// \| AliFMDRawStream \|------------------------+
	41	// +-----------------+
	42	// \|
	43	// V
	44	// +----------------+
	45	// \| AliAltroStream \|
	46	// +----------------+
	47	//
56b1929b	48	#include <AliLog.h> // ALILOG_H
1a1fdef7	49	#include "AliFMDParameters.h" // ALIFMDPARAMETERS_H
e802be3e	50	#include "AliFMDDigit.h" // ALIFMDDIGIT_H
	51	#include "AliFMDRawStream.h" // ALIFMDRAWSTREAM_H
	52	#include "AliRawReader.h" // ALIRAWREADER_H
	53	#include "AliFMDRawReader.h" // ALIFMDRAWREADER_H
c2fc1258	54	// #include "AliFMDAltroIO.h" // ALIFMDALTROIO_H
56b1929b	55	#include <TArrayI.h> // ROOT_TArrayI
1a1fdef7	56	#include <TTree.h> // ROOT_TTree
1a1fdef7	57	#include <TClonesArray.h> // ROOT_TClonesArray
1e8f773e	58	#include <iostream>
	59	#include <iomanip>
	60	#include <sstream>
	61	#define PRETTY_HEX(N,X) \
	62	" 0x" << std::setfill('0') << std::setw(N) << std::hex << X \
	63	<< std::setfill(' ') << std::dec
e802be3e	64
e802be3e	65	//____________________________________________________________________
925e6570	66	ClassImp(AliFMDRawReader)
1a1fdef7	67	#if 0
	68	; // This is here to keep Emacs for indenting the next line
	69	#endif
e802be3e	70
e802be3e	71	//____________________________________________________________________
1a1fdef7	72	AliFMDRawReader::AliFMDRawReader(AliRawReader* reader, TTree* tree)
e802be3e	73	: TTask("FMDRawReader", "Reader of Raw ADC values from the FMD"),
1a1fdef7	74	fTree(tree),
	75	fReader(reader),
	76	fSampleRate(1)
e802be3e	77	{
56b1929b	78	// Default CTOR
e802be3e	79	}
e802be3e	80
c2fc1258	81	//____________________________________________________________________
	82	void
	83	AliFMDRawReader::Exec(Option_t*)
	84	{
	85	TClonesArray* array = new TClonesArray("AliFMDDigit");
	86	if (!fTree) {
	87	AliError("No tree");
	88	return;
	89	}
	90	fTree->Branch("FMD", &array);
	91	ReadAdcs(array);
	92	Int_t nWrite = fTree->Fill();
	93	AliDebug(1, Form("Got a grand total of %d digits, wrote %d bytes to tree",
	94	array->GetEntries(), nWrite));
	95	}
	96
	97
	98	#if 1
	99	//____________________________________________________________________
	100	Bool_t
	101	AliFMDRawReader::ReadAdcs(TClonesArray* array)
	102	{
	103	// Read raw data into the digits array, using AliFMDAltroReader.
	104	if (!array) {
	105	AliError("No TClonesArray passed");
	106	return kFALSE;
	107	}
	108	if (!fReader->ReadHeader()) {
	109	AliError("Couldn't read header");
	110	return kFALSE;
	111	}
	112	// Get sample rate
	113	AliFMDParameters* pars = AliFMDParameters::Instance();
	114	AliFMDRawStream input(fReader);
	115	// Select FMD DDL's
	116	fReader->Select(AliFMDParameters::kBaseDDL>>8);
	117
	118	UShort_t stripMin = 0;
	119	UShort_t stripMax = 127;
	120	UShort_t preSamp = 0;
	121
	122	UInt_t ddl = 0;
	123	UInt_t rate = 0;
	124	UInt_t last = 0;
	125	UInt_t hwaddr = 0;
	126	// Data array is approx twice the size needed.
	127	UShort_t data[2048];
	128	while (input.ReadChannel(ddl, hwaddr, last, data)) {
	129	AliDebug(5, Form("Read channel 0x%x of size %d", hwaddr, last));
	130	UShort_t det, sec, str;
	131	Char_t ring;
	132	if (!pars->Hardware2Detector(ddl, hwaddr, det, ring, sec, str)) {
	133	AliError(Form("Failed to get detector id from DDL %d "
	134	"and hardware address 0x%x", ddl, hwaddr));
	135	continue;
	136	}
	137	rate = pars->GetSampleRate(det, ring, sec, str);
	138	stripMin = pars->GetMinStrip(det, ring, sec, str);
	139	stripMax = pars->GetMaxStrip(det, ring, sec, str);
	140	AliDebug(5, Form("DDL 0x%04x, address 0x%03x maps to FMD%d%c[%2d,%3d]",
	141	ddl, hwaddr, det, ring, sec, str));
	142
	143	// Loop over the `timebins', and make the digits
	144	for (size_t i = 0; i < last; i++) {
145	if (i < preSamp) continue;
146	Int_t n = array->GetEntries();
147	UShort_t curStr = str + stripMin + i / rate;
148	if ((curStr-str) > stripMax) {
149	AliError(Form("Current strip is %d but DB says max is %d",
150	curStr, stripMax));
151	}
152	AliDebug(5, Form("making digit for FMD%d%c[%2d,%3d] from sample %4d",
153	det, ring, sec, curStr, i));
154	new ((*array)[n]) AliFMDDigit(det, ring, sec, curStr, data[i],
155	(rate >= 2 ? data[i+1] : 0),
156	(rate >= 3 ? data[i+2] : 0));
157	if (rate >= 2) i++;
158	if (rate >= 3) i++;
159	}
160	}
161	return kTRUE;
162	}
163	#else
1e8f773e	164	//____________________________________________________________________
d760ea03	165	Bool_t
d760ea03	166	AliFMDRawReader::ReadAdcs(TClonesArray* array)
1e8f773e	167	{
1e8f773e	168	// Read raw data into the digits array, using AliFMDAltroReader.
d760ea03	169	if (!array) {
	170	AliError("No TClonesArray passed");
	171	return kFALSE;
	172	}
1e8f773e	173	if (!fReader->ReadHeader()) {
d760ea03	174	AliError("Couldn't read header");
d760ea03	175	return kFALSE;
1e8f773e	176	}
1e8f773e	177	// Get sample rate
	178	AliFMDParameters* pars = AliFMDParameters::Instance();
	179
	180	// Select FMD DDL's
	181	fReader->Select(AliFMDParameters::kBaseDDL>>8);
	182
	183	UShort_t stripMin = 0;
	184	UShort_t stripMax = 127;
	185	UShort_t preSamp = 0;
	186
	187	do {
	188	UChar_t* cdata;
	189	if (!fReader->ReadNextData(cdata)) break;
	190	size_t nchar = fReader->GetDataSize();
	191	UShort_t ddl = AliFMDParameters::kBaseDDL + fReader->GetDDLID();
c2fc1258	192	UShort_t rate = 0;
1e8f773e	193	AliDebug(1, Form("Reading %d bytes (%d 10bit words) from %d",
	194	nchar, nchar * 8 / 10, ddl));
	195	// Make a stream to read from
	196	std::string str((char*)(cdata), nchar);
	197	std::istringstream s(str);
	198	// Prep the reader class.
	199	AliFMDAltroReader r(s);
	200	// Data array is approx twice the size needed.
	201	UShort_t data[2048], hwaddr, last;
	202	while (r.ReadChannel(hwaddr, last, data) > 0) {
	203	AliDebug(5, Form("Read channel 0x%x of size %d", hwaddr, last));
	204	UShort_t det, sec, str;
	205	Char_t ring;
	206	if (!pars->Hardware2Detector(ddl, hwaddr, det, ring, sec, str)) {
	207	AliError(Form("Failed to detector id from DDL %d "
	208	"and hardware address 0x%x", ddl, hwaddr));
	209	continue;
	210	}
c2fc1258	211	rate = pars->GetSampleRate(det, ring, sec, str);
	212	stripMin = pars->GetMinStrip(det, ring, sec, str);
	213	stripMax = pars->GetMaxStrip(det, ring, sec, str);
1e8f773e	214	AliDebug(5, Form("DDL 0x%04x, address 0x%03x maps to FMD%d%c[%2d,%3d]",
	215	ddl, hwaddr, det, ring, sec, str));
	216
	217	// Loop over the `timebins', and make the digits
	218	for (size_t i = 0; i < last; i++) {
	219	if (i < preSamp) continue;
d760ea03	220	Int_t n = array->GetEntries();
1e8f773e	221	UShort_t curStr = str + stripMin + i / rate;
	222	if ((curStr-str) > stripMax) {
	223	AliError(Form("Current strip is %d but DB says max is %d",
	224	curStr, stripMax));
	225	}
	226	AliDebug(5, Form("making digit for FMD%d%c[%2d,%3d] from sample %4d",
	227	det, ring, sec, curStr, i));
	228	new ((*array)[n]) AliFMDDigit(det, ring, sec, curStr, data[i],
	229	(rate >= 2 ? data[i+1] : 0),
	230	(rate >= 3 ? data[i+2] : 0));
	231	if (rate >= 2) i++;
	232	if (rate >= 3) i++;
	233	}
	234	if (r.IsBof()) break;
	235	}
	236	} while (true);
d760ea03	237	return kTRUE;
	238	}
	239
	240
	241
1e8f773e	242	// This is the old method, for comparison. It's really ugly, and far
1e8f773e	243	// too convoluted.
e802be3e	244	//____________________________________________________________________
	245	void
	246	AliFMDRawReader::Exec(Option_t*)
	247	{
56b1929b	248	// Read raw data into the digits array
e802be3e	249	if (!fReader->ReadHeader()) {
	250	Error("ReadAdcs", "Couldn't read header");
	251	return;
	252	}
	253
1a1fdef7	254	Int_t n = 0;
	255	TClonesArray* array = new TClonesArray("AliFMDDigit");
	256	fTree->Branch("FMD", &array);
	257
8f6ee336	258	// Get sample rate
	259	AliFMDParameters* pars = AliFMDParameters::Instance();
	260	fSampleRate = pars->GetSampleRate(AliFMDParameters::kBaseDDL);
	261
e802be3e	262	// Use AliAltroRawStream to read the ALTRO format. No need to
	263	// reinvent the wheel :-)
	264	AliFMDRawStream input(fReader, fSampleRate);
	265	// Select FMD DDL's
8f6ee336	266	fReader->Select(AliFMDParameters::kBaseDDL);
e802be3e	267
	268	Int_t oldDDL = -1;
	269	Int_t count = 0;
	270	UShort_t detector = 1; // Must be one here
	271	UShort_t oldDetector = 0;
	272	Bool_t next = kTRUE;
	273
	274	// local Cache
	275	TArrayI counts(10);
	276	counts.Reset(-1);
	277
	278	// Loop over data in file
	279	while (next) {
	280	next = input.Next();
	281
	282	count++;
	283	Int_t ddl = fReader->GetDDLID();
1e8f773e	284	AliDebug(10, Form("Current DDL is %d", ddl));
e802be3e	285	if (ddl != oldDDL \|\| input.IsNewStrip() \|\| !next) {
	286	// Make a new digit, if we have some data (oldDetector == 0,
	287	// means that we haven't really read anything yet - that is,
	288	// it's the first time we get here).
	289	if (oldDetector > 0) {
	290	// Got a new strip.
	291	AliDebug(10, Form("Add a new strip: FMD%d%c[%2d,%3d] "
	292	"(current: FMD%d%c[%2d,%3d])",
	293	oldDetector, input.PrevRing(),
	294	input.PrevSector() , input.PrevStrip(),
	295	detector , input.Ring(), input.Sector(),
	296	input.Strip()));
1a1fdef7	297	new ((*array)[n]) AliFMDDigit(oldDetector,
	298	input.PrevRing(),
	299	input.PrevSector(),
	300	input.PrevStrip(),
	301	counts[0], counts[1], counts[2]);
	302	n++;
e802be3e	303	#if 0
	304	AliFMDDigit* digit =
	305	static_cast<AliFMDDigit*>(fFMD->Digits()->
	306	UncheckedAt(fFMD->GetNdigits()-1));
	307	#endif
	308	}
	309
	310	if (!next) {
	311	AliDebug(10, Form("Read %d channels for FMD%d",
	312	count + 1, detector));
	313	break;
	314	}
	315
	316
	317	// If we got a new DDL, it means we have a new detector.
	318	if (ddl != oldDDL) {
	319	if (detector != 0)
1e8f773e	320	AliDebug(10, Form("Read %d channels for FMD%d", count + 1, detector));
e802be3e	321	// Reset counts, and update the DDL cache
	322	count = 0;
	323	oldDDL = ddl;
	324	// Check that we're processing a FMD detector
	325	Int_t detId = fReader->GetDetectorID();
1a1fdef7	326	if (detId != (AliFMDParameters::kBaseDDL >> 8)) {
1e8f773e	327	AliError(Form("Detector ID %d != %d",
1e8f773e	328	detId, (AliFMDParameters::kBaseDDL >> 8)));
e802be3e	329	break;
	330	}
	331	// Figure out what detector we're deling with
	332	oldDetector = detector;
	333	switch (ddl) {
	334	case 0: detector = 1; break;
	335	case 1: detector = 2; break;
	336	case 2: detector = 3; break;
	337	default:
1e8f773e	338	AliError(Form("Unknown DDL 0x%x for FMD", ddl));
e802be3e	339	return;
	340	}
	341	AliDebug(10, Form("Reading ADCs for 0x%x - That is FMD%d",
	342	fReader->GetEquipmentId(), detector));
	343	}
	344	counts.Reset(-1);
	345	}
	346
	347	counts[input.Sample()] = input.Count();
	348
	349	AliDebug(10, Form("ADC of FMD%d%c[%2d,%3d] += %d",
	350	detector, input.Ring(), input.Sector(),
	351	input.Strip(), input.Count()));
	352	oldDetector = detector;
	353	}
1a1fdef7	354	fTree->Fill();
e802be3e	355	return;
	356
	357	}
1e8f773e	358	#endif
e802be3e	359
	360	//____________________________________________________________________
	361	//
	362	// EOF
	363	//