[u/mrichter/AliRoot.git] / FMD / AliFMDAltroIO.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    AliFMDAltroIO.cxx
    @author  Christian Holm Christensen <cholm@nbi.dk>
    @date    Sun Mar 26 18:27:06 2006
    @brief   Altro Input/Output
*/
//____________________________________________________________________
//                                                                          
// Mapping of ALTRO hardware channel to detector coordinates 
//
#include "AliFMDAltroIO.h"
#include <AliRawDataHeader.h>
#include <AliRawReader.h>
#include "AliLog.h"
#include <iostream>
#include <iomanip>
#define PRETTY_HEX(N,X) \
  "  0x" << std::setfill('0') << std::setw(N) << std::hex << X \
         << std::setfill(' ') << std::dec

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

//____________________________________________________________________
const AliFMDAltroIO::W40_t AliFMDAltroIO::fgkTrailerMask = 
((AliFMDAltroIO::W40_t(0x2aaa) << 26) + (AliFMDAltroIO::W40_t(0xa) << 12));

//____________________________________________________________________
AliFMDAltroIO::AliFMDAltroIO() 
  : fBuffer(0), fIBuffer(0)
{}

//____________________________________________________________________
const char*
AliFMDAltroIO::ErrorString(Int_t err)  const
{
  switch (err) {
  case kNoError:    return "No error";                          break;
  case kBadFile:    return "Bad state after open/close file";   break;
  case kBadBits:    return "Bad bit offset specified";          break;
  case kBadRead:    return "Bad state after reading from file"; break;
  case kBadWrite:   return "Bad state after writing to file";   break;
  case kBadSeek:    return "Bad state after seeking in file";   break;
  case kBadTell:    return "Could not tell position in file";   break;
  case kBadTrailer: return "Bad trailer 40 bit word in file";   break;
  case kBadFill:    return "Bad fill word in file";             break;
  }
  return "Unknown";
}


//____________________________________________________________________
AliFMDAltroIO::W40_t
AliFMDAltroIO::ConcatW40(UShort_t n, const W10_t& w) const
{
  if (n > 3) return -kBadBits;
  return W40_t(w & 0x3ff) << (10 * n);
}

//____________________________________________________________________
AliFMDAltroIO::W10_t
AliFMDAltroIO::ExtractW10(UShort_t n, const W40_t w) const
{
  if (n > 3) return -kBadBits;
  return (w >> (10 * n)) & 0x3ff;
}

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

//____________________________________________________________________
AliFMDAltroReader::AliFMDAltroReader(std::istream& stream)
  : fInput(stream)
  // : fBuffer(buffer), fCurrent(n / 10 * sizeof(char))
{
  // fInput.open(filename);
  if (!fInput)      throw -kBadFile;
  fBegin   = fInput.tellg();
  if (fInput.bad()) throw -kBadTell;
  fInput.seekg(0, std::ios_base::end);
  if (fInput.bad()) throw -kBadSeek;
  fCurrent = fInput.tellg();
  if (fInput.bad()) throw -kBadTell;
#if 0
  fInput.seekg(fBegin);
  UShort_t i = 0;
  do {
    W40_t w = 0;
    fInput.read((char*)&w, 5);
    std::cout << std::setw(6) << i << ": " << PRETTY_HEX(10, w) << std::endl;
    i++;
  } while (!fInput.eof());
  fInput.seekg(fCurrent);
#endif
}

//____________________________________________________________________
Int_t
AliFMDAltroReader::ReadChannel(UShort_t& board, UShort_t& chip, 
			       UShort_t& channel, UShort_t& last, 
			       UShort_t* data) 
{
  UShort_t hwaddr;
  Int_t    ret = ReadChannel(hwaddr, last, data);
  board        = (hwaddr >>  7) & 0x1f;
  chip         = (hwaddr >>  4) & 0x3;
  channel      = hwaddr & 0xf;
  return ret;
}

//____________________________________________________________________
Int_t
AliFMDAltroReader::ReadChannel(UShort_t& hwaddr, UShort_t& last, 
			       UShort_t* data) 
{
  Int_t ret, tmp;
  AliFMDDebug(15, ("Reading a channel"));
  if ((ret = ExtractTrailer(hwaddr, last)) < 0) { 
    AliError(Form("Failed to read trailer: %s", ErrorString(-ret)));
    return ret;
  }
  AliFMDDebug(15, ("Now extracting bunches from %d 10 bit words", last));
  tmp     =  ExtractBunches(last, data); 
  if (tmp < 0) {
    AliError(Form("Failed to read bunches: %s", ErrorString(-tmp)));
    return tmp;
  }
  ret     += tmp;
  last    =  (last == 0 ? 0 : last - 2); 
  return ret;
}

//____________________________________________________________________
Int_t
AliFMDAltroReader::ExtractTrailer(UShort_t& hwaddr, UShort_t& last)
{
  AliFMDDebug(15, ("Extracting trailer"));
  W40_t trailer = GetNextW40();
  if (trailer < 0) {
    AliError(Form("Trailer 0x%x is bad: %s", trailer, ErrorString(-trailer)));
    return trailer;
  }
  if (!IsTrailer(trailer)) { 
    AliError(Form("Bad trailer: 0x%08x", trailer));
    return -kBadTrailer;
  }
  last    = (trailer >> 16) & 0x3ff;
  hwaddr  = (trailer & 0xfff);
  return 4;
}

//____________________________________________________________________
Int_t
AliFMDAltroReader::ExtractBunches(UShort_t last, UShort_t* data) 
{
  Int_t ret;
  if ((ret = ExtractFillWords(last)) < 0) { 
    AliError(Form("Failed to read fill words: %s", ErrorString(-ret)));
    return ret;
  }
  while (last > 0) { 
    Int_t tmp = ExtractBunch(data);
    if (tmp <= 0) { 
      AliError(Form("Failed to extract bunch at %d: %s", 
		    last, ErrorString(-tmp)));
      return tmp;
    }
    ret  += tmp;
    last -= tmp;
  }
  return ret;
}

//____________________________________________________________________
Int_t
AliFMDAltroReader::ExtractFillWords(UShort_t last) 
{
  // Number of fill words 
  UShort_t nFill = (last % 4 == 0 ? 0 : 4 - last % 4);
  // Read the fill words 
  for (UShort_t i = 3; i >= 4 - nFill; i--) {
    W10_t f = GetNextW10();
    if (f != 0x2aa) return -kBadFill;
  }
  return nFill;
}

//____________________________________________________________________
Int_t
AliFMDAltroReader::ExtractBunch(UShort_t* data)
{
  Int_t ret =  0;
  W10_t l =  GetNextW10(); 
  if (l < 0) { 
    AliError(Form("Failed to read bunch length: %s", ErrorString(-l)));
    return l;
  }
  W10_t t =  GetNextW10(); 
  if (t < 0) { 
    AliError(Form("Failed to read bunch time: %s", ErrorString(-t)));
    return t;
  }
  ret     += 2;
  for (Int_t i = 2; i < l; i++) {
    W10_t s = GetNextW10();
    if (s < 0) { 
      AliError(Form("Failed to read bunch data: %s", ErrorString(-s)));
      return 2;
    }
    AliFMDDebug(50, ("Assigning to data[%d - (%d - 1)] = 0x%X", t, i, s));
    data[t - (i-1)] = s;
    ret++;
  }
  return ret;
}

//____________________________________________________________________
Bool_t
AliFMDAltroReader::IsTrailer(W40_t x) 
{
  return ((x & fgkTrailerMask) == fgkTrailerMask);
}

//____________________________________________________________________
Bool_t
AliFMDAltroReader::IsBof() 
{
  return fCurrent == fBegin;
}

//____________________________________________________________________
Int_t
AliFMDAltroReader::ReadW40() 
{
  fInput.seekg(fCurrent-std::istream::pos_type(5));
  if (fInput.bad()) return -kBadSeek;
  fCurrent = fInput.tellg();
  if (fInput.bad()) return -kBadTell;
  fInput.read((char*)&fBuffer, 5 * sizeof(char));
  if (fInput.bad()) return -kBadRead;
  fIBuffer = 4;
  AliFMDDebug(15, ("  0x%03x  0x%03x  0x%03x  0x%03x    0x%010x  %6d", 
		    ExtractW10(3, fBuffer), ExtractW10(2, fBuffer), 
		    ExtractW10(1, fBuffer), ExtractW10(0, fBuffer), 
		    fBuffer, fCurrent));
  return fCurrent;
}

//____________________________________________________________________
AliFMDAltroIO::W10_t
AliFMDAltroReader::GetNextW10()
{
  if (fIBuffer <= 0) {
    Int_t ret;
    if ((ret = ReadW40()) < 0) return ret;
  }
  fIBuffer--;
  W10_t w10 = ExtractW10(fIBuffer, fBuffer); 
  return w10;
}

//____________________________________________________________________
AliFMDAltroIO::W40_t
AliFMDAltroReader::GetNextW40() 
{
  W40_t w40 = 0;
  for (Int_t i = 3; i >= 0; i--) {
    W10_t tmp  =  GetNextW10();
    W40_t bits =  ConcatW40(i, tmp);
    if (bits < 0) return bits;
    w40        += bits;
  }
  return w40;
}

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

//____________________________________________________________________
AliFMDAltroWriter::AliFMDAltroWriter(std::ostream& stream) 
  : fThreshold(0), fTotal(0), fOutput(stream)
{
  AliFMDDebug(15, ("New AliFMDAltroWriter object"));
  fTime   = 0;
  fLength = 0;
  fLast   = 0;
  // Write a dummy header
  fHeader = fOutput.tellp();
  if (fOutput.bad()) throw -kBadTell;
  AliRawDataHeader header;
  fOutput.write((char*)(&header), sizeof(header));
  if (fOutput.bad()) throw -kBadWrite;
  fBegin = fOutput.tellp();
  if (fOutput.bad()) throw -kBadTell;
}

//____________________________________________________________________
Int_t
AliFMDAltroWriter::Flush() 
{
  if (fIBuffer == 0) return 0;
  fOutput.write((char*)&fBuffer, 5 * sizeof(char));
  if (fOutput.bad()) return -kBadWrite;
  // for (UShort_t i = 0; i < 4; i++) 
  //   std::cout << "\t" << PRETTY_HEX(3, ExtractW10(i, fBuffer));
  // std::cout << "\t" << PRETTY_HEX(10, fBuffer) << std::endl;
  fTotal   += 5;
  fIBuffer =  0;
  fBuffer  =  0;
  return 5;
}

//____________________________________________________________________
Int_t 
AliFMDAltroWriter::Close() 
{
  Flush();
  std::ostream::pos_type end = fOutput.tellp();
  if (fOutput.bad()) return -kBadTell;
  fOutput.seekp(fHeader, std::ios_base::beg);
  if (fOutput.bad()) return -kBadSeek;
  AliRawDataHeader header;
  header.fSize = (UShort_t(end) - fHeader);
  AliFMDDebug(15, ("Size set to %d (%d)", header.fSize, fTotal));
  header.SetAttribute(0);
  fOutput.write((char*)(&header), sizeof(header));
  if (fOutput.bad()) return -kBadWrite;
  fOutput.seekp(end);
  if (fOutput.bad()) return -kBadSeek;
  return sizeof(header);
}


//____________________________________________________________________
Int_t
AliFMDAltroWriter::AddSignal(UShort_t adc) 
{
  Int_t ret = 0;
  if (adc < fThreshold) 
    ret = AddBunchTrailer();
  else {
    ret = AddToBuffer(adc);
    fLength++;
  }
  fTime++;
  if (ret < 0) AliError(Form("Failed to add signal %x: %s", ErrorString(ret)));
  return ret;
}

//____________________________________________________________________
Int_t
AliFMDAltroWriter::AddChannelTrailer(UShort_t board, UShort_t chip, 
				     UShort_t channel)
{
  UInt_t hwaddr = (channel & 0xf)+((chip & 0x3) << 4)+((board & 0x1f) << 7);
  return AddChannelTrailer(hwaddr);
}

//____________________________________________________________________
Int_t
AliFMDAltroWriter::AddChannelTrailer(UInt_t hwaddr)
{
  Int_t ret =0, tmp;
  if ((tmp = AddBunchTrailer()) < 0) { 
    AliError(Form("Failed to bad bunch trailer: %s", ErrorString(tmp)));
    return tmp;
  }
  ret += tmp;
  if ((tmp = AddFillWords())    < 0) { 
    AliError(Form("Failed to bad fill words: %s", ErrorString(tmp)));
    return tmp;
  }
  ret += tmp;
  W40_t trailer = (fgkTrailerMask + hwaddr + ((fLast & 0x3ff) << 16));
  fBuffer = trailer;
  fIBuffer = 3;
  ret     += 4;
  if ((tmp = Flush()) < 0) {
    AliError(Form("Failed to flush: %s", ErrorString(tmp)));
    return tmp;
  }
  ret     += tmp;
  fTime   =  0;
  fLast   =  0;
  return ret;
}

//____________________________________________________________________
Int_t
AliFMDAltroWriter::AddToBuffer(UShort_t x) 
{
  W40_t tmp = ConcatW40(fIBuffer, x);
  if (tmp < 0) return tmp;
  fBuffer += tmp;
  fIBuffer++;
  fLast++;
  Int_t ret = 0;
  if (fIBuffer > 3 && (ret = Flush() < 0)) return ret;
  return 1;
}

//____________________________________________________________________
Int_t
AliFMDAltroWriter::AddBunchTrailer()
{
  if (fLength <= 0) return 0;    
  Int_t ret = 0, tmp;
  if ((tmp = AddToBuffer(fTime))     < 0) return tmp;
  ret += tmp;
  if ((tmp = AddToBuffer(fLength+2)) < 0) return tmp;
  ret += tmp;
  fLength = 0;
  return ret;
}

//____________________________________________________________________
Int_t
AliFMDAltroWriter::AddFillWords() 
{
  Int_t ret = 0, tmp;
  if (fIBuffer == 0) return ret;
  for (Int_t i = fIBuffer; i < 4; i++) { 
    if ((tmp = AddToBuffer(0x2aa)) < 0) return tmp;
    ret += tmp;
    fLast--; 
  }
  if ((tmp = Flush() < 0)) return tmp;
  return ret;
}

//_____________________________________________________________________________
//
// EOF
//
Commit	Line	Data
1e8f773e	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	**************************************************************************/
1e8f773e	15	/* $Id$ */
c2fc1258	16	/** @file AliFMDAltroIO.cxx
	17	@author Christian Holm Christensen <cholm@nbi.dk>
	18	@date Sun Mar 26 18:27:06 2006
	19	@brief Altro Input/Output
	20	*/
1e8f773e	21	//____________________________________________________________________
	22	//
	23	// Mapping of ALTRO hardware channel to detector coordinates
	24	//
	25	#include "AliFMDAltroIO.h"
	26	#include <AliRawDataHeader.h>
	27	#include <AliRawReader.h>
	28	#include "AliLog.h"
	29	#include <iostream>
	30	#include <iomanip>
	31	#define PRETTY_HEX(N,X) \
	32	" 0x" << std::setfill('0') << std::setw(N) << std::hex << X \
	33	<< std::setfill(' ') << std::dec
	34
	35	//====================================================================
	36	ClassImp(AliFMDAltroIO)
	37	#if 0
	38	; // This is here to keep Emacs for indenting the next line
	39	#endif
	40
	41	//____________________________________________________________________
	42	const AliFMDAltroIO::W40_t AliFMDAltroIO::fgkTrailerMask =
	43	((AliFMDAltroIO::W40_t(0x2aaa) << 26) + (AliFMDAltroIO::W40_t(0xa) << 12));
	44
	45	//____________________________________________________________________
	46	AliFMDAltroIO::AliFMDAltroIO()
	47	: fBuffer(0), fIBuffer(0)
	48	{}
	49
	50	//____________________________________________________________________
	51	const char*
	52	AliFMDAltroIO::ErrorString(Int_t err) const
	53	{
	54	switch (err) {
	55	case kNoError: return "No error"; break;
	56	case kBadFile: return "Bad state after open/close file"; break;
	57	case kBadBits: return "Bad bit offset specified"; break;
	58	case kBadRead: return "Bad state after reading from file"; break;
	59	case kBadWrite: return "Bad state after writing to file"; break;
	60	case kBadSeek: return "Bad state after seeking in file"; break;
	61	case kBadTell: return "Could not tell position in file"; break;
	62	case kBadTrailer: return "Bad trailer 40 bit word in file"; break;
	63	case kBadFill: return "Bad fill word in file"; break;
	64	}
	65	return "Unknown";
	66	}
	67
	68
	69	//____________________________________________________________________
	70	AliFMDAltroIO::W40_t
6e79feeb	71	AliFMDAltroIO::ConcatW40(UShort_t n, const W10_t& w) const
1e8f773e	72	{
	73	if (n > 3) return -kBadBits;
	74	return W40_t(w & 0x3ff) << (10 * n);
	75	}
	76
	77	//____________________________________________________________________
	78	AliFMDAltroIO::W10_t
6e79feeb	79	AliFMDAltroIO::ExtractW10(UShort_t n, const W40_t w) const
1e8f773e	80	{
	81	if (n > 3) return -kBadBits;
	82	return (w >> (10 * n)) & 0x3ff;
	83	}
	84
	85	//====================================================================
	86	ClassImp(AliFMDAltroReader)
	87	#if 0
	88	; // This is here to keep Emacs for indenting the next line
	89	#endif
	90
	91	//____________________________________________________________________
	92	AliFMDAltroReader::AliFMDAltroReader(std::istream& stream)
	93	: fInput(stream)
	94	// : fBuffer(buffer), fCurrent(n / 10 * sizeof(char))
	95	{
	96	// fInput.open(filename);
	97	if (!fInput) throw -kBadFile;
	98	fBegin = fInput.tellg();
	99	if (fInput.bad()) throw -kBadTell;
	100	fInput.seekg(0, std::ios_base::end);
	101	if (fInput.bad()) throw -kBadSeek;
	102	fCurrent = fInput.tellg();
	103	if (fInput.bad()) throw -kBadTell;
	104	#if 0
	105	fInput.seekg(fBegin);
6e79feeb	106	UShort_t i = 0;
1e8f773e	107	do {
	108	W40_t w = 0;
	109	fInput.read((char*)&w, 5);
	110	std::cout << std::setw(6) << i << ": " << PRETTY_HEX(10, w) << std::endl;
	111	i++;
	112	} while (!fInput.eof());
	113	fInput.seekg(fCurrent);
	114	#endif
	115	}
	116
	117	//____________________________________________________________________
	118	Int_t
	119	AliFMDAltroReader::ReadChannel(UShort_t& board, UShort_t& chip,
	120	UShort_t& channel, UShort_t& last,
	121	UShort_t* data)
	122	{
	123	UShort_t hwaddr;
	124	Int_t ret = ReadChannel(hwaddr, last, data);
	125	board = (hwaddr >> 7) & 0x1f;
	126	chip = (hwaddr >> 4) & 0x3;
	127	channel = hwaddr & 0xf;
	128	return ret;
	129	}
	130
	131	//____________________________________________________________________
	132	Int_t
	133	AliFMDAltroReader::ReadChannel(UShort_t& hwaddr, UShort_t& last,
	134	UShort_t* data)
	135	{
	136	Int_t ret, tmp;
f95a63c4	137	AliFMDDebug(15, ("Reading a channel"));
1e8f773e	138	if ((ret = ExtractTrailer(hwaddr, last)) < 0) {
	139	AliError(Form("Failed to read trailer: %s", ErrorString(-ret)));
	140	return ret;
	141	}
f95a63c4	142	AliFMDDebug(15, ("Now extracting bunches from %d 10 bit words", last));
1e8f773e	143	tmp = ExtractBunches(last, data);
	144	if (tmp < 0) {
	145	AliError(Form("Failed to read bunches: %s", ErrorString(-tmp)));
	146	return tmp;
	147	}
	148	ret += tmp;
	149	last = (last == 0 ? 0 : last - 2);
	150	return ret;
	151	}
	152
	153	//____________________________________________________________________
	154	Int_t
	155	AliFMDAltroReader::ExtractTrailer(UShort_t& hwaddr, UShort_t& last)
	156	{
f95a63c4	157	AliFMDDebug(15, ("Extracting trailer"));
1e8f773e	158	W40_t trailer = GetNextW40();
	159	if (trailer < 0) {
	160	AliError(Form("Trailer 0x%x is bad: %s", trailer, ErrorString(-trailer)));
	161	return trailer;
	162	}
	163	if (!IsTrailer(trailer)) {
	164	AliError(Form("Bad trailer: 0x%08x", trailer));
	165	return -kBadTrailer;
	166	}
	167	last = (trailer >> 16) & 0x3ff;
	168	hwaddr = (trailer & 0xfff);
	169	return 4;
	170	}
	171
	172	//____________________________________________________________________
	173	Int_t
	174	AliFMDAltroReader::ExtractBunches(UShort_t last, UShort_t* data)
	175	{
	176	Int_t ret;
	177	if ((ret = ExtractFillWords(last)) < 0) {
	178	AliError(Form("Failed to read fill words: %s", ErrorString(-ret)));
	179	return ret;
	180	}
	181	while (last > 0) {
	182	Int_t tmp = ExtractBunch(data);
	183	if (tmp <= 0) {
	184	AliError(Form("Failed to extract bunch at %d: %s",
	185	last, ErrorString(-tmp)));
	186	return tmp;
	187	}
	188	ret += tmp;
	189	last -= tmp;
	190	}
	191	return ret;
	192	}
	193
	194	//____________________________________________________________________
	195	Int_t
	196	AliFMDAltroReader::ExtractFillWords(UShort_t last)
	197	{
	198	// Number of fill words
6e79feeb	199	UShort_t nFill = (last % 4 == 0 ? 0 : 4 - last % 4);
1e8f773e	200	// Read the fill words
6e79feeb	201	for (UShort_t i = 3; i >= 4 - nFill; i--) {
1e8f773e	202	W10_t f = GetNextW10();
	203	if (f != 0x2aa) return -kBadFill;
	204	}
	205	return nFill;
	206	}
	207
	208	//____________________________________________________________________
	209	Int_t
	210	AliFMDAltroReader::ExtractBunch(UShort_t* data)
	211	{
	212	Int_t ret = 0;
	213	W10_t l = GetNextW10();
	214	if (l < 0) {
	215	AliError(Form("Failed to read bunch length: %s", ErrorString(-l)));
	216	return l;
	217	}
	218	W10_t t = GetNextW10();
	219	if (t < 0) {
	220	AliError(Form("Failed to read bunch time: %s", ErrorString(-t)));
	221	return t;
	222	}
	223	ret += 2;
	224	for (Int_t i = 2; i < l; i++) {
	225	W10_t s = GetNextW10();
	226	if (s < 0) {
	227	AliError(Form("Failed to read bunch data: %s", ErrorString(-s)));
	228	return 2;
	229	}
f95a63c4	230	AliFMDDebug(50, ("Assigning to data[%d - (%d - 1)] = 0x%X", t, i, s));
1e8f773e	231	data[t - (i-1)] = s;
	232	ret++;
	233	}
	234	return ret;
	235	}
	236
	237	//____________________________________________________________________
	238	Bool_t
	239	AliFMDAltroReader::IsTrailer(W40_t x)
	240	{
	241	return ((x & fgkTrailerMask) == fgkTrailerMask);
	242	}
	243
	244	//____________________________________________________________________
	245	Bool_t
	246	AliFMDAltroReader::IsBof()
	247	{
	248	return fCurrent == fBegin;
	249	}
	250
	251	//____________________________________________________________________
	252	Int_t
	253	AliFMDAltroReader::ReadW40()
	254	{
	255	fInput.seekg(fCurrent-std::istream::pos_type(5));
	256	if (fInput.bad()) return -kBadSeek;
	257	fCurrent = fInput.tellg();
	258	if (fInput.bad()) return -kBadTell;
	259	fInput.read((char)&fBuffer, 5 sizeof(char));
	260	if (fInput.bad()) return -kBadRead;
	261	fIBuffer = 4;
f95a63c4	262	AliFMDDebug(15, (" 0x%03x 0x%03x 0x%03x 0x%03x 0x%010x %6d",
1e8f773e	263	ExtractW10(3, fBuffer), ExtractW10(2, fBuffer),
	264	ExtractW10(1, fBuffer), ExtractW10(0, fBuffer),
	265	fBuffer, fCurrent));
	266	return fCurrent;
	267	}
	268
	269	//____________________________________________________________________
	270	AliFMDAltroIO::W10_t
	271	AliFMDAltroReader::GetNextW10()
	272	{
	273	if (fIBuffer <= 0) {
	274	Int_t ret;
	275	if ((ret = ReadW40()) < 0) return ret;
	276	}
	277	fIBuffer--;
	278	W10_t w10 = ExtractW10(fIBuffer, fBuffer);
	279	return w10;
	280	}
	281
	282	//____________________________________________________________________
	283	AliFMDAltroIO::W40_t
	284	AliFMDAltroReader::GetNextW40()
	285	{
	286	W40_t w40 = 0;
	287	for (Int_t i = 3; i >= 0; i--) {
	288	W10_t tmp = GetNextW10();
	289	W40_t bits = ConcatW40(i, tmp);
	290	if (bits < 0) return bits;
	291	w40 += bits;
	292	}
	293	return w40;
	294	}
	295
	296	//====================================================================
	297	ClassImp(AliFMDAltroWriter)
	298	#if 0
	299	; // This is here to keep Emacs for indenting the next line
	300	#endif
	301
	302	//____________________________________________________________________
	303	AliFMDAltroWriter::AliFMDAltroWriter(std::ostream& stream)
	304	: fThreshold(0), fTotal(0), fOutput(stream)
	305	{
f95a63c4	306	AliFMDDebug(15, ("New AliFMDAltroWriter object"));
1e8f773e	307	fTime = 0;
	308	fLength = 0;
	309	fLast = 0;
	310	// Write a dummy header
	311	fHeader = fOutput.tellp();
	312	if (fOutput.bad()) throw -kBadTell;
	313	AliRawDataHeader header;
	314	fOutput.write((char*)(&header), sizeof(header));
	315	if (fOutput.bad()) throw -kBadWrite;
	316	fBegin = fOutput.tellp();
	317	if (fOutput.bad()) throw -kBadTell;
	318	}
	319
	320	//____________________________________________________________________
	321	Int_t
	322	AliFMDAltroWriter::Flush()
	323	{
	324	if (fIBuffer == 0) return 0;
	325	fOutput.write((char)&fBuffer, 5 sizeof(char));
	326	if (fOutput.bad()) return -kBadWrite;
6e79feeb	327	// for (UShort_t i = 0; i < 4; i++)
1e8f773e	328	// std::cout << "\t" << PRETTY_HEX(3, ExtractW10(i, fBuffer));
	329	// std::cout << "\t" << PRETTY_HEX(10, fBuffer) << std::endl;
	330	fTotal += 5;
	331	fIBuffer = 0;
	332	fBuffer = 0;
	333	return 5;
	334	}
	335
	336	//____________________________________________________________________
	337	Int_t
	338	AliFMDAltroWriter::Close()
	339	{
	340	Flush();
	341	std::ostream::pos_type end = fOutput.tellp();
	342	if (fOutput.bad()) return -kBadTell;
	343	fOutput.seekp(fHeader, std::ios_base::beg);
	344	if (fOutput.bad()) return -kBadSeek;
	345	AliRawDataHeader header;
6e79feeb	346	header.fSize = (UShort_t(end) - fHeader);
f95a63c4	347	AliFMDDebug(15, ("Size set to %d (%d)", header.fSize, fTotal));
1e8f773e	348	header.SetAttribute(0);
	349	fOutput.write((char*)(&header), sizeof(header));
	350	if (fOutput.bad()) return -kBadWrite;
	351	fOutput.seekp(end);
	352	if (fOutput.bad()) return -kBadSeek;
	353	return sizeof(header);
	354	}
	355
	356
	357	//____________________________________________________________________
	358	Int_t
	359	AliFMDAltroWriter::AddSignal(UShort_t adc)
	360	{
	361	Int_t ret = 0;
	362	if (adc < fThreshold)
	363	ret = AddBunchTrailer();
	364	else {
	365	ret = AddToBuffer(adc);
	366	fLength++;
	367	}
	368	fTime++;
	369	if (ret < 0) AliError(Form("Failed to add signal %x: %s", ErrorString(ret)));
	370	return ret;
	371	}
	372
	373	//____________________________________________________________________
	374	Int_t
	375	AliFMDAltroWriter::AddChannelTrailer(UShort_t board, UShort_t chip,
	376	UShort_t channel)
	377	{
	378	UInt_t hwaddr = (channel & 0xf)+((chip & 0x3) << 4)+((board & 0x1f) << 7);
	379	return AddChannelTrailer(hwaddr);
	380	}
	381
	382	//____________________________________________________________________
	383	Int_t
	384	AliFMDAltroWriter::AddChannelTrailer(UInt_t hwaddr)
	385	{
	386	Int_t ret =0, tmp;
	387	if ((tmp = AddBunchTrailer()) < 0) {
	388	AliError(Form("Failed to bad bunch trailer: %s", ErrorString(tmp)));
	389	return tmp;
	390	}
	391	ret += tmp;
	392	if ((tmp = AddFillWords()) < 0) {
	393	AliError(Form("Failed to bad fill words: %s", ErrorString(tmp)));
	394	return tmp;
	395	}
	396	ret += tmp;
	397	W40_t trailer = (fgkTrailerMask + hwaddr + ((fLast & 0x3ff) << 16));
	398	fBuffer = trailer;
	399	fIBuffer = 3;
	400	ret += 4;
	401	if ((tmp = Flush()) < 0) {
	402	AliError(Form("Failed to flush: %s", ErrorString(tmp)));
	403	return tmp;
	404	}
	405	ret += tmp;
	406	fTime = 0;
	407	fLast = 0;
	408	return ret;
	409	}
	410
	411	//____________________________________________________________________
412	Int_t
413	AliFMDAltroWriter::AddToBuffer(UShort_t x)
414	{
415	W40_t tmp = ConcatW40(fIBuffer, x);
416	if (tmp < 0) return tmp;
417	fBuffer += tmp;
418	fIBuffer++;
419	fLast++;
420	Int_t ret = 0;
421	if (fIBuffer > 3 && (ret = Flush() < 0)) return ret;
422	return 1;
423	}
424
425	//____________________________________________________________________
426	Int_t
427	AliFMDAltroWriter::AddBunchTrailer()
428	{
429	if (fLength <= 0) return 0;
430	Int_t ret = 0, tmp;
431	if ((tmp = AddToBuffer(fTime)) < 0) return tmp;
432	ret += tmp;
433	if ((tmp = AddToBuffer(fLength+2)) < 0) return tmp;
434	ret += tmp;
435	fLength = 0;
436	return ret;
437	}
438
439	//____________________________________________________________________
440	Int_t
441	AliFMDAltroWriter::AddFillWords()
442	{
443	Int_t ret = 0, tmp;
444	if (fIBuffer == 0) return ret;
445	for (Int_t i = fIBuffer; i < 4; i++) {
446	if ((tmp = AddToBuffer(0x2aa)) < 0) return tmp;
447	ret += tmp;
448	fLast--;
449	}
450	if ((tmp = Flush() < 0)) return tmp;
451	return ret;
452	}
453
454	//_____________________________________________________________________________
455	//
456	// EOF
457	//